Imaginative and prescient AI verlässt die Demoversion und geht in die Produktion über. Es wird verwendet, um Produkte zu inspizieren, Umgebungen zu überwachen, Sicherheitsabläufe zu unterstützen und Systemen zu helfen, zu verstehen, was in Bildern und Videostreams passiert. Mit zunehmenden Einsätzen steigen auch die Kosten für schlechte Schulungen. Ein Modell, das in einem sauberen Testsatz eine gute Leistung erbringt, kann in der realen Welt immer noch kaputt gehen, wenn sich die Beleuchtung ändert, sich Objekte überlappen oder sich die Umgebung im Laufe der Zeit verändert.

Aus diesem Grund sehen leistungsstarke Imaginative and prescient-KI-Programme in der Regel weniger wie ein einmaliges Modelltraining aus, sondern eher wie eine operative Disziplin. Sie kombinieren eine starke Datenerfassung, klare Annotationsregeln, Domänenexpertise, synthetische Erweiterung, wo sie hilft, und kontinuierliche Überwachung nach der Einführung. Das Ziel ist nicht nur eine höhere Genauigkeit auf dem Papier. Es ist eine zuverlässige Leistung, wenn die Szene chaotisch wird.

Warum Trainingsqualität wichtiger ist als Modellneuheit

Viele Groups konzentrieren sich zunächst auf die Architektur. Das ist wichtig, aber bei Imaginative and prescient AI entscheidet oft die Datenqualität darüber, ob ein Projekt in Produktion geht. Wenn Ihre Bilder inkonsistent beschriftet sind, Ihre Fehlerkategorien vage sind oder Ihre Randfälle fehlen, lernt das Modell eine verschwommene Model der Realität.

Eine einfache Analogie besteht darin, jemandem beizubringen, eine Sportart nur mithilfe von Spotlight-Clips zu leiten. Sie erkennen vielleicht die offensichtlichen Spielzüge, haben aber mit ungünstigen Blickwinkeln, Teilansichten und grenzwertigen Aussagen zu kämpfen. Imaginative and prescient AI verhält sich genauso. Es braucht mehr als ideale Beispiele. Es braucht auch die harten Fälle.

Beginnen Sie mit den Daten, nicht mit dem Dashboard

Definieren Sie vor Trainingsbeginn, was das Modell sehen soll und was als Erfolg gilt. Das bedeutet zu entscheiden, ob es sich bei der Aufgabe um Objekterkennung, Klassifizierung, Segmentierung, Verfolgung, Anomalieerkennung oder Szenenverständnis handelt. Es bedeutet auch, sich frühzeitig auf Label-Definitionen zu einigen.

Wenn ein System beispielsweise dazu gedacht ist, Gefahren in einer Produktionslinie zu kennzeichnen, was genau gilt dann als Gefahr? Ist eine teilweise Okklusion noch beschriftbar? Zählt Blendung als Negativbeispiel oder Sonderfall? Diese Particulars prägen den Datensatz, lange bevor sie das Modell prägen.

Hier gefallen Dienstleistungen Datenerfassung, DatenanmerkungUnd Unterstützung für Pc-Imaginative and prescient-Trainingsdaten strategisch wichtig werden. Starke Upstream-Workflows helfen Groups dabei, Bildformate zu standardisieren, eine breitere Abdeckung zu erfassen und Unklarheiten zu reduzieren, bevor sie sich in der Pipeline verbreiten.

Warum ist eine generische Kennzeichnung selten genug?

Generische Annotatoren sind für einfache Aufgaben nützlich, hochwertige visuelle KI hängt jedoch oft vom Kontext ab. Ein Fertigungsexperte kann subtile Fehlermuster erkennen, die für einen allgemeinen Prüfer regular erscheinen. Ein Sicherheitsspezialist kann zwischen gewöhnlicher Bewegung und einem erheblichen Risiko unterscheiden. Ein medizinischer Gutachter kann herausfinden, warum ein Bildgebungsmuster wichtig ist, ein anderes jedoch nicht.

Dieser Unterschied zeigt sich am deutlichsten in Grenzfällen. Die schwerwiegendsten Fehler bei der Imaginative and prescient-KI treten oft in unklaren, ungewöhnlichen oder risikoreichen Szenarien auf. Aus diesem Grund ist die domänenbezogene Kennzeichnung so wichtig, wenn Groups von Prototypen zur Produktion übergehen.

Synthetische Daten helfen, aber nur, wenn sie gezielt genutzt werden

Synthetische Bilder und Movies können hilfreich sein, wenn reale Daten selten, gefährlich, teuer oder langsam zu erfassen sind. Sie sind besonders nützlich bei ungewöhnlichen Defekten, riskanten Szenarien und unterrepräsentierten Bedingungen. Aber synthetische Daten sind keine Zauberei. Wenn es zu sauber oder zu eng ist, kann das Modell in der simulierten Realität intestine und in der tatsächlichen Realität schwach werden.

Die beste Nutzung synthetischer Daten ist in der Regel die gezielte Erweiterung. Es füllt Lücken, erhöht die Variation und bereitet das Modell auf Ereignisse vor, die in realen Aufnahmen nicht oft genug vorkommen.

Trainieren Sie den Szenenkontext, nicht nur die Objektpräsenz

Ein ausgereiftes Imaginative and prescient-KI-System kann mehr als nur Elemente in Pixeln erkennen. Es interpretiert das Geschehen im Kontext. Ein überfüllter Gang kann zu einer Stunde regular sein und zu einer anderen ein Risikosignal. Ein angehaltenes Fahrzeug kann in einer Scenario harmlos und in einer anderen kritisch sein. Ein Defekt kann nur dann von Bedeutung sein, wenn er mit einem bestimmten Standort, Bewegungsmuster oder Betriebszustand kombiniert wird.

Aus diesem Grund sind hochwertige Systeme zunehmend auf umfassendere Kennzeichnungs- und Bewertungsstrategien angewiesen, anstatt sich auf eine enge Leistungsbewertung zu verlassen.

Eine Mini-Story: Als das Modell bis zum Beginn der Nachtschicht genau aussah

Stellen Sie sich einen Einzelhändler vor, der Imaginative and prescient-KI einsetzt, um Verschüttungsrisiken und blockierte Gänge zu erkennen. Während der Pilottests sehen die Ergebnisse überzeugend aus. Das Filmmaterial am Tag ist klar, die Beschriftungen sind ordentlich und das Modell erkennt die offensichtlichsten Probleme.

Dann beginnt die Nachtschicht. Die Beleuchtung ist schwächer. Bodenreflexionen verändern sich. Reinigungswagen blockieren teilweise die Kamerasicht. Mitarbeiter bewegen sich anders. Plötzlich übersieht das System echte Gefahren und überkennt harmlose Aktivitäten.

Am Originalmodell battle nichts auszusetzen, nur unvollständig. Die Trainingsdaten spiegelten eine Model der Umgebung wider, nicht die vollständige Umgebung. Nachdem das Workforce Nachtaufnahmen, Randfallanmerkungen und Rezensenten-Suggestions von Ladenbetreibern hinzugefügt hatte, verbesserte sich die Leistung, da das Modell endlich aus den Bedingungen lernte, denen es tatsächlich ausgesetzt sein würde.

Der Entscheidungsrahmen: wann mehr Daten, mehr Experten oder mehr Suggestions hinzugefügt werden sollen

Eine praktische Möglichkeit zur Verbesserung der visuellen KI besteht darin, vier Fragen zu stellen:

1. Welche Arten von Fehlschlägen sind am wichtigsten?
   Falsch-negative Ergebnisse haben in den Bereichen Sicherheit, Gesundheitswesen, Einzelhandel und Fertigung unterschiedliche Auswirkungen.
2. Welche Erkrankungen sind unterrepräsentiert?
   Achten Sie auf Beleuchtungsschwankungen, Bewegungsunschärfe, Verdeckung, saisonale Veränderungen, Kamerawinkelverschiebungen und seltene Ereignisse.
3. Wo verändert menschliches Urteilsvermögen die Bezeichnung?
   Hier verdienen Fachexperten ihren Lebensunterhalt.
4. Was werden Sie nach dem Begin überwachen?
   Genauigkeit reicht nicht aus. Groups sollten Fehlerraten, Drift, Latenz und Leistung unter sich ändernden realen Bedingungen beobachten.

Wie gute Imaginative and prescient-KI-Operationen aussehen

Die stärksten Trainingsprogramme haben normalerweise einige gemeinsame Gewohnheiten. Sie standardisieren die Daten vor der Kennzeichnung. Sie erstellen Annotationsrichtlinien mit Beispielen und Ausnahmeregeln. Sie fügen QA-Prüfungen hinzu, anstatt davon auszugehen, dass alle Etiketten gleichermaßen zuverlässig sind. Sie verwenden synthetische Daten, um sinnvolle Lücken zu schließen, nicht um die Realität zu ersetzen. Und sie schaffen Feedbackschleifen nach dem Einsatz, sodass Bediener Fehler melden und diese Informationen in die Umschulung einspeisen können.

Aus diesem Grund behandeln viele Groups Imaginative and prescient-Projekte auch als fortlaufende Datenoperationen und nicht als isolierte Modellexperimente. Eine starke Infrastruktur für Trainingsdaten, Überprüfungs- und Aktualisierungszyklen macht es einfacher, Modelle nützlich zu halten, wenn sich die Welt um sie herum verändert.

Abschluss

Qualitativ hochwertige Ergebnisse in der Imaginative and prescient-KI resultieren nicht allein aus der Größe. Sie basieren auf einem besseren Urteilsvermögen darüber, was gesammelt werden soll, wie es gekennzeichnet werden soll, wo Experten eingesetzt werden sollten, wann Randfälle simuliert werden sollten und wie die Leistung nach der Bereitstellung gemessen werden sollte.

Mit anderen Worten: Das Coaching von Imaginative and prescient AI ist nicht so, als würde man einen Tank füllen. Es ist eher so, als würde man eine Mannschaft unter wechselnden Spielbedingungen trainieren. Die besten Systeme werden an realistischen Beispielen trainiert, mit schwierigen Szenarien herausgefordert und kontinuierlich verbessert, sobald sie im Einsatz sind.

Was sind synthetische Daten?

Daten, die von einem Pc erstellt wurden, der vorhandene Daten replizieren oder erweitert.

Warum ist es nützlich?

Wir alle haben den Erfolg von Chatgpt, Lama und in jüngerer Zeit von Deepseek erlebt. Diese Sprachmodelle werden allgegenwärtig in der gesamten Gesellschaft verwendet und haben viele Behauptungen ausgelöst, dass wir uns schnell künstliche allgemeine Intelligenz nähern – KI, die in der Lage sind, jede menschliche Funktion zu replizieren.

Bevor wir je nach Ihrer Perspektive zu aufgeregt oder verängstigt sind, nähern wir uns auch schnell einer Hürde für die Weiterentwicklung dieser Sprachmodelle. Laut einer von einer Gruppe des Forschungsinstituts, Epoch, veröffentlichten Arbeit (1)Anwesend Wir haben keine Daten mehr. Sie schätzen, dass wir bis 2028 die Obergrenze der möglichen Daten erreicht haben werden, an denen Sprachmodelle geschult sind.

Was passiert, wenn uns die Daten ausgehen?

Nun, wenn uns die Daten ausgehen, werden wir nichts Neues haben, mit dem wir unsere Sprachmodelle trainieren können. Diese Modelle werden dann nicht mehr verbessert. Wenn wir künstliche allgemeine Intelligenz verfolgen wollen, müssen wir neue Möglichkeiten zur Verbesserung der KI finden, ohne nur das Volumen der realen Trainingsdaten zu erhöhen.

Ein potenzieller Retter sind synthetische Daten, die generiert werden können, um vorhandene Daten nachzuahmen, und wurde bereits zur Verbesserung der Leistung von Modellen wie Gemini und DBRX verwendet.

Synthetische Daten jenseits der LLMs

Über die Überwindung der Datenknappheit für Großsprachmodelle hinaus können synthetische Daten in den folgenden Situationen verwendet werden:

• Wise Daten – Wenn wir keine sensiblen Attribute teilen oder verwenden möchten, können synthetische Daten generiert werden, die die Eigenschaften dieser Merkmale nachahmen und gleichzeitig die Anonymität aufrechterhalten.
• Teure Daten-Wenn das Sammeln von Daten teuer ist, können wir ein großes Volumen von synthetischen Daten aus einer kleinen Menge an realen Daten erzeugen.
• Datenmangel– Datensätze sind voreingenommen, wenn es eine unverhältnismäßig niedrige Anzahl einzelner Datenpunkte aus einer bestimmten Gruppe gibt. Synthetische Daten können verwendet werden, um einen Datensatz auszugleichen.

Unausgewogene Datensätze

Unausgeglichene Datensätze können (*, aber nicht immer*) problematisch sein, da sie möglicherweise nicht genügend Informationen enthalten, um ein prädiktives Modell effektiv zu schulen. Wenn beispielsweise ein Datensatz viel mehr Männer als Frauen enthält, kann unser Modell darauf verzerrt sein, Männer zu erkennen und zukünftige weibliche Proben als Männer falsch zu klassifizieren.

In diesem Artikel zeigen wir das Ungleichgewicht in der beliebten UCI Erwachsenen Datensatz (2), und wie wir a verwenden können Variations-Auto-Coder zu erzeugen Synthetische Daten Verbesserung der Klassifizierung in diesem Beispiel.

Wir laden zuerst den Datensatz für Erwachsene herunter. Dieser Datensatz enthält Funktionen wie Alter, Bildung und Beruf, mit denen das Zielergebnis „Einkommen“ vorhergesagt werden kann.

# Obtain dataset right into a dataframe
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/grownup/grownup.knowledge"
columns = (
   "age", "workclass", "fnlwgt", "schooling", "education-num", "marital-status",
   "occupation", "relationship", "race", "intercourse", "capital-gain",
   "capital-loss", "hours-per-week", "native-country", "earnings"
)
knowledge = pd.read_csv(url, header=None, names=columns, na_values=" ?", skipinitialspace=True)

# Drop rows with lacking values
knowledge = knowledge.dropna()

# Break up into options and goal
X = knowledge.drop(columns=("earnings"))
y = knowledge('earnings').map({'>50K': 1, '<=50K': 0}).values

# Plot distribution of earnings
plt.determine(figsize=(8, 6))
plt.hist(knowledge('earnings'), bins=2, edgecolor="black")
plt.title('Distribution of Revenue')
plt.xlabel('Revenue')
plt.ylabel('Frequency')
plt.present()

Im Datensatz für Erwachsene ist das Einkommen eine binäre Variable, die Personen, die oben und darunter 50.000 US -Greenback verdienen, repräsentiert. Wir zeichnen die Einkommensverteilung über den gesamten Datensatz unten dar. Wir können sehen, dass der Datensatz mit einer weitaus größeren Anzahl von Personen, die weniger als 50.000 US -Greenback verdienen, stark unausgewogen ist.

Trotz dieses Ungleichgewichts können wir immer noch einen Klassifizierer für maschinelles Lernen für den Datensatz für Erwachsene schulen, mit dem wir feststellen können, ob unsichtbare oder Assessments Einzelpersonen wie oben oder unter 50 km klassifiziert werden sollten.

# Preprocessing: One-hot encode categorical options, scale numerical options
numerical_features = ("age", "fnlwgt", "education-num", "capital-gain", "capital-loss", "hours-per-week")
categorical_features = (
   "workclass", "schooling", "marital-status", "occupation", "relationship",
   "race", "intercourse", "native-country"
)

preprocessor = ColumnTransformer(
   transformers=(
       ("num", StandardScaler(), numerical_features),
       ("cat", OneHotEncoder(), categorical_features)
   )
)

X_processed = preprocessor.fit_transform(X)

# Convert to numpy array for PyTorch compatibility
X_processed = X_processed.toarray().astype(np.float32)
y_processed = y.astype(np.float32)
# Break up dataset in practice and check units
X_model_train, X_model_test, y_model_train, y_model_test = train_test_split(X_processed, y_processed, test_size=0.2, random_state=42)


rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)
rf_classifier.match(X_model_train, y_model_train)

# Make predictions
y_pred = rf_classifier.predict(X_model_test)

# Show confusion matrix
plt.determine(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt="d", cmap="YlGnBu", xticklabels=("Destructive", "Constructive"), yticklabels=("Destructive", "Constructive"))
plt.xlabel("Predicted")
plt.ylabel("Precise")
plt.title("Confusion Matrix")
plt.present()

Das Ausdrucken der Verwirrungsmatrix unseres Klassifikators zeigt, dass unser Modell trotz des Ungleichgewichts ziemlich intestine funktioniert. Unser Modell hat eine Gesamtfehlerrate von 16%, aber die Fehlerrate für die optimistic Klasse (Einkommen> 50.000) beträgt 36%, wobei die Fehlerrate für die destructive Klasse (Einkommen <50K) 8% beträgt.

Diese Diskrepanz zeigt, dass das Modell tatsächlich in der negativen Klasse voreingenommen ist. Das Modell klassifiziert häufig Personen, die mehr als 50.000 als weniger als 50.000 verdienen.

Im Folgenden zeigen wir, wie wir a verwenden können Variations -Autocoder So generieren synthetische Daten der positiven Klasse, um diesen Datensatz auszugleichen. Anschließend trainieren wir das gleiche Modell mit dem synthetisch ausgeglichenen Datensatz und reduzieren Modellfehler im Testsatz.

Wie können wir synthetische Daten generieren?

Es gibt viele verschiedene Methoden zum Generieren von synthetischen Daten. Diese können traditionellere Methoden wie Smote und Gaußsche Rauschen umfassen, die neue Daten erzeugen, indem vorhandene Daten geändert werden. Alternativ generative Modelle wie variationsübergreifende Autoencoder oder allgemeine kontroverse Netzwerke sind prädisponiert, um neue Daten zu generieren, wenn ihre Architekturen die Verteilung realer Daten lernen und diese verwenden, um synthetische Proben zu generieren.

In diesem Tutorial verwenden wir einen variativen AutoCodierer, um synthetische Daten zu generieren.

Variations Autoencoder

Variational Autocoders (VAEs) eignen sich hervorragend für die Erzeugung der synthetischen Daten, da sie reale Daten verwenden, um einen kontinuierlichen latenten Raum zu erlernen. Wir können diesen latenten Raum als einen magischen Eimer betrachten, aus dem wir synthetische Daten probieren können, die den vorhandenen Daten stark ähneln. Die Kontinuität dieses Raums ist eines ihrer großen Verkaufsargumente, da das Modell das Modell intestine verallgemeinert und sich nicht nur den latenten Raum spezifischer Eingaben auswendig merkt.

Ein VAE besteht aus einer Encoder die Eingabedaten in eine Wahrscheinlichkeitsverteilung (Mittelwert und Varianz) und a abbilden Decoder die die Daten aus dem latenten Raum rekonstruiert.

Für diesen kontinuierlichen latenten Raum verwenden Vaes einen Reparameterizing -TrickAnwesend wobei ein zufälliger Rauschvektor unter Verwendung des gelernten Mittelwerts und der Varianz skaliert und verschoben wird, um reibungslose und kontinuierliche Darstellungen im latenten Raum zu gewährleisten.

Unten konstruieren wir a Basicvae Klasse, der diesen Prozess mit einer einfachen Architektur implementiert.

• Der EncoderKomprimiert die Eingabe in eine kleinere, verborgene Darstellung und erzeugt sowohl eine Mittelwert- als auch eine logarithmische Varianz, die eine Gaußsche Verteilung definiert, auch wenn wir unseren magischen Stichproben -Eimer erstellen. Anstelle einer direkten Abtastung wendet das Modell den Reparameterisierungstrick an, um latente Variablen zu erzeugen, die dann an den Decoder übergeben werden.
• Der DecoderRekonstruiert die ursprünglichen Daten aus diesen latenten Variablen und stellt sicher, dass die generierten Daten die Eigenschaften des ursprünglichen Datensatzes beibehalten.

class BasicVAE(nn.Module):
   def __init__(self, input_dim, latent_dim):
       tremendous(BasicVAE, self).__init__()
       # Encoder: Single small layer
       self.encoder = nn.Sequential(
           nn.Linear(input_dim, 8),
           nn.ReLU()
       )
       self.fc_mu = nn.Linear(8, latent_dim)
       self.fc_logvar = nn.Linear(8, latent_dim)
      
       # Decoder: Single small layer
       self.decoder = nn.Sequential(
           nn.Linear(latent_dim, 8),
           nn.ReLU(),
           nn.Linear(8, input_dim),
           nn.Sigmoid()  # Outputs values in vary (0, 1)
       )

   def encode(self, x):
       h = self.encoder(x)
       mu = self.fc_mu(h)
       logvar = self.fc_logvar(h)
       return mu, logvar

   def reparameterize(self, mu, logvar):
       std = torch.exp(0.5 * logvar)
       eps = torch.randn_like(std)
       return mu + eps * std

   def decode(self, z):
       return self.decoder(z)

   def ahead(self, x):
       mu, logvar = self.encode(x)
       z = self.reparameterize(mu, logvar)
       return self.decode(z), mu, logvar

Angesichts unserer BasicVae -Architektur konstruieren wir unsere Verlustfunktionen und unsere Modelltraining unten.

def vae_loss(recon_x, x, mu, logvar, tau=0.5, c=1.0):
   recon_loss = nn.MSELoss()(recon_x, x)
 
   # KL Divergence Loss
   kld_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
   return recon_loss + kld_loss / x.measurement(0)

def train_vae(mannequin, data_loader, epochs, learning_rate):
   optimizer = optim.Adam(mannequin.parameters(), lr=learning_rate)
   mannequin.practice()
   losses = ()
   reconstruction_mse = ()

   for epoch in vary(epochs):
       total_loss = 0
       total_mse = 0
       for batch in data_loader:
           batch_data = batch(0)
           optimizer.zero_grad()
           reconstructed, mu, logvar = mannequin(batch_data)
           loss = vae_loss(reconstructed, batch_data, mu, logvar)
           loss.backward()
           optimizer.step()
           total_loss += loss.merchandise()

           # Compute batch-wise MSE for comparability
           mse = nn.MSELoss()(reconstructed, batch_data).merchandise()
           total_mse += mse

       losses.append(total_loss / len(data_loader))
       reconstruction_mse.append(total_mse / len(data_loader))
       print(f"Epoch {epoch+1}/{epochs}, Loss: {total_loss:.4f}, MSE: {total_mse:.4f}")
   return losses, reconstruction_mse

combined_data = np.concatenate((X_model_train.copy(), y_model_train.cop
y().reshape(26048,1)), axis=1)

# Prepare-test break up
X_train, X_test = train_test_split(combined_data, test_size=0.2, random_state=42)

batch_size = 128

# Create DataLoaders
train_loader = DataLoader(TensorDataset(torch.tensor(X_train)), batch_size=batch_size, shuffle=True)
test_loader = DataLoader(TensorDataset(torch.tensor(X_test)), batch_size=batch_size, shuffle=False)

basic_vae = BasicVAE(input_dim=X_train.form(1), latent_dim=8)

basic_losses, basic_mse = train_vae(
   basic_vae, train_loader, epochs=50, learning_rate=0.001,
)

# Visualize outcomes
plt.determine(figsize=(12, 6))
plt.plot(basic_mse, label="Fundamental VAE")
plt.ylabel("Reconstruction MSE")
plt.title("Coaching Reconstruction MSE")
plt.legend()
plt.present()

VAE_LOSS besteht aus zwei Komponenten: Wiederaufbauverlustwas misst, wie intestine die generierten Daten mit dem ursprünglichen Eingang mit dem mittleren Quadratfehler (MSE) übereinstimmen, und KL -Divergenzverlustwas sicherstellt, dass der gelehrte latente Raum einer Normalverteilung folgt.

Train_vaeOptimiert die VAE mit dem Adam -Optimierer über mehrere Epochen. Während des Trainings nimmt das Modell Minibatches von Daten, rekonstruiert sie und berechnet den Verlust mithilfe VAE_LOSS. Diese Fehler werden dann über die Backpropagation korrigiert, bei der die Modellgewichte aktualisiert werden. Wir trainieren das Modell für 50 Epochen und zeichnen, wie der Rekonstruktionsmittel -quadratische Fehler beim Coaching abnimmt.

Wir können sehen, dass unser Modell schnell lernt, wie wir unsere Daten rekonstruieren und ein effizientes Lernen belegen.

Jetzt haben wir unsere Basicvae geschult, um den Datensatz für Erwachsene genau zu rekonstruieren, den wir jetzt verwenden können, um synthetische Daten zu generieren. Wir möchten mehr Proben der positiven Klasse (Personen, die über 50.000 verdienen) generieren, um die Klassen auszugleichen und die Verzerrung aus unserem Modell zu entfernen.

Dazu wählen wir alle Stichproben aus unserem VAE -Datensatz aus, in dem das Einkommen die optimistic Klasse ist (verdienen mehr als 50.000). Anschließend codieren wir diese Proben in den latenten Raum. Da wir nur Proben der positiven Klasse ausgewählt haben, um zu codieren, spiegelt dieser latente Raum die Eigenschaften der positiven Klasse wider, aus der wir synthetische Daten erstellen können.

Wir probieren 15000 neue Proben aus diesem latenten Raum und dekodieren diese latenten Vektoren als unsere synthetischen Datenpunkte wieder in den Eingangsdatenraum.

# Create column names
col_number = sample_df.form(1)
col_names = (str(i) for i in vary(col_number))
sample_df.columns = col_names

# Outline the function worth to filter
feature_value = 1.0  # Specify the function worth - right here we set the earnings to 1

# Set all earnings values to 1 : Over 50k
selected_samples = sample_df(sample_df(col_names(-1)) == feature_value)
selected_samples = selected_samples.values
selected_samples_tensor = torch.tensor(selected_samples, dtype=torch.float32)

basic_vae.eval()  # Set mannequin to analysis mode
with torch.no_grad():
   mu, logvar = basic_vae.encode(selected_samples_tensor)
   latent_vectors = basic_vae.reparameterize(mu, logvar)

# Compute the imply latent vector for this function
mean_latent_vector = latent_vectors.imply(dim=0)


num_samples = 15000  # Variety of new samples
latent_dim = 8
latent_samples = mean_latent_vector + 0.1 * torch.randn(num_samples, latent_dim)

with torch.no_grad():
   generated_samples = basic_vae.decode(latent_samples)

Jetzt haben wir synthetische Daten der positiven Klasse generiert. Wir können diese mit den ursprünglichen Trainingsdaten kombinieren, um einen ausgewogenen synthetischen Datensatz zu generieren.

new_data = pd.DataFrame(generated_samples)

# Create column names
col_number = new_data.form(1)
col_names = (str(i) for i in vary(col_number))
new_data.columns = col_names

X_synthetic = new_data.drop(col_names(-1),axis=1)
y_synthetic = np.asarray((1 for _ in vary(0,X_synthetic.form(0))))

X_synthetic_train = np.concatenate((X_model_train, X_synthetic.values), axis=0)
y_synthetic_train = np.concatenate((y_model_train, y_synthetic), axis=0)

mapping = {1: '>50K', 0: '<=50K'}
map_function = np.vectorize(lambda x: mapping(x))
# Apply mapping
y_mapped = map_function(y_synthetic_train)

plt.determine(figsize=(8, 6))
plt.hist(y_mapped, bins=2, edgecolor="black")
plt.title('Distribution of Revenue')
plt.xlabel('Revenue')
plt.ylabel('Frequency')
plt.present()

Wir können jetzt unseren ausgewogenen Trainings -synthetischen Datensatz verwenden, um unseren zufälligen Waldklassifizierer zu übertreffen. Anschließend können wir dieses neue Modell für die ursprünglichen Testdaten bewerten, um zu sehen, wie effektiv unsere synthetischen Daten bei der Reduzierung der Modellverzerrung sind.

rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)
rf_classifier.match(X_synthetic_train, y_synthetic_train)

# Step 5: Make predictions
y_pred = rf_classifier.predict(X_model_test)

cm = confusion_matrix(y_model_test, y_pred)

# Create heatmap
plt.determine(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt="d", cmap="YlGnBu", xticklabels=("Destructive", "Constructive"), yticklabels=("Destructive", "Constructive"))
plt.xlabel("Predicted")
plt.ylabel("Precise")
plt.title("Confusion Matrix")
plt.present()

Unser neuer Klassifizierer, der auf dem ausgewogenen synthetischen Datensatz trainiert wurde, macht weniger Fehler im Authentic -Testsatz als unser ursprünglicher Klassifikator, der auf dem unausgeglichenen Datensatz trainiert wurde, und unsere Fehlerrate wird nun auf 14percentreduziert.

Wir konnten jedoch nicht die Diskrepanz der Fehler um einen signifikanten Betrag reduzieren. Unsere Fehlerrate für die optimistic Klasse beträgt immer noch 36%. Dies könnte an die folgenden Gründe zurückzuführen sein:

• Wir haben diskutiert, wie einer der Vorteile von Vaes das Erlernen eines kontinuierlichen latenten Raums ist. Wenn die Mehrheitsklasse jedoch dominiert, kann der latente Raum der Mehrheitsklasse zugute kommen.
• Das Modell hat aufgrund des Mangels an Daten möglicherweise keine eindeutige Darstellung für die Minderheitenklasse richtig gelernt, wodurch es schwierig ist, aus diesem Bereich genau zu probieren.

In diesem Tutorial haben wir eine BasicVae -Architektur eingeführt und erstellt, mit der synthetische Daten generiert werden können, die die Klassifizierungsgenauigkeit auf einem unausgeglichenen Datensatz verbessert.

Folgen Sie zukünftigen Artikeln, in denen ich zeigen werde, wie wir anspruchsvollere VAE -Architekturen aufbauen können, die die oben genannten Probleme mit unausgeglichener Stichproben und vielem mehr angehen.

(1) Villalobos, P., Ho, A., Sevilla, J., Besiroglu, T., Heim, L. & Hobbhahn, M. (2024). Werden uns die Daten ausgehen? Grenzen der LLM-Skalierung basierend auf Daten von Menschen erzeugten Daten. Arxiv Preprint Arxiv: 2211.04325Anwesend 3.

(2) Becker, B. & Kohavi, R. (1996). Erwachsener (Datensatz). UCI maschinelles Lernen Repository. https://doi.org/10.24432/c5xw20.