Der KI-App-Builder integriert Website positioning, KI-Suchoptimierung und Stay-SEMrush-Intelligenz in sein Produkt und löst so ein Auffindbarkeitsproblem, das immer schwieriger wird, als die meisten Entwickler erkennen

Der schwierigste Teil bei der Entwicklung eines Produkts besteht nicht mehr darin, es zu bauen. Es wird gefunden, und dieses Downside wird schneller schwieriger, als den meisten Bauherren bewusst ist.

Warum Auffindbarkeit das neue Schlachtfeld ist

Die Suche, wie sie seit zwei Jahrzehnten existiert, ist fragmentiert. Eine Analyse von Seer Interactive vom November 2025, die 25,1 Millionen Impressionen bei mehr als 3.000 Suchanfragen untersuchte, ergab, dass 58 % der Google-Suchanfragen mittlerweile ohne einen einzigen Klick auf eine Web site enden. Bei Suchanfragen, bei denen die KI-Übersichten von Google erscheinen, die mittlerweile bei mehr als 27 % aller Suchanfragen vorhanden sind, gegenüber weniger als 4 % im Januar 2025, sind die organischen Klickraten um 61 % gesunken.

Gleichzeitig öffnet sich ein anderer Kanal. Eine SE-Rating-Studie, die den Verkehr auf quick 64.000 Web sites verfolgt, ergab, dass der Verweisverkehr auf KI-Plattformen zwischen 2024 und 2025 um das Siebenfache gestiegen ist. Das Volumen ist im Vergleich zur herkömmlichen Suche immer noch gering, aber die Qualität ist beeindruckend: Besucher, die über KI-Plattformen kommen, verbringen 68 % mehr Zeit auf Web sites als Besucher über die organische Suche, was darauf hindeutet, dass sie vorab qualifizierter ankommen und in ihrer Entscheidungsfindung weiter fortgeschritten sind. Die Disziplin der Optimierung speziell für diesen Kanal, bekannt als Generative Motoroptimierungoder GEO – hat sich zu einer eigenständigen Praxis für Marken entwickelt, die sichtbar bleiben möchten, während KI die Artwork und Weise verändert, wie Menschen Produkte entdecken.

Die Implikation für App-Entwickler ist direkt. Die Indexierung durch Google ist weniger wichtig, wenn weniger Nutzer über Google klicken. Das Erscheinen in KI-generierten Antworten wird zu einer sinnvollen Various. Die meisten auf KI-Plattformen basierenden Apps waren für beide Kanäle strukturell unsichtbar. Lovable hat gerade versucht, das zu ändern.

Vom Second der Veröffentlichung an gefunden

Am 13. Mai 2026 hat Lovable, der KI-App-Builder mit einem Wert von 6,6 Milliarden US-Greenback, der von mehr als 8 Millionen Entwicklern weltweit genutzt wird, Website positioning, KI-Suchoptimierung und Stay-SEMrush-Intelligenz in den Kern seines Produkts integriert. Apps werden jetzt mit bereits vorhandenen technischen Grundlagen für die Auffindbarkeit ausgeliefert und nicht als Downside nach dem Begin abgetan.

Das Rückgrat des Updates ist eine architektonische Änderung. Neue Apps auf Lovable laufen jetzt auf TanStack Begin, einem Full-Stack-React-Framework, das vollständiges HTML auf dem Server rendert, bevor es jemals den Browser erreicht. Zuvor lieferten Lovable-Apps eine leere HTML-Shell für Suchcrawler, Inhalte erschienen erst, nachdem JavaScript auf der Clientseite ausgeführt wurde, was bedeutete, dass Seiten tage- oder wochenlang in der Warteschlange für die Indexierung standen, Metadaten oft vollständig fehlten und Social-Share-Hyperlinks zu leeren Vorschaukarten führten.

Beim serverseitigen Rendering verschwindet diese Warteschlange. Google, Bing und Suchcrawler erhalten bei der ersten Anfrage die vollständig ausgefüllte Seite, Inhalte, Titel, Beschreibungen und strukturierte Daten. Bei neuen Apps geschieht dies automatisch und ist in jedem Plan kostenlos, auch kostenlos.

Bestehende Apps, die auf Lovables bisherigem React- und Tailwind-CSS-Stack basieren, werden separat, aber genauso automatisch gehandhabt. Die Plattform hat Pre-Rendering auf alle bereitgestellten öffentlichen URLs angewendet: Statische HTML-Snapshots, die anstelle der leeren Hülle an Suchmaschinen und Crawler geliefert werden, während das Erlebnis für menschliche Besucher genau so bleibt, wie es conflict. Keine Migration, keine manuelle Arbeit, kein Choose-in. Es ist bereits in allen vorhandenen Apps verfügbar. Auch die sozialen Vorschauen wurden verbessert – freigegebene Hyperlinks auf LinkedIn, Slack, WhatsApp und X generieren jetzt einzigartige Vorschaukarten professional Seite.

KI-Suchsichtbarkeit, strukturiert in

Neben der herkömmlichen Suche strukturiert Lovable Apps jetzt so, dass sie von KI-gestützten Suchtools gelesen werden können. Jede veröffentlichte App stellt KI-Crawlern automatisch eine saubere Markdown-Model jeder Seite zur Verfügung – eine Ebene, die Inhalte ohne zusätzliche Konfiguration maschinenlesbar macht. Die Plattform prüft im Rahmen ihrer Website positioning-Überprüfung auch auf semantische HTML- und JSON-LD-strukturierte Daten, deckt etwaige Lücken auf und ermöglicht Entwicklern, diese mit einem Klick zu beheben. Apps können auch mit einer llms.txt-Datei eingerichtet werden, einem Manifest, das den KI-Instruments signalisiert, was eine Web site enthält, das die Website positioning-Überprüfung markiert und bei Fehlen generieren kann.

Wie Lovable CMO Cecilia Stallsmith es in der Ankündigung ausdrückte: „Früher waren Auffindbarkeit und Markensichtbarkeit ein Marketingproblem, das man später abgeben konnte. Aber in einer Welt, in der es nur noch sehr wenige Wettbewerbsgräben gibt, gibt es kein Später mehr.“

Ein SEMrush-Forschungspartner, integriert in den Chat

Die auffälligste Ergänzung ist eine Stay-SEMrush-Integration, die direkt in den Builder-Chat eingebettet ist. SEMrush, die Search-Intelligence-Plattform von Adobe, liefert einen Datensatz mit 28 Milliarden Schlüsselwörtern, 43 Billionen Backlinks und Profilen von 808 Millionen Domains in 32 Regionen. Diese Datenbank steht jetzt jedem Lovable-Benutzer zur Verfügung, ohne dass ein SEMrush-Konto erforderlich ist.

Der Arbeitsablauf ist gesprächig. Fragen Sie den Builder: „Auf welche Key phrases soll ich abzielen?“ Und es liefert reale Suchvolumenzahlen, Wettbewerbslücken und Site visitors-Schätzungen, die aus Stay-SEMrush-Daten stammen. Der Builder reagiert dann auf diese Antworten: Wenn SEMrush ein Key phrase mit hohem Volumen entdeckt, für das die App kein Rating erzielt, kann Lovable mithilfe regulärer Construct-Credit im selben Gespräch eine optimierte Zielseite, einen Titel, eine Meta-Beschreibung und H1 generieren und bereitstellen, die die Recherche widerspiegeln. SEMrush-Daten sind bis zum 15. August 2026 ohne zusätzliche Kosten verfügbar.

Führen Sie eine vollständige Website positioning-Überprüfung durch und beheben Sie das Downside mit einem Klick

Jede App kann jetzt zu jedem Zeitpunkt des Entwicklungszyklus eine On-Demand-Website positioning- und KI-Suchüberprüfung durchführen. Die Prüfung umfasst Leistung, Metadatenqualität, Überschriftenstruktur, Bild-Alternativtext, kanonische Tags, Open Graph-Tags, robots.txt und Sitemap-Standing. Die Ergebnisse werden nach Auswirkung geordnet, die meisten werden mit einem einzigen Klick mithilfe regulärer Construct-Credit gelöst und die Überprüfung selbst ist für alle Pläne, einschließlich unveröffentlichter Projekte, kostenlos. Die Einrichtung der Google Search Console und die benutzerdefinierte Domainverwaltung sind in derselben Registerkarte integriert.

Verfügbar für jeden Bauherrn und jeden Plan

Alle Funktionen der Discovery-Suite, serverseitiges Rendering für neue Apps, automatisches Pre-Rendering für bestehende, die SEMrush-Chat-Integration und die On-Demand-Website positioning-Überprüfung, werden auf jeder Lovable-Stufe ausgeliefert, auch kostenlos. Es gibt kein Auffindbarkeits-Improve und es muss kein separates Produkt erworben werden.

Auf einer Plattform, die jeden Tag mehr als 200.000 neue Projekte hervorbringt, verändert die Festlegung der Auffindbarkeit als integrierte Standardeinstellung die Wirtschaftlichkeit dessen, was es bedeutet, auf Lovable zu versenden. Aber es signalisiert auch etwas umfassenderes. Da sich die Suche auf herkömmliche Ergebnisse, KI-Übersichten und KI-Chat-Instruments verteilt, reicht es für KI-Builder-Plattformen nicht mehr aus, nur über die Erstellungsgeschwindigkeit zu konkurrieren. Die Plattformen, die die nächste Section definieren, werden diejenigen sein, die ihren Benutzern dabei helfen, in der gesamten Section aufzutreten. Lovable hat diese Wette gerade explizit gemacht.

sah solide aus. Die KL-Divergenz lag deutlich innerhalb akzeptabler Bereiche. Beim Prepare on Artificial, Take a look at on Actual (TSTR)-Take a look at erreichte das Modell eine Genauigkeit von 91 %, wenn es mit den synthetischen Daten trainiert und mit den realen Daten getestet wurde, was etwas niedriger conflict als die 93 %, die bei Verwendung der tatsächlichen Daten erreicht wurden – ein Unterschied, der deutlich innerhalb der Grenzen liegt, die das Crew für die Datentoleranzen festgelegt hatte. Darüber hinaus conflict das Risiko einer Mitgliedschaftsinferenz relativ gering. Der synthetische Datensatz wurde als sicher für die Verwendung im Modelltraining für maschinelles Lernen zertifiziert; die echten Daten wurden sicher gespeichert; und das Modell wurde trainiert.

Drei Monate später konnte das Betrugserkennungsmodell jedoch die zuvor erkannten Transaktionsklassen nicht mehr fehlerfrei erkennen, was nicht nur zu Leistungseinbußen führte, sondern sogar einen völligen Ausfall zur Folge hatte. Eine ganze Gruppe von Randverhaltensweisen wurde effektiv aus der Realität des Modells entfernt.

Bei der Untersuchung des Issues konnte das Crew keine technischen Fehler bei den synthetischen Daten feststellen. Alle vom Crew ermittelten Kennzahlen haben weiterhin bestanden.

Das Downside bestand jedoch darin, dass keine dieser Kennzahlen tatsächlich misst, was wirklich wichtig ist.

Das Drei-Metrik-System und warum es Praktiker in die Irre führt

Das Dreieck aus Treue, Nutzen und Privatsphäre ist zum Standardlexikon für die Bewertung der Qualität synthetischer Daten geworden, und das aus gutem Grund. Es erfasst die drei Qualitätsaspekte, die Sie wirklich erreichen möchten: Ähneln die synthetischen Daten den realen Daten (Wiedergabetreue); Trainieren die synthetischen Daten Modelle, die sich ähnlich verhalten wie Modelle, die auf realen Daten trainiert werden (Nützlichkeit); und schützen die synthetischen Daten die Identität der Personen, von denen die Daten stammen (Privatsphäre)?

Der Rahmen selbst ist solide. Bei der Umsetzung dieses Rahmenwerks treten jedoch Probleme auf.

Die meisten Praktiker bewerten die drei Qualitätsmetriken nacheinander und betrachten den erfolgreichen Abschluss jeder einzelnen als ausreichend für den Einsatz. Dieser Ansatz ist aus drei miteinander verbundenen Gründen fehlerhaft, die einer detaillierten Erläuterung bedürfen:

Downside Nr. 1: Genauigkeitsmetriken bewerten Randverteilungen, nicht Interaktionen zwischen Options

Die am häufigsten verwendeten Genauigkeitsmetriken KL-Divergenz, Kolmogorov-Smirnov-Take a look at, Gesamtvariationsdistanz und Wasserstein-Distanz messen alle den Grad, in dem die individuelle Merkmalsverteilung im synthetischen Datensatz mit dem Authentic verglichen wird.
Keines dieser Maße beurteilt, wie Merkmale miteinander korrelieren.

Dies ist eine subtile, aber entscheidende Unterscheidung. Stellen Sie sich beispielsweise einen Gesundheitsdatensatz vor, bei dem die synthetische Model die Randverteilungen des Patientenalters und der Schwere der Erkrankung genau wiedergibt und die Randverteilungen praktisch nicht unterscheidbar erscheinen. Es gibt jedoch eine geringfügige Diskrepanz in der Korrelation zwischen den beiden Merkmalen in den synthetischen Daten. Wenn ein Modell darauf trainiert wird, identifiziert das Modell daher die entsprechenden Signale separat, aber die falsche Interaktion zwischen den Signalen.

Im Jahr 2025 wurden in einer Peer-Assessment-Studie zu synthetischen Patientendaten fünf generative Modelle anhand von drei klinischen Datensätzen evaluiert. Die Ergebnisse zeigten, dass die Randverteilungen zwar quick immer sehr ähnlich waren, sich die Korrelationswerte jedoch um 20 Punkte oder mehr unterschieden. Die nachgelagerten Auswirkungen waren dramatisch: Bei einem Datensatz ergaben Modelle, die mit synthetischen Daten trainiert wurden, Werte für die Fläche unter der Kurve (AUC) von etwa 0,80, während bei Verwendung der realen Daten AUC-Werte von etwa 0,88 erzielt wurden. Die Variable, die darüber entschied, ob es sich um Ersteres oder Letzteres handelte, conflict eher die Erhaltung der Korrelation als die Genauigkeit der Randverteilung.

Um dies zu beheben: Führen Sie KS- und KL-Exams als Foundation durch, um die Ähnlichkeit der Randverteilungen zu bestätigen. Schließen Sie immer einen Vergleich der Korrelationsmatrizen ein. Berechnen Sie die Frobenius-Norm der Differenz, um einen einzelnen Wert zu erhalten, der den Umfang der verlorenen Korrelationsstruktur darstellt. Legen Sie einen Schwellenwert für den Verlust der Korrelationsstruktur fest, bevor Sie die Daten synthetisieren, nicht danach.

import numpy as np
import pandas as pd
def correlation_drift_score(real_df: pd.DataFrame, synthetic_df: pd.DataFrame) -> float:
“””
Computes the Frobenius norm of the distinction between
actual and artificial correlation matrices.
Decrease is healthier. A rating above 0.5 warrants investigation.
“””
real_corr = real_df.corr().fillna(0).values
synth_corr = synthetic_df.corr().fillna(0).values
return np.linalg.norm(real_corr — synth_corr, ‘fro’)
rating = correlation_drift_score(real_df, synthetic_df)
print(f”Correlation Drift Rating: {rating:.4f}”)

Eine Nummer. Führen Sie es jedes Mal aus. Wenn es über Ihrem Schwellenwert liegt, kehren Sie zum Generator zurück, bevor Sie etwas anderes tun.

Downside 2: TSTR-Utility-Scores verbergen das Tail-Verhalten, wenn sie nur die durchschnittliche Leistung darstellen

„Prepare on Artificial Information, Take a look at on Actual Information“ ist eine der „Goldstandards“-Nutzungsmetriken und verdient den Ruf, den sie erworben hat. Ein Modell anhand synthetischer Daten zu trainieren und sicherzustellen, dass es anhand realer Daten intestine funktioniert, ist sicherlich ein aussagekräftiger Beweis für die Nützlichkeit.

Allerdings basieren die TSTR-Werte auf Durchschnittswerten. Somit verbergen sie genau das, was in der Produktion kaputt gehen wird. Im Betrugserkennungsbeispiel am Anfang dieses Artikels betrug die Gesamt-TSTR-AUC 91 %, aber als die Leistung nach Dezil des Transaktionsvolumens aufgeschlüsselt wurde, sank das Dezil mit der niedrigsten Leistung (die seltensten Transaktionen mit dem höchsten Wert) auf 67 % (die synthetischen Daten generierten häufige Transaktionen sehr genau; die seltensten oder ungewöhnlichsten Szenarien stellten die synthetischen Daten jedoch nicht so genau dar). Daher lernte das Modell, das anhand synthetischer Daten trainiert wurde, die häufigsten Verhaltensweisen mit äußerster Genauigkeit und das am wenigsten häufige Verhalten mit geringer Genauigkeit.

Dies ist das Tail-Loss-Downside. Es wird in der Modellkollaps-Literatur formal behandelt (Alemohammad et al., 2024, ICLR) und kann auf jede Artwork von synthetischem Datengenerierungsprozess angewendet werden: Generative Modelle, die für die Generierung von Bereichen der Verteilung mit hoher Wahrscheinlichkeit optimiert sind, repräsentieren seltene Ereignisse zunehmend unterrepräsentiert. Der synthetische Datengenerator versucht nicht, seltene Ereignisse zu unterrepräsentieren – er stellt lediglich die Mathematik dar, wie diese Modelle lernen.

Repair: Melden Sie den TSTR nicht auf aggregierter Foundation. Geben Sie den TSTR separat für jedes Dezil an, in das Sie Ihre Zielvariable geschichtet haben. Die Dezile, in denen die synthetisch trainierte Leistung am stärksten von der actual trainierten Leistung abweicht, zeigen Ihnen genau an, welche Dezile Ihre synthetischen Daten nicht genau wiedergeben.

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import roc_auc_score
import pandas as pd
import numpy as np
def tstr_by_decile(
real_train: pd.DataFrame,
synthetic_train: pd.DataFrame,
real_test: pd.DataFrame,
target_col: str,
n_deciles: int = 10
) -> pd.DataFrame:
“””
Runs TSTR analysis stratified by deciles of the goal variable.
Returns a comparability dataframe for actual vs artificial coaching efficiency.
“””
outcomes = ()
real_test = real_test.copy()
real_test(‘decile’) = pd.qcut(
real_test(target_col), q=n_deciles, labels=False, duplicates=’drop’
)
feature_cols = (c for c in real_train.columns if c != target_col)
for label, train_df in ((“Actual”, real_train), (“Artificial”, synthetic_train)):
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.match(train_df(feature_cols), train_df(target_col))
for decile_id, group in real_test.groupby(‘decile’):
if len(group(target_col).distinctive()) < 2:
proceed
rating = roc_auc_score(
group(target_col),
clf.predict_proba(group(feature_cols))(:, 1)
)
outcomes.append({
‘Prepare Supply’: label,
‘Decile’: decile_id,
‘AUC-ROC’: spherical(rating, 4)
})
return pd.DataFrame(outcomes).pivot(
index=’Decile’, columns=’Prepare Supply’, values=’AUC-ROC’
)
decile_results = tstr_by_decile(real_train, synthetic_train, real_test, ‘fraud_flag’)
print(decile_results)

Downside 3: Datenschutzmetriken sollten alle Funktionen gleich behandeln, obwohl dies nicht der Fall sein sollte.

Das Risiko einer Mitgliedschaftsinferenz ist die häufigste Datenschutzmetrik. Das Risiko einer Mitgliedschaftsinferenz stellt eine Frage: Kann ein Angreifer feststellen, ob ein bestimmter Datensatz im Trainingsdatensatz vorhanden ist? Niedrige Werte sind wirklich gute Nachrichten.

Dies wird jedoch auf Datensatzebene gemessen und misst daher das Risiko, einen Datensatz als Ganzes zu identifizieren. Die riskantere Angriffsart ist die Attributinferenz; Kann ein Angreifer anhand öffentlich verfügbarer Informationen über die Merkmale einer Particular person ein sensibles Attribut in den synthetischen Daten identifizieren? Dies ist das Angriffsmodell, mit dem sich die Aufsichtsbehörden im Rahmen des DSGVO-Requirements zur Neuidentifizierung befassen, und es funktioniert auf der Kombinationsebene (nicht auf der Datensatzebene).

Ein Consensus Privateness Metrics Framework (Pilgram et al., 2025) definiert drei verschiedene Arten von Risiken: Herausgreifen (Identifizieren einer einzelnen Particular person), Verknüpfbarkeit (Datensätze über Datensätze hinweg verknüpfen) und Rückschluss (Ableiten sensibler Attribute aus Kombinationen von Quasi-Identifikatoren). Praktiker messen quick ausschließlich den ersten Typ (Singling Out). Die dritte Artwork von Risiko (Inferenz) ist der Bereich, in dem tatsächlich vertrauliche Daten verloren gehen und der für die standardmäßige Mitglieder-Inferenzbewertung völlig unsichtbar ist.

Repair: Priorisieren Sie Ihre Funktionen vor der Synthese basierend auf der Empfindlichkeit. Kategorisieren Sie sie in öffentlich (Merkmale, die ohne Einschränkung in die synthetischen Daten einbezogen werden können), Quasi-Identifikatoren (Kombinationen öffentlicher Merkmale, die eine Verknüpfung ermöglichen können) und sensibel (die Attribute, die Sie schützen möchten). Messen Sie das Risiko der Mitgliedschaftsinferenz nur für die sensiblen Options und beziehen Sie nicht den gesamten Datensatz mit ein. Führen Sie als Nächstes einen Attributinferenztest durch: Trainieren Sie ein externes Modell, um jedes smart Merkmal basierend auf den Quasi-Identifikatoren mithilfe synthetischer Daten vorherzusagen. Vergleichen Sie die Genauigkeit des trainierten Modells mit einem Modell, das darauf trainiert wurde, jedes smart Merkmal auf der Grundlage derselben Quasi-Identifikatoren, aber unter Verwendung zurückgehaltener Daten vorherzusagen. Wenn der Genauigkeitsunterschied gering ist, sind Ihre synthetischen Daten verloren gegangen.

from sklearn.ensemble import GradientBoostingClassifier
def attribute_inference_risk(
synthetic_df: pd.DataFrame,
real_test_df: pd.DataFrame,
quasi_identifiers: record,
sensitive_feature: str
) -> dict:
“””
Estimates attribute inference threat by checking how nicely
a mannequin educated on artificial information predicts a delicate function
utilizing solely quasi-identifiers.
Excessive accuracy on actual take a look at information = artificial information is leaking
details about the delicate attribute.
“””
clf = GradientBoostingClassifier(random_state=42)
clf.match(synthetic_df(quasi_identifiers), synthetic_df(sensitive_feature))
real_accuracy = clf.rating(
real_test_df(quasi_identifiers),
real_test_df(sensitive_feature)
)
majority_class_accuracy = (
real_test_df(sensitive_feature).value_counts(normalize=True).max()
)
elevate = real_accuracy — majority_class_accuracy
return {
“inference_accuracy_on_real”: spherical(real_accuracy, 4),
“baseline_accuracy”: spherical(majority_class_accuracy, 4),
“inference_lift”: spherical(elevate, 4),
“risk_level”: “HIGH” if elevate > 0.10 else “MODERATE” if elevate > 0.05 else “LOW”
}
threat = attribute_inference_risk(
synthetic_df, real_test_df,
quasi_identifiers=(‘age_band’, ‘area’, ‘employment_status’),
sensitive_feature=’income_bracket’
)
print(threat)

Wenn Sie für die Steigerung einen „über 0,10“ (oder eine beliebige andere Zahl) sehen, bedeutet dies, dass Ihr synthetischer Datensatz die sensiblen Attribute Ihrer Benutzer besser identifizieren kann als der Zufall. Es spielt keine Rolle, ob Ihr Membership Inference Rating (MIS) unter 0,10 oder einem anderen Schwellenwert liegt; das ist irrelevant.

Das einheitliche Bewertungsrahmenwerk

Wie bereits erwähnt, handelt es sich bei diesen drei Herausforderungen im Wesentlichen um eine Herausforderung: Sie ergeben sich jeweils aus der Verwendung von Metriken zur Bewertung der Merkmale eines Datensatzes und der anschließenden Verwendung derselben Metriken als Grundlage für die Zertifizierung eines Datensatzes für den Produktionseinsatz. Das sind zwei sehr unterschiedliche Aufgaben.

Nachfolgend finden Sie eine vollständige Checkliste der Bewertungen, die die einzelnen Bewertungslücken schließen:

Dimension, Standardmetrik, was es vermisst und erweiterte Prüfung

Treue

• KL-Divergenz, KS-Take a look at
• Korrelationsstruktur zwischen Options
• Korrelationsdrift-Rating (Frobenius-Norm)

Dienstprogramm

• TSTR durchschnittliche AUC
• Tail-Efficiency bei seltenen Ereignissen
• TSTR stratifiziert nach Zieldezil

Privatsphäre

• Risiko einer Mitgliedschaftsinferenz
• Attributinferenz über Quasi-Identifikatoren
• Attribut-Inferenz-Carry-Take a look at

Der richtige Schwellenwert hängt von Ihrem Anwendungsfall ab

Der am meisten übersehene Aspekt des Runden Tisches zwischen FCA, ICO und Alan Turing Institute zur Validierung synthetischer Daten conflict dieser: „Null Risiko = Null Nutzen.“ Synthetische Daten können nicht vollständig privat und gleichzeitig ebenso nützlich sein. Die Frage lautet nicht mehr: „Gehen die Daten weiter?“ Die Frage lautet: „Erfüllen die Kompromisse die Anforderungen der Anwendungsfälle?“

Die synthetischen Daten, die für interne QS-Exams einer Anwendung verwendet werden, erfordern eine hohe Wiedergabetreue und strukturelle Genauigkeit. Da der Zugriff auf die Daten jedoch kontrolliert wird, wird der Datenschutz weniger groß geschrieben.

Andererseits müssen die Daten, die Sie an externe Benutzer, organisationsübergreifend, an Aufsichtsbehörden oder zu Forschungszwecken weitergeben, über höhere Datenschutzgarantien verfügen. In solchen Fällen können Sie eine geringere statistische Genauigkeit der synthetischen Daten akzeptieren.

Definieren Sie daher bei der Entwicklung Ihres Bewertungsrahmens den Anwendungsfall, bevor Sie Ihre synthetischen Daten auswerten. Beantworten Sie die folgenden Fragen, bevor Sie synthetische Daten generieren:

1) Wer hat unter welchen Bedingungen Zugriff auf diesen synthetischen Datensatz? Dies legt Ihren Schwellenwert für den Datenschutz fest.

2) Welche nachgelagerte Aufgabe werden diese Daten trainieren oder testen? Dies definiert die Nutzmetriken, die sich auf Tragfähigkeit und Lärm auswirken.

3) Sind für die nachgelagerte Aufgabe Funktionen erforderlich? Wenn ja, definiert dies, wo Sie die Treue wahren müssen und wo Sie Abweichungen tolerieren können.

Legen Sie diese Schwellenwerte basierend auf Ihren Antworten auf die oben genannten Fragen fest, bevor Sie die Synthese durchführen. Führen Sie Ihre Auswertungen anhand Ihrer festgelegten Schwellenwerte durch (nicht der vom Instrument standardmäßig gemeldeten Schwellenwerte).

Fazit: Die Qualitätslücke ist eine Messlücke

Das Betrugserkennungsmodell scheiterte nicht daran, dass die synthetischen Daten unzureichend waren. Das Modell scheiterte, weil das Crew die falschen Eigenschaften bewertete und aufgrund der korrekten Messungen falsche Schlussfolgerungen zog. Treue, Nützlichkeit und Privatsphäre sind die richtigen Dimensionen.

Die Standardmetriken innerhalb jeder Dimension sind gute Ausgangspunkte. Sie wurden jedoch zur Messung und Beschreibung von Daten entwickelt und nicht zur Zertifizierung von Daten für den Produktionsgebrauch. Um diese Messlücke zu schließen, sind drei zusätzliche Bewertungen erforderlich, die die Lücken in den Standardmetriken identifizieren; Korrelationsdrift, Endnutzen professional Dezil und Attributinferenzrisiko.

Für diese drei Beurteilungen sind keine speziellen Instruments erforderlich. Die drei in diesem Artikel beschriebenen Implementierungen laufen im Commonplace-Scikit-Be taught und NumPy. Die schwierige Arbeit besteht nicht darin, den Code zu schreiben, sondern darin, die richtigen Fragen zu stellen, bevor Sie Ihr Modell in Produktion bringen.

Was ist eine Aufgabe, die alle Fachleute und Studenten an der einen oder anderen Stelle in ihrem Leben erledigen müssen? Nein, es weint nicht in einer Ecke, sondern PPTs! Nun, Gamma 3.0 könnte Sie mit den schönen PPTs, die es in nur wenigen Minuten erzeugen kann, wieder tränenartige Augen machen! Gamma 3.0 wird mit Gamma Agent, einem PPT -Spezialisten -AI -Agenten, gepanzert. Lassen Sie uns in diesem Weblog diese Behauptung testen und verstehen, was Gamma 3.0 ist, was der Gamma -Agent ist, seine Funktionen, wie man auf den KI -PPT -Hersteller zugreift und wie man PPTs mit Gamma 3.0 baut.

Es ist Zeit, einige PPTs mit Gamma 3.0 zu entwerfen!

Was ist Gamma 3.0?

Gamma 3.0 ist die neueste Model des beliebten KI -PPT -Hersteller Gamma. Es ist kein neues Werkzeug, sondern ein Legacy -Bauunternehmer für die Welt der KI -PPT -Herstellung. Es battle eines der ersten Werkzeuge, um PPTs mit nur einem einzigen Befehl zu erzeugen. Diese neueste Model ist voller neuer Funktionen und bringt das Gamma -Erlebnis auf die nächste Stufe. Es nutzt eine Kombination verschiedener LLMs wie Claude’s HaikuAnwesend ChatgptAnwesend Dall-eund mehr, um verschiedene Teile der PPTs zu erzeugen.

Einige seiner herausragenden Funktionen sind:

• Bessere Layouts und Themen
• Intelligentere Diagramme, die gemäß Ihrer Eingabeaufforderung erzeugt werden
• Einfachere Integration des Feedbacks

Die beiden wichtigsten Ergänzungen zu Gamma 3.0 sind jedoch: Gamma Agent und Gamma API.

Was ist Gamma Agent?

Gamma Agent ist ein spezialisierter PPT -Gebäudeagent, der an Ihren Aufforderungen zur Verbesserung Ihrer PPTs arbeitet. Dieser Agent wurde auch so konzipiert, dass Menschen ihre generierten PPTs gemäß ihren Anforderungen bearbeiten können. Der Agent arbeitet an den Aufforderungen, die Sie angeben, und führt dann die Änderungen in der generierten PPT aus.

Einige der Höhepunkte des Gamma -Agenten sind:

• Es kann das Internet erforschen und Zitate finden, um die in Ihrem PPT genannten Punkte zu unterstützen.
• Es kann nützliche Hyperlinks oder Screenshots finden und sie in Ihr PPT -Deck einbauen.
• Es kann Ihre gesamte PPT mit nur einer einzigen Eingabeaufforderung verändern.
• Es kann Ihr PPT überprüfen und Suggestions geben und dann auch dieses Suggestions einbeziehen.

Grundsätzlich kann dieser Agent alle Lücken füllen, die Sie in der erzeugten PPT finden.

Gamma -API

Sagen Sie, Sie mögen einen PPT wirklich und wollen jetzt mehr wie das Gleiche mit nur geringfügigen Änderungen. Wie sind Ihre Optionen? Sie können entweder all diese Änderungen in jedem Deck selbst vornehmen oder den gesamten Vorgang mit der Gamma -API automatisieren. Einige seiner Funktionen, die dabei helfen, sind:

• Es wird an Zapier angeschlossen, MachenExcel, Drive, Slack oder eine andere Datenquelle.
• Es kann die PPT -Herstellung von jeder Eingabe automatisieren.
• Es kann das gleiche PPT in über 60 Sprachen übersetzen.

Derzeit gibt es eine Grenze für die API -Verwendung. Bezahlte Benutzer können maximal 50 Generationen professional Tag professional Benutzer generieren, und die Assist -Authentifizierung erfolgt nur über API -Schlüssel.

Sowohl Gamma Agent als auch Gamma API verleihen den vorhandenen Funktionen von Gamma eine Menge Benutzerfreundlichkeit und machen es nicht nur zu einem persönlichen Software, sondern auch zu einer Ausgabe von Unternehmensqualität.

Wie kann ich mit Gamma 3.0 zugreifen und arbeiten?

Um Gamma 3.0 über Chat oder API zu verwenden, sind zwei Schritte üblich:

• Gehen Sie zu https://gamma.app/
• Erstellen Sie ein neues Konto oder melden Sie sich in Ihrem vorhandenen Konto an.

Nun zugreifen auf Gamma 3.0 im Chat zuzugreifen

• Wählen Sie die Choice aus, für die Sie Gamma, Ihre Rolle und andere Particulars verwenden möchten
• Sie können die Artwork und Weise auswählen, wie Sie Ihr PPT erstellen möchten. Du kannst:
  – Fügen Sie Ihren eigenen Inhalt ein
  – Generieren Sie PPT mit der Eingabeaufforderung
  – Laden Sie eine Datei oder einen Hyperlink hoch und generieren Sie eine PPT.
• Klicken Sie auf Generate, um loszulegen.

Während über API zugreift, um Gamma 3.0 zuzugreifen,

• Klicken Sie unten im linken Seitenfeld unten auf „Einstellungen und Mitglieder“.
• Klicken Sie dann in der Mitte des Bildschirms im oberen Feld auf „API -Schlüssel“.

• Sie müssen ein Improve auf ein kostenpflichtiges Professional -Konto haben, um auf die API zuzugreifen.
• Verwenden Sie nach Abschluss den folgenden Code, um loszulegen:

python -m pip set up requests

import requests

url = "https://public-api.gamma.app/v0.2/generations"

headers = {
    "settle for": "utility/json",
    "Content material-Sort": "utility/json"
}

response = requests.submit(url, headers=headers)

print(response.textual content)

Wie erstelle ich PPTs mit Gamma 3.0?

Gamma 3.0 bietet eine sehr intuitive Umgebung, um PPT zu generieren. Befolgen Sie die unten angegebenen Schritte, um Ihre Präsentation innerhalb weniger Minuten zu generieren.

Schritt 1: Eingabeaufforderung

Sobald Sie auf Generate geklickt haben, werden Sie auf die folgende Seite gerichtet:

Geben Sie in der Mitte des Bildschirms die Eingabeaufforderung für die PPT ein, die Sie generieren möchten.

Meine Aufforderung: „Trendkultur im Zeitalter der KI“

Sie können die Anzahl der Karten, das PPT -Seitenverhältnis und die Sprache ändern, in der Sie die PPT aus den Auswahltasten oben im Eingabeaufforderungsfeld generieren möchten. In den kostenlosen Versionen können Sie eine PPT mit 10 Karten (maximal) oder Folien erstellen. In der kostenpflichtigen Model können Sie diese jedoch auch auf 15 oder 20 erhöhen.

Sobald Sie mit allen Particulars zufrieden sind, klicken Sie auf den Umriss erstellen.

Schritt 2: Umriss

Gamma generiert eine Gliederung, die auf Ihrer Eingabeaufforderung basiert und die Sie überprüfen und bearbeiten können.

Unterhalb dieser generierten Gliederung finden Sie die Anpassungsoptionen. Hier wählen Sie die Particulars aus, die Sie in Ihrem PPT sehen möchten. Sie können die Inhaltsgröße, das Thema, die Bildquellen und mehr auswählen.

Wenn Sie Ihre PPT weiter anpassen möchten, können Sie unten auf dem Bildschirm auf die Schaltfläche „Erweiterte Modus“ klicken. Hier finden Sie Optionen, um das Publikum, den Ton und sogar die komplizierten Particulars zum Inhalt jeder Seite (oder der Karte) in der PPT anzugeben.

Sobald alle Änderungen vorgenommen wurden, klicken Sie auf „Generieren“.

Gamma erzeugt schnell die Folien oder Karten gemäß Ihrer Eingabeaufforderung und anderen Auswahlmöglichkeiten.

Hier ist die PPT, die ich auf meiner Aufforderung basiert:

Sie können es schnell überprüfen. Wenn Sie feststellen, dass es einige Nacharbeiten benötigt, können Sie entweder jeden Abschnitt auswählen und Änderungen selbst vornehmen oder den neuen Gamma -Agenten die Führung übernehmen lassen.

Schritt 3: Gamma Agent

Um auf den Gamma-Agenten zuzugreifen, klicken Sie im Feld oben rechts auf die Schaltfläche „Agent“. Sie sehen ein neues Panel am rechten Rand des Bildschirms.

Erwähnen Sie in der Eingabeaufforderung in diesem Feld die gewünschten Änderungen.

Meine Aufforderung: ‚In diesem PPT geht es darum, wie die Trendkultur durch KI neu definiert wird. Erklären Sie, was Trendkultur ist. Wie wird es von KI betroffen, insbesondere der multimodalen KI, und erstellen oder modifizieren Sie dann den Relaxation des PPT, während Sie den Relaxation entfernen, die nicht erforderlich sind. Finden Sie einige Ressourcen, die dies diskutieren, und fügen Sie diese Hyperlinks in die PPT ein. “

Sobald Sie diese Eingabeaufforderung eingegeben haben, arbeitet der Gamma -Agent schnell daran, die Änderungen einzubeziehen. Bevor es die Änderungen abschließt, werden Sie aufgefordert, die geänderte Model zu überprüfen. Sehen Sie, ob Sie die Änderungen beibehalten oder zur Originalversion zurückkehren möchten.

Der Agent wird die Änderungen entsprechend im gesamten PPT abschließen. Wenn weitere Änderungen benötigt werden, können Sie weiterhin Eingabeaufforderungen in das Eingabeaufforderungsfeld hinzufügen, und der Agent arbeitet jedes Mal daran.

Notiz: Es ist besser, Änderungen nacheinander in separaten Eingabeaufforderungen zu markieren. Auf diese Weise arbeitet der Agent Schritt für Schritt an den Änderungen, ohne dass es etwas verpasst.

Ich habe diese drei Eingabeaufforderungen dem Gamma -Agenten weiter hinzugefügt:

„Machen Sie den Inhalt präzise.“

„Bilder müssen kleiner und vielleicht illustrativer sein.“

„Ändern Sie den Hintergrund in leichtere Beige und den Textual content in Kastanienbraun.“

Nachdem all diese Eingabeaufforderungen ausgeführt wurden, ist die letzte PPT, die ich habe, hier:

Sobald Sie mit dem Endergebnis zufrieden sind, klicken Sie im oberen Feld auf die Schaltfläche „Freigabe“. Hier können Sie die PPT entweder als Objektträger, PowerPoint, PDF oder PNG speichern. Wählen Sie, was Sie wollen, und Ihr PPT ist bereit!

Verfügbarkeit und Preisgestaltung von Gamma 3.0

Gamma 3.0 wird mit einem Freemium -Nutzungsmodell geliefert. Sie können alle KI -Funktionen in der kostenlosen Model ausprobieren, aber es gibt eine begrenzte Anzahl von Credit, die Sie erhalten.

Um seine KI -Funktionen und die Gamma -Agent öfter zu verwenden, müssen Sie sein kostenpflichtiges Abonnement einnehmen. In dem kostenpflichtigen Plan erhalten Sie frühzeitigen Zugriff auf alle neuen Funktionen sowie die zusätzliche Flexibilität, auch mit verschiedenen Modellen zu arbeiten.

Meine Einstellung zu Gamma 3.0

Bei so vielen kostenlosen KI -PPT -Instruments, die in uns in der Nähe angeboten werden, können Sie Geld für Gamma 3.0 ausgeben. Während der Gamma -Agent es wert ist, dafür zu bezahlen, fühle ich Optionen wie Kimi gleitetGLM 4.5 und TOME usw., erlauben Sie auch eine solche Flexibilität.

Aber diese KI -PPT -Hersteller haben nur begrenzte Themen und benötigen oft mehrere Eingabeaufforderungen, um die Änderungen vorzunehmen. Gamma 3.0 bietet an dieser Entrance viel Leichtigkeit. Es bearbeitet schnell und genau – ohne viel zu verpassen. Tatsächlich hilft die Self-Assessment-Funktion des Gamma-Agenten dabei, Fehler zu erfassen, die Sie wahrscheinlich verpasst haben.

Wenn Sie additionally jemand sind, der PPTs viel herstellt und oft unter engen Fristen mit hohen Einsätzen arbeitet, ist Gamma 3.0 ein Kinderspiel. Für Unternehmen, die die PPT -Technology automatisieren möchten, ist dies wieder ein großartiger Wert. Andere können es einmal versuchen und dann sehen, ob es sich lohnt, dafür zu bezahlen oder nicht.

Abschluss

Lohnt sich Gamma 3.0? Ein großes Ja! Es battle so einfach, damit zu arbeiten. Obwohl das Ergebnis, das ich erzielte, nicht nach meinen Anforderungen im ersten Entwurf entsprach, machte es sein Agent sehr einfach, alles zu bearbeiten! Wisse, dass ich dieses PPT in weniger als 10 Minuten erstellt habe. Versuche das zu schlagen!

Es bietet viel Flexibilität in Bezug auf Themen, und es besteht die Möglichkeit, dass bald weitere Themen verfügbar sein werden.

Wie ich immer empfehle, überprüfen Sie jeden Aspekt des generierten PPT. Wenn Sie jedoch jemand sind, der Tag für Tag PPTs machen muss, wird Gamma Agent möglicherweise nur zu Ihrem persönlichen Lieblingshelfer.

Haben Sie sich jemals gefragt, wie Ihr Telefon Sprachbefehle versteht oder das perfekte Wort vorschlägt, auch ohne Internetverbindung? Wir sind mitten in einer großen KI-Verschiebung: von der Cloud-basierten Verarbeitung bis hin zu On-System-Intelligenz. Hier geht es nicht nur um Geschwindigkeit. Es geht auch um Privatsphäre und Zugänglichkeit. Im Zentrum dieser Verschiebung steht das Einbettungsgecken, das neue offene Einbettungsmodell von Google. Es ist kompakt, schnell und entwickelt, um große Datenmengen direkt auf Ihrem Gerät zu verarbeiten.

In diesem Weblog werden wir untersuchen, was Emettdinggeemma ist, wie wichtig es ist, wie sie es verwenden können, und welche Anwendungen es mit Strom versorgt. Lass uns eintauchen!

Was genau ist ein „Einbettungsmodell“?

Bevor wir uns mit den Particulars befassen, lasst uns ein Kernkonzept aufschlüsseln. Wenn wir einen Pc unterrichten, um die Sprache zu verstehen, können wir ihn nicht nur um Wörter ernähren, da Pc nur Zahlen verarbeiten. Hier kommt ein Einbettungsmodell ins Spiel. Es funktioniert wie ein Übersetzer und konvertiert Textual content in eine Reihe von Zahlen (a Vektor) Das erfasst Sinn und Kontext.

Betrachten Sie es als einen Fingerabdruck für Textual content. Je mehr Texten ähnlich sind, desto näher sind ihre Fingerabdrücke in einem mehrdimensionalen Raum. Diese einfache Ideen führt Anwendungen wie semantische Suche (Finden von Bedeutung und nicht nur Schlüsselwörter) und Chatbots, die die relevantesten Antworten abrufen.

Verständnis des Emettdinggeemma

Additionally, was macht aus Einbettungge besonders? Es geht darum, mehr mit weniger zu tun. Das von Google Deepmind erstellte Modell hat gerade 308 Millionen Parameter. Das magazine riesig klingen, aber in der KI -Welt gilt es als leicht. Diese kompakte Größe ist ihre Stärke, sodass sie direkt auf einem Smartphone, einem Laptop computer oder sogar einem kleinen Sensor ausgeführt werden kann, ohne sich auf eine Rechenzentrumsverbindung zu verlassen.

Diese Fähigkeit zu arbeiten On-System ist mehr als nur eine nette Funktion. Es ist eine echte Paradigmenverschiebung.

Schlüsselmerkmale

1. Unerreichte Privatsphäre: Ihre Daten bleiben auf Ihrem Gerät. Das Modell verarbeitet alles lokal, sodass Sie sich keine Sorgen über Ihre privaten Fragen oder persönlichen Daten machen müssen, die an die Cloud gesendet werden.
2. Offline -Funktionalität: Kein Web? Kein Drawback. Anwendungen, die mit Emettdinggeemma erstellt wurden, können komplexe Aufgaben wie die Suche durch Ihre Notizen oder die Organisation Ihrer Fotos ausführen, auch wenn Sie vollständig offline sind.
3. Unglaubliche Geschwindigkeit: Ohne Latenz, die Daten auf einen Server hin und her senden, ist die Antwortzeit sofort.

Und hier ist der coole Teil: Trotz seiner kompakten Größe liefert EmbedingGemma eine modernste Leistung.

• Es verfügt über das höchste Rang für ein offenes mehrsprachiges Texteinbettungsmodell unter 500 m auf dem massiven Textbettverbindungs ​​-Benchmark (MTEB).
• Seine Leistung ist vergleichbar mit oder überschreitet die von Modellen quick doppelt so groß wie sie.
• Dies ist auf sein hocheffizientes Design zurückzuführen, das mit einer Quantisierung mit weniger als 200 MB RAM ausgeführt werden kann und eine Latenz mit geringer Inferenz von Sub-15 ms auf EDGETPU für 256 Eingangs-Token bietet, wodurch es für Echtzeit-Anwendungen geeignet ist.

Lesen Sie auch: Wie wähle ich die richtige Einbettung für Ihr Lappenmodell aus?

Wie ist das Einbettunggeemma entworfen?

Eines der herausragenden Merkmale von EmbedingGemma ist die Repräsentation von Matryoshka Repräsentation (MRL). Dies gibt Entwicklern die Flexibilität, die Ausgangsabmessungen des Modells anhand ihrer Anforderungen anzupassen. Das vollständige Modell erzeugt einen detaillierten 768-dimensionalen Vektor für maximale Qualität, kann jedoch auf 512, 256 oder sogar 128 Dimensionen mit geringer Genauigkeitsverlust reduziert werden. Diese Anpassungsfähigkeit ist besonders für Geräte für ressourcenbezogene Geräte wertvoll und ermöglicht eine schnellere Ähnlichkeitssuche und niedrigere Speicheranforderungen.

Jetzt, da wir verstehen, was Emettdinggeemma mächtig macht, sehen wir es in Aktion.

Einbettung Gemma: Handson

Lassen Sie uns einen Lappen unter Verwendung von Gemma und Langgraph erstellen.

Set 1: Laden Sie den Datensatz herunter

!gdown 1u8ImzhGW2wgIib16Z_wYIaka7sYI_TGK

Schritt 2: Laden und Vorverarbeitung der Daten

from pathlib import Path

import json

from langchain.docstore.doc import Doc

# ---- Configure dataset path (replace if wanted) ----

DATA_PATH = Path("./rag_demo_docs052025.jsonl")  # similar file title as earlier pocket book

if not DATA_PATH.exists():

   increase FileNotFoundError(

       f"Anticipated dataset at {DATA_PATH}. "

       "Please place the JSONL file right here or replace DATA_PATH."

   )

# Load JSONL

raw_docs = ()

with DATA_PATH.open("r", encoding="utf-8") as f:

   for line in f:

       raw_docs.append(json.masses(line))

# Convert to Doc objects with metadata

paperwork = ()

for i, d in enumerate(raw_docs):

   sect = d.get("sectioned_report", {})

   textual content = (

       f"Difficulty:n{sect.get('Difficulty','')}nn"

       f"Impression:n{sect.get('Impression','')}nn"

       f"Root Trigger:n{sect.get('Root Trigger','')}nn"

       f"Advice:n{sect.get('Advice','')}"

   )

   paperwork.append(Doc(page_content=textual content))

print(paperwork(0).page_content)

Schritt 3: Erstellen Sie einen Vektor DB

Verwenden Sie die vorverarbeiteten Daten und einbetten Sie Gemma ein, um einen Vektor -DB zu erstellen:

from langchain_openai import OpenAIEmbeddings

from langchain_chroma import Chroma

from langchain_huggingface import HuggingFaceEmbeddings

persist_dir = "./reports_db"

assortment = "reports_db"

embedder = HuggingFaceEmbeddings(model_name="google/embeddinggemma-300m")

# Construct or rebuild the vector retailer

vectordb = Chroma.from_documents(

   paperwork=paperwork,

   embedding=embedder,

   collection_name=assortment,

   collection_metadata={"hnsw:house": "cosine"},

   persist_directory=persist_dir

)

Schritt 4: Erstellen Sie einen Hybrid -Retriever (Semantic + BM25 Key phrase Retriever)

# Reopen deal with (demonstrates persistence)

vectordb = Chroma(

   embedding_function=embedder,

   collection_name=assortment,

   persist_directory=persist_dir,

)

vectordb._collection.depend()

from langchain.retrievers import BM25Retriever, EnsembleRetriever

from langchain.retrievers import ContextualCompressionRetriever

# Base semantic retriever (cosine sim + threshold)

semantic = vectordb.as_retriever(

   search_type="similarity_score_threshold",

   search_kwargs={"ok": 5, "score_threshold": 0.2},

)

# BM25 key phrase retriever

bm25 = BM25Retriever.from_documents(paperwork)

bm25.ok = 3

# Ensemble (hybrid)

hybrid_retriever = EnsembleRetriever(

   retrievers=(bm25, semantic),

   weights=(0.6, 0.4),

   ok=5

)

# Fast check

hybrid_retriever.invoke("What are the key points in finance approval workflows?")(:3)

Schritt 5: Knoten erstellen

Erstellen wir nun zwei Knoten – einen zum Abrufen und die andere für die Era:

Definieren von Langgraph State

from typing import Listing, TypedDict, Annotated

from langgraph.graph import StateGraph, START, END

from langchain.docstore.doc import Doc as LCDocument

# We maintain overwrite semantics for all keys (no reducers wanted for appends right here).

class RAGState(TypedDict):

   query: str

   retrieved_docs: Listing(LCDocument)

   reply: str

Knoten 1: Abruf

def retrieve_node(state: RAGState) -> RAGState:

   question = state("query")

   docs = hybrid_retriever.invoke(question)  # returns listing(Doc)

   return {"retrieved_docs": docs}

Knoten 2: Era

from langchain_openai import ChatOpenAI

from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model_name="gpt-4o-mini", temperature=0)

PROMPT = ChatPromptTemplate.from_template(

   """You might be an assistant for Analyzing inner experiences for Operational Insights.

      Use the next items of retrieved context to reply the query.

      If you do not know the reply or there is no such thing as a related context, simply say that you do not know.

      give a well-structured and to the purpose reply utilizing the context info.

      Query:

      {query}

      Context:

      {context}

   """

)

def _format_docs(docs: Listing(LCDocument)) -> str:

   return "nn".be part of(d.page_content for d in docs) if docs else ""

def generate_node(state: RAGState) -> RAGState:

   query = state("query")

   docs = state.get("retrieved_docs", ())

   context = _format_docs(docs)

   immediate = PROMPT.format(query=query, context=context)

   resp = llm.invoke(immediate)

   return {"reply": resp.content material}

Construct the Graph and Edges

builder = StateGraph(RAGState)

builder.add_node("retrieve", retrieve_node)

builder.add_node("generate", generate_node)

builder.add_edge(START, "retrieve")

builder.add_edge("retrieve", "generate")

builder.add_edge("generate", END)

graph = builder.compile()

from IPython.show import Picture, show, display_markdown

show(Picture(graph.get_graph().draw_mermaid_png()))

Schritt 6: Führen Sie das Modell aus

Lassen Sie uns nun einige Beispiele für den Lappen machen, den wir gebaut haben:

example_q = "What are the key points in finance approval workflows?"

final_state = graph.invoke({"query": example_q})

display_markdown(final_state("reply"), uncooked=True)

example_q = "What brought on bill SLA breaches within the final quarter?"

final_state = graph.invoke({"query": example_q})

display_markdown(final_state("reply"), uncooked=True)

example_q = "How did AutoFlow Perception enhance SLA adherence?"

final_state = graph.invoke({"query": example_q})

display_markdown(final_state("reply"), uncooked=True)

Schauen Sie sich das gesamte Notizbuch an Hier.

Einbetten von Gemma: Leistungsbenchmarks

Jetzt, da wir ein Emettdinggeemma in Aktion gesehen haben, lassen Sie uns schnell sehen, wie es sich gegen seine Kollegen entwickelt. Die folgende Tabelle unterteilt die Unterschiede zwischen allen Prime -Einbettungsmodellen:

• Einbettunggeemma erzielt einen mittleren MTEB -Rating von 61,15, der die meisten Modelle ähnlicher und sogar größerer Größe eindeutig besiegt.
• Das Modell zeichnet sich im Abruf hervor, Klassifizierung mit soliden Clustering.
• Es schlägt größere Modelle wie mehrsprachige E5-Giant (560 m) und BGE-M3 (568 m).
• Das einzige Modell, das seine Punktzahlen schlägt, ist Qwen-Embedding-0,6B, das quick doppelt so groß ist.

Lesen Sie auch: 14 leistungsstarke Techniken, die die Entwicklung der Einbettung definieren

Einbetten von Gemma gegen OpenAi -Einbettungsmodelle

Ein wichtiger Vergleich ist zwischen Einbettungsgemma und OpenAIs Einbettungsmodellen. OpenAI-Einbettungen sind für kleine Projekte im Allgemeinen kostengünstiger, aber für größere, skalierbare Anwendungen hat das Einbettunggeemma den Vorteil. Ein weiterer wichtiger Unterschied ist die Kontextgröße: OpenAI -Einbettungsdings unterstützen bis zu 8K -Token, während die Emettdinggeemma derzeit bis zu 2K -Token unterstützt.

Anwendungen der Einbettungge

Die wahre Kraft des Einbettungsgeckens liegt in der Vielzahl von Anwendungen, die es ermöglicht. Durch die Generierung hochwertiger Texteinbettungen direkt auf dem Gerät führt es eine neue Era von Datenschutz-zentrierten und effizienten KI-Erlebnissen.

Hier sind einige Schlüsselanwendungen:

1. LAPPEN: Wie bereits erwähnt, kann Emettdinggeemma verwendet werden, um eine robuste Lappenpipeline zu erstellen, die vollständig offline funktioniert. Sie können einen persönlichen KI -Assistenten erstellen, der Ihre Dokumente durchsuchen und präzise, ​​geerdete Antworten geben kann. Dies ist besonders nützlich, um Chatbots zu erstellen, die Fragen basierend auf einer bestimmten privaten Wissensbasis beantworten können.

2. Semantische Suche und Informationsabruf: Anstatt nur nach Schlüsselwörtern zu suchen, können Sie Suchfunktionen erstellen, die die Bedeutung der Abfrage eines Benutzers verstehen. Dies eignet sich perfekt für die Suche nach großen Dokumentbibliotheken, Ihren persönlichen Notizen oder der Wissensbasis eines Unternehmens, um sicherzustellen, dass Sie schnell und genau die relevantesten Informationen finden.

3. Klassifizierung und Clustering: Einbettungsgemma kann verwendet werden, um Anwendungen für das Gerät für Aufgaben wie Klassifizierung von Texten (z. B. Stimmungsanalyse, SPAM-Erkennung) oder sie in Gruppen zu gruppieren, basierend auf ihren Ähnlichkeiten (z. B. Organisation von Dokumenten, Marktforschung).

4. Semantische Ähnlichkeits- und Empfehlungssysteme: Die Fähigkeit des Modells, die Ähnlichkeit zwischen Texten zu messen, ist eine Kernkomponente von Empfehlungsmotoren. Zum Beispiel kann es einem Benutzer, der auf seinem Leseverlauf basierend auf dem Leserhistorium, neue Artikel oder Produkte empfehlen und gleichzeitig ihre Daten privat halten.

5. Code -Abruf & Faktenüberprüfung: Entwickler können ein Emettdinggeemma verwenden, um Instruments zu erstellen, mit denen relevante Codeblöcke basierend auf einer natürlichen Sprachabfrage abgerufen werden. Es kann auch in Fakten zur Überprüfung von Systemen verwendet werden, um Dokumente abzurufen, die eine Erklärung unterstützen oder widerlegen, wodurch die Zuverlässigkeit von Informationen verbessert wird.

Abschluss

Google hat nicht nur ein Modell gestartet. Sie haben ein Toolkit veröffentlicht. Einbettinggeemma integriert sich in Frameworks wie Satztransformers, Lama.cpp und Langchain, was es den Entwicklern erleichtert, leistungsstarke Anwendungen aufzubauen. Die Zukunft ist lokal. Einbettunggeemma ermöglicht die Privatsphäre, die erste, effiziente und schnelle KI, die direkt auf Geräten ausgeführt wird. Es demokratisiert Zugang und legt leistungsstarke Werkzeuge in die Hände von Milliarden.

Openai GPT-5 gestartet Letzte Nacht, und es wird während der Cursor -Startwoche kostenlos zur Verfügung gestellt! Seit der Veröffentlichung von GPT-5 habe ich seine Funktionen streng getestet, und ehrlich gesagt habe ich eine Weile gebraucht, um zu verstehen, wie großartig dieses neue Modell wirklich ist.

Mein allererster Schritt, nachdem ich heute Morgen mit der GPT-5-Ankündigung aufgewacht conflict, bestand darin, GPT-5 auf Cursor zu testen. Cursor Bietet kostenlose GPT-5-Credit für die Zahlung von Benutzern während der Startwoche in Zusammenarbeit mit OpenAI und ich habe es hart gedrängt. Ich denke, das, was ich entdeckt habe, könnte sich wahrscheinlich um den Geist auswirken.

Wenn Sie auf die GPT-5-Veröffentlichung gewartet haben oder sich gefragt haben, worum es bei all dem großen Begeisterung in Bezug auf die neuesten GPT-5-Tech-Nachrichten geht, dann betrachten Sie sich für einen Vergnügen. Hier führen ich Sie durch alles: Von den Tremendous-Cool-GPT-5-Funktionen bis hin zu praktischen Codierungsbeispielen, die Sie ausprobieren können.

Was macht GPT-5 so besonders?

Bevor ich in die GPT-5-Codierungsbeispiele eingehe, muss ich die Gründe für die so begeisterten Entwickler über dieses neue GPT-5-Modell auflisten. Nach stundenlangem intensiven Check haben hier die Dinge, die Chatgpts GPT-5 zu einem echten Sport-Changer gemacht haben:

Das 400k-Kontextfenster des GPT-5 ist groß. Ich warf eine 300-seitige Codebasis darauf, und GPT-5 verstand die gesamte Projektstruktur, als hätte sie seit Monaten daran gearbeitet. Die Gedankenkette von GPT-5 ist so knackig, dass sie sich tatsächlich verfeinert und erklärt, warum sie eine bestimmte Entscheidung getroffen hat.

Aber hier ist das einzige, was mich wirklich begeistert-die Multimodal-KI-Funktion GPT-5. Es können Screenshots Ihres Codes erfordern, Diagramme verstehen und beim Debuggen für visuelles Format helfen. Ich kann ehrlich sagen, dass ich so etwas noch nie gesehen habe.

Erste Schritte: So greifen Sie auf GPT-5 kostenlos auf Cursor zu

Bereit, auf echte Arbeit zu gelangen? Hier erfahren Sie, wie Sie GPT-5 auf Cursor verwenden, und glauben Sie mir, es ist wirklich viel einfacher als Sie denken.

Schritt 1. Cursor herunterladen und installieren

Das Wichtigste zuerst, besuchen Sie Cursor.so und laden Sie diesen Editor herunter. Denken Sie an als Vs Code mit zusätzlichen KI -Leckereien. Nur ein paar Klicks für die Set up:

• Laden Sie den Cursor für Ihr Betriebssystem herunter
• Installieren Sie es wie jede normale Anwendung
• Nach der Set up öffnen Sie es und Sie sehen die schlanke Oberfläche sofort

Schritt 2: Richten Sie Ihren GPT-5-Zugriff ein

Hier wird es interessant. Während der GPT-5-Startwoche versorgte Cursor den Benutzern einen kostenlosen GPT-5-Testzugriff, und viele Benutzer erhalten weiterhin kostenlose Credit für Cursor GPT-5. Hier erfahren Sie, wie Sie es einrichten:

• Öffnen Sie den Cursor, drücken Sie Strg+Shift+P (CMD+Shift+P auf dem Mac).
• Geben Sie Cursor ein: Melden Sie sich an und melden Sie sich mit Ihrem Konto an
• Gehen Sie zu Einstellungen> AI -Modelle
• Wählen Sie GPT-5 im Dropdown-Menü

Professional -Tipp: Wenn Sie GPT-5 zuerst nicht sehen, starten Sie den Cursor neu. Manchmal handelt die OpenAI-GPT-5-Integration etwas dunstig.

Praktische Codierungsdemo: Erstellen eines echten Projekts

Der lustige Teil! Jetzt werde ich Ihnen zeigen, was genau ich mit der GPT-5-Codegenerierung gemacht habe. Mit den Funktionen des GPT-5-Codierungsmodells werden wir eine Full-Stack-Job-Administration-App erstellen.

Demo -Projekt: Sensible Job Supervisor mit KI -Funktionen

Lassen Sie mich Sie durch den Bau etwas erstellen, das wirklich GPT-5-Funktionen hervorbringt. Wir werden einen Job -Supervisor erstellen, der mit AI die automatischen Kategorisierung und Priorisierung von Aufgaben priorisieren.

Schritt 1: Projekteinrichtung und Projektstruktur

Öffnen Sie den Cursor und erstellen Sie einen neuen Ordner namens GPT5-Job-Supervisor. Was ich getan habe conflict:

Hier schockierte mich GPT-5. Ich habe gerade den Chat eingegeben: „Erstellen Sie eine moderne React -App -Struktur mit TypeScript, Rashwind und Specific -Backend für eine Job -Administration -App“.

GPT-5 hat nicht nur die Dateistruktur, sondern auch die gesamte Kesselplatte erstellt. Wirklich umwerfend sind die Fähigkeiten, die GPT-5 für die Softwareentwicklung hat-es verstand den gesamten Projektkontext und erstellte:

• Frontend React -Komponenten mit TypeScript
• Specific.js Backend mit ordnungsgemäßem Routing
• Datenbankschema für Aufgaben
• Richtige Fehlerbehandlung

Schritt 2: Frontend-Entwicklung mit GPT-5

Lassen Sie mich Ihnen den tatsächlichen Code zeigen, den GPT-5 generierte. Dies ist die Hauptkomponente der Taskmanager:

import React, { useState, useEffect } from 'react';
import { Job, TaskPriority, TaskStatus } from '../sorts/activity';
import TaskCard from './TaskCard';
import AddTaskModal from './AddTaskModal';

interface TaskManagerProps {
  // GPT-5 mechanically inferred these props
}

const TaskManager: React.FC = () => {
  const (duties, setTasks) = useState<Job()>(());
  const (loading, setLoading) = useState(false);
  const (filter, setFilter) = useState<'all' | 'pending' | 'accomplished'>('all');

  // GPT-5 generated this good categorization operate
  const categorizeTask = async (taskDescription: string): Promise<string> => {
    // That is the place GPT-5's AI reasoning shines
    const response = await fetch('/api/categorize', {
      methodology: 'POST',
      headers: { 'Content material-Kind': 'software/json' },
      physique: JSON.stringify({ description: taskDescription })
    });
    return response.json();
  };

  const addTask = async (taskData: Partial<Job>) => {
    setLoading(true);
    attempt  '');
      const newTask = ;
      
      setTasks(prev => (...prev, newTask as Job));
     catch (error) {
      console.error('Error including activity:', error);
    } lastly {
      setLoading(false);
    }
  };

  return (
    <div className="min-h-screen bg-gradient-to-br from-blue-50 to-indigo-100">
      <div className="container mx-auto px-4 py-8">
        <header className="mb-8">
          <h1 className="text-4xl font-bold text-gray-800 mb-2">
            Sensible Job Supervisor
          </h1>
          <p className="text-gray-600">Powered by GPT-5 AI Intelligence</p>
        </header>
        
        <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
          {/* Job filters and controls */}
          <div className="lg:col-span-1">
            <TaskFilters 
              currentFilter={filter} 
              onFilterChange={setFilter}
            />
          </div>
          
          {/* Fundamental activity checklist */}
          <div className="lg:col-span-2">
            <TaskList 
              duties= activity.standing === filter
              )
              onTaskUpdate={updateTask}
              loading={loading}
            />
          </div>
        </div>
      </div>
    </div>
  );
};

export default TaskManager;

Das einzige, was mich völlig verblüffte, conflict die Artwork und Weise, wie GPT-5-Code debugged conflict. Ich meine, ich hatte diesen Typscript-Fehler, ich würde nur den Code mit dem Drawback hervorheben und GPT-5 bitten, ihn zu beheben. Und es hat nicht nur den Fehler behoben; Es erklärte die Artwork des Fehlers und die Verbesserung des Codes, um solche Fehler in Zukunft zu vermeiden.

Schritt 3: Backend -API mit intelligenten Funktionen

Der von GPT-5 generierte Backend-Code conflict genauso beeindruckend. Hier ist der Specific.js-Server mit KI-angetanter Aufgabenkategorisierung:

const categorical = require('categorical');
const cors = require('cors');
const { OpenAI } = require('openai');

const app = categorical();
const port = 3001;

app.use(cors());
app.use(categorical.json());

// GPT-5 generated this clever categorization endpoint
app.publish('/api/categorize', async (req, res) => {
  attempt {
    const { description } = req.physique;
    
    // That is the place the magic occurs - utilizing AI to categorize duties
    const immediate = `
      Categorize this activity into one in all these classes: 
      Work, Private, Purchasing, Well being, Studying, Leisure
      
      Job: "${description}"
      
      Return solely the class title.
    `;
    
    // Simulating AI categorization (in actual app, you'd use OpenAI API)
    const classes = ('Work', 'Private', 'Purchasing', 'Well being', 'Studying', 'Leisure');
    const class = classes(Math.flooring(Math.random() * classes.size));
    
    res.json({ class });
  } catch (error) {
    console.error('Categorization error:', error);
    res.standing(500).json({ error: 'Did not categorize activity' });
  }
});

// Sensible precedence calculation endpoint
app.publish('/api/calculate-priority', async (req, res) => {
  attempt {
    const { description, dueDate } = req.physique;
    
    // GPT-5's reasoning for precedence calculation
    let precedence = 'medium';
    
    const urgentKeywords = ('pressing', 'asap', 'emergency', 'important');
    const lowKeywords = ('possibly', 'sometime', 'ultimately', 'when doable');
    
    const desc = description.toLowerCase();
    
    if (urgentKeywords.some(key phrase => desc.contains(key phrase))) {
      precedence = 'excessive';
    } else if (lowKeywords.some(key phrase => desc.contains(key phrase))) {
      precedence = 'low';
    }
    
    // Contemplate due date
    if (dueDate) {
      const due = new Date(dueDate);
      const now = new Date();
      const daysUntilDue = (due - now) / (1000 * 60 * 60 * 24);
      
      if (daysUntilDue <= 1) precedence = 'excessive';
      else if (daysUntilDue <= 3) precedence = 'medium';
    }
    
    res.json({ precedence });
  } catch (error) {
    console.error('Precedence calculation error:', error);
    res.standing(500).json({ error: 'Did not calculate precedence' });
  }
});

// GET all duties
app.get('/api/duties', (req, res) => {
  res.json(duties);
});

// POST new activity
app.publish('/api/duties', (req, res) => {
  const newTask = {
    id: Date.now().toString(),
    ...req.physique,
    createdAt: new Date(),
    standing: 'pending'
  };
  
  duties.push(newTask);
  res.standing(201).json(newTask);
});

app.hear(port, () => {
  console.log(`Server working on http://localhost:${port}`);
});

Schritt 4: Superior Options Showcase

Hier überstrahlt GPT-5 Multimodal AI die anderen Modelle wirklich. Ich habe es gebeten, eine Komponente zu erstellen, mit der hochgeladene Bilder für die Aufgabenerstellung analysiert werden könnten:

import React, { useState, useCallback } from 'react';
import { useDropzone } from 'react-dropzone';

const ImageTaskCreator: React.FC = () => {
  const (imageAnalysis, setImageAnalysis) = useState<string>('');
  const (loading, setLoading) = useState(false);

  const onDrop = useCallback(async (acceptedFiles: File()) => {
    const file = acceptedFiles(0);
    if (!file) return;

    setLoading(true);
    
    attempt {
      // Convert picture to base64
      const base64 = await fileToBase64(file);
      
      // In an actual app, you'd ship this to GPT-5's imaginative and prescient API
      // For demo functions, we'll simulate evaluation
      const analysisResult = await analyzeImageForTasks(base64);
      setImageAnalysis(analysisResult);
      
    } catch (error) {
      console.error('Picture evaluation failed:', error);
    } lastly {
      setLoading(false);
    }
  }, ());

  const { getRootProps, getInputProps, isDragActive } = useDropzone({
    onDrop,
    settle for: {
      'picture/*': ('.png', '.jpg', '.jpeg', '.gif')
    },
    a number of: false
  });

  const fileToBase64 = (file: File): Promise<string> => {
    return new Promise((resolve, reject) => {
      const reader = new FileReader();
      reader.readAsDataURL(file);
      reader.onload = () => resolve(reader.end result as string);
      reader.onerror = error => reject(error);
    });
  };

  const analyzeImageForTasks = async (base64Image: string): Promise<string> => {
    // Simulate GPT-5 imaginative and prescient evaluation
    const eventualities = (
      "I can see a messy desk. Urged duties: 'Arrange workspace', 'File paperwork', 'Clear desk space'",
      "This seems to be a recipe. Urged duties: 'Purchase substances', 'Put together meal', 'Set cooking time'",
      "I discover a to-do checklist within the picture. Urged duties: 'Evaluate handwritten notes', 'Digitize activity checklist'",
      "This seems to be like a gathering whiteboard. Urged duties: 'Observe up on motion gadgets', 'Schedule subsequent assembly'"
    );
    
    return eventualities(Math.flooring(Math.random() * eventualities.size));
  };

  return (
    <div className="bg-white rounded-lg shadow-lg p-6">
      <h3 className="text-xl font-semibold mb-4">AI Picture Job Creator</h3>
      <p className="text-gray-600 mb-6">
        Add a picture and let GPT-5's imaginative and prescient capabilities recommend related duties
      </p>
      
      <div
        {...getRootProps()}
        className={`border-2 border-dashed rounded-lg p-8 text-center transition-colors ${
          isDragActive 
            ? 'border-blue-400 bg-blue-50' 
            : 'border-gray-300 hover:border-gray-400'
        }`}
      >
        <enter {...getInputProps()} />
        {loading ? (
          <div className="flex items-center justify-center">
            <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600"></div>
            <span className="ml-2">Analyzing picture with GPT-5...</span>
          </div>
        ) : (
          <div>
            <svg className="mx-auto h-12 w-12 text-gray-400" stroke="currentColor" fill="none" viewBox="0 0 48 48">
              <path d="M28 8H12a4 4 0 00-4 4v20m32-12v8m0 0v8a4 4 0 01-4 4H12a4 4 0 01-4-4v-4m32-4l-3.172-3.172a4 4 0 00-5.656 0L28 28M8 32l9.172-9.172a4 4 0 015.656 0L28 28m0 0l4 4m4-24h8m-4-4v8m-12 4h.02" strokeWidth="2" strokeLinecap="spherical" strokeLinejoin="spherical" />
            </svg>
            <p className="mt-2 text-sm text-gray-600">
              {isDragActive ? 'Drop the picture right here' : 'Drag & drop a picture right here, or click on to pick out'}
            </p>
          </div>
        )}
      </div>
      
      {imageAnalysis && (
        <div className="mt-6 p-4 bg-green-50 border border-green-200 rounded-lg">
          <h4 className="font-medium text-green-800 mb-2">GPT-5 Evaluation Outcomes:</h4>
          <p className="text-green-700">{imageAnalysis}</p>
          <button className="mt-3 px-4 py-2 bg-green-600 text-white rounded hover:bg-green-700 transition-colors">
            Create Urged Duties
          </button>
        </div>
      )}
    </div>
  );
};

export default ImageTaskCreator;

Meine Bewertung

Nachdem ich GPT-5 seit seiner Begin verwendet habe, bin ich wirklich schockiert darüber, wie intestine es ist. Der Code, den es entwickelt hat, ist nicht nur verwendbar-die, die ich in die Produktion einsetzte, hatte eine angemessene Fehlerbehandlung, vollständige Typskriptypen und Leistungsoptimierungen, die ich nicht einmal anforderte. Ich gab ihm einen Screenshot von kaputten CSS und eine sofortige Diagnose und es wurde sofort das Drawback der Flexbox behoben. Die multimodale KI von GPT-5 ist atemberaubend. Im Gegensatz zu GPT-4, das den Kontext oft „vergessen“ hat, gelang es ihm, die gesamte 300-Zeilen-Projektstruktur für die gesamte Sitzung im Kontext zu halten. Schießen Sie, manchmal schafft es ein wenig zu viel für ein Drawback, und manchmal wird es wörtlich, wenn ich schnelle Korrekturen möchte, aber diese sind ein Nitpicking.

Finales Urteil: 9 von 10

Dies ist die erste KI, die mir das Gefühl gegeben hat, zusammen mit einem hochrangigen Entwickler, der nie schläft, niemals meine naiven Fragen beurteilt und jeden gelesen hat Stapelüberlauf Antwort jemals geschrieben. Junior-Entwickler lernen schneller als je zuvor, hochrangige Entwickler werden sich mehr auf die Architektur konzentrieren, während GPT-5 die Kesselplatte mit Perfektion nageln wird. Nach einem Vorgeschmack auf den GPT-5-unterstützten Software program-Entwicklungs-Workflow bei Cursor gibt es einfach keine Rückkehr zur Codierung ohne ihn. Was im Second einem perfekten 10 widersteht, ist, dass ich es für größere Unternehmensprojekte werfen muss, aber ab diesem Second? Dies verändert alles für Tech -Enthusiasten und Entwickler gleichermaßen.

Efficiency der realen Welt: GPT-5 gegenüber früheren Modellen

Nachdem ich Stunden mit GPT-5 verbracht hatte, musste ich einen Vergleich dagegen machen GPT-4. Es gibt einen starken Unterschied, wenn es um GPT-5-Fehlerfixierungen und komplexe Argumentationsaufgaben geht.

Qualität und Verständnis Code

Das Verständnis des Kontextes des Code durch GPT-5 ist wirklich intestine. Als ich es bat, einige komplexe Reaktionskomponenten neu zu neu auszurufen, änderte es nicht nur den Code:

• Es erläuterte die Leistungsauswirkungen jeder Änderung
• Es schlug bessere Typ -Skript -Schnittstellen vor
• Es fügte die richtigen Fehlergrenzen hinzu
• Es fügte ein paar Barrierefreiheitsverbesserungen hinzu, über die ich noch nicht einmal nachgedacht hatte

Mit dem GPT-5-Kontextfenster von 400K-Token können Sie Ihr gesamtes Projekt buchstäblich einfügen und den Kontext während des gesamten Gesprächs beibehalten. Ich habe dies mit einem 50-Datei-React-Projekt auf die Probe gestellt und die Beziehungen zwischen verschiedenen Komponenten perfekt verstanden.

Debuggen von Supermächten

Ein hervorragendes Beispiel für die KI-Argumentation für das Debuggen mit GPT-5 ist, dass es nicht nur Syntaxfehler behebt. Stattdessen versteht es die Absicht der Funktion. Hier ist eine tatsächliche Debugging -Sitzung:

Hier conflict meine Fehlerfunktion:

const calculateTaskScore = (activity) => {
  let rating = 0;
  if (activity.precedence = 'excessive') rating += 10; // BUG: task as an alternative of comparability
  if (activity.dueDate < new Date()) rating += 5;
  return rating / activity.description.size; // BUG: potential division by zero
}

GPT-5 hat nicht nur die Syntaxprobleme behoben, sondern auch erklärt:

• Der Zuordnungsfehler und wie es Probleme verursacht
• Die potenzielle Aufteilung nach Nullfehler
• Vorgeschlagene Eingabevalidierung
• Empfohlenere robustere Bewertungsberechnungen
• Sogar Unit -Check -Verhinderung von Regressionen

Warum dies alles für Entwickler verändert

Bei GPT-5-Zugriff über Cursor geht es nicht nur um schnelleres Codieren. Es geht darum, die Entwicklung der Software program radikal zu transformieren. Das neuere AI-Modell GPT-5 versteht nicht nur, was Sie tun möchten, aber auch, warum Sie es tun möchten.

Der Lernbeschleunigereffekt

Für einen Junior -Entwickler ähnelt es einem älteren Entwickler, der mit ihm/ihr rund um die Uhr programmiert. GPT-5 schreibt nicht nur Code-It-Lehre. Es bietet Erklärungen, various Ansätze und Finest Practices mit jeder Lösung.

Für ältere Entwickler ist es, als hätte ein superverkennbarer Kollege, der jede Dokumentation, jedes Tutorial und jeden Stack-Überlauf-Thread gelesen hat. Diese Funktionen der GPT-5-Softwareentwicklung ermöglichen es Seniorentwicklern, ihre Gedanken für Architektur und kreative Problemlösung zu befreien.

Jenseits der Codegenerierung

Was mich am meisten beeindruckte, conflict nicht das GPT-5-Codierungsmodell, das Boilerplate generierte, sondern strategisches Denken. Als ich es hatte, mir zu helfen, ein Datenbankschema zu entwerfen, dachte es darüber nach:

• Zukünftige Skalierbarkeitsanforderungen
• Gemeinsame Abfragemuster
• Indexoptimierungsstrategien
• Datenkonsistenzherausforderungen
• Migrationsstrategien für Schemaänderungen

Diese Artwork des gründlichen Denkens ist der Schlüssel, um GPT-5 von seinen Vorgängern abzuheben.

Nehmen Sie das Beste aus Ihrer GPT-5-Erfahrung heraus

Nach umfangreichen Assessments finden Sie hier meine Empfehlungen zur Maximierung der GPT-5-Mächte:

Schnelltechnik für Entwickler

• Seien Sie spezifisch zum Kontext: Im Gegensatz zu so etwas wie „Repair diesen Code“, machen Sie etwas Konkretteres wie „Diese React -Komponente hat ein Speicherleck, da der UseSeffect -Ereignis -Hörer keine Ereignis -Hörer bereinigt. Hier ist die Komponente (Code einfügen).“
• Erfordernis Erklärungen: Verfolgen Sie immer „Erklären Sie Ihre Argumentation“, damit Sie verstehen, wie die KI diese Wahl getroffen hat.
• Anfordern Sie mehrere Lösungen: „Zeigen Sie mir 3 verschiedene Möglichkeiten, dies mit Vor- und Nachteilen zu lösen.“

Nutzen Sie die große Kontextkapazität

Das GPT-5 400K-Kontextfenster ist ein echter Sport-Changer. Laden Sie Ihre gesamte Projektstruktur hoch und fragen Sie nach:

• Architekturkritiken
• Vorschläge für die Komponentenoptimierung
• Konsistenzverbesserungen über die Codebasis
• Sicherheitsanfälligkeitsbewertungen

Schlussfolgerung: Ist GPT-5 den Hype wert?

Nachdem ich tief eingetaucht conflict, ist meine starke Meinung, dass das gesamte GPT-5-Development-Buzz ziemlich gerechtfertigt ist. Es ist eine großartige Entwicklungserfahrung für wirklich futuristische Entwicklungen, die GPT-5-Merkmale kombinieren: enormes Kontextfenster, multimodales und fortgeschrittenes Denken.

Unglaublich ist die Tatsache, dass wir während dieser Startphase freien Zugang zu GPT-5 durch Cursor haben. Wenn Sie ein Entwickler sind und dies nicht ausprobiert haben, verpassen Sie, was möglicherweise der höchste Produktivitätsschub sein kann.

In Teil 3.1 Wir haben begonnen, zu diskutieren, wie die Zeitreihendaten in Pattern-, Saisonalitäts- und Restkomponenten zerlegt werden. Da es sich um eine glättungsbasierte Technik handelt, müssen wir für STL eine harte Schätzung des Traits und der Saisonalität benötigen, um eine Glättung durchzuführen.

Zu diesem Zweck haben wir eine grobe Schätzung eines Traits berechnet, indem wir ihn unter Verwendung der zentrierten Transferring -Durchschnittsmethode berechnet haben, und dann mit diesem anfänglichen Pattern die anfängliche Saisonalität berechnet. (Eine detaillierte Mathematik wird in erörtert Teil 3.1)

In diesem Teil implementieren wir die LOESS (lokal geschätzte Streuplot -Glättung) Methode Als nächstes den letzten Pattern und die saisonalen Komponenten der Zeitreihe.

Am Ende von Teil 3.1 haben wir folgende Daten:

Da wir die zentrierte saisonale Komponente haben, besteht der nächste Schritt darin, dies von der ursprünglichen Zeitreihe abzuziehen, um die deseasonalisierte Serie zu erhalten.

Wir haben die Serie von Desesta -Werten erhalten und wissen, dass dies sowohl Pattern- als auch Restkomponenten enthält.

Jetzt wenden wir Löss (lokal geschätzte Streuplot -Glättung) in dieser descesaison -Serie an.

Hier wollen wir das Konzept und die Mathematik hinter der Lösungstechnik verstehen. Zu diesem Zweck betrachten wir einen einzelnen Datenpunkt aus der deseasonalisierten Serie und implementieren Sie die Lösungslösungen Schritt für Schritt und beobachten, wie sich der Wert ändert.

---

Bevor wir die Mathematik hinter der Löss verstehen, versuchen wir zu verstehen, was tatsächlich im Lösungs -Glättungsprozess getan wird.

Losse ist der Prozess ähnlich wie die einfache lineare Regression, aber der einzige Unterschied besteht darin, dass wir den Punkten Gewichte zuweisen, so dass die Punkte, die dem Zielpunkt näher sind, mehr Gewicht und weiter vom Zielpunkt entfernt werden.

Wir können es eine gewichtete einfache lineare Regression nennen.

Hier ist der Zielpunkt der Punkt, an dem die Lösungsglättung durchgeführt wird, und in diesem Prozess wählen wir einen Alpha -Wert, der zwischen 0 und 1 liegt.

Meistens verwenden wir 0,3 oder 0,5 als Alpha -Wert.

Nehmen wir beispielsweise an, Alpha = 0,3, was bedeutet, dass 30% der Datenpunkte in dieser Regression verwendet werden. Wenn wir 100 Datenpunkte haben, werden in diesem Glättungsprozess 15 Punkte vor dem Zielpunkt und 15 Punkte nach dem Zielpunkt (einschließlich Zielpunkt) verwendet.

Gleich wie bei einer einfachen linearen Regression passen wir in diesem Glättungsprozess eine Linie mit zusätzlichen Gewichten an die Datenpunkte.

Wir fügen den Datenpunkten Gewichte hinzu, da es der Linie hilft, sich an das lokale Verhalten der Daten anzupassen und Schwankungen oder Ausreißer zu ignorieren, da wir versuchen, die Trendkomponente in diesem Prozess abzuschätzen.

Jetzt haben wir die Idee, dass wir im Lösungsglättungsprozess eine Zeile passen, die am besten zu den Daten passt, und von diesem, dem wir den geglätteten Wert am Zielpunkt berechnen.

Als nächstes werden wir Loess -Glättung implementieren, indem wir als Beispiel einen einzelnen Punkt annehmen.

---

Versuchen wir zu verstehen, was tatsächlich in der Lösungsglättung getan wird, indem wir als Beispiel einen einzigen Punkt annehmen.

Betrachten Sie den 01.08.2010, hier beträgt der desesseinalisierte Wert 14751.02.

Um die Mathematik hinter LOESS leicht zu verstehen, sollten wir eine Zeitspanne von fünf Punkten betrachten.

Hier bedeutet die Spannweite von fünf Punkten, die Punkte, die dem Zielpunkt (1-8-2010) in der Nähe des Zielpunkts am nächsten sind.

Um im August 2010 Lösungsglättung zu demonstrieren, haben wir die Werte von Juni 2010 bis Oktober 2010 berücksichtigt.

Hier stammen die Indexwerte (ab Null) aus den Originaldaten.

Der erste Schritt bei der Loess -Glättung besteht darin, dass wir die Abstände zwischen dem Zielpunkt und den benachbarten Punkten berechnen.

Wir berechnen diesen Abstand basierend auf den Indexwerten.

Wir haben die Abstände berechnet und der maximale Abstand vom Zielpunkt ist ‚2‘.

Der nächste Schritt bei der Glättung von Lösern besteht nun darin, die Tricube -Gewichte zu berechnen. Los weist jedem Punkt auf der Grundlage der skalierten Abstände Gewichte zu.

Hier sind die Tricube -Gewichte für 5 Punkte (0,00, 0,66, 1,00, 0,66, 0,00).

Nachdem wir die Tricube -Gewichte berechnet haben, besteht der nächste Schritt darin, eine gewichtete einfache lineare Regression durchzuführen.

Die Formeln sind ähnlich wie SLR, wobei die üblichen Durchschnittswerte durch gewichtete Durchschnittswerte ersetzt werden.

Hier ist die vollständige Schritt -für -Schritt -Mathematik zur Berechnung des loess -geglätteten Wertes bei t = 7.

Hier beträgt die Schätzung des Lösungstrends im August 2010 14212,96, was geringer ist als der sessichtisierte Wert von 14751.02.

Wenn wir in unserem 5-Punkte-Fenster die Werte der benachbarten Monate sehen, können wir feststellen, dass die Werte abnehmen und der Wert im August wie ein plötzlicher Sprung aussieht.

LOESS versucht, eine Zeile anzupassen, die am besten zu den Daten passt, die den zugrunde liegenden lokalen Pattern darstellen. Es glättet scharfe Spikes oder Dips und gibt uns ein echtes lokales Verhalten der Daten.

---

So berechnet Löss den geglätteten Wert für einen Datenpunkt.

Für unseren Datensatz, wenn wir die STL -Dekomposition mit Python implementieren, kann der Alpha -Wert zwischen 0,3 und 0,5 basierend auf der Anzahl der Punkte im Datensatz liegen.

Wir können auch verschiedene Alpha -Werte ausprobieren und sehen, welche die Daten am besten darstellen, und wählen Sie die entsprechenden aus.

Dieser Vorgang wird für jeden Punkt in den Daten wiederholt.

Sobald wir die loess -geglättete Trendkomponente erhalten haben, wird sie von der Originalserie abgezogen, um Saisonalität und Rauschen zu isolieren.

Als nächstes folgen wir den gleichen Lösungsglättungsverfahren über saisonale Unterserien wie alle Januarare, Februars usw. (wie in Teil 3.1), um loess -geglättete saisonale Komponente zu erhalten.

Nachdem wir sowohl den loess geglätteten Pattern als auch die Saisonalitätskomponenten erhalten haben, subtrahieren wir sie von Originalserien, um den Relaxation zu erhalten.

Danach wird der gesamte Vorgang wiederholt, um die Komponenten weiter zu verfeinern, die loess -glättete Saisonalität wird von der Originalserie abgezogen, um einen loess -geglätteten Pattern zu finden, und dieser neue Lösungsstrend wird von der Originalserie abgehoben, um die Loess Smoothed Saisonalität zu finden.

Dies können wir als eine Iteration bezeichnen, und nach mehreren Iterationsrunden (10-15) werden die drei Komponenten stabilisiert und es gibt keine weitere Änderung und STL gibt den endgültigen Pattern, die Saisonalität und die Restkomponenten zurück.

Dies passiert, wenn wir den folgenden Code verwenden, um die STL -Dekoration auf dem Datensatz anzuwenden, um die drei Komponenten zu erhalten.

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.seasonal import STL

# Load the dataset
df = pd.read_csv("C:/RSDSELDN.csv", parse_dates=('Observation_Date'), dayfirst=True)
df.set_index('Observation_Date', inplace=True)
df = df.asfreq('MS')  # Guarantee month-to-month frequency

# Extract the time collection
collection = df('Retail_Sales')

# Apply STL decomposition
stl = STL(collection, seasonal=13)
end result = stl.match()

# Plot and save STL elements
fig, axs = plt.subplots(4, 1, figsize=(10, 8), sharex=True)

axs(0).plot(end result.noticed, coloration='sienna')
axs(0).set_title('Noticed')

axs(1).plot(end result.development, coloration='goldenrod')
axs(1).set_title('Pattern')

axs(2).plot(end result.seasonal, coloration='darkslategrey')
axs(2).set_title('Seasonal')

axs(3).plot(end result.resid, coloration='rebeccapurple')
axs(3).set_title('Residual')

plt.suptitle('STL Decomposition of Retail Gross sales', fontsize=16)
plt.tight_layout()

plt.present()

Datensatz: In diesem Weblog werden öffentlich verfügbare Daten von Fred (Wirtschaftsdaten der Federal Reserve) verwendet. Die Serie Voraussetzungen für den Einzelhandel: Kaufhäuser (RSDSELD) wird vom US Census Bureau veröffentlicht und kann zur Analyse und Veröffentlichung mit angemessenem Zitat verwendet werden.

Offizielles Zitat:
US Census Bureau, Voraussetzungen für den Einzelhandel: Kaufhäuser (Rsdseld), abgerufen von Fred, Federal Reserve Financial institution of St. Louis; https://fred.stlouisfed.org/collection/rsdseld7. Juli 2025.

Hinweis: Alle Bilder, sofern nicht anders angegeben, werden vom Autor.

Ich hoffe, Sie haben eine grundlegende Vorstellung davon, wie die STL -Zersetzung funktioniert, von der Berechnung des anfänglichen Traits und der Saisonalität bis hin zur Suche nach endgültigen Komponenten mithilfe von Loess -Glättung.

Als nächstes in der Serie diskutieren wir ‚Stationarität einer Zeitreihe ‚ ausführlich.

Danke fürs Lesen!

Wir kümmern uns um Klassifizierungsalgorithmen In maschinellem Lernen wie logistischer Regression, Ok-Nearest-Nachbarn, unterstützen Vektorklassifizierer usw., verwenden wir keine Bewertungsmetriken wie den mittleren Absolute-Fehler (MAE), den mittleren quadratischen Fehler (MSE) oder den Stammquadrat (RMSE).

Stattdessen erstellen wir eine Verwirrungsmatrix und basierend auf der Verwirrungsmatrix, einem Klassifizierungsbericht.

In diesem Weblog wollen wir verstehen, was eine Verwirrungsmatrix ist, wie die Genauigkeit, Präzision, Rückruf und F1-Rating mithilfe der Relevanz berechnet werden und wie die relevante Metrik basierend auf den Merkmalen der Daten ausgewählt werden kann.

Um die Verwirrungsmatrix und Klassifizierungsmetriken zu verstehen, verwenden wir die Brustkrebs Wisconsin -Datensatz.

Dieser Datensatz besteht aus 569 Zeilen, und jede Zeile enthält Informationen zu verschiedenen Merkmalen eines Tumors zusammen mit seiner Diagnose, sei es bösartig (krebsartig) oder gutartig (nicht krebsartig).

Erstellen wir nun ein Klassifizierungsmodell für diese Daten, um die Tumoren anhand ihrer Merkmale zu klassifizieren.

Wir wenden nun eine logistische Regression an, um ein Modell auf diesem Datensatz zu trainieren.

Code:

import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, classification_report
import seaborn as sns
import matplotlib.pyplot as plt

# Load the dataset 
column_names = (
    "id", "analysis", "radius_mean", "texture_mean", "perimeter_mean", "area_mean", "smoothness_mean",
    "compactness_mean", "concavity_mean", "concave_points_mean", "symmetry_mean", "fractal_dimension_mean",
    "radius_se", "texture_se", "perimeter_se", "area_se", "smoothness_se", "compactness_se", "concavity_se",
    "concave_points_se", "symmetry_se", "fractal_dimension_se", "radius_worst", "texture_worst",
    "perimeter_worst", "area_worst", "smoothness_worst", "compactness_worst", "concavity_worst",
    "concave_points_worst", "symmetry_worst", "fractal_dimension_worst"
)

df = pd.read_csv("C:/wdbc.information", header=None, names=column_names)

# Drop ID column
df = df.drop(columns=("id"))

# Encode goal: M=1 (malignant), B=0 (benign)
df("analysis") = df("analysis").map({"M": 1, "B": 0})

# Break up options and goal
X = df.drop(columns=("analysis"))
y = df("analysis")

# Practice-test cut up
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)

# Scale the options
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.rework(X_test)

# Practice logistic regression
mannequin = LogisticRegression(max_iter=10000)
mannequin.match(X_train, y_train)

# Predict
y_pred = mannequin.predict(X_test)

# Confusion Matrix and Classification Report
conf_matrix = confusion_matrix(y_test, y_pred, labels=(1, 0))  # 1 = Malignant, 0 = Benign

report = classification_report(y_test, y_pred, labels=(1, 0), target_names=("Malignant", "Benign"))

# Show outcomes
print("Confusion Matrix:n", conf_matrix)
print("nClassification Report:n", report)

# Plot Confusion Matrix
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Purples", xticklabels=("Malignant", "Benign"), yticklabels=("Malignant", "Benign"))
plt.xlabel("Predicted")
plt.ylabel("Precise")
plt.title("Confusion Matrix")
plt.tight_layout()
plt.present()

Nachdem wir nach Anwendung der logistischen Regression auf die Daten eine Verwirrungsmatrix und einen Klassifizierungsbericht generiert haben, um die Leistung des Modells zu bewerten.

Lassen Sie uns zunächst die Verwirrungsmatrix verstehen

Aus der obigen Verwirrungsmatrix

’60‘ ‚ repräsentiert die korrekt vorhergesagte maligne Tumorenwas wir uns bezeichnen „Wahre Constructive“.

‚4‘ repräsentiert die Falsch vorhergesagte gutartige Tumoren, die tatsächlich bösartige Tumoren sindwas wir uns bezeichnen „Falsche Adverse“.

‚1‘ repräsentiert die Falsch vorhergesagte maligne Tumoren, die tatsächlich gutartige Tumoren sindwas wir uns bezeichnen „Falsches Aspekte“.

‚106‘ repräsentiert die korrekt vorhergesagte gutartige Tumoren, was wir als als bezeichnen „Wahre Adverse“.

Lassen Sie uns nun sehen, was wir mit diesen Werten machen können.

Dafür betrachten wir den Klassifizierungsbericht.

Aus dem obigen Klassifizierungsbericht können wir das sagen

Für bösartig:
– Die Präzision beträgt 0,98, was bedeutet, dass es in 98% der Fälle korrekt ist, wenn das Modell den Tumor als bösartig vorhersagt.
– Der Rückruf beträgt 0,94, was bedeutet, dass das Modell 94% aller malignen Tumoren korrekt identifiziert hat.
-F1-Rating beträgt 0,96, was sowohl die Präzision als auch den Rückruf in Einklang bringt.

Für gutartig:
– Präzision beträgt 0,96, was bedeutet, dass es in 96% der Fälle korrekt ist, wenn das Modell den Tumor als gutartig vorhersagt.
– Der Rückruf beträgt 0,99, was bedeutet, dass das Modell 99% aller gutartigen Tumoren korrekt identifiziert hat.
-F1-Rating ist 0,98.

Aus dem Bericht können wir feststellen, dass die Genauigkeit des Modells 97percentbeträgt.

Wir haben auch Makro -Durchschnitt und gewichteter Durchschnitt, sehen wir, wie diese berechnet werden.

Makro -Durchschnitt

Der Makro-Durchschnitt berechnet den Durchschnitt aller Metriken (Präzision, Rückruf und F1-Rating) in beiden Klassen, die jeder Klasse gleiches Gewicht haben, unabhängig davon, wie viele Stichproben jede Klasse enthält.

Wir verwenden den Makro -Durchschnitt, wenn wir die Leistung des Modells in allen Klassen kennenlernen möchten und Klassenstörungen ignorieren möchten.

Für diese Daten:

Gewichteter Durchschnitt

Der gewichtete Durchschnitt berechnet auch den Durchschnitt aller Metriken, verleiht der Klasse jedoch mehr Proben.

Im obigen Code haben wir verwendet test_size = 0.3Dies bedeutet, dass wir 30% zum Testen beiseite legen, was bedeutet, dass wir 171 Proben aus Daten von 569 Proben für einen Testsatz verwenden.

Der Refusionsmatrix und der Klassifizierungsbericht basieren auf diesem Testsatz.

Von 171 Proben des Testsatzes haben wir 64 maligne Tumoren und 107 gutartige Tumoren.

Lassen Sie uns nun sehen, wie dieser gewichtete Durchschnitt für alle Metriken berechnet wird.

Der gewichtete Durchschnitt gibt uns eine realistischere Leistungsmaßnahme, wenn die Klassen unausgeglichene Datensätze haben.

Wir haben jetzt eine Vorstellung von jedem Begriff im Klassifizierungsbericht und wie man das Makro und die gewichteten Durchschnittswerte berechnet.

Lassen Sie uns nun sehen, wie die Verwirrungsmatrix zur Erstellung eines Klassifizierungsberichts verwendet wird.

Im Klassifizierungsbericht haben wir unterschiedliche Metriken wie Genauigkeit, Präzision usw. und diese Metriken werden unter Verwendung der Werte in der Verwirrungsmatrix berechnet.

Aus der Verwirrungsmatrix haben wir
Wahre constructive (tp) = 60
Falsche Adverse (fn) = 4
Fehlalarme (FP) = 1
Wahre Adverse (TN) = 106

Berechnen wir nun die Klassifizierungsmetriken anhand dieser Werte.

So berechnen wir die Klassifizierungsmetriken mithilfe einer Verwirrungsmatrix.

Aber warum haben wir vier verschiedene Klassifizierungsmetriken anstelle einer Metrik wie Genauigkeit? Dies liegt daran, dass die verschiedenen Metriken unterschiedliche Stärken und Schwächen des Klassifizierers auf der Grundlage des Kontextes der Daten zeigen.

Kommen wir nun zum Wisconsin -Brustkrebs -Datensatz zurück, den wir hier verwendet haben.

Als wir ein logistisches Regressionsmodell auf diese Daten angewendet haben, haben wir eine Genauigkeit von 97% erhältlich, was uns dazu bringen kann, dass das Modell effizient ist.

Betrachten wir jedoch eine andere Metrik namens „Rückruf“, die für dieses Modell 0,94 beträgt. Dies bedeutet, dass aus allen bösartigen Tumoren, die wir im Testsatz haben, das das Modell korrekt identifizieren konnte.

Hier verpasste das Modell 6% der malignen Fälle.

In realen Szenarien, hauptsächlich Gesundheitsanwendungen wie Krebserkennung, kann dies, wenn wir einen positiven Fall verpassen, die Diagnose und Behandlung verzögern.

Damit können wir verstehen, dass wir, wenn wir eine Genauigkeit von 97percenthaben, basierend auf dem Kontext der Daten durch Berücksichtigung unterschiedlicher Metriken tiefer aussehen müssen.

Additionally, was wir jetzt tun können, sollten wir einen Rückrufwert von 1,0 anstreben, was bedeutet, dass alle malignen Tumoren korrekt identifiziert werden. Wenn wir uns jedoch auf 1,0 auf 1,0 einsetzen, fällt die Präzision ab, weil das Modell kennhaftere Tumoren als bösartig klassifizieren kann.

Wenn das Modell gutartigere Tumoren als bösartig einstuft, würde es unnötige Angst geben und möglicherweise zusätzliche Checks oder Behandlungen erfordern.

Hier sollten wir den „Rückruf“ maximieren, indem wir die „Präzision“ einigermaßen hoch halten.

Wir können dies tun, indem wir die von Klassifikatoren festgelegten Schwellenwerte ändern, um die Stichproben zu klassifizieren.

Die meisten Klassifikatoren setzen den Schwellenwert auf 0,5, und wenn wir ihn 0,3 ändern, sagen wir, dass es, selbst wenn es 30% zuversichtlich ist, als bösartig klassifizieren.

Verwenden wir nun einen benutzerdefinierten Schwellenwert von 0,3.

Code:

# Practice logistic regression
mannequin = LogisticRegression(max_iter=10000)
mannequin.match(X_train, y_train)

# Predict possibilities
y_probs = mannequin.predict_proba(X_test)(:, 1)

# Apply customized threshold
threshold = 0.3
y_pred_custom = (y_probs >= threshold).astype(int)

# Classification Report
report = classification_report(y_test, y_pred_custom, target_names=("Benign", "Malignant"))

# Confusion Matrix
conf_matrix = confusion_matrix(y_test, y_pred_custom, labels=(1, 0))

# Plot Confusion Matrix
plt.determine(figsize=(6, 4))
sns.heatmap(
    conf_matrix,
    annot=True,
    fmt="d",
    cmap="Purples",
    xticklabels=("Malignant", "Benign"),
    yticklabels=("Malignant", "Benign")
)
plt.xlabel("Predicted")
plt.ylabel("Precise")
plt.title("Confusion Matrix (Threshold = 0.3)")
plt.tight_layout()
plt.present()

Hier haben wir einen benutzerdefinierten Schwellenwert von 0,3 angewendet und eine Verwirrungsmatrix und einen Klassifizierungsbericht erstellt.

Klassifizierungsbericht:

Hier stieg die Genauigkeit auf 98% und der Rückruf für Malignant stieg auf 97% und die Präzision blieb gleich.

Wir haben zuvor darüber diskutiert, dass die Genauigkeit möglicherweise zu einer Verringerung der Genauigkeit kommt, wenn wir versuchen, den Rückruf zu maximieren, aber hier bleibt die Genauigkeit gleich. Dies hängt von den Daten ab (ob ausgewogen oder nicht), die Vorbereitung von Schritten und das Einstellen des Schwellenwerts.

Bei solchen medizinischen Datensätzen wird der Maximierungsrückruf häufig gegenüber Genauigkeit oder Präzision bevorzugt.

Wenn wir Datensätze wie Spam -Erkennung oder Betrugserkennung berücksichtigen, bevorzugen wir Präzision und wie bei der obigen Methode, versuchen wir, die Genauigkeit zu verbessern, indem wir den Schwellenwert entsprechend einstellen und den Kompromiss zwischen Präzision und Rückruf ausbalancieren.

Wir verwenden F1-Rating, wenn die Daten unausgewogen sind und wenn wir sowohl Präzision als auch erinnern, wo weder falsch constructive noch falsche Adverse ignoriert werden können.

---

Datensatzquelle
Wisconsin Brustkrebs Datensatz
W. W. W., O. Mangasarian, N. Avenue & W. Avenue (1993). Brustkrebs Wisconsin (diagnostisch) (Datensatz). UCI maschinelles Lernen Repository. https://doi.org/10.24432/c5dw2b.

Dieser Datensatz ist unter einem lizenziert Inventive Commons Attribution 4.0 Worldwide (CC für 4.0) Lizenz und kann frei für kommerzielle oder pädagogische Zwecke verwendet werden, solange die ursprüngliche Quelle ordnungsgemäß eingestuft wird.

---

Hier haben wir diskutiert, was eine Verwirrungsmatrix ist und wie sie verwendet wird, um die verschiedenen Klassifizierungsmetriken wie Genauigkeit, Präzision, Rückruf und F1-Rating zu berechnen.

Wir haben auch untersucht, wann die Klassifizierungsmetrik priorisieren soll, wobei der Wisconsin Most cancers -Datensatz als Beispiel verwendet wird, wo wir die Maximierung des Rückrufs bevorzugten.

Ich hoffe, Sie haben diesen Weblog hilfreich gefunden, um Verwirrungsmatrix und Klassifizierungsmetriken klarer zu verstehen.

Danke fürs Lesen.

Aktuelle Texteinbettungsmodelle wie BERT sind auf die gleichzeitige Verarbeitung von jeweils nur 512 Token beschränkt, was ihre Wirksamkeit bei langen Dokumenten beeinträchtigt. Diese Einschränkung führt häufig zu einem Verlust des Kontexts und eines differenzierten Verständnisses. Jina Embeddings v2 behebt dieses Downside jedoch, indem es Sequenzen mit bis zu 8192 Token unterstützt, wodurch der Kontext erhalten bleibt und die Genauigkeit und Relevanz der verarbeiteten Informationen in langen Dokumenten verbessert wird. Dieser Fortschritt stellt eine wesentliche Verbesserung beim Umgang mit komplexen Textdaten dar.

Lernziele

• Verstehen Sie die Einschränkungen traditioneller Texteinbettungsmodelle wie BERT bei der Verarbeitung langer Dokumente.
• Erfahren Sie, wie Jina Embeddings v2 diese Einschränkungen mit seiner 8192-Token-Unterstützung und seiner fortschrittlichen Architektur überwindet.
• Entdecken Sie die wichtigsten Innovationen hinter Jina Embeddings v2, darunter ALiBi, GLU und den dreistufigen Schulungsprozess.
• Entdecken Sie reale Anwendungen von Jina Embeddings v2 in Bereichen wie Rechtsrecherche, Content material Administration und generative KI.
• Erwerben Sie praktische Kenntnisse über die Integration von Jina Embeddings v2 in Ihre Projekte mithilfe von Hugging Face-Bibliotheken.

Dieser Artikel wurde im Rahmen der veröffentlicht Knowledge Science-Blogathon.

Die Herausforderungen der Einbettung langer Dokumente

Lange Dokumente stellen im NLP einzigartige Herausforderungen dar. Herkömmliche Modelle verarbeiten Textual content in Blöcken, kürzen den Kontext oder erzeugen fragmentierte Einbettungen, die das Originaldokument falsch darstellen. Daraus ergibt sich:

• Erhöhter Rechenaufwand
• Höhere Speichernutzung
• Verminderte Leistung bei Aufgaben, die ein ganzheitliches Verständnis des Textes erfordern

Jina Embeddings v2 geht diese Probleme direkt an, indem es das Token-Restrict auf erweitert 8192Dadurch entfällt die Notwendigkeit einer übermäßigen Segmentierung und die semantische Integrität des Dokuments bleibt erhalten.

Lesen Sie auch: Leitfaden zum Worteinbettungssystem

Innovatives Architektur- und Schulungsparadigma

Jina Embeddings v2 nutzt das Beste von BERT und bereichert es mit modernsten Innovationen. So funktioniert es:

• Achtung bei linearen Biases (ALiBi): ALiBi ersetzt herkömmliche Positionseinbettungen durch eine lineare Verzerrung, die auf Aufmerksamkeitswerte angewendet wird. Dadurch kann das Modell effektiv auf Sequenzen extrapolieren, die viel länger sind als diejenigen, die während des Trainings beobachtet wurden. Im Gegensatz zu früheren Implementierungen, die für unidirektionale generative Aufgaben konzipiert waren, verwendet Jina Embeddings v2 eine bidirektionale Variante, um die Kompatibilität mit kodierungsbasierten Aufgaben sicherzustellen.
• Gated Linear Items (GLU): Die Feedforward-Schichten verwenden GLU, das für die Verbesserung der Transformatoreffizienz bekannt ist. Das Modell verwendet Varianten wie GEGLU und ReGLU, um die Leistung basierend auf der Modellgröße zu optimieren.
• Optimierter Schulungsprozess: Jina Embeddings v2 folgt einem dreistufigen Trainingsparadigma:
• Vorschulung: Das Modell wird auf dem Colossal Clear Crawled Corpus (C4) trainiert und nutzt Masked Language Modeling (MLM), um eine robuste Grundlage zu schaffen.
• Feinabstimmung mit Textpaaren: Konzentriert sich auf die Ausrichtung von Einbettungen für semantisch ähnliche Textpaare.
• Harte detrimental Feinabstimmung: Enthält herausfordernde Distraktor-Beispiele, um die Rating- und Retrieval-Fähigkeiten des Modells zu verbessern.
• Gedächtniseffizientes Coaching: Techniken wie gemischtes Präzisionstraining und Aktivierungs-Checkpointing gewährleisten die Skalierbarkeit für größere Stapelgrößen, was für kontrastive Lernaufgaben von entscheidender Bedeutung ist.

Bei der ALiBi-Aufmerksamkeit wird vor der Softmax-Operation eine lineare Verzerrung in jeden Aufmerksamkeitswert einbezogen. Jeder Aufmerksamkeitskopf verwendet einen eigenen konstanten Skalar m, der seine Berechnung diversifiziert. Unser Modell übernimmt die Encoder-Variante, bei der sich alle Token bei der Berechnung gegenseitig berücksichtigen, im Gegensatz zur kausalen Variante, die ursprünglich für die Sprachmodellierung entwickelt wurde. Im letzteren Fall beschränkt eine Kausalmaske die Token darauf, sich ausschließlich um die vorhergehenden Token in der Sequenz zu kümmern.

Leistungsbenchmarks

Jina Embeddings v2 bietet hochmoderne Leistung in mehreren Benchmarks, einschließlich des Large Textual content Embedding Benchmark (MTEB) und neu gestalteten Datensätzen für lange Dokumente. Zu den wichtigsten Highlights gehören:

• Einstufung: Erreicht höchste Genauigkeit bei Aufgaben wie der Amazon-Polaritäts- und Poisonous-Conversations-Klassifizierung und demonstriert ein robustes semantisches Verständnis.
• Clustering: Übertrifft die Konkurrenz bei der Gruppierung verwandter Texte, bestätigt durch Aufgaben wie PatentClustering und WikiCitiesClustering.
• Abruf: Hervorragend geeignet für Retrieval-Aufgaben wie NarrativeQA, bei denen ein umfassender Dokumentkontext unerlässlich ist.
• Umgang mit langen Dokumenten: Behält die MLM-Genauigkeit auch bei 8192-Token-Sequenzen bei und stellt damit seine Fähigkeit zur effektiven Verallgemeinerung unter Beweis.

Das Diagramm vergleicht die Leistung von Einbettungsmodellen bei Abruf- und Clustering-Aufgaben mit unterschiedlichen Sequenzlängen. Textual content-embedding-ada-002 zeichnet sich insbesondere durch seine 8191-Token-Obergrenze aus und zeigt erhebliche Fortschritte bei Aufgaben mit langem Kontext. Andere Modelle wie e5-base-v2 zeigen konsistente, aber weniger dramatische Verbesserungen bei längeren Sequenzen, was möglicherweise auf das Fehlen von Präfixen wie question: in seinem Setup zurückzuführen ist. Insgesamt erweist sich die Handhabung längerer Sequenzen als entscheidend für die Maximierung der Leistung bei diesen Aufgaben.

Anwendungen in realen Szenarien

• Juristische und akademische Forschung: Die Fähigkeit von Jina Embeddings v2, lange Dokumente zu kodieren, macht es supreme für die Suche und Analyse von juristischen Schriftsätzen, wissenschaftlichen Arbeiten und Patentanmeldungen. Es gewährleistet kontextreiche und semantisch genaue Einbettungen, die für detaillierte Vergleiche und Abrufaufgaben von entscheidender Bedeutung sind.
• Content material-Administration-Systeme: Unternehmen, die umfangreiche Repositories mit Artikeln, Handbüchern oder Multimedia-Untertiteln verwalten, können Jina Embeddings v2 für effizientes Tagging, Clustering und Abruf nutzen.
• Generative KI: Mit seiner erweiterten Kontextverarbeitung kann Jina Embeddings v2 generative KI-Anwendungen erheblich verbessern. Zum Beispiel:
• Verbesserung der Qualität von KI-generierten Zusammenfassungen durch die Bereitstellung umfangreicherer, kontextbezogener Einbettungen.
• Ermöglicht relevantere und präzisere Vervollständigungen für auf Eingabeaufforderungen basierende Modelle.
• E-Commerce: Erweiterte Produktsuch- und Empfehlungssysteme profitieren von Einbettungen, die differenzierte Particulars in langen Produktbeschreibungen und Benutzerbewertungen erfassen.

Vergleich mit bestehenden Modellen

Jina Embeddings v2 zeichnet sich nicht nur durch seine Fähigkeit aus, längere Sequenzen zu verarbeiten, sondern auch durch seine konkurrenzfähige Leistung gegenüber proprietären Modellen wie text-embedding-ada-002 von OpenAI. Während viele Open-Supply-Modelle ihre Sequenzlänge auf 512 Token begrenzen, ermöglicht die 16-fache Verbesserung von Jina Embeddings v2 völlig neue Anwendungsfälle im NLP.

Darüber hinaus gewährleistet die Open-Supply-Verfügbarkeit die Zugänglichkeit für verschiedene Organisationen und Projekte. Das Modell kann mithilfe von Ressourcen für bestimmte Anwendungen verfeinert werden Hugging Face-Repository.

Wie verwende ich Jina Embeddings v2 mit Hugging Face?

Schritt 1: Set up

!pip set up transformers  
!pip set up -U sentence-transformers  

Schritt 2: Verwenden von Jina Embeddings mit Transformers

Sie können Jina-Einbettungen direkt über die Transformers-Bibliothek verwenden:

import torch  
from transformers import AutoModel  
from numpy.linalg import norm  

# Outline cosine similarity perform  
cos_sim = lambda a, b: (a @ b.T) / (norm(a) * norm(b))  

# Load the Jina embedding mannequin  
mannequin = AutoModel.from_pretrained('jinaai/jina-embeddings-v2-base-en', trust_remote_code=True)  

# Encode sentences  
embeddings = mannequin.encode(('How is the climate immediately?', 'What's the present climate like immediately?'))  

# Calculate cosine similarity  
print(cos_sim(embeddings, embeddings))  

Ausgabe:

Umgang mit langen Sequenzen

Um längere Sequenzen zu verarbeiten, geben Sie den Parameter max_length an:

embeddings = mannequin.encode(('Very lengthy ... doc'), max_length=2048)  

Schritt 3: Verwendung von Jina-Einbettungen mit Satztransformatoren

Alternativ können Sie Jina-Einbettungen mit der Satztransformatoren-Bibliothek verwenden:

from sentence_transformers import SentenceTransformer  
from sentence_transformers.util import cos_sim  

# Load the Jina embedding mannequin  
mannequin = SentenceTransformer('jinaai/jina-embeddings-v2-base-en', trust_remote_code=True)  

# Encode sentences  
embeddings = mannequin.encode(('How is the climate immediately?', 'What's the present climate like immediately?'))  

# Calculate cosine similarity  
print(cos_sim(embeddings, embeddings))  

Festlegen der maximalen Sequenzlänge

Steuern Sie die Länge der Eingabesequenz nach Bedarf:

mannequin.max_seq_length = 1024  # Set most sequence size to 1024 tokens 

Wichtige Hinweise

• Stellen Sie sicher, dass Sie bei Hugging Face angemeldet sind, um auf geschlossene Modelle zugreifen zu können. Stellen Sie bei Bedarf ein Zugriffstoken bereit.
• Der Leitfaden gilt für englische Modelle; Verwenden Sie für andere Sprachen die entsprechende Modellkennung (z. B. Chinesisch oder Deutsch).

Lesen Sie auch: Erkunden des Einbettens von Modellen mit Vertex AI

Abschluss

Jina Embeddings v2 stellt einen wichtigen Fortschritt im NLP dar und geht auf die Herausforderungen der Einbettung langer Dokumente ein. Durch die Unterstützung von Sequenzen von bis zu 8192 Token und die Bereitstellung einer starken Leistung ermöglicht es eine Vielzahl von Anwendungen, einschließlich akademischer Forschung, Unternehmenssuche und generativer KI. Da NLP-Aufgaben zunehmend die Verarbeitung langer und komplexer Texte umfassen, werden Innovationen wie Jina Embeddings v2 unverzichtbar. Seine Fähigkeiten verbessern nicht nur aktuelle Arbeitsabläufe, sondern eröffnen auch neue Möglichkeiten für die zukünftige Arbeit mit langen Textdaten.

Für weitere Particulars oder um Jina Embeddings v2 in Ihre Projekte zu integrieren, besuchen Sie es Umarmende Gesichtsseite.

Wichtige Erkenntnisse

• Jina Embeddings v2 unterstützt bis zu 8192 Token und behebt damit eine wichtige Einschränkung bei NLP-Aufgaben mit langen Dokumenten.
• ALiBi (Consideration with Linear Biases) ersetzt herkömmliche Positionseinbettungen und ermöglicht es dem Modell, längere Sequenzen effektiv zu verarbeiten.
• Gated Linear Items (GLU) verbessern die Transformatoreffizienz, wobei Varianten wie GEGLU und ReGLU die Leistung steigern.
• Der dreistufige Trainingsprozess (Vortraining, Feinabstimmung und harte detrimental Feinabstimmung) stellt sicher, dass das Modell robuste und genaue Einbettungen erzeugt.
• Jina Embeddings v2 schneidet bei Aufgaben wie Klassifizierung, Clustering und Abruf außergewöhnlich intestine ab, insbesondere bei langen Dokumenten.

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.