Gesponserte Inhalte

ChatLLM von Abacus AI verfolgt einen anderen Ansatz. Anstatt mit einzelnen Instruments zu konkurrieren, werden diese in einem einzigen Arbeitsbereich gebündelt, der das Schreiben, Codieren, die Bilderzeugung, die Videoerstellung und sogar autonome Arbeitsabläufe übernimmt.

ChatLLM basiert auf einer produktionstauglichen KI-Plattform und ist nicht nur ein weiterer Chatbot – es ist als einheitliches System konzipiert, das den Werkzeugwechsel reduziert und die Einbindung von KI in die reale Arbeit vereinfacht.

TL;DR – Das einzige Abonnement, das Ihren KI-Workflow vereinfacht

• Eine Plattform für Textual content, Code, Bilder, Movies und Agenten
• Wählt automatisch das beste Modell aus (kein manueller Wechsel)
• Beginnt bei 10 $/Monat mit 20.000 Credit
• Kann als Various zu Instruments wie ChatGPT, Claude, Midjourney dienen (für die meisten Benutzer)
• Deep Agent verwaltet mehrstufige Arbeitsabläufe wie Recherche, Präsentationen und Automatisierung
• Nachteile: Credit score-System, schwere Aufgaben beanspruchen die Nutzung schnell

Wenn Ihr aktueller Arbeitsablauf mehrere Abonnements umfasst, vereinfacht ChatLLM alles.

Was ist ChatLLM und warum reden alle darüber?

Im Kern läuft ChatLLM darauf hinaus: eine zentralisierte KI-Plattform, die das Jonglieren mehrerer Abonnements überflüssig macht.

Im Gegensatz zu eigenständigen Instruments ChatLLM abacus ai basiert auf einer breiteren Infrastruktur, die für reale Arbeitsabläufe und nicht nur für gelegentliche Eingabeaufforderungen konzipiert ist. Dieser Unterschied wird deutlich, sobald Sie mit der Nutzung beginnen.

Anstatt manuell zwischen Modellen zum Schreiben, Codieren oder Recherchieren auszuwählen, führt die Plattform etwas ein, das „Route LLM“ genannt wird. Stellen Sie sich das wie einen intelligenten Router vor – er analysiert Ihre Eingaben und entscheidet, welches Modell die Aufgabe übernehmen soll.

Erster Eindruck: Weniger wie ein Chatbot, eher wie ein Kontrollzentrum

Bei den meisten KI-Instruments geht es nach einer Weile ähnlich: Eingabeaufforderung, Antwort.

ChatLLM fühlt sich anders an.

Die Benutzeroberfläche ist vertraut genug (denken Sie an ein Structure im ChatGPT-Stil), aber der eigentliche Wandel liegt unter der Haube:

• Sie müssen Modelle nicht manuell auswählen
• Sie benötigen keine separaten Instruments für Bilder oder Movies
• Sie müssen Arbeitsabläufe nicht extern verwalten

Alles ist von einem Ort aus zugänglich.

Dies allein beseitigt eine Menge Reibung, insbesondere wenn Sie den ganzen Tag zwischen Werkzeugen wechseln.

Die Kernfunktion, die wirklich zählt: Route LLM

Hier wird es interessant.

Anstatt zu fragen: „Welches Modell soll ich verwenden?“, beantwortet ChatLLM das für Sie.

Das integrierte Routing-System namens RouteLLM führt automatisch Folgendes durch:

• Analysiert Ihre Eingabeaufforderung
• Bestimmt die Komplexität
• Wählt das am besten geeignete Modell aus

Zum Beispiel:

• Einfache Abfragen → schnellere, günstigere Modelle
• Codierungsaufgaben → optimierte Codierungsmodelle
• Komplexes Denken → Hochleistungsmodelle

In der Praxis wird dadurch einer der größten versteckten Kosten beim Einsatz von KI beseitigt: Entscheidungsmüdigkeit.

Und überraschenderweise funktioniert es die meiste Zeit intestine.

Wie ChatLLM alltägliche KI-Aufgaben bewältigt

Schreiben und Erstellen von Inhalten

Mithilfe der integrierten Humanisierungsfunktionen können Sie Artikel erstellen, Inhalte umschreiben oder den Ton anpassen.

Was herausragte:

• Die Klanganpassung ist flexibel
• Die Ausgaben fühlen sich im Vergleich zu Customary-LLM-Antworten weniger starr an
• Nützlich für Web optimization-Content material-Workflows

Codierung und technische Aufgaben

Ich habe grundlegende und fortgeschrittene Codierungsaufforderungen getestet (Python-Skripte, Datenverarbeitung).

Beobachtungen:

• Das System leitet automatisch an starke Codierungsmodelle weiter
• Die Ausgabequalität struggle konstant
• Die modellübergreifende Regeneration lässt sich leicht vergleichen

Für Entwickler entfällt dadurch eine Menge Versuch und Irrtum.

Bilderzeugung (ohne Werkzeugwechsel)

Anstatt eine andere Plattform zu öffnen, können Sie Bilder direkt in ChatLLM generieren.

Was den meisten Benutzern gefallen wird:

• Zugriff auf mehrere Bildmodelle
• Gute Kontrolle über die Ausgabe
• Kein zusätzliches Abonnement erforderlich

Es ist kein Ersatz für spezielle Design-Instruments, aber für die meisten Arbeitsabläufe ist es mehr als ausreichend.

Videoerstellung mit Agenten

Hier geht es über typische KI-Instruments hinaus.

Mit seinem agentenbasierten System können Sie:

• Konvertieren Sie Bilder in Movies
• Automatisieren Sie mehrstufige kreative Arbeitsabläufe
• Generieren Sie Inhalte mit minimalem manuellen Setup

Der entscheidende Unterschied?
Sie geben nicht nur Aufforderungen – Sie geben Anweisungen.

Deep Agent: Die Automatisierungsschicht

Diese Funktion verdient besondere Erwähnung.

Im Gegensatz zu Customary-Chat-Instruments kann der Agent:

• Unterteilt Aufgaben in Schritte
• Wählt Werkzeuge automatisch aus
• Führt mehrstufige Workflows aus

Beispielhafte Anwendungsfälle sind:

• Recherche und Präsentationserstellung
• Inhalte, Bilder und Formatierung in einem Fluss
• Automatisierte Aufgabenausführung

Es ist nicht fehlerfrei, aber es ist derzeit eine der praktischeren Implementierungen von KI-Agenten.

ChatLLM-Preise: Ist es tatsächlich kosteneffektiv?

Lassen Sie uns über die ChatLLM-Preise sprechen, denn hier weckt das Interesse der meisten Menschen.

Anstelle separater Abonnements verwendet ChatLLM ein rechenbasiertes Modell.

Typische Pläne umfassen:

• Monatliche Rechenguthaben
• Verwendung für Textual content-, Bild-, Video- und Agentenfunktionen
• Keine separate Abrechnung professional Funktion

Was das in der Praxis bedeutet:

• Leichte Aufgaben = niedrige Kosten
• Schwere Aufgaben (Video/Agenten) = höherer Verbrauch
• Keine Verschwendung von Ausgaben für ungenutzte Werkzeuge

Hier ein vereinfachter Vergleich:

ChatLLM:
$10–$20/Monat für alles zusammen.

4,4★ von 10.000+ Benutzern? Die ChatLLM-Bewertungen, die Sie überraschen könnten

Bevor Sie einer KI-Plattform vertrauen, erzählen echte Benutzerfeedbacks oft eine ehrlichere Geschichte als Produktseiten oder Demos.

ChatLLM zeigt derzeit:

Auf den ersten Blick spiegeln diese Zahlen die starke Akzeptanz und das wachsende Interesse an der Plattform wider.

Die aussagekräftigere Bewertung ergibt sich jedoch aus der praktischen Nutzung, der Funktionstiefe und der Frage, wie effektiv sie in reale Arbeitsabläufe passt.

Was sich von Adoptionstrends abhebt

Eine beträchtliche Anzahl von Benutzern hebt einen wesentlichen Vorteil hervor: Konsolidierung.

Anstatt mehrere Abonnements zu verwalten, ermöglicht die Plattform Benutzern Folgendes:

• Inhalte erstellen
• Bilder generieren
• Greifen Sie auf mehrere KI-Modelle zu
• Erledigen Sie Aufgaben innerhalb einer einzigen Schnittstelle

Dieser Komfort wird in positiven Bewertungen immer wieder erwähnt. Für viele Benutzer liegt der Wert weniger in der Spitzenleistung als vielmehr darin Workflow-Effizienz.

Als großer Vorteil stechen auch Kosteneinsparungen hervor. Benutzer, die von mehreren KI-Instruments wechseln, bemerken häufig sofortige Einsparungen bei den monatlichen Ausgaben.

Vor- und Nachteile (ehrliche Sichtweise)

Vorteile

• Einheitlicher KI-Arbeitsbereich (größter Vorteil)
• Intelligentes Modellrouting spart Zeit
• Multimodale Funktionen an einem Ort
• Versatile nutzungsbasierte Preisgestaltung
• Stark für Produktivitätsworkflows

Nachteile

• Lernkurve für neue Benutzer
• Schwere Aufgaben können schnell Credit verbrauchen
• Nicht immer der Klassenbeste professional einzelnem Characteristic
• Die Arbeitsabläufe der Agenten entwickeln sich immer noch weiter

Wer sollte ChatLLM eigentlich nutzen?

Basierend auf Exams ist dieses Device am sinnvollsten für:

• Vermarkter, die Inhalte und visuelle Elemente verwalten
• Entwickler experimentieren mit mehreren Modellen
• Schöpfer, die formatübergreifend arbeiten
• Groups versuchen, die Werkzeugvielfalt zu reduzieren

Wenn Ihr Arbeitsablauf einen ständigen Tab-Wechsel beinhaltet, wird dies eine Erleichterung sein.

Endgültiges Urteil: Lohnt sich ChatLLM?

Diese ChatLLM-Rezension läuft auf eine einfache Frage hinaus:

Möchten Sie die besten Einzeltools oder den besten kombinierten Workflow?

ChatLLM ist eindeutig für den Second konzipiert.

Es geht nicht darum, jedes Werkzeug einzeln zu besiegen, sondern darum, sie gemeinsam zu ersetzen.

Und für viele Benutzer ist das tatsächlich wertvoller.

einer Serie über verteilte KI über mehrere GPUs:

Einführung

Im vorherigen Beitrag haben wir gesehen, wie Distributed Knowledge Parallelism (DDP) das Coaching beschleunigt, indem es Stapel auf GPUs aufteilt. DDP löst das Durchsatzproblem, bringt jedoch eine neue Herausforderung mit sich: Speicherredundanz.

In Vanilla DDP enthält jede GPU eine vollständige Kopie der Modellparameter, Verläufe und Optimiererzustände. Bei großen Modellen wie GPT-3 (175B-Parameter) führt diese Redundanz zu einer großen Verschwendung wertvollen VRAMs.

ZeRO (Zero Redundancy Optimizer) löst dieses Drawback. Es gibt drei Ebenen:

• ZeRO-1 Partitionen nur Optimiererzustände
• ZeRO-2 Partitioniert Optimiererzustände + Farbverläufe
• ZeRO-3 Partitioniert Optimiererzustände + Verläufe + Modellparameter

ZeRO ist keine Parallelitätstechnik, da alle GPUs immer noch die gleichen Vorwärts- und Rückwärtsdurchläufe ausführen. Es ist ein Speicheroptimierung Strategie, die Redundanz zwischen GPUs eliminiert und es Ihnen ermöglicht, größere Modelle auf derselben {Hardware} zu trainieren.

Das Speicherproblem in DDP

Lassen Sie uns aufschlüsseln, was während des Trainings tatsächlich Speicher verbraucht. Für ein Modell mit Parametern:

• Modellparameter: Werte (die Gewichte Ihres neuronalen Netzwerks)
• Farbverläufe: Werte (ein Gradient professional Parameter)
• Optimiererzustände (Adam): Werte (erstes Second und zweites Second für jeden Parameter)
• Aktivierungen: Zwischenausgaben, die während des Vorwärtsdurchlaufs zur Verwendung im Rückwärtsdurchlauf gespeichert werden

Die ersten drei skalieren mit Modellgröße und sind GPU-übergreifend redundant im DDP. Die Aktivierungen skalieren mit der Batch-Größe, der Sequenzlänge und der Anzahl der Neuronen Einzigartig professional GPU da jede GPU unterschiedliche Daten verarbeitet. ZeRO berührt den Aktivierungsspeicher nicht.

Berechnen wir die Speichernutzung für ein 7B-Parameter-Modell mit Adam und FP32:

• Parameter: 7 Milliarden * 4 Bytes = 28 GB
• Farbverläufe: 7 Milliarden * 4 Bytes = 28 GB
• Der Optimierer gibt an: 7 Milliarden * 2 * 4 Bytes = 56 GB
• Speicher professional GPU in DDP: 112 GB

Aktivierungen fügen darüber hinaus erheblichen Speicher hinzu, aber da sie professional GPU einzigartig sind, kann ZeRO sie nicht partitionieren. Techniken wie Aktivierungs-Checkpointing kann helfen, es verwirft einige Aktivierungen und berechnet sie dann nach Bedarf während des Rückwärtsdurchlaufs neu. Aber das würde den Rahmen dieses Artikels sprengen.

Lassen Sie uns verstehen, wie ZeRO funktioniert, indem wir es von Grund auf implementieren, beginnend mit ZeRO-1 und uns bis hin zu ZeRO-3 vorarbeiten.

ZeRO-1: Optimierer-Zustandspartitionierung

In ZeRO-1 nur die Optimiererzustände sind partitioniert. Jede GPU:

• Hält immer noch vollständige Modellparameter und -verläufe
• Nur Geschäfte 1/N der Optimiererzustände (N = Anzahl der GPUs)
• Aktualisiert nur das entsprechende 1/N der Parameter

Dies ist die Reihenfolge der während des Trainings durchgeführten Aktionen:

1. Vorwärtspass: Jede GPU verarbeitet ihren eigenen Mikrobatch
2. Rückwärtspass: Berechnen Sie Farbverläufe
3. all-reduce Steigungen: Jede GPU erhält alle Farbverläufe
4. Optimierungsschritt: Jede GPU aktualisiert ihre Parameterpartition
5. all-gather Parameter: Synchronisieren Sie das aktualisierte Modell über GPUs hinweg

Hier ist eine vereinfachte Implementierung:

import torch
import torch.distributed as dist


class ZeRO_1:
    def __init__(self, mannequin, optimizer_cls):
        self.mannequin = mannequin
        self.rank = dist.get_rank()
        self.world_size = dist.get_world_size()

        self.param_shards = listing()  # every rank holds solely its shard of the optimizer states
        self.param_metadata = listing()  # metadata to reconstruct shards

        for param in self.mannequin.parameters():
            original_shape = param.information.form
            flat = param.information.view(-1)
            numel = flat.numel()

            the rest = numel % self.world_size
            pad_size = (self.world_size - the rest) % self.world_size
            padded_numel = numel + pad_size
            shard_size = padded_numel // self.world_size

            shard_start = self.rank * shard_size
            shard_end = shard_start + shard_size

            self.param_metadata.append(
                {
                    "original_shape": original_shape,
                    "numel": numel,
                    "padded_numel": padded_numel,
                    "shard_size": shard_size,
                    "shard_start": shard_start,
                    "shard_end": shard_end,
                }
            )

            if pad_size > 0:
                flat_padded = torch.cat((flat, flat.new_zeros(pad_size)))
            else:
                flat_padded = flat

            shard = flat_padded(shard_start:shard_end).clone()
            shard.requires_grad_(True)
            self.param_shards.append(shard)

        self.optimizer = optimizer_cls(self.param_shards)

    def training_step(self, inputs, targets, loss_fn):
        output = self.mannequin(inputs) # ahead
        loss = loss_fn(output, targets) # compute loss
        loss.backward() # backward

        self._sync_gradients()  # all-reduce gradients throughout GPUs
        self.optimizer.step() # replace native shard of parameters
        self._sync_params() # all collect mannequin params

        # clear gradients for the subsequent step
        for param in self.mannequin.parameters():
            param.grad = None

    def _sync_gradients(self):
        for idx, param in enumerate(self.mannequin.parameters()):
            meta = self.param_metadata(idx)

            dist.all_reduce(param.grad, op=dist.ReduceOp.SUM)
            param.grad /= self.world_size

            self.param_shards(idx).grad = param.grad.view(-1)(meta("shard_start"):meta("shard_end"))

    def _sync_params(self):
        for idx, param in enumerate(self.mannequin.parameters()):
            meta = self.param_metadata(idx)

            full_flat = torch.empty(meta("padded_numel"), gadget=param.gadget, dtype=param.dtype)
            dist.all_gather_into_tensor(
                output_tensor=full_flat,
                input_tensor=self.param_shards(idx).information,
            )
            
            reconstructed = full_flat(:meta("numel")).view(meta("original_shape"))
            param.information.copy_(reconstructed)

Beachten Sie, dass die all-reduce synchronisiert alle Farbverläufe, aber jede GPU verwendet die Farbverläufe nur für ihre eigene Parameterpartition, es kommt zu einer Überkommunikation. ZeRO-2 behebt dieses Drawback, indem es auch die Farbverläufe aufteilt.

In der Praxis würden Sie ZeRO-1 niemals verwenden, da Sie mit ZeRO-2 bei im Wesentlichen gleichen Kosten bessere Speichereinsparungen erzielen. Aber es lohnt sich trotzdem, es zu Lernzwecken noch einmal durchzugehen.

Speicher mit ZeRO-1, 7B-Modell, 8 GPUs:

• Parameter: 28 GB (vollständig repliziert)
• Farbverläufe: 28 GB (vollständig repliziert)
• Optimierer gibt an: 56 GB / 8 = 7 GB
• Insgesamt professional GPU: 63 GB (von GB)

ZeRO-2: Gradientenpartitionierung

ZeRO-2 partitioniert beide Optimiererzustände und Farbverläufe. Da jede GPU nur eine Partition von Parametern aktualisiert, benötigt sie nur die entsprechenden Farbverläufe.

ZeRO-1 verwendet all-reducewas jeder GPU alle Farbverläufe verleiht. ZeRO-2 ersetzt dies durch reduce-scattererhält jede GPU nur die Farbverläufe, die sie tatsächlich benötigt. Dies spart sowohl Speicher als auch Kommunikationsbandbreite.

Trainingsschritte:

1. Vorwärtspass: Jede GPU verarbeitet ihren eigenen Mikrobatch
2. Rückwärtspass: Berechnen Sie Farbverläufe
3. reduce-scatter Steigungen: Jede GPU erhält nur ihre Partition
4. Optimierungsschritt: Jede GPU aktualisiert ihre Parameterpartition
5. all-gather Parameter: Synchronisieren Sie das aktualisierte Modell über GPUs hinweg

Die Implementierung ist ZeRO-1 sehr ähnlich, verwendet jedoch den Gradientensynchronisationsschritt reduce-scatter anstatt all-reduce:
Aber Second, wenn jede GPU während des Backprops alle Farbverläufe berechnet, wie spart das dann tatsächlich VRAM? So geht’s:

• Da die Parameterverläufe Schicht für Schicht berechnet werden, sind sie sofort sichtbar reduce-scattered und die lokale Kopie wird freigegeben (unsere vereinfachte Implementierung führt dies nicht durch).
• Beim Backprop benötigen Sie nur den Gradienten der nächsten Neuronenaktivierung, um den Gradienten des aktuellen Parameters zu berechnen, dh Sie benötigen nicht das gesamte Gradientendiagramm.
• Auf diese Weise können Sie den Speicher für Farbverläufe freigeben, während Sie sich rückwärts bewegen, wobei nur die zugewiesene Partition für jede GPU erhalten bleibt.

Speicher mit ZeRO-2, 7B-Modell, 8 GPUs:

• Parameter: 28 GB (vollständig repliziert)
• Farbverläufe: 28 GB / 8 = 3,5 GB
• Optimierer gibt an: 56 GB / 8 = 7 GB
• Gesamt professional GPU: 38,5 GB (vorher 112 GB)

ZeRO-3: Parameterpartitionierung

ZeRO-3 partitioniert Optimiererzustände, -verläufe usw Parameter. Jede GPU speichert nur 1/N des gesamten Modellstatus.

Bei Vorwärts- und Rückwärtsdurchläufen benötigt jede Schicht ihre vollständigen Parameter, aber jede GPU speichert nur einen Bruchteil. Additionally wir Alle Parameter Simply-in-Time erfassenverwenden Sie sie und entsorgen Sie sie sofort danach.

Trainingsschritte:

• Vorwärtspass:
  • Sammeln Sie alle Parameter der Ebene von allen GPUs
  • Führen Sie den Vorwärtsdurchlauf der Ebene aus und verwenden Sie dabei die Aktivierungen der vorherigen Ebene als Eingabe
  • Verwerfen Sie die gesammelten Parameter (behalten Sie nur die lokale Partition bei)
  • Wiederholen Sie diese Schritte, bis alle Schichten fertig sind

• Rückwärtsdurchlauf (professional Schicht, rückwärts):
  • Erfassen Sie erneut alle Parameter der Ebene
  • Berechnen Sie die Farbverläufe für die aktuelle Ebene mithilfe der Aktivierungsgradienten der nächsten Ebene
  • Reduzieren Sie die Streuung der Farbverläufe (jede GPU behält ihren Shard)
  • Verwerfen Sie die gesammelten Parameter (behalten Sie nur die lokale Partition bei)
  • Wiederholen Sie diese Schritte, bis alle Schichten fertig sind

• Jede GPU führt einen Optimierungsschritt auf ihrer Partition aus
• Es ist keine abschließende Gesamterfassung erforderlich, da die Parameter während des Vorwärtsdurchlaufs Schicht für Schicht erfasst werden

Hier ist eine vereinfachte Implementierung:

class ZeRO_3(ZeRO_2):
    """
    ZeRO-3: Shard optimizer states (stage 1) + gradients (stage 2) + mannequin parameters (stage 3).

    At relaxation, every rank holds solely param_shards(idx) — a 1/world_size slice
    of every parameter. Full parameters are materialised briefly throughout
    the ahead and backward passes by way of all_gather, then instantly freed.
    """

    def __init__(self, mannequin, optimizer_cls):
        self.mannequin = mannequin
        self.rank = dist.get_rank()
        self.world_size = dist.get_world_size()

        self.param_metadata = ()
        shard_list = ()

        self._param_to_idx = {}

        for idx, param in enumerate(self.mannequin.parameters()):
            original_shape = param.information.form
            flat = param.information.view(-1)
            numel = flat.numel()

            the rest = numel % self.world_size
            pad_size = (self.world_size - the rest) % self.world_size
            padded_numel = numel + pad_size
            shard_size = padded_numel // self.world_size

            shard_start = self.rank * shard_size
            shard_end = shard_start + shard_size

            self.param_metadata.append(
                {
                    "original_shape": original_shape,
                    "numel": numel,
                    "padded_numel": padded_numel,
                    "shard_size": shard_size,
                    "shard_start": shard_start,
                    "shard_end": shard_end,
                }
            )

            if pad_size > 0:
                flat_padded = torch.cat((flat, flat.new_zeros(pad_size)))
            else:
                flat_padded = flat

            shard = flat_padded(shard_start:shard_end).clone()
            shard_list.append(shard)

            # Substitute the total tensor with solely this rank's shard.
            # The mannequin's param.information now factors to a tiny slice; the total
            # weight will likely be reconstructed on demand throughout ahead/backward.
            param.information = shard.detach()
            self._param_to_idx(param) = idx

        self.param_shards = (s.requires_grad_(True) for s in shard_list)
        self.optimizer = optimizer_cls(self.param_shards)

        self._register_hooks()

    def _gather_param(self, idx, gadget, dtype):
        """All-gather the total parameter tensor for parameter `idx`."""
        meta = self.param_metadata(idx)
        full_flat = torch.empty(meta("padded_numel"), gadget=gadget, dtype=dtype)
        dist.all_gather_into_tensor(
            output_tensor=full_flat,
            input_tensor=self.param_shards(idx).information,
        )
        return full_flat(: meta("numel")).view(meta("original_shape"))

    def _gather_module_params(self, module):
        """Collect full params for each parameter that belongs to this module solely (not kids)."""
        for param in module.parameters(recurse=False):
            idx = self._param_to_idx(param)
            param.information = self._gather_param(idx, param.gadget, param.dtype)

    def _reshard_module_params(self, module):
        """Reshard params again to native shard for each direct param of this module."""
        for param in module.parameters(recurse=False):
            idx = self._param_to_idx(param)
            param.information = self.param_shards(idx).information

    def _register_hooks(self):
        self._hooks = ()
        for module in self.mannequin.modules():
            # Skip container modules that haven't any direct parameters
            if not listing(module.parameters(recurse=False)):
                proceed

            # Ahead: collect -> run -> reshard
            h1 = module.register_forward_pre_hook(
                lambda mod, _inputs: self._gather_module_params(mod)
            )
            h2 = module.register_forward_hook(
                lambda mod, _inputs, _output: self._reshard_module_params(mod)
            )

            # Backward: collect earlier than grad computation → reshard after
            h3 = module.register_full_backward_pre_hook(
                lambda mod, _grad_output: self._gather_module_params(mod)
            )
            h4 = module.register_full_backward_hook(
                lambda mod, _grad_input, _grad_output: self._reshard_module_params(mod)
            )

            self._hooks.lengthen((h1, h2, h3, h4))

    def training_step(self, inputs, targets, loss_fn):
        # Hooks deal with all collect/reshard round every module robotically
        output = self.mannequin(inputs)
        loss = loss_fn(output, targets)
        loss.backward()

        self._sync_gradients()

        # Every rank updates solely its native shard
        self.optimizer.step()

        for param in self.mannequin.parameters():
            param.grad = None

Die Parameter jeder Ebene werden unmittelbar vor ihrem Bedarf erfasst und unmittelbar danach freigegeben. Dadurch wird der Spitzenspeicher auf ein Minimal reduziert, allerdings auf Kosten einer höheren Kommunikation. In der Praxis überlappen Implementierungen das All-Collect für Layer N+1 mit dem Ahead von Layer N, um die Latenz zu verbergen.

Speicher mit ZeRO-3, 7B-Modell, 8 GPUs:

• Parameter: 28 GB / 8 = 3,5 GB
• Farbverläufe: 28 GB / 8 = 3,5 GB
• Optimierer gibt an: 56 GB / 8 = 7 GB
• Insgesamt professional GPU: 14 GB (vorher 112 GB)

Das ist ein 8-fache Reduzierung bei der Speichernutzung, was genau das ist, was wir von einer Partitionierung auf 8 GPUs erwarten würden.

Verwendung von ZeRO in PyTorch

PyTorch wird mit zwei Implementierungen von ZeRO-3 ausgeliefert: FSDP1 (älter, weniger optimiert) und FSDP2 (neuer, empfohlen). Verwenden Sie immer FSDP2.

FSDP (Absolutely Sharded Knowledge Parallel) übernimmt automatisch die Parametererfassung, Gradientenstreuung, Kommunikationsüberlappung und Speicherverwaltung:

from torch.distributed.fsdp import fully_shard

mannequin = Transformer()
for layer in mannequin.layers:
    fully_shard(layer)
fully_shard(mannequin)

Sie müssen sich bewerben fully_shard Schicht für Schicht und wickeln Sie dann das gesamte Modell ein.

Abschluss

ZeRO tauscht Erinnerung gegen Kommunikation aus, es ist additionally kein kostenloses Mittagessen. Im Allgemeinen lohnt es sich für kleinere Modelle (z. B. BERT) nicht, aber für größere Modelle ist es ein Recreation Changer.

Herzlichen Glückwunsch, dass Sie es bis zum Ende geschafft haben! In diesem Beitrag haben Sie Folgendes erfahren:

• Das Speicherredundanzproblem im Commonplace-DDP
• Wie ZeRO Optimiererzustände, Verläufe und Parameter auf GPUs verteilt
• Die drei Phasen von ZeRO und ihre Kompromisse zwischen Gedächtnis und Kommunikation
• So verwenden Sie ZeRO-3 über PyTorchs FSDP

Im nächsten Artikel befassen wir uns mit der Tensor-Parallelität, einer Modellparallelitätstechnik, die die Berechnung einer Ebene beschleunigt, indem sie die Arbeit auf GPUs verteilt.

Referenzen

1. ZeRO: Speicheroptimierungen für das Coaching von Billionen-Parametermodellen (Originalpapier)
2. PyTorch FSDP-Tutorial
3. FSDP-API-Referenz
4. Das Extremely-Scale-Playbook von Huggging Face

ist Teil einer Serie über verteilte KI über mehrere GPUs:

Einführung

Bevor wir uns mit fortgeschrittenen Parallelitätstechniken befassen, müssen wir die Schlüsseltechnologien verstehen, die es GPUs ermöglichen, miteinander zu kommunizieren.

Aber warum müssen GPUs überhaupt kommunizieren? Beim Coaching von KI-Modellen auf mehreren GPUs verarbeitet jede GPU unterschiedliche Datenstapel, aber alle müssen synchronisiert bleiben, indem sie während der Backpropagation Farbverläufe teilen oder Modellgewichte austauschen. Die Einzelheiten darüber, was wann kommuniziert wird, hängen von Ihrer Parallelitätsstrategie ab, die wir in den nächsten Blogbeiträgen ausführlich untersuchen werden. Bedenken Sie vorerst nur, dass modernes KI-Coaching kommunikationsintensiv ist und eine effiziente Datenübertragung von GPU zu GPU für die Leistung von entscheidender Bedeutung ist.

Der Kommunikationsstapel

PCIe

NVLink

Hinweis: auf NVLink für die CPU-GPU-Kommunikation

Bestimmte CPU-Architekturen unterstützen NVLink als PCIe-Ersatz und beschleunigen die CPU-GPU-Kommunikation erheblich, indem der PCIe-Engpass bei Datenübertragungen überwunden wird, z. B. beim Verschieben von Trainingsstapeln von der CPU auf die GPU. Diese CPU-GPU-NVLink-Funktion macht CPU-Offloading (eine Technik, die VRAM spart, indem Daten stattdessen im RAM gespeichert werden) für reale KI-Anwendungen praktisch. Da die Skalierung des RAM in der Regel kostengünstiger ist als die Skalierung des VRAM, bietet dieser Ansatz erhebliche wirtschaftliche Vorteile.

Zu den CPUs mit NVLink-Unterstützung gehören IBM POWER8, POWER9 und NVIDIA Grace.

Allerdings gibt es einen Haken. In einem Server mit 8x H100 muss jede GPU mit 7 anderen kommunizieren und diese 900 GB/s auf sieben Punkt-zu-Punkt-Verbindungen mit jeweils etwa 128 GB/s aufteilen. Hier kommt NVSwitch ins Spiel.

NVSwitch

InfiniBand

Lineare Skalierung verstehen

Die Bedeutung der Überschneidung von Pc und Kommunikation

Intra-Node vs. Inter-Node: Die Efficiency-Klippe

Folgen Sie mir auf X für weitere kostenlose KI-Inhalte @l_cesconetto

Herzlichen Glückwunsch, dass Sie es bis zum Ende geschafft haben! In diesem Beitrag haben Sie Folgendes erfahren:

• Die Grundlagen der CPU-GPU- und GPU-GPU-Kommunikation:
  • PCIe, NVLink, NVSwitch und InfiniBand
• Wichtige Designprinzipien für verteiltes GPU-Computing
• Sie sind jetzt in der Lage, beim Entwerfen Ihrer KI-Workloads wesentlich fundiertere Entscheidungen zu treffen

Im nächsten Blogbeitrag befassen wir uns mit unserer ersten Parallelitätstechnik, der Distributed Knowledge Parallelism.

1. NVIDIA-Weblog
2. GPU Direct

ist Teil einer Serie über verteilte KI über mehrere GPUs:

• Teil 1: Das Host- und Geräteparadigma verstehen
• Teil 2: Punkt-zu-Punkt- und Sammeloperationen (dieser Artikel)
• Teil 3: Wie GPUs kommunizieren (kommt bald)
• Teil 4: Gradientenakkumulation und verteilte Datenparallelität (DDP) (kommt bald)
• Teil 5: ZeRO (kommt bald)
• Teil 6: Tensorparallelität (kommt bald)

Einführung

Im vorherigen Beitrag haben wir das Host-Gerät-Paradigma etabliert und das Konzept der Ränge für Multi-GPU-Workloads eingeführt. Jetzt untersuchen wir die spezifischen Kommunikationsmuster, die PyTorch bietet torch.distributed Modul zur Koordinierung der Arbeit und zum Datenaustausch zwischen diesen Ebenen. Diese Operationen, bekannt als Kollektivesind die Bausteine ​​verteilter Workloads.

Obwohl PyTorch diese Vorgänge offenlegt, ruft es letztendlich ein Backend-Framework auf, das die Kommunikation tatsächlich implementiert. Für NVIDIA-GPUs ist es so NCCL (NVIDIA Collective Communications Library), während es sich bei AMD um RCCL (ROCm Communication Collectives Library) handelt.

NCCL implementiert Multi-GPU- und Multi-Node-Kommunikationsprimitive, die für NVIDIA-GPUs und Netzwerke optimiert sind. Es erkennt automatisch die aktuelle Topologie (Kommunikationskanäle wie PCIe, NVLink, InfiniBand) und wählt die effizienteste aus.

Haftungsausschluss 1: Da NVIDIA-GPUs am häufigsten vorkommen, konzentrieren wir uns auf die NCCL Backend für diesen Beitrag.

Haftungsausschluss 2: Der Kürze halber stellt der unten dargestellte Code nur die Hauptargumente jeder Methode anstelle aller verfügbaren Argumente bereit.

Haftungsausschluss 3: Der Einfachheit halber zeigen wir nicht die Speicherfreigabe von Tensoren, sondern Operationen wie scatter wird den Speicher des Quellrangs nicht automatisch freigeben (wenn Sie nicht verstehen, was ich meine, ist das in Ordnung, es wird sehr bald klar werden).

Kommunikation: Blockieren vs. Nicht-Blockieren

Um zusammenzuarbeiten, müssen GPUs Daten austauschen. Die CPU initiiert die Kommunikation, indem sie NCCL-Kernel in CUDA-Streams einreiht (wenn Sie nicht wissen, was CUDA-Streams sind, schauen Sie sich die an erster Blogbeitrag dieser Serie), aber die eigentliche Datenübertragung erfolgt direkt zwischen GPUs über die Verbindung, wobei der Hauptspeicher der CPU vollständig umgangen wird. Idealerweise sind die GPUs mit einer Hochgeschwindigkeitsverbindung wie NVLink oder InfiniBand verbunden (diese Verbindungen werden im behandelt). Dritter Beitrag dieser Serie).

Diese Kommunikation kann synchron (blockierend) oder asynchron (nicht blockierend) sein, was wir weiter unten untersuchen.

Synchrone (blockierende) Kommunikation

Asynchrone (nicht blockierende) Kommunikation

Große „Fallstricke“ in NCCL

rank = torch.distributed.get_rank()
if rank == 0:
   t = torch.tensor((1,2,3), dtype=torch.float32, system=system)
   # torch.distributed.ship(t, dst=1) # No ship operation is carried out
else: # rank == 1 (assuming solely 2 ranks)
   t = torch.empty(3, dtype=torch.float32, system=system)
   torch.distributed.recv(t, src=0) # Blocks solely till enqueued (after first run)
   print("This WILL print if NCCL is warmed-up")
   print
   print("This can NOT print")

One-to-All-Kollektive

Bei diesen Vorgängen sendet ein Rang Daten an alle anderen Ränge in der Gruppe.

Übertragen

• torch.distributed.broadcast(tensor, src): Kopiert einen Tensor aus einem einzelnen Quellrang (src) zu allen anderen Rängen. Jeder Prozess führt zu einer identischen Kopie des Tensors. Der tensor Der Parameter dient zwei Zwecken: (1) wenn der Rang des Prozesses mit dem übereinstimmt srcDie tensor werden die Daten gesendet? (2) andernfalls, tensor dient der Speicherung der empfangenen Daten.

rank = torch.distributed.get_rank()
if rank == 0: # supply rank
  tensor = torch.tensor((1,2,3), dtype=torch.int64, system=system)
else: # vacation spot ranks
  tensor = torch.empty(3, dtype=torch.int64, system=system)
torch.distributed.broadcast(tensor, src=0)

Streuen

• torch.distributed.scatter(tensor, scatter_list, src): Verteilt Datenblöcke von einem Quellrang über alle Ränge. Der scatter_list auf dem Quellrang enthält mehrere Tensoren, und jeder Rang (einschließlich der Quelle) erhält einen Tensor aus dieser Liste in seinen tensor Variable. Die Zielränge gehen einfach vorbei None für die scatter_list.

# The scatter_list should be None for all non-source ranks.
scatter_list = None if rank != 0 else (torch.tensor((i, i+1)).to(system) for i in vary(0,4,2))
tensor = torch.empty(2, dtype=torch.int64).to(system)
torch.distributed.scatter(tensor, scatter_list, src=0)
print(f'Rank {rank} obtained: {tensor}')

All-to-One-Kollektive

Diese Vorgänge sammeln Daten von allen Rängen und konsolidieren sie auf einem einzigen Zielrang.

Reduzieren

• torch.distributed.cut back(tensor, dst, op): Nimmt einen Tensor von jedem Rang und wendet eine Reduktionsoperation an (wie SUM, MAX, MIN) und speichert das Endergebnis auf dem Zielrang (dst) nur.

rank = torch.distributed.get_rank()
tensor = torch.tensor((rank+1, rank+2, rank+3), system=system)
torch.distributed.cut back(tensor, dst=0, op=torch.distributed.ReduceOp.SUM)
print(tensor)

Versammeln

• torch.distributed.collect(tensor, gather_list, dst): Sammelt einen Tensor von jedem Rang in einer Liste von Tensoren auf dem Zielrang. Der gather_list muss eine Liste von Tensoren (richtige Größe und Typ) am Ziel und sein None überall sonst.

# The gather_list should be None for all non-destination ranks.
rank = torch.distributed.get_rank()
world_size = torch.distributed.get_world_size()
gather_list = None if rank != 0 else (torch.zeros(3, dtype=torch.int64).to(system) for _ in vary(world_size))
t = torch.tensor((0+rank, 1+rank, 2+rank), dtype=torch.int64).to(system)
torch.distributed.collect(t, gather_list, dst=0)
print(f'After op, Rank {rank} has: {gather_list}')

Die Variable world_size ist die Gesamtzahl der Ränge. Es kann mit erhalten werden torch.distributed.get_world_size(). Aber machen Sie sich zunächst keine Gedanken über die Implementierungsdetails. Das Wichtigste ist, die Konzepte zu verstehen.

All-to-All-Kollektive

Bei diesen Operationen sendet und empfängt jeder Rang Daten von allen anderen Rängen.

Alles reduzieren

• torch.distributed.all_reduce(tensor, op): Das Gleiche wie cut backaber das Ergebnis wird gespeichert jederRang statt nur ein Ziel.

# Instance for torch.distributed.all_reduce
rank = torch.distributed.get_rank()
tensor = torch.tensor((rank+1, rank+2, rank+3), dtype=torch.float32, system=system)
torch.distributed.all_reduce(tensor, op=torch.distributed.ReduceOp.SUM)
print(f"Rank {rank} after all_reduce: {tensor}")

Alle versammeln sich

• torch.distributed.all_gather(tensor_list, tensor): Das Gleiche wie collectaber die gesammelte Liste der Tensoren ist auf verfügbar jeder Rang.

# Instance for torch.distributed.all_gather
rank = torch.distributed.get_rank()
world_size = torch.distributed.get_world_size()
input_tensor = torch.tensor((rank), dtype=torch.float32, system=system)
tensor_list = (torch.empty(1, dtype=torch.float32, system=system) for _ in vary(world_size))
torch.distributed.all_gather(tensor_list, input_tensor)
print(f"Rank {rank} gathered: {(t.merchandise() for t in tensor_list)}")

Streuung reduzieren

• torch.distributed.reduce_scatter(output, input_list): Äquivalent zur Durchführung einer Reduzierungsoperation für eine Liste von Tensoren und der anschließenden Streuung der Ergebnisse. Jeder Rang erhält einen anderen Teil der reduzierten Leistung.

# Instance for torch.distributed.reduce_scatter
rank = torch.distributed.get_rank()
world_size = torch.distributed.get_world_size()
input_list = (torch.tensor((rank + i), dtype=torch.float32, system=system) for i in vary(world_size))
output = torch.empty(1, dtype=torch.float32, system=system)
torch.distributed.reduce_scatter(output, input_list, op=torch.distributed.ReduceOp.SUM)
print(f"Rank {rank} obtained lowered worth: {output.merchandise()}")

Synchronisation

Die beiden am häufigsten verwendeten Operationen sind request.wait() Und torch.cuda.synchronize(). Es ist wichtig, den Unterschied zwischen diesen beiden zu verstehen:

• request.wait(): Dies wird für asynchrone Vorgänge verwendet. Es synchronisiert den aktuell aktiven CUDA-Stream für diesen Vorgang und stellt sicher, dass der Stream auf den Abschluss der Kommunikation wartet, bevor er fortfährt. Mit anderen Worten: Es blockiert den aktuell aktiven CUDA-Stream, bis die Datenübertragung abgeschlossen ist. Auf der Host-Seite bewirkt es nur, dass der Host wartet, bis der Kernel in die Warteschlange gestellt wird; der Gastgeber tut es nicht Warten Sie, bis die Datenübertragung abgeschlossen ist.
• torch.cuda.synchronize(): Dies ist ein energischerer Befehl, der den Host-CPU-Thread bis pausiert alle Zuvor auf der GPU eingereihte Aufgaben sind abgeschlossen. Es stellt sicher, dass die GPU vollständig im Leerlauf ist, bevor die CPU weitermacht, kann jedoch bei unsachgemäßer Verwendung zu Leistungsengpässen führen. Wann immer Sie Benchmark-Messungen durchführen müssen, sollten Sie diese verwenden, um sicherzustellen, dass Sie genau den Second erfassen, in dem die GPUs fertig sind.

Abschluss

Herzlichen Glückwunsch, dass Sie es bis zum Ende geschafft haben! In diesem Beitrag haben Sie Folgendes erfahren:

• Punkt-zu-Punkt-Operationen
• Synchronisierung und Asynchronisierung in NCCL
• Kollektive Operationen
• Synchronisationsmethoden

Im nächsten Blogbeitrag befassen wir uns mit PCIe, NVLink und anderen Mechanismen, die die Kommunikation in einer verteilten Umgebung ermöglichen!

Referenzen