Sie sagen es Ihrer KI „Polieren Sie meine E-Mail und senden Sie sie.“

1. A Chatbot gibt Ihnen einen Absatz darüber, wie das gemacht wird.
2. Ein Agentisches LLM öffnet Ihren Posteingang und versucht es. Manchmal funktioniert es. Manchmal klickt es dreimal auf die falsche Schaltfläche.
3. A Großes Aktionsmodell macht es einfach, bestätigt und geht weiter.

Gleicher Satz, drei Ergebnisse. Die Kluft dazwischen Große Aktionsmodelle (LAMs) Und Agentische LLMs ist heute einer der praktisch wichtigsten Unterschiede in der KI und auch einer der am wenigsten klar erklärten.

In diesem Artikel beseitigen wir die Verwirrung durch eine einfache Aufschlüsselung des Aufbaus der einzelnen Systeme und eine klare Anleitung, wann welches System zu verwenden ist.

Was ist ein Agentic LLM?

Ein LLM wie ChatGPT, Claude oder Gemini ist im Grunde ein Wortprädiktor. Es liest den Kontext und erzeugt das nützlichste nächste Token. Seine Kraft entsteht dadurch, dass er dies in großem Maßstab tut.

Bei einem Agenten-LLM handelt es sich um dasselbe Modell, das mit Werkzeugen in eine Argumentationsschleife eingefügt wird. Es liest ein Ziel, wählt ein Werkzeug aus, liest das Ergebnis und entscheidet, was als nächstes zu tun ist, bis die Aufgabe abgeschlossen ist oder etwas fehlschlägt. Diese Schleife wird oft als ReAct bezeichnet: Grund, Akt, beobachten.

Es ist wichtig zu verstehen, dass sich das Modell selbst nicht geändert hat. Entfernen Sie die Schleife, Tooldefinitionen, Eingabeaufforderungen und Orchestrierungscode, und schon sind Sie wieder bei einem Chatbot. Die Handlungsfähigkeit lebt im Gerüst.

Das macht die Umnutzung leistungsstark: Dasselbe Modell kann ohne Umschulung Kopien schreiben, Code debuggen oder eine API aufrufen. Aber die Zuverlässigkeit leidet. Es kann das falsche Werkzeug auswählen, Parameter erfinden oder in Schleifen stecken bleiben. In der Produktion sind diese Fehler keine Randfälle. Es sind die Vorfälle um 2 Uhr morgens.

Wenn Sie die Schleife und die Instruments weglassen, wird ein Agenten-LLM wieder zu einem Chatbot. Das „Tun“ lebt in der Hülle, nicht im Modell.

Was ist ein großes Aktionsmodell?

Ein LAM geht das Drawback anders an. Anstatt ein Sprachmodell zu nehmen und es zum Handeln zu überreden, trainieren Sie ein Modell, bei dem es darum geht, korrekte, ausführbare Aktionen zu erzeugen Hauptziel vom ersten Tag an.

Die Trainingsdaten sind unterschiedlich. Ein Normal-LLM wird auf Net-Scale-Textual content trainiert. Ein LAM wird auf Aktionsverläufe trainiert: Klicks, API-Aufrufe, UI-Interaktionen und mehrstufige Aufgabenabschlüsse. Salesforces Agent Ohana Die Pipeline wurde entwickelt, um diese Artwork von Aktionsdaten in einem Trainingsformat zu vereinen. Das Modell lernt, wie eine gute Actionsequenz aussieht, nicht nur ein guter Satz.

Die Architektur verfolgt das gleiche Ziel. Die meisten LAMs verwenden einen Wahrnehmen-Plan-Handeln-Lern-Zyklus: Lesen Sie die Umgebung, das Ziel brechen, eine Aktion durchführenUnd den Plan aktualisieren. Es ähnelt der Agenten-LLM-Schleife, das Verhalten wird jedoch in das Modell eingelernt und nicht durch Orchestrierungscode angeschraubt.

Spezialisierung führt zu überraschender Effizienz. xLAM-1B von Salesforce, ein 1-Milliarde-Parameter-Modell mit dem Spitznamen „Tiny Large“, übertrifft GPT-3.5 bei Funktionsaufruf-Benchmarks und ist dabei etwa 175-mal kleiner. Wenn das Trainingsziel mit der Bereitstellungsaufgabe übereinstimmt, brauchen Sie keine Skalierung, um zu gewinnen.

Sind sie nicht dasselbe?

Das ist eine berechtigte Frage, und an den Rändern verschwimmt die Grenze wirklich. Ein Agenten-LLM mit starker Feinabstimmung von Funktionsaufrufen kann einem LAM sehr ähneln. Einige Produkte verwenden „LAM“ als Marketingbegriff für etwas, das schlicht ein verpacktes GPT mit einigen Tooldefinitionen ist.

Die sinnvolle Unterscheidung liegt darin, wo die Handlungsfähigkeit ihren Ursprung hat:

Die stärksten Produktionssysteme im Jahr 2026 werden sich nicht zwischen beiden entscheiden. Sie verwenden einen Agenten-LLM für die Argumentation und offene Interpretation und leiten dann hochriskante Aktionen wie Zahlungen, Datenänderungen oder API-Aufrufe über einen geschützten LAM.

Direkter Vergleich

Welches sollten Sie verwenden?

Die praktische Frage ist, ob der Aktionsraum offen oder geschlossen ist. Wenn die Aktionen des Techniques begrenzt und im Voraus bekannt sind, wie z. B. feste APIs, UI-Workflows oder Geschäftsprozesse, ist ein Modell im LAM-Stil normalerweise zuverlässiger, schneller und kostengünstiger professional Vorgang.

Wenn die Aufgabe ein offenes Ende hat oder ein umfassendes Sprachverständnis innerhalb der Schleife erfordert, bietet Ihnen ein Agenten-LLM mehr Flexibilität.

Greifen Sie nach einem Agent LLM, wenn:

• Die Aufgabe ist offen oder schlecht definiert
• Werkzeugdefinitionen ändern sich häufig
• Sie brauchen starke Argumente und Taten
• Sie erstellen Prototypen und wünschen sich eine schnelle Iteration

Greifen Sie zu einem LAM, wenn:

• Der Aktionsraum ist fest und klar definiert
• Eine falsche Handlung hat echte Konsequenzen
• Latenz, Kosten oder Bereitstellung auf dem Gerät spielen eine Rolle
• Sie benötigen eine vorhersehbare, überprüfbare Ausführung

Häufig gestellte Fragen

In PythonDie Move -Erklärung ist ein einfaches, aber leistungsstarkes Software, das als Platzhalter in Ihrem Code verwendet wird. Sie können einen Codeblock erstellen, der nichts tut, was während des Entwicklungsprozesses besonders nützlich sein kann. Egal, ob Sie zukünftige Funktionen planen oder Ihren Code strukturieren, die move Die Erklärung hilft bei der Aufrechterhaltung der syntaktischen Korrektheit, ohne Operationen auszuführen.

Was ist die Move -Erklärung?

Die Move -Erklärung in Python ist ein einzigartiges Merkmal, das als Platzhalter für zukünftige Code dient. Es ermöglicht Entwicklern, den syntaktisch korrekten Code zu schreiben, ohne die Funktionalität sofort zu implementieren. Dies ist besonders nützlich in Szenarien, in denen eine Aussage syntaktisch erforderlich ist, aber in diesem Second ist keine Aktion erwünscht.

Der move Aussage ist im Wesentlichen eine Nulloperation; Bei der Ausführung führt es keine Aktion aus. Es wird häufig in verschiedenen Programmierkonstrukten verwendet, darunter:

• Funktionsdefinitionen: Wenn Sie eine Funktion definieren müssen, aber ihre Logik noch nicht implementiert haben.
• Klassendefinitionen: Zum Erstellen von Klassen, die später ausgearbeitet werden.
• Schleifen: In Kontrollflussanweisungen, in denen Sie bestimmte Iterationen überspringen möchten, ohne Code auszuführen.
• Bedingte Aussagen: In ifAnwesend elifoder else Blöcke, bei denen keine Aktion für einen bestimmten Zustand erforderlich ist.

Syntax

Die Syntax für die move Aussage ist einfach:

move

Warum verwenden wir die Passanweisung?

Die Hauptgründe für die Verwendung der move Aussage enthalten:

• Codestruktur aufrechterhalten: Es ermöglicht den Entwicklern, das Skelett ihres Codes zu erstellen, ohne jedes Element sofort ausfüllen zu müssen. Dies kann besonders nützlich in den anfänglichen Entwicklungsstadien sein.
• Verhinderung von Syntaxfehlern: Python benötigt bestimmte Codeblöcke (wie Funktionen, Schleifen und Bedingungen), um mindestens eine Anweisung zu enthalten. Verwendung move verhindert Syntaxfehler in diesen Fällen.
• Verbesserung der Lesbarkeit: Durch Verwendung moveEntwickler signalisieren anderen (oder sich selbst), dass dieser Codeabschnitt absichtlich unvollständig bleibt und später angesprochen wird.
• Erleichterung inkrementeller Entwicklung: Entwickler können ihre Codebasis inkrementell erstellen, indem sie die Funktionalität im Laufe der Zeit hinzufügen, ohne sich Gedanken darüber zu machen, vorhandene Syntaxregeln zu brechen.
• Platzhalter für zukünftige Logik: Es erinnert daran, dass mehr Arbeit zu erledigen ist und bei der Planung und Organisation innerhalb des Codes hilft.

Vorteile der Verwendung move

• Code -Lesbarkeit: Es zeigt an, dass ein Teil Ihres Codes absichtlich unvollständig gelassen wird, sodass jeder, der Ihren Code liest, deutlich wird.
• Syntaktischer Platzhalter: Es ermöglicht Ihnen, den syntaktisch korrekten Code zu schreiben, ohne die Funktionalität sofort zu implementieren.

Beispiele für die Nutzung der Python -Move -Erklärung

Im Folgenden sehen wir verschiedene Beispiele für die Nutzung der Move -Erklärung:

Funktionsdefinitionen

Wenn Sie eine Funktion definieren, die Sie später implementieren möchten, können Sie die verwenden move Erklärung als Platzhalter. Auf diese Weise können Sie die Funktionsstruktur einrichten, ohne die vollständige Implementierung sofort schreiben zu müssen.

def my_function():
    move  # Placeholder for future implementation

Hier, my_function ist definiert, tut aber nichts, wenn es aufgerufen wird, weil es nur die enthält move Stellungnahme. Dies ist in den ersten Entwicklungsstadien nützlich, wenn Sie Ihre Funktionen skizzieren möchten, ohne sich in den Particulars zu verleihen.

Klassendefinitionen

Der move Die Anweisung kann auch in Klassendefinitionen verwendet werden, was besonders hilfreich ist, wenn Sie eine Klasse erstellen möchten, die später mit Attributen und Methoden ausgearbeitet wird.

class MyClass:
    move  # No attributes or strategies outlined but

In diesem Beispiel, MyClass ist definiert, hat aber keine Attribute oder Methoden. Auf diese Weise können Sie eine Klassenstruktur festlegen, auf die Sie später erweitern können, ohne Syntaxfehler zu verursachen.

In bedingten Aussagen

Sie können auf Szenarien stoßen, in denen bestimmte Bedingungen überprüft werden müssen. Für bestimmte Fälle sind jedoch keine Maßnahmen erforderlich. Die Python -Move -Erklärung kann hier verwendet werden, um anzuzeigen, dass unter bestimmten Bedingungen nichts passieren sollte.

x = 10
if x > 5:
    move  # Future logic will go right here
else:
    print("x shouldn't be better than 5")

In diesem Code -Snippet, wenn x ist größer als 5, das Programm tut nichts (aufgrund der move Stellungnahme). Wenn x waren nicht größer als 5, es würde eine Nachricht drucken. Diese Struktur ermöglicht es, zukünftige Logik hinzuzufügen, ohne den Stromfluss zu stören.

In Schleifen

In Schleifen möchten Sie möglicherweise bestimmte Iterationen auf der Grundlage einer Bedingung überspringen, ohne Code für diese Iterationen auszuführen. Der move Die Erklärung dient in solchen Fällen als Platzhalter.

for i in vary(5):
    if i == 3:
        move  # Do nothing when i equals 3
    else:
        print(i)

Diese Schleife iteriert über Zahlen von 0 bis 4. Wann i gleich 3, die move Die Aussage wird ausgeführt, was bedeutet, dass während dieser Iteration nichts passiert. Für alle anderen Werte von ies druckt die Nummer. Mit dieser Struktur können Sie explizit angeben, dass Sie absichtlich eine Iteration überspringen, ohne Maßnahmen auszuführen.

In Ausnahmebehandlung

Der move Die Anweisung kann auch in Ausnahmebehandlungsblöcken verwendet werden, in denen Sie möglicherweise nicht sofort eine Ausnahme abwickeln möchten, aber dennoch einen gültigen Codeblock benötigen.

strive:
    risky_code()
besides ValueError:
    move  # Deal with ValueError later

In diesem Beispiel, wenn risky_code() Erhöht a ValueErrorDas Programm wird die ausführen move Anweisung anstatt zu stürzen oder eine Aktion auszuführen. Auf diese Weise können Entwickler anerkennen, dass sie diese Ausnahme später abwickeln müssen, ohne den Fluss ihres Programms zu unterbrechen.

Häufige Fallstricke und Finest Practices

Lassen Sie uns nun die gemeinsamen Fallstricke und Finest Practices untereinander untersuchen:

Häufige Fallstricke

• Überbeanspruchung move: Obwohl es als Platzhalter nützlich ist, kann es zu einem zu hohen Verlassenen zu einem unvollständigen Code führen, der möglicherweise nie implementiert wird.
• Vernachlässigung zukünftiger Implementierung: Entwickler können vergessen, zu Abschnitten zurückzukehren, die mit gekennzeichnet sind movewas zu unvollendeten Merkmalen oder Logik führt.
• Missbrauch in der Ausnahmebehandlung: Verwenden move In der Ausnahmeregelung kann das Debuggen ohne Protokollierung oder Handhabung erschweren, da Fehler möglicherweise unbemerkt bleiben.

Finest Practices

• Verwenden Sie Kommentare: Bei Verwendung moveErwägen Sie, Kommentare hinzuzufügen, die erklären, was später implementiert werden soll. Dies liefert Kontext und Erinnerungen für die zukünftige Entwicklung.
• Planen Sie Ihre Codestruktur: Verwenden move strategisch in der ersten Planungsphase, aber stellen Sie sicher, dass Sie einen Plan haben, um die Funktionalität später umzusetzen.
• Regelmäßig überprüfen: Überprüfen Sie Ihren Code regelmäßig, um Abschnitte zu identifizieren, die noch enthalten move. Dies hilft sicher, dass alle Teile Ihres Codes letztendlich abgeschlossen sind.
• Kombinieren Sie mit Todos: Erwägen Sie eine Kombination von zu verwenden move und Todo kommentiert (z. B., zB, # TODO: Implement this perform) um zu verfolgen, was getan werden muss.

Abschluss

Der move Die Aussage in Python ist ein wesentliches Instrument für Entwickler, das eine Möglichkeit bietet, Struktur und Lesbarkeit aufrechtzuerhalten und gleichzeitig die zukünftige Entwicklung zu ermöglichen. Es dient als wirksamer Platzhalter in verschiedenen Programmierkonstrukten und erleichtert es, Ihre Gedanken und Pläne in Ihrem Code zu organisieren.

Key Takeaways

• Der move Die Aussage behält nur die syntaktische Korrektheit bei.
• Es ist nützlich in Funktionsdefinitionen, Schleifen, Bedingungen und Klassendefinitionen.
• Verwendung move Verbessert die Code -Lesbarkeit, indem sie unvollständige Abschnitte angegeben.
• Es ermöglicht Entwicklern, ihren Code ohne sofortige Implementierung zu planen.

Häufig gestellte Fragen

Mein Title ist Ayushi Trivedi. Ich bin ein B. Tech -Absolvent. Ich habe 3 Jahre Erfahrung als Pädagoge und Content material -Editor. Ich habe mit verschiedenen Python -Bibliotheken zusammengearbeitet, wie Numpy, Pandas, Seeborn, Matplotlib, Scikit, Underblearn, lineare Regression und vieles mehr. Ich bin auch Autor. Mein erstes Buch mit dem Namen #Turn25 wurde veröffentlicht und ist bei Amazon und Flipkart erhältlich. Hier bin ich bei Analytics Vidhya technischer Content material -Editor. Ich bin stolz und glücklich, Vogel zu sein. Ich habe ein großartiges Staff, mit dem ich arbeiten kann. Ich liebe es, die Brücke zwischen der Technologie und dem Lernenden aufzubauen.

Entwurf asynchroner Pipelines für eine effiziente Datenverarbeitung

10 Minuten Lesezeit

·

vor 19 Stunden

Notiz. Dieser Artikel setzt bereits voraus, dass Sie mit Callbacks und Guarantees vertraut sind und über ein grundlegendes Verständnis des asynchronen Paradigmas in JavaScript verfügen.

Der asynchrone Mechanismus ist eines der wichtigsten Konzepte in JavaScript und der Programmierung im Allgemeinen. Er ermöglicht es einem Programm, sekundäre Aufgaben separat im Hintergrund auszuführen, ohne den aktuellen Thread daran zu hindern, primäre Aufgaben auszuführen. Wenn eine sekundäre Aufgabe abgeschlossen ist, wird ihr Ergebnis zurückgegeben und das Programm wird regular weiter ausgeführt. In diesem Zusammenhang werden solche sekundären Aufgaben genannt asynchron.

Zu asynchronen Aufgaben gehören typischerweise Anfragen an externe Umgebungen wie Datenbanken, Net-APIs oder Betriebssysteme.Wenn das Ergebnis einer asynchronen Operation die Logik des Hauptprogramms nicht beeinflusst, ist es viel besser, diese Zeit nicht zu verschwenden und mit der Ausführung primärer Aufgaben fortzufahren, anstatt einfach zu warten, bis die Aufgabe abgeschlossen ist.

Dennoch kommt es vor, dass das Ergebnis einer asynchronen Operation sofort in den nächsten Codezeilen verwendet wird. In solchen Fällen sollten die nachfolgenden Codezeilen erst ausgeführt werden, wenn die asynchrone Operation abgeschlossen ist.

Notiz. Bevor ich zum Hauptteil dieses Artikels komme, möchte ich die Gründe dafür darlegen, warum Asynchronität als wichtiges Thema in der Datenwissenschaft angesehen wird und warum ich JavaScript anstelle von Python verwendet habe, um die async / await Syntax.

Datentechnik ist ein untrennbarer Teil der Datenwissenschaft, die hauptsächlich aus der Entwicklung robuster und effizienter Datenpipelines besteht. Zu den typischen Aufgaben der Datentechnik gehören regelmäßige Aufrufe von APIs, Datenbanken oder anderen Quellen, um Daten abzurufen, zu verarbeiten und irgendwo zu speichern.

Stellen Sie sich eine Datenquelle vor, die Netzwerkprobleme hat und die angeforderten Daten nicht sofort zurückgeben kann. Wenn wir die Anforderung einfach im Code an diesen Dienst stellen, müssen wir ziemlich lange warten und tun nichts. Wäre das nicht Wäre es beispielsweise besser, keine kostbare Prozessorzeit zu verschwenden und stattdessen eine andere Funktion auszuführen? Hier kommt die Macht der Asynchronität ins Spiel, die das zentrale Thema dieses Artikels sein wird!

Niemand wird die Tatsache leugnen, dass Python derzeit die beliebteste Wahl für die Erstellung von Information Science-Anwendungen ist. Dennoch ist JavaScript eine weitere Sprache mit einem riesigen Ökosystem, das verschiedenen Entwicklungszwecken dient, einschließlich der Erstellung von Webanwendungen, die von anderen Diensten abgerufene Daten verarbeiten. Wie sich herausstellt, spielt Asynchronität eine der grundlegendsten Rollen in JavaScript.

Darüber hinaus verfügt JavaScript im Vergleich zu Python über eine umfassendere integrierte Unterstützung für den Umgang mit Asynchronität und dient im Allgemeinen als besseres Beispiel, um tiefer in dieses Thema einzutauchen.

Schließlich hat Python eine ähnliche async / await Konstruktion. Daher können die in diesem Artikel über JavaScript vorgestellten Informationen auch auf Python übertragen werden, um effiziente Datenpipelines zu entwerfen.

In den ersten Versionen von JavaScript wurde asynchroner Code hauptsächlich mit Callbacks geschrieben. Leider führte dies bei Entwicklern zu einem bekannten Drawback namens „Rückruf Hölle”. Asynchroner Code, der mit einfachen Callbacks geschrieben wurde, führte häufig zu mehreren verschachtelten Codebereichen, die extrem schwer zu lesen waren. Aus diesem Grund führten die JavaScript-Entwickler 2012 Folgendes ein: Versprechen.

// Instance of the "callback hell" downside
functionOne(perform () {
functionTwo(perform () {
functionThree(perform () {
functionFour(perform () {
...
});
});
});
});

Guarantees bieten eine praktische Schnittstelle für die asynchrone Code-Entwicklung. Ein Promise nimmt in einen Konstruktor eine asynchrone Funktion auf, die zu einem bestimmten Zeitpunkt in der Zukunft ausgeführt wird. Bevor die Funktion ausgeführt wird, befindet sich das Promise in einem ausstehend Zustand. Abhängig davon, ob die asynchrone Funktion erfolgreich abgeschlossen wurde oder nicht, ändert das Promise seinen Zustand entweder in erfüllt oder abgelehnt Für die letzten beiden Zustände können Programmierer .then()Und .catch() Methoden mit dem Versprechen, die Logik zu deklarieren, wie das Ergebnis der asynchronen Funktion in verschiedenen Szenarien behandelt werden soll.

Außerdem kann eine Gruppe von Guarantees durch Kombinationsmethoden wie any(), all(), race()usw.

Obwohl Guarantees eine deutliche Verbesserung gegenüber Callbacks darstellen, sind sie aus mehreren Gründen immer noch nicht ultimate:

1. Ausführlichkeit. Guarantees erfordern normalerweise das Schreiben einer Menge Boilerplate-Code. In manchen Fällen erfordert das Erstellen eines Guarantees mit einer einfachen Funktionalität aufgrund der ausführlichen Syntax ein paar zusätzliche Codezeilen.
2. Lesbarkeit. Wenn mehrere Aufgaben voneinander abhängig sind, führt dies dazu, dass Guarantees ineinander verschachtelt werden. Dieses berüchtigte Drawback ist sehr ähnlich dem „Rückrufhölle“ Dies erschwert das Lesen und Warten des Codes. Darüber hinaus ist es bei der Fehlerbehandlung normalerweise schwierig, der Codelogik zu folgen, wenn ein Fehler über mehrere Promise-Ketten propagiert wird.
3. Debuggen. Durch Überprüfen der Stacktrace-Ausgabe kann es schwierig sein, die Fehlerquelle in Guarantees zu identifizieren, da diese normalerweise keine eindeutigen Fehlerbeschreibungen liefern.
4. Integration mit älteren Bibliotheken. Viele ältere Bibliotheken in JavaScript wurden in der Vergangenheit für die Arbeit mit einfachen Callbacks entwickelt, wodurch sie nicht ohne weiteres mit Guarantees kompatibel sind. Wenn Code mithilfe von Guarantees geschrieben wird, sollten zusätzliche Codekomponenten erstellt werden, um die Kompatibilität mit alten Bibliotheken zu gewährleisten.

Zum größten Teil async / await development wurde in JavaScript als synthetischer Zucker anstelle von Guarantees hinzugefügt. Wie der Identify schon sagt, führt es zwei neue Code-Schlüsselwörter ein:

• async wird vor der Funktionssignatur verwendet und markiert die Funktion als asynchron, was immer ein Versprechen zurückgibt (auch wenn ein Versprechen nicht explizit zurückgegeben wird, da es implizit verpackt wird).
• await wird innerhalb von Funktionen verwendet, die als gekennzeichnet sind asynchron und wird im Code vor asynchronen Operationen deklariert, die ein Versprechen zurückgeben. Enthält eine Codezeile den await Schlüsselwort, dann werden die folgenden Codezeilen innerhalb der asynchronen Funktion nicht ausgeführt, bis das zurückgegebene Versprechen erfüllt ist (entweder in der erfüllt oder abgelehnt Zustand)Dadurch wird sichergestellt, dass die folgenden Zeilen nicht ausgeführt werden, wenn ihre Ausführungslogik vom Ergebnis der asynchronen Operation abhängt.

– Der await Schlüsselwort kann innerhalb einer asynchronen Funktion mehrmals verwendet werden.

– Wenn await innerhalb einer Funktion verwendet wird, die nicht als asynchron markiert ist, SyntaxErrorwird geworfen.

– Das zurückgegebene Ergebnis einer Funktion, die mit await es die aufgelöster Wert eines Versprechens.

Der async / await Ein Anwendungsbeispiel wird im folgenden Snippet gezeigt.

// Async / await instance.
// The code snippet prints begin and finish phrases to the console.
perform getPromise() {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve('finish');
},
1000);
});
}
// since this perform is marked as async, it should return a promise
async perform printInformation() {
console.log('begin');
const end result = await getPromise();
console.log(end result) // this line is not going to be executed till the promise is resolved
}

Es ist wichtig zu verstehen, dass await die Ausführung des Haupt-JavaScript-Threads nicht blockiert. Stattdessen unterbricht es nur die einschließende asynchrone Funktion (während anderer Programmcode außerhalb der asynchronen Funktion ausgeführt werden kann).

Fehlerbehandlung

Der async / await Konstruktion bietet eine Standardmethode zur Fehlerbehandlung mit strive / catch Schlüsselwörter. Um Fehler zu behandeln, ist es notwendig, den gesamten Code, der möglicherweise einen Fehler verursachen kann, zu umschließen (einschließlich await Erklärungen) in der strive Block und schreiben Sie entsprechende Deal with-Mechanismen in die catch Block.

In der Praxis ist die Fehlerbehandlung mit strive / catch Blöcke ist einfacher und lesbarer als das gleiche in Versprechen mit zu erreichen .catch() Ablehnungsverkettung.

// Error dealing with template inside an async perform
async perform functionOne() {
strive {
...
const end result = await functionTwo()
} catch (error) {
...
}
}

async / await ist eine großartige Different zu Guarantees. Sie beseitigen die oben genannten Nachteile von Guarantees: Der mit async / await ist normalerweise besser lesbar und wartungsfreundlicher und wird von den meisten Softwareentwicklern bevorzugt.

Es wäre jedoch falsch, die Bedeutung von Guarantees in JavaScript zu leugnen: In manchen Situationen sind sie die bessere Possibility, insbesondere beim Arbeiten mit Funktionen, die standardmäßig ein Promise zurückgeben.

Code-Austauschbarkeit

Betrachten wir den gleichen Code, geschrieben mit async / await und Versprechen. Wir gehen davon aus, dass unser Programm eine Verbindung zu einer Datenbank herstellt und im Falle einer hergestellten Verbindung Daten über Benutzer anfordert, um diese anschließend in der Benutzeroberfläche anzuzeigen.

// Instance of asynchronous requests dealt with by async / await
async perform functionOne() {
strive {
...
const end result = await functionTwo()
} catch (error) {
...
}
}

Beide asynchronen Anfragen können einfach verpackt werden, indem man await Syntax. Bei jedem dieser beiden Schritte stoppt das Programm die Codeausführung, bis die Antwort abgerufen wird.

Da bei asynchronen Anfragen immer etwas schief gehen kann (Verbindungsabbruch, Dateninkonsistenz, and many others.), sollten wir das ganze Codefragment in ein strive / catch Block. Wenn ein Fehler auftritt, zeigen wir ihn auf der Konsole an.

Schreiben wir nun dasselbe Codefragment mit Guarantees:

// Instance of asynchronous requests dealt with by guarantees
perform displayUsers() {
...
connectToDatabase()
.then((response) => {
...
return getData(information);
})
.then((customers) => {
showUsers(customers);
...
})
.catch((error) => {
console.log(`An error occurred: ${error.message}`);
...
});
}

Dieser verschachtelte Code sieht ausführlicher und schwerer lesbar aus. Außerdem können wir feststellen, dass jede await-Anweisung in eine entsprechende then() -Methode und dass sich der Catch-Block nun innerhalb der .catch() Methode eines Versprechens.

Der gleichen Logik folgend, jeder async / await Code kann mit Guarantees umgeschrieben werdenDiese Aussage belegt die Tatsache, dass async / await ist bloß synthetischer Zucker statt Versprechungen.

Mit async / await geschriebener Code kann in die Promise-Syntax umgewandelt werden, wobei jede Await-Deklaration einer separaten .then()-Methode entspricht und die Ausnahmebehandlung in der .catch()-Methode durchgeführt wird.

In diesem Abschnitt werden wir uns ein reales Beispiel ansehen, wie async / await funktioniert.

Wir verwenden die REST-Länder-API das demografische Informationen für ein angefordertes Land im JSON-Format unter der folgenden URL-Adresse bereitstellt: https://restcountries.com/v3.1/identify/$nation.

Lassen Sie uns zunächst eine Funktion deklarieren, die die wichtigsten Informationen aus dem JSON abruft. Wir möchten Informationen zum Namen des Landes, seiner Hauptstadt, seiner Fläche und seiner Bevölkerung abrufen. Das JSON wird in Type eines Arrays zurückgegeben, wobei das erste Objekt alle erforderlichen Informationen enthält. Wir können auf die oben genannten Eigenschaften zugreifen, indem wir auf die Schlüssel des Objekts mit den entsprechenden Namen zugreifen.

const retrieveInformation = perform (information) {
information = information(0)
return {
nation: information("identify")("widespread"),
capital: information("capital")(0),
space: `${information("space")} km`,
inhabitants: `{$information("inhabitants")} individuals`
};
};

Dann verwenden wir die API abrufen um HTTP-Anfragen auszuführen. Fetch ist eine asynchrone Funktion, die gibt ein Versprechen zurück. Da wir die von fetch zurückgegebenen Daten sofort benötigen, müssen wir warten, bis fetch seinen Job beendet hat, bevor wir die folgenden Codezeilen ausführen. Dazu verwenden wir den await Schlüsselwort vor dem Abrufen.

// Fetch instance with async / await
const getCountryDescription = async perform (nation) {
strive {
const response = await fetch(
`https://restcountries.com/v3.1/identify/${nation}`
);
if (!response.okay) {
throw new Error(`Unhealthy HTTP standing of the request (${response.standing}).`);
}
const information = await response.json();
console.log(retrieveInformation(information));
} catch (error) {
console.log(
`An error occurred whereas processing the request.nError message: ${error.message}`
);
}
};

Ebenso platzieren wir ein weiteres await vor dem .json() Methode zum Parsen der Daten, die unmittelbar danach im Code verwendet wird. Im Falle eines fehlerhaften Antwortstatus oder einer Unfähigkeit, die Daten zu parsen, wird ein Fehler ausgegeben, der dann im Catch-Block verarbeitet wird.

Zu Demonstrationszwecken schreiben wir den Codeausschnitt auch mithilfe von Guarantees neu:

// Fetch instance with guarantees
const getCountryDescription = perform (nation) {
fetch(`https://restcountries.com/v3.1/identify/${nation}`)
.then((response) => {
if (!response.okay) {
throw new Error(`Unhealthy HTTP standing of the request (${response.standing}).`);
}
return response.json();
})
.then((information) => {
console.log(retrieveInformation(information));
})
.catch((error) => {
console.log(
`An error occurred whereas processing the request. Error message: ${error.message}`
);
});
};

Wenn Sie eine Both-Funktion mit einem angegebenen Ländernamen aufrufen, werden dessen Hauptinformationen gedruckt:

// The results of calling getCountryDescription("Argentina")
{
nation: 'Argentina',
capital: 'Buenos Aires',
space: '27804000 km',
inhabitants: '45376763 individuals'
}

In diesem Artikel haben wir die async / await Konstruktion in JavaScript, die 2017 in der Sprache erschien. Als Verbesserung gegenüber Guarantees ermöglicht es das synchrone Schreiben von asynchronem Code, wodurch verschachtelte Codefragmente eliminiert werden. Die korrekte Verwendung in Kombination mit Guarantees ergibt eine leistungsstarke Mischung, die den Code so sauber wie möglich macht.

Schließlich sind die in diesem Artikel über JavaScript präsentierten Informationen auch für Python wertvoll, das hat das gleiche async / await Konstruktion. Wenn jemand tiefer in die Asynchronität eintauchen möchte, würde ich persönlich empfehlen, sich mehr auf JavaScript als auf Python zu konzentrieren. Wenn man sich der zahlreichen Instruments bewusst ist, die in JavaScript für die Entwicklung asynchroner Anwendungen zur Verfügung stehen, kann man die gleichen Konzepte auch in anderen Programmiersprachen leichter verstehen.

Alle Bilder stammen, sofern nicht anders angegeben, vom Autor.

Nachrichten über den Hackerangriff auf TeamViewer sind heute in allen Schlagzeilen. Der Datendiebstahl bei TeamViewer, der am 26. Juni 2024 in den internen IT-Systemen des Unternehmens entdeckt wurde, löste Panik auf industrieller Ebene aus. Da die Software program von TeamViewer für Millionen von Menschen weltweit ein wesentlicher Bestandteil des Fernzugriffs ist, wirft jeder Datendiebstahl kritische Bedenken hinsichtlich der Datensicherheit und der Betriebsintegrität auf. Lassen Sie uns genauer untersuchen, wie der Datendiebstahl entdeckt wurde, welche Maßnahmen TeamViewer ergreift, um die Folgen abzumildern, und was Benutzer und Unternehmen tun können, um sich nach diesem Cybersicherheitsvorfall zu schützen.

Ist TeamViewer gehackt?

TeamViewer, bekannt für seine Fernzugriffssoftware, mit der Benutzer Laptop aus der Ferne steuern können, gab den Verstoß bekannt über seine Trustcenter. Das Unternehmen betonte, dass der TeamViewer-Hack in seiner internen IT-Umgebung stattgefunden habe, die sich von der Produktumgebung unterscheidet, in der die Kunden bedient werden. Diese Unterscheidung ist von entscheidender Bedeutung, da sie darauf hindeutet, dass zwar die internen Abläufe von TeamViewer beeinträchtigt wurden, es jedoch keine Hinweise darauf gibt, dass die Funktionalität der Fernzugriffssoftware oder die Sicherheit der Kundendaten direkt beeinträchtigt wurden.

Nach Feststellung der Unregelmäßigkeit aktivierte TeamViewer sein Reaktionsteam und arbeitete mit globalen Cybersicherheitsexperten zusammen, um Untersuchungen einzuleiten und Abhilfemaßnahmen umzusetzen. Die Entscheidung des Unternehmens, auf seiner Seite mit Sicherheitsupdates ein -Tag zu verwenden, hat jedoch Kritik ausgelöst, da dies die Auffindbarkeit der Seite einschränkt und möglicherweise die Transparenzbemühungen behindert.

Lernen Sie den mutmaßlichen Bedrohungsakteur kennen: APT

Berichten zufolge könnte eine Superior Persistent Menace (APT)-Gruppe für den Datendiebstahl bei TeamViewer verantwortlich sein. Während TeamViewer keine spezifischen Particulars zur Identität oder den Motiven der Angreifer bekannt gab, gab das Cybersicherheitsunternehmen NCC Group eine Warnung heraus, die auf eine erhebliche Kompromittierung von TeamViewer durch eine APT-Gruppe hindeutet. Solche Gruppen werden typischerweise mit ausgeklügelten Cyber-Spionage-Aktivitäten in Verbindung gebracht, die es auf wertvolles geistiges Eigentum, Finanzdaten oder andere vertrauliche Informationen abgesehen haben.

Was bedeutet der TeamViewer-Datenverstoß?

Obwohl TeamViewer sagt, dass der Datendiebstahl bei TeamViewer nicht die Software program betraf, die die Kunden nutzen, ist es dennoch eine große Sache, da TeamViewer von Millionen von Menschen und Unternehmen weltweit genutzt wird. Es ist eine Erinnerung daran, wie wichtig es für Unternehmen ist, ihre internen Systeme vor Hackern zu schützen. Laut TeamViewer jedoch du brauchst dir noch keine Sorgen zu machen.

Als Reaktion auf den TeamViewer-Angriff wurden Warnungen verbreitet von Web-Sicherheit Organisationen wie das niederländische Digital Belief Heart und Well being-ISAC haben Bedenken hinsichtlich einer möglichen Ausnutzung der TeamViewer-Dienste durch Bedrohungsakteure geäußert. TeamViewer ist hinsichtlich des TeamViewer-Hacks clear, einige sind jedoch kritisch, da ihre Updates zum TeamViewer-Datenverstoß in Suchmaschinen nicht leicht zu finden sind.

Was können Sie jetzt tun?

Wenn Sie über den TeamViewer-Datenverstoß oder die Cybersicherheit im Allgemeinen besorgt sind, können Sie die folgenden Schritte unternehmen:

• Sicherheitsmaßnahmen aktualisieren: Stellen Sie sicher, dass Ihre Antivirensoftware, Firewalls und alle anderen Sicherheitstools auf dem neuesten Stand sind.
• Konten überwachen: Achten Sie auf ungewöhnliche Aktivitäten bei Ihrem TeamViewer oder anderen Distant-Entry-Konten.
• Aktivieren Sie die Zwei-Faktor-Authentifizierung: Aktivieren Sie, falls verfügbar, die Zwei-Faktor-Authentifizierung (2FA) für zusätzliche Sicherheit.
• Mitarbeiter schulen: Wenn Sie ein Unternehmen mithilfe von Distant-Entry-Instruments leiten, klären Sie Ihr Crew über Phishing-Betrug und andere Sicherheitsbedrohungen auf.
• Bleib informiert: Folgen Sie den Updates von TeamViewer und Nachrichtenquellen zur Cybersicherheit, um sich über die neuesten Entwicklungen und Finest Practices zu informieren.
• Zugriffsprotokolle überprüfen: Überprüfen Sie regelmäßig die Zugriffsprotokolle auf nicht autorisierte oder verdächtige Distant-Zugriffsversuche.

Diese Schritte können dazu beitragen, Risiken zu mindern und Ihre Cybersicherheitslage angesichts von Vorfällen wie dem TeamViewer-Hack zu verbessern.

Rekapitulieren

TeamViewer entdeckte am 26. Juni 2024 einen Einbruch in seinem internen IT-Netzwerk, der nichts mit seinen kundenorientierten Diensten zu tun hatte. Obwohl der Vorfall weder Benutzerdaten noch Softwarefunktionen beeinträchtigte, führte er zu einer sofortigen Reaktion und Zusammenarbeit mit Cybersicherheitsexperten weltweit. Berichte deuten auf die Beteiligung einer Superior Persistent Menace (APT)-Gruppe hin, was in der Branche Bedenken hervorruft. TeamViewer steht unter Beobachtung, weil es auf seiner Seite mit Sicherheitsupdates einen -Tag verwendet, was möglicherweise die Transparenz einschränkt. Während die Untersuchungen fortgesetzt werden, sind fortlaufende Updates verfügbar. Benutzer werden gebeten, wachsam zu bleiben und Cybersicherheitsprotokolle einzuhalten.

Alle Bilder werden erstellt von Eray Eliacık/Bing

Das Konzept der Diffusion

Rauschunterdrückungsdiffusionsmodelle werden trainiert, um Muster aus Rauschen herauszufiltern und ein gewünschtes Bild zu erzeugen. Der Trainingsprozess umfasst das Zeigen von Modellbeispielen von Bildern (oder anderen Daten) mit unterschiedlichen Rauschpegeln, die anhand eines Rauschplanungsalgorithmus bestimmt werden, um vorherzusagen, welche Teile der Daten Rauschen sind. Bei erfolgreichem Coaching kann das Rauschvorhersagemodell schrittweise ein realistisch aussehendes Bild aus reinem Rauschen aufbauen, indem es bei jedem Zeitschritt Rauschinkremente vom Bild abzieht.

Anders als das Bild oben in diesem Abschnitt sagen moderne Diffusionsmodelle kein Rauschen aus einem Bild mit zusätzlichem Rauschen voraus, zumindest nicht direkt. Stattdessen sagen sie Rauschen in einer latenten Raumdarstellung des Bildes voraus. Der latente Raum stellt Bilder in einem komprimierten Satz numerischer Merkmale dar, der Ausgabe eines Kodierungsmoduls eines Variational Autoencoders oder VAE. Dieser Trick legte das „latente“ in latente Diffusionund reduzierte den Zeit- und Rechenaufwand für die Bilderzeugung erheblich. Wie die Autoren des Artikels berichten, beschleunigt latente Diffusion die Inferenz um mindestens das 2,7-Fache gegenüber direkter Diffusion und trainiert etwa dreimal schneller.

Wer mit latenter Diffusion arbeitet, spricht oft von der Verwendung eines „Diffusionsmodells“, aber tatsächlich umfasst der Diffusionsprozess mehrere Module. Wie im obigen Diagramm enthält eine Diffusionspipeline für Textual content-zu-Bild-Workflows normalerweise ein Texteinbettungsmodell (und seinen Tokenizer), ein Rauschprädiktions-/Diffusionsmodell und einen Bilddecoder. Ein weiterer wichtiger Teil der latenten Diffusion ist der Scheduler, der bestimmt, wie das Rauschen über eine Reihe von „Zeitschritten“ (eine Reihe iterativer Aktualisierungen, die das Rauschen schrittweise aus dem latenten Raum entfernen) skaliert und aktualisiert wird.

Beispiel für einen latenten Diffusionscode

Wir verwenden CompVis/latent-diffusion-v1-4 für die meisten unserer Beispiele. Die Texteinbettung übernimmt ein CLIPTextModel und CLIPTokenizer. Die Rauschvorhersage verwendet ein ‚U-Netz,‘ eine Artwork Bild-zu-Bild-Modell, das ursprünglich als Modell für Anwendungen in biomedizinischen Bildern (insbesondere Segmentierung) an Bedeutung gewann. Um Bilder aus entrauschten latenten Arrays zu erzeugen, verwendet die Pipeline einen Variational Autoencoder (VAE) zur Bilddekodierung, um diese Arrays in Bilder umzuwandeln.

Wir beginnen mit dem Erstellen unserer Model dieser Pipeline aus HuggingFace-Komponenten.

# native setup
virtualenv diff_env –python=python3.8
supply diff_env/bin/activate
pip set up diffusers transformers huggingface-hub
pip set up torch --index-url https://obtain.pytorch.org/whl/cu118

Überprüfen Sie unbedingt pytorch.org um sicherzustellen, dass Sie die richtige Model für Ihr System haben, wenn Sie lokal arbeiten. Unsere Importe sind relativ unkompliziert und der folgende Codeausschnitt reicht für alle folgenden Demos aus.

import os
import numpy as np
import torch
from diffusers import StableDiffusionPipeline, AutoPipelineForImage2Image
from diffusers.pipelines.pipeline_utils import numpy_to_pil
from transformers import CLIPTokenizer, CLIPTextModel
from diffusers import AutoencoderKL, UNet2DConditionModel, 
       PNDMScheduler, LMSDiscreteScheduler

from PIL import Picture
import matplotlib.pyplot as plt

Nun zu den Particulars. Beginnen Sie mit der Definition der Bild- und Diffusionsparameter und einer Eingabeaufforderung.

immediate = (" ")

# picture settings
top, width = 512, 512

# diffusion settings
number_inference_steps = 64
guidance_scale = 9.0
batch_size = 1

Initialisieren Sie Ihren Pseudozufallszahlengenerator mit einem Startwert Ihrer Wahl, um Ihre Ergebnisse zu reproduzieren.

def seed_all(seed):
    torch.manual_seed(seed)
    np.random.seed(seed)

seed_all(193)

Jetzt können wir das Texteinbettungsmodell, den Autoencoder, ein U-Web und den Zeitschrittplaner initialisieren.

tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-large-patch14")
text_encoder = CLIPTextModel.from_pretrained("openai/clip-vit-large-patch14")
vae = AutoencoderKL.from_pretrained("CompVis/stable-diffusion-v1-4", 
        subfolder="vae")
unet = UNet2DConditionModel.from_pretrained("CompVis/stable-diffusion-v1-4",
        subfolder="unet")
scheduler = PNDMScheduler()
scheduler.set_timesteps(number_inference_steps)

my_device = torch.gadget("cuda") if torch.cuda.is_available() else torch.gadget("cpu")
vae = vae.to(my_device)
text_encoder = text_encoder.to(my_device)
unet = unet.to(my_device)

Um die Texteingabe als Einbettung zu kodieren, muss zunächst die Zeichenfolge tokenisiert werden. Bei der Tokenisierung werden Zeichen durch ganzzahlige Codes ersetzt, die einem Vokabular semantischer Einheiten entsprechen, z. B. durch Bytepaarkodierung (BPE). Unsere Pipeline bettet neben der Textaufforderung für unser Bild eine Null-Eingabeaufforderung (kein Textual content) ein. Dies gleicht den Diffusionsprozess zwischen der bereitgestellten Beschreibung und natürlich wirkenden Bildern im Allgemeinen aus. Später in diesem Artikel erfahren Sie, wie Sie die relative Gewichtung dieser Komponenten ändern können.

immediate = immediate * batch_size
tokens = tokenizer(immediate, padding="max_length",
max_length=tokenizer.model_max_length, truncation=True,
        return_tensors="pt")

empty_tokens = tokenizer(("") * batch_size, padding="max_length",
max_length=tokenizer.model_max_length, truncation=True,
        return_tensors="pt")
with torch.no_grad():
    text_embeddings = text_encoder(tokens.input_ids.to(my_device))(0)
    max_length = tokens.input_ids.form(-1)
    notext_embeddings = text_encoder(empty_tokens.input_ids.to(my_device))(0)
    text_embeddings = torch.cat((notext_embeddings, text_embeddings))

Wir initialisieren den latenten Raum als zufälliges normales Rauschen und skalieren ihn entsprechend unserem Diffusionszeitschrittplaner.

latents = torch.randn(batch_size, unet.config.in_channels, 
        top//8, width//8)
latents = (latents * scheduler.init_noise_sigma).to(my_device)

Alles ist startklar und wir können in die Diffusionsschleife selbst eintauchen. Wir können die Bilder verfolgen, indem wir in regelmäßigen Abständen Proben entnehmen, damit wir sehen können, wie das Rauschen allmählich abnimmt.

pictures = ()
display_every = number_inference_steps // 8

# diffusion loop
for step_idx, timestep in enumerate(scheduler.timesteps):
    with torch.no_grad():
        # concatenate latents, to run null/textual content immediate in parallel.
        model_in = torch.cat((latents) * 2)
        model_in = scheduler.scale_model_input(model_in,
                timestep).to(my_device)
        predicted_noise = unet(model_in, timestep, 
                encoder_hidden_states=text_embeddings).pattern
        # pnu - empty immediate unconditioned noise prediction
        # pnc - textual content immediate conditioned noise prediction
        pnu, pnc = predicted_noise.chunk(2)
        # weight noise predictions based on steering scale
        predicted_noise = pnu + guidance_scale * (pnc - pnu)
        # replace the latents
        latents = scheduler.step(predicted_noise, 
                timestep, latents).prev_sample
        # Periodically log pictures and print progress throughout diffusion
        if step_idx % display_every == 0
                or step_idx + 1 == len(scheduler.timesteps):
           picture = vae.decode(latents / 0.18215).pattern(0)
           picture = ((picture / 2.) + 0.5).cpu().permute(1,2,0).numpy()
           picture = np.clip(picture, 0, 1.0)
           pictures.lengthen(numpy_to_pil(picture))
           print(f"step {step_idx}/{number_inference_steps}: {timestep:.4f}")

Am Ende des Diffusionsprozesses haben wir ein ordentliches Rendering dessen, was Sie erzeugen wollten. Als Nächstes werden wir zusätzliche Techniken für eine bessere Kontrolle durchgehen. Da wir unsere Diffusionspipeline bereits erstellt haben, können wir für den Relaxation unserer Beispiele die optimierte Diffusionspipeline von HuggingFace verwenden.

Steuerung der Diffusionspipeline

Wir verwenden in diesem Abschnitt eine Reihe von Hilfsfunktionen:

def seed_all(seed):
    torch.manual_seed(seed)
    np.random.seed(seed)

def grid_show(pictures, rows=3):
    number_images = len(pictures)
    top, width = pictures(0).measurement
    columns = int(np.ceil(number_images / rows))
    grid = np.zeros((top*rows,width*columns,3))
    for ii, picture in enumerate(pictures):
        grid(ii//columns*top:ii//columns*top+top, 
                iipercentcolumns*width:iipercentcolumns*width+width) = picture
        fig, ax = plt.subplots(1,1, figsize=(3*columns, 3*rows))
        ax.imshow(grid / grid.max())
    return grid, fig, ax

def callback_stash_latents(ii, tt, latents):
    # tailored from fastai/diffusion-nbs/stable_diffusion.ipynb
    latents = 1.0 / 0.18215 * latents
    picture = pipe.vae.decode(latents).pattern(0)
    picture = (picture / 2. + 0.5).cpu().permute(1,2,0).numpy()
    picture = np.clip(picture, 0, 1.0)
    pictures.lengthen(pipe.numpy_to_pil(picture))

my_seed = 193

Wir beginnen mit der bekanntesten und einfachsten Anwendung von Diffusionsmodellen: der Bildgenerierung aus Textaufforderungen, bekannt als Textual content-zu-Bild-Generierung. Das Modell, das wir verwenden, wurde von der akademischen Labor, das das Papier zur latenten Diffusion veröffentlicht hat. Hugging Face koordiniert Arbeitsabläufe wie die latente Diffusion über die praktische Pipeline-API. Wir möchten definieren, welches Gerät und welcher Gleitkommawert berechnet werden soll, basierend darauf, ob wir eine GPU haben oder nicht.

if (1):
    #Run CompVis/stable-diffusion-v1-4 on GPU
    pipe_name = "CompVis/stable-diffusion-v1-4"
    my_dtype = torch.float16
    my_device = torch.gadget("cuda")
    my_variant = "fp16"
    pipe = StableDiffusionPipeline.from_pretrained(pipe_name,
    safety_checker=None, variant=my_variant,
        torch_dtype=my_dtype).to(my_device)
else:
    #Run CompVis/stable-diffusion-v1-4 on CPU
    pipe_name = "CompVis/stable-diffusion-v1-4"
    my_dtype = torch.float32
    my_device = torch.gadget("cpu")
    pipe = StableDiffusionPipeline.from_pretrained(pipe_name, 
            torch_dtype=my_dtype).to(my_device)

Orientierungsskala

Wenn Sie eine sehr ungewöhnliche Texteingabeaufforderung verwenden (die sich stark von denen im Datensatz unterscheidet), kann es passieren, dass Sie in einem weniger frequentierten Teil des latenten Raums landen. Die Einbettung der Nulleingabeaufforderung sorgt für einen Ausgleich und die Kombination der beiden gemäß Guidance_Scale ermöglicht es Ihnen, die Spezifität Ihrer Eingabeaufforderung gegen allgemeine Bildmerkmale abzuwägen.

guidance_images = ()
for steering in (0.25, 0.5, 1.0, 2.0, 4.0, 6.0, 8.0, 10.0, 20.0):
    seed_all(my_seed)
    my_output = pipe(my_prompt, num_inference_steps=50, 
    num_images_per_prompt=1, guidance_scale=steering)
    guidance_images.append(my_output.pictures(0))
    for ii, img in enumerate(my_output.pictures):
        img.save(f"prompt_{my_seed}_g{int(steering*2)}_{ii}.jpg")

temp = grid_show(guidance_images, rows=3)
plt.savefig("prompt_guidance.jpg")
plt.present()

Da wir die Eingabeaufforderung mithilfe der 9 Leitkoeffizienten generiert haben, können Sie die Eingabeaufforderung grafisch darstellen und die Entwicklung der Diffusion verfolgen. Der Standardleitkoeffizient beträgt 0,75, daher wäre das 7. Bild die Standardbildausgabe.

Damaging Eingabeaufforderungen

Manchmal „will“ die latente Diffusion wirklich ein Bild erzeugen, das nicht Ihren Absichten entspricht. In diesen Szenarien können Sie einen negativen Immediate verwenden, um den Diffusionsprozess von unerwünschten Ergebnissen wegzudrängen. Wir könnten zum Beispiel einen negativen Immediate verwenden, um die Diffusionsergebnisse unserer Mars-Astronauten etwas weniger menschlich zu gestalten.

my_prompt = " "
my_negative_prompt = " "

output_x = pipe(my_prompt, num_inference_steps=50, num_images_per_prompt=9, 
        negative_prompt=my_negative_prompt)

temp = grid_show(output_x)
plt.present()

Sie sollten Ausgaben erhalten, die Ihrer Eingabeaufforderung folgen, und gleichzeitig die Ausgabe der in Ihrer negativen Eingabeaufforderung beschriebenen Dinge vermeiden.

Bildvariation

Die Generierung von Textual content zu Bild von Grund auf ist nicht die einzige Anwendung für Diffusionspipelines. Tatsächlich eignet sich Diffusion intestine zur Bildmodifikation, ausgehend von einem Ausgangsbild. Wir verwenden eine etwas andere Pipeline und ein vorab trainiertes Modell, das auf Bild-zu-Bild-Diffusion abgestimmt ist.

pipe_img2img = AutoPipelineForImage2Image.from_pretrained(

        "runwayml/stable-diffusion-v1-5", safety_checker=None,

torch_dtype=my_dtype, use_safetensors=True).to(my_device)

Eine Anwendung dieses Ansatzes besteht darin, Variationen zu einem Thema zu erzeugen. Ein Konzeptkünstler könnte diese Technik verwenden, um schnell verschiedene Ideen für die Illustration eines Exoplaneten auf der Grundlage der neuesten Forschung zu iterieren.

Wir laden zunächst das Konzept eines gemeinfreien Künstlers für Planet 1e im TRAPPIST-System herunter (Quelle: NASA/JPL-Caltech).
Anschließend verwenden wir nach der Herunterskalierung zum Entfernen von Particulars eine Diffusionspipeline, um mehrere unterschiedliche Versionen des Exoplaneten TRAPPIST-1e zu erstellen.

url = 
"https://add.wikimedia.org/wikipedia/commons/thumb/3/38/TRAPPIST-1e_artist_impression_2018.png/600px-TRAPPIST-1e_artist_impression_2018.png"
img_path = url.cut up("https://www.kdnuggets.com/")(-1)
if not (os.path.exists("600px-TRAPPIST-1e_artist_impression_2018.png")):
    os.system(f"wget      '{url}'")
    init_image = Picture.open(img_path)

seed_all(my_seed)

trappist_prompt = "Artist's impression of TRAPPIST-1e"
                  "giant Earth-like water-world exoplanet with oceans,"
                  "NASA, artist idea, practical, detailed, intricate"

my_negative_prompt = "cartoon, sketch, orbiting moon"

my_output_trappist1e = pipe_img2img(immediate=trappist_prompt, num_images_per_prompt=9, 
     picture=init_image, negative_prompt=my_negative_prompt, guidance_scale=6.0)

grid_show(my_output_trappist1e.pictures)
plt.present()

Indem wir dem Modell ein Beispielbild zuführen, können wir ähnliche Bilder erzeugen. Sie können auch eine textgesteuerte Bild-zu-Bild-Pipeline verwenden, um den Stil eines Bildes zu ändern, indem Sie die Anleitung erweitern, destructive Eingabeaufforderungen und mehr hinzufügen, wie z. B. „nicht realistisch“ oder „Aquarell“ oder „Papierskizze“. Ihre Vorgehensweise kann unterschiedlich sein und die Anpassung Ihrer Eingabeaufforderungen ist der einfachste Weg, das richtige Bild zu finden, das Sie erstellen möchten.

Schlussfolgerungen

Trotz des Diskurses über Diffusionssysteme und die Nachahmung von menschengemachter Kunst haben Diffusionsmodelle andere, wirkungsvollere Zwecke. Es hat gewesen angewendet Vorhersage der Proteinfaltung für Proteindesign und Arzneimittelentwicklung. Textual content-to-Video ist auch ein Aktive Fläche von Forschung und wird von mehreren Unternehmen angeboten (zB Stabilitäts-KI, Google). Diffusion ist auch ein neuer Ansatz für Textual content zu Sprache Anwendungen.

Es ist klar, dass der Diffusionsprozess eine zentrale Rolle bei der Entwicklung der KI und der Interaktion der Technologie mit der globalen menschlichen Umwelt spielt. Die Feinheiten des Urheberrechts, anderer Gesetze zum geistigen Eigentum und die Auswirkungen auf die menschliche Kunst und Wissenschaft sind sowohl positiv als auch negativ erkennbar. Was jedoch wirklich positiv ist, ist die beispiellose Fähigkeit der KI, Sprache zu verstehen und Bilder zu erzeugen. Es warfare AlexNet, das Laptop ein Bild analysieren und Textual content ausgeben ließ, und erst jetzt können Laptop Texteingaben analysieren und zusammenhängende Bilder ausgeben.

Unique. Mit Genehmigung erneut veröffentlicht.

Kevin Vu verwaltet Weblog von Exxact Corp und arbeitet mit vielen seiner talentierten Autoren zusammen, die über verschiedene Aspekte des Deep Studying schreiben.

Bewährte Methoden für Torch.multiprocessing

Der virtuelle Speicher ist jedoch nur eine Seite der Geschichte. Was ist, wenn das Downside nach dem Anpassen der Auslagerungsdiskette nicht behoben wird?

Die andere Seite der Geschichte sind die zugrunde liegenden Probleme des Moduls torch.multiprocessing. Auf der offiziellen Webseite finden Sie eine Reihe von Greatest-Observe-Empfehlungen:

Darüber hinaus sollten jedoch noch drei weitere Ansätze berücksichtigt werden, insbesondere im Hinblick auf die Speichernutzung.

Das erste ist ein gemeinsam genutzter Speicherverlust. Leckage bedeutet, dass der Speicher nach jedem Durchlauf des Youngster-Employees nicht richtig freigegeben wird. Dieses Phänomen können Sie beobachten, wenn Sie die Nutzung des virtuellen Speichers zur Laufzeit überwachen. Der Speicherverbrauch steigt weiter an und erreicht den Punkt, an dem „kein Speicher mehr vorhanden ist“. Dies ist ein sehr typischer Speicherverlust.

Was additionally verursacht das Leck?

Werfen wir einen Blick auf die DataLoader-Klasse selbst:

https://github.com/pytorch/pytorch/blob/predominant/torch/utils/knowledge/dataloader.py

Wenn wir uns DataLoader genauer ansehen, sehen wir, dass _MultiProcessingDataLoaderIter aufgerufen wird, wenn nums_worker > 0 ist. Innerhalb von _MultiProcessingDataLoaderIter erstellt Torch.multiprocessing die Employee-Warteschlange. Torch.multiprocessing verwendet zwei verschiedene Strategien für die Speicherfreigabe und das Caching: Dateideskriptor Und Dateisystem. Während Dateisystem erfordert kein Zwischenspeichern von Dateideskriptoren, ist aber anfällig für Lecks im gemeinsam genutzten Speicher.

Um zu prüfen, welche Freigabestrategie Ihr Laptop verwendet, fügen Sie einfach das Skript hinzu:

torch.multiprocessing.get_sharing_strategy()

Um Ihr Systemdateideskriptorlimit (Linux) zu ermitteln, führen Sie den folgenden Befehl im Terminal aus:

ulimit -n

Um Ihre Freigabestrategie zu ändern auf Dateideskriptor:

torch.multiprocessing.set_sharing_strategy(‘file_descriptor’)

Um die Anzahl der geöffneten Dateideskriptoren zu zählen, führen Sie den folgenden Befehl aus:

ls /proc/self/fd | wc -l

Sofern das System dies zulässt, Dateideskriptor Strategie wird empfohlen.

Die zweite ist die Multiprocessing-Employee-Startmethode. Einfach ausgedrückt geht es um die Debatte, ob man als Methode zum Starten des Employees Fork oder Spawn verwenden soll. Fork ist die Standardmethode zum Starten von Multiprocessing in Linux und kann bestimmte Dateikopien vermeiden, ist additionally viel schneller, kann aber Probleme beim Umgang mit CUDA-Tensoren und Drittanbieterbibliotheken wie OpenCV in Ihrem DataLoader haben.

Um die Spawn-Methode zu verwenden, können Sie einfach das Argument übergeben multiprocessing_context= „laichen“. zum DataLoader.

Drittens: Machen Sie die Dataset-Objekte auswählbar/serialisierbar

Es gibt einen tremendous netten Beitrag, der den „Copy-on-Learn“-Effekt beim Prozess-Folding näher bespricht: https://ppwwyyxx.com/weblog/2022/Demystify-RAM-Utilization-in-Multiprocess-DataLoader/

Einfach gesagt, es ist kein guter Ansatz mehr um eine Liste mit Dateinamen zu erstellen und diese in die Methode __getitem__ zu laden. Erstellen Sie ein Numpy-Array oder einen Panda-Dataframe, um die Liste mit Dateinamen für Serialisierungszwecke zu speichern. Und wenn Sie mit HuggingFace vertraut sind, ist die Verwendung eines CSV/Dataframes die empfohlene Methode zum Laden eines lokalen Datensatzes: https://huggingface.co/docs/datasets/v2.19.0/en/package_reference/loading_methods#datasets.load_dataset.example-2