Daten aus der realen Welt sind chaotisch. Jeder, der mit gecrackten Webdaten gearbeitet hat, hat dieses Muster gesehen: als Textual content gespeicherte Preise, unmögliche Jahreswerte, Spalten ohne Variation und numerische Felder, die sich auf verdächtig begrenzte Weise wiederholen. Bei der Bereinigung dieser Daten findet der Großteil der eigentlichen analytischen Arbeit tatsächlich statt.

In diesem Projekt werden wir einen realistischen Datenbereinigungs- und Analyse-Workflow mit a durcharbeiten Datensatz mit 50.000 Gebrauchtwagenangeboten entnommen aus eBay Kleinanzeigen, dem Kleinanzeigenbereich der deutschen eBay-Web site. Wir schlüpfen in die Rolle eines Datenanalysten, der einem Gebrauchtwagen-Kleinanzeigendienst dabei hilft, zu verstehen, wie sich Marke und Kilometerstand auf die Autopreise auswirken.

Was Sie lernen werden

Am Ende dieses Tutorials wissen Sie, wie Sie:

• Laden Sie Daten mit Codierungsproblemen und verstehen Sie, warum diese auftreten
• Bereinigen Sie die Spaltennamen von „camelCase“ bis „snake_case“.
• Identifizieren und löschen Sie nutzlose oder redundante Spalten
• Entfernen Sie Formatierungszeichen aus numerischen Zeichenfolgen und konvertieren Sie Datentypen
• Erkennen und entfernen Sie Preisausreißer mithilfe ermessensbasierter Schwellenwerte
• Filtern Sie ungültige Registrierungsjahre
• Gruppieren und aggregieren Sie Daten nach Marken, um Preistrends aufzudecken

Bevor Sie beginnen

Sie benötigen Python 3.8+, Jupyter Pocket book, Pandas und NumPy. Sie können sie mit installieren pip set up pandas numpy wenn nötig.

Vertrautheit mit Python-Pay attention, Wörterbüchern, Schleifen und grundlegenden Pandas-Operationen wird Ihnen dabei helfen, weiterzumachen. Wenn Sie zuerst eine Rezension lesen möchten, die Einführung in Pandas und NumPy für die Datenanalyse Der Kurs behandelt die Kernkonzepte. Greifen Sie auf das vollständige Projekt zu Dataquest-App und das Lösungsnotizbuch an GitHub.

Der Datensatz

Die Daten wurden ursprünglich von eBay Kleinanzeigen entnommen und auf Kaggle hochgeladen. Wir arbeiten mit einem von Dataquest erstellten Beispiel mit 50.000 Zeilen, das eine weniger bereinigte Model des Originals simuliert. Jede Zeile stellt einen einzelnen Gebrauchtwageneintrag dar, mit Spalten, die den Namen, den Preis, die Marke, das Modell, den Kilometerstand, das Zulassungsjahr, den Kraftstofftyp des Wagens und verschiedene Metadaten zum Eintrag selbst abdecken.

Unser Ziel ist es, diese Daten zu bereinigen und Preistrends nach Marken zu analysieren.

Schritt 1: Laden der Daten

import pandas as pd
import numpy as np

autos = pd.read_csv('autos.csv', encoding='Latin-1')
autos.information()
autos.head()

Wenn Sie versuchen, die Datei zu laden, ohne eine Codierung anzugeben, erhalten Sie eine UnicodeDecodeError. Dies liegt daran, dass der Datensatz nicht-englische Zeichen (deutscher Textual content und Sonderzeichen) enthält, mit denen die standardmäßige UTF-8-Kodierung nicht umgehen kann. Wenn Sie diesen Fehler sehen, encoding='Latin-1' ist oft die Lösung. Latin-1 deckt ein breiteres Spektrum westeuropäischer Schriftzeichen ab und löst das Downside in etwa 90 % der Fälle.

<class 'pandas.core.body.DataFrame'>
RangeIndex: 50000 entries, 0 to 49999
Knowledge columns (complete 20 columns):
 #   Column               Non-Null Depend  Dtype
---  ------               --------------  -----
 0   dateCrawled          50000 non-null  object
 1   title                 50000 non-null  object
...
 4   value                50000 non-null  object
...
11   odometer             50000 non-null  object
...

Ein paar Dinge fallen auf information(). Die meisten Spalten sind object Typ (Strings in Pandas). Vor allem, value Und odometer sind beide Objekte, obwohl sie numerisch sein sollten – ein Blick auf die tatsächlichen Datenwerte zeigt sofort, warum.

value: $5,000    odometer: 150,000km

Beide Spalten enthalten nicht numerische Zeichen: Dollarzeichen und Kommas beim Preis und „km“ plus Kommas beim Kilometerzähler. Diese müssen entfernt werden, bevor wir mit diesen Spalten rechnen können.

Lerneinblick: Der information() Und head() Die Kombination dieser Methoden ist Ihre erste Verteidigungslinie in jedem neuen Datensatz. information() teilt Ihnen Datentypen und Nullzahlen mit. head() Zeigt Ihnen die tatsächlichen Werte an, damit Sie sie sehen können Warum Diese Typen sind, was sie sind. Zusammen decken sie viele der Reinigungsaufgaben ab, die Sie erledigen müssen.

Schritt 2: Spalten umbenennen

Die ursprünglichen Spaltennamen verwenden camelCase (dateCrawled, vehicleType, yearOfRegistration). Die Python-Konvention ist „snake_case“, additionally benennen wir sie alle auf einmal um.

autos.columns = ('date_crawled', 'title', 'vendor', 'offer_type', 'value', 'ab_test',
       'vehicle_type', 'registration_year', 'gearbox', 'power_ps', 'mannequin',
       'odometer', 'registration_month', 'fuel_type', 'model',
       'unrepaired_damage', 'ad_created', 'num_photos', 'postal_code',
       'last_seen')

Dies erleichtert die Arbeit mit den Spalten und stimmt mit den Greatest Practices von Pandas überein. Beachten Sie, dass wir auch die Gelegenheit genutzt haben, einige Spalten aussagekräftiger umzubenennen: yearOfRegistration wird registration_year, notRepairedDamage wird unrepaired_damageUnd nrOfPictures wird num_photos.

Schritt 3: Unbrauchbare Spalten löschen

Der describe(embrace='all') Die Methode liefert uns zusammenfassende Statistiken für jede Spalte, einschließlich Zeichenfolgenspalten.

autos.describe(embrace='all')

Ein paar Dinge fallen sofort auf. Der vendor Die Spalte enthält nur zwei eindeutige Werte und 49.999 von 50.000 sind identisch. offer_type ist für quick jede Zeile identisch. Diese Spalten enthalten im Wesentlichen keine Informationen.

Der num_photos Kolumne ist noch eindeutiger:

autos("num_photos").value_counts()

0    50000
Title: num_photos, dtype: int64

Jede einzelne Zeile ist Null. Die Spalte ist nutzlos. Wir lassen alle drei fallen.

autos = autos.drop(("num_photos", "vendor", "offer_type"), axis=1)

Schritt 4: Reinigen der Preis- und Kilometerzählerspalten

Nun zur Kernreinigungsarbeit. Beide value Und odometer werden als Zeichenfolgen mit Formatierungszeichen gespeichert, die eine numerische Konvertierung verhindern.

autos("value") = (autos("value")
                  .str.substitute("$", "")
                  .str.substitute(",", "")
                  .astype(int)
                  )
autos("value").head()

0    5000
1    8500
2    8990
3    4350
4    1350
Title: value, dtype: int64

Dabei handelt es sich um Methodenverkettung: drei Operationen werden nacheinander in einem einzigen lesbaren Block angewendet. Wir entfernen das Dollarzeichen, entfernen das Komma (wird in der deutschen Notation als Tausendertrennzeichen verwendet, wobei Kommas auch Dezimalstellen bezeichnen können) und konvertieren in eine Ganzzahl. Der gleiche Ansatz funktioniert für den Kilometerzähler.

autos("odometer") = (autos("odometer")
                     .str.substitute("km", "")
                     .str.substitute(",", "")
                     .astype(int)
                     )
autos.rename({"odometer": "odometer_km"}, axis=1, inplace=True)

Wir benennen die Spalte auch in um odometer_km Es ist additionally klar, dass die Einheit Kilometer ist, da wir „km“ aus den Werten selbst entfernen.

Schritt 5: Preis erkunden und bereinigen

Lassen Sie uns vor dem Filtern verstehen, womit wir arbeiten.

print(autos("value").distinctive().form)
print(autos("value").describe())
autos("value").value_counts().sort_index(ascending=False).head(20)

(2357,)
rely    5.000000e+04
imply     9.840044e+03
std      4.811044e+05
min      0.000000e+00
25%      1.100000e+03
50%      2.950000e+03
75%      7.200000e+03
max      1.000000e+08
Title: value, dtype: float64

min      0.000000e+00
max      1.000000e+08

Der Mindestpreis beträgt 0 $ und der Höchstpreis 100.000.000 $. Beides ist verdächtig. Blick auf die tatsächlichen Excessive-Finish-Werte:

99999999    1
27322222    1
12345678    3

Diese Preise liegen weit über der Preisspanne eines typischen oder Excessive-Finish-Fahrzeugs. Blick auf das untere Ende:

0     1421
1      156

Es sind 1.421 Autos für 0 $ gelistet. Obwohl es sich um einen kleinen Bruchteil von 50.000 Zeilen handelt, stellt $0 für unsere Analyse keinen echten Verkaufspreis dar. Wir entfernen Nullen und alles über 350.000 US-Greenback, wo die Preise von plausiblen Excessive-Finish-Werten zu einer kleinen Gruppe von Ausreißern springen.

autos = autos(autos("value").between(1, 351000))
autos("value").describe()

rely     48565.000000
imply       5888.935591
min           1.000000
max      350000.000000

Wir behalten 48.565 Zeilen bei – eine kleine Reduzierung, die Rauschen entfernt, ohne aussagekräftige Daten zu verwerfen.

Lerneinblick: Die Entscheidung, wo der Ausreißerschwellenwert ermittelt werden soll, ist eine der Ermessensentscheidungen bei der Datenbereinigung. Oft gibt es keine einzige richtige Antwort. Wir haben uns für 350.000 US-Greenback entschieden, weil dort die Preise in den Daten von allmählichen Anstiegen zu extremen Werten springen. Dokumentieren Sie Ihre Argumentation überall dort, wo Sie diese Anrufe tätigen, insbesondere wenn Sie Ihre Analyse mit einem Stakeholder teilen.

Schritt 6: Erkunden der Kilometerzählerwerte

autos("odometer_km").value_counts()

150000    32424
125000     5170
100000     2169
...
Title: odometer_km, dtype: int64

Interessanterweise gibt es nur 13 unterschiedliche Werte, obwohl es sich um eine kontinuierliche numerische Variable handelt. Dies liegt daran, dass die Angebotsoberfläche von eBay wahrscheinlich über eine Dropdown-Auswahl und nicht über ein Freitextfeld verfügte, sodass Verkäufer aus voreingestellten Meilenbereichen auswählen konnten. Das ist kein Fehler – es bedeutet nur, dass wir weniger detailliert sind, als wir vielleicht erwarten. Die 13 unterschiedlichen Werte sind sauber und interpretierbar.

Schritt 7: Reinigung des Registrierungsjahres

autos("registration_year").describe()

min       1000.000000
max       9999.000000

Das Jahr 1000 liegt etwa 900 Jahre vor dem Automobil. Das Jahr 9999 liegt 8.000 Jahre in der Zukunft. Wir müssen auf einen realistischen Bereich filtern.

(~autos("registration_year").between(1900, 2016)).sum() / autos.form(0)

0.038793

Nur etwa 4 % der Zeilen liegen außerhalb unseres gültigen Bereichs von 1900 bis 2016 (dem Erfassungsjahr des Datensatzes). Das ist klein genug, um es problemlos entfernen zu können.

autos = autos(autos("registration_year").between(1900, 2016))
autos("registration_year").value_counts(normalize=True).head(10)

2000    0.067608
2005    0.062895
1999    0.062060

Die Verteilung sieht genau so aus, wie man es für einen Gebrauchtwagenmarkt erwarten würde: Die meisten Fahrzeuge wurden in den letzten 20 Jahren zugelassen.

Schritt 8: Preis nach Marke analysieren

. Mit den bereinigten Daten können wir nun die gängigsten Automarken in den Auflistungen vergleichen und sehen, wie sich ihre Durchschnittspreise unterscheiden.

autos("model").value_counts(normalize=True)

volkswagen        0.211264
bmw               0.110045
opel              0.107581
mercedes_benz     0.096463
audi              0.086566
ford              0.069900
...

Volkswagen dominiert mit rund 21 % der Einträge. Deutsche Hersteller (Volkswagen, BMW, Opel, Mercedes-Benz, Audi) machen zusammen etwa die Hälfte aller Einträge aus.

Viele Marken im hinteren Bereich haben einen Anteil von weniger als 1 %. Für eine aussagekräftige Preisanalyse konzentrieren wir uns auf Marken mit mehr als 5 % der Gesamteinträge.

brand_counts = autos("model").value_counts(normalize=True)
common_brands = brand_counts(brand_counts > .05).index
print(common_brands)

Index(('volkswagen', 'bmw', 'opel', 'mercedes_benz', 'audi', 'ford'), dtype='object')

Jetzt berechnen wir den Durchschnittspreis für jede dieser Marken.

brand_mean_prices = {}

for model in common_brands:
    brand_only = autos(autos("model") == model)
    mean_price = brand_only("value").imply()
    brand_mean_prices(model) = int(mean_price)

brand_mean_prices

{'volkswagen': 5402,
 'bmw': 8332,
 'opel': 2975,
 'mercedes_benz': 8628,
 'audi': 9336,
 'ford': 3749}

Es zeichnet sich ein klares Muster ab: Audi, BMW und Mercedes-Benz liegen im Bereich zwischen 8.000 und 9.300 US-Greenback. Ford und Opel liegen im Bereich zwischen 3.000 und 3.700 US-Greenback. Volkswagen liegt dazwischen bei 5.400 $.

Schritt 9: Vergleich der Kilometerleistung verschiedener Marken

Entspricht ein höherer Durchschnittspreis einer höheren Kilometerleistung? Finden wir es heraus.

brand_mean_mileage = {}

for model in common_brands:
    brand_only = autos(autos("model") == model)
    mean_mileage = brand_only("odometer_km").imply()
    brand_mean_mileage(model) = int(mean_mileage)

mean_mileage = pd.Collection(brand_mean_mileage).sort_values(ascending=False)
mean_prices = pd.Collection(brand_mean_prices).sort_values(ascending=False)

brand_info = pd.DataFrame(mean_mileage, columns=('mean_mileage'))
brand_info("mean_price") = mean_prices
brand_info

               mean_mileage  mean_price
bmw               132572        8332
mercedes_benz     130788        8628
opel              129310        2975
audi              129157        9336
volkswagen        128707        5402
ford              124266        3749

Die Laufleistung liegt zwischen den Marken in einem relativ engen Bereich (ungefähr 124.000 bis 133.000 km), während die Preise zwischen dem günstigsten (Opel für ca. 3.000 $) und dem teuersten (Audi für ca. 9.300 $) um mehr als das Dreifache variieren. BMW und Mercedes-Benz haben die höchste Laufleistung und erzielen auch hohe Preise, was darauf hindeutet, dass Käufer für diese Marken unabhängig vom Verschleiß einen Aufpreis zahlen.

Lerneinblick: Wenn Sie mehrere Metriken gruppenübergreifend vergleichen, lassen sich Muster viel leichter erkennen, wenn Sie sie nebeneinander in einem einzigen DataFrame platzieren, als wenn Sie zwei separate Ausgaben lesen. Hier zeigt die Kombination, dass die Kilometerleistung nicht der Hauptfaktor für den Preisunterschied zwischen deutschen Luxusmarken und preisgünstigen Optionen ist.

Zusammenfassung der Ergebnisse

Nachdem der Datensatz von 50.000 Zeilen auf etwa 46.900 gültige Einträge bereinigt wurde, sind die wichtigsten Erkenntnisse:

Der Gebrauchtwagenmarkt bei eBay Kleinanzeigen wird von deutschen Marken dominiert, wobei allein Volkswagen 21 % der Angebote ausmacht. Unter den gängigen Marken gibt es einen deutlichen Preisunterschied: Audi, BMW und Mercedes-Benz durchschnittlich 8.000 bis 9.300 US-Greenback professional Fahrzeug, während Ford und Opel durchschnittlich 3.000 bis 3.700 US-Greenback professional Fahrzeug haben. Volkswagen liegt dazwischen, was seine Beliebtheit als Mittelklasse-Possibility erklären könnte.

Die durchschnittliche Kilometerleistung variiert von Marke zu Marke kaum (alle innerhalb von 10 % voneinander), was bedeutet, dass die Kilometerleistung allein die Preisunterschiede nicht erklärt. Das Markenprestige und das typische Marktsegment, das diese Hersteller besetzen, sind stärkere Treiber.

Nächste Schritte

Dieser Datensatz kann noch viel mehr unterstützen:

Analysieren Sie die Preise auf Modellebene. Wir haben uns die Marke angesehen, aber die mannequin In der Spalte können Sie tiefer gehen. Unterscheidet sich der Preis deutlich zwischen einem BMW 3er und einem BMW 7er? Gibt es bestimmte Volkswagen-Modelle in höheren oder niedrigeren Preisklassen?

Segmentieren Sie nach Kilometerbereichen. Der Kilometerzähler zeigt uns bereits 13 saubere Eimer. Sinken die Durchschnittspreise mit zunehmender Kilometerleistung stetig oder ist die Beziehung markenabhängig?

Entdecken Sie nicht reparierte Schäden. Der unrepaired_damage Spalte sagt uns, ob ein Auto einen Schaden hat, der nicht behoben wurde. Sind beschädigte Autos deutlich günstiger? Welcher Anteil der Einträge jeder Marke weist Schäden auf?

Bereinigen und verwenden Sie die Datumsspalten. Wir haben übersprungen date_crawled, ad_createdUnd last_seen für diese Komplettlösung. Die Analyse, wie lange Einträge aktiv blieben, bevor sie entfernt wurden, könnte Aufschluss darüber geben, welche Marken oder Preisklassen sich am schnellsten verkaufen.

Ressourcen

Teilen Sie Ihre erweiterte Analyse in der Neighborhood und taggen Sie @Anna_strahl. Es gibt mehrere interessante Richtungen für dieses Projekt, und es lohnt sich immer, zu sehen, welche Muster andere in den Daten finden.

In diesem Tutorial erkunden wir das Lambda/hermes-agent-reasoning-traces-Datensatz um zu verstehen, wie agentenbasierte Modelle denken, Instruments verwenden und Antworten in Gesprächen mit mehreren Runden generieren. Wir beginnen mit dem Laden und Untersuchen des Datensatzes und untersuchen seine Struktur, Kategorien und Konversationsformat, um eine klare Vorstellung von den verfügbaren Informationen zu erhalten. Anschließend erstellen wir einfache Parser, um Schlüsselkomponenten wie Argumentationsspuren, Toolaufrufe und Toolantworten zu extrahieren und so internes Denken von externen Aktionen zu trennen. Außerdem analysieren wir Muster wie die Häufigkeit der Instrument-Nutzung, die Gesprächslänge und Fehlerraten, um das Agentenverhalten besser zu verstehen. Wir erstellen auch Visualisierungen, um diese Tendencies hervorzuheben und die Analyse intuitiver zu gestalten. Abschließend bereiten wir den Datensatz für das Coaching vor, indem wir ihn in ein modellfreundliches Format konvertieren, sodass er für Aufgaben wie überwachte Feinabstimmung geeignet ist.

!pip -q set up -U datasets pandas matplotlib seaborn transformers speed up trl


import json, re, random, textwrap
from collections import Counter, defaultdict
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datasets import load_dataset, concatenate_datasets


random.seed(0)


CONFIG = "kimi"
ds = load_dataset("lambda/hermes-agent-reasoning-traces", CONFIG, break up="prepare")
print(ds)
print("Config:", CONFIG, "| Fields:", ds.column_names)
print("Classes:", sorted(set(ds("class"))))


COMPARE_BOTH = False
if COMPARE_BOTH:
   ds_kimi = load_dataset("lambda/hermes-agent-reasoning-traces", "kimi", break up="prepare")
   ds_glm  = load_dataset("lambda/hermes-agent-reasoning-traces", "glm-5.1", break up="prepare")
   ds_kimi = ds_kimi.add_column("supply", ("kimi") * len(ds_kimi))
   ds_glm  = ds_glm.add_column("supply", ("glm-5.1") * len(ds_glm))
   ds = concatenate_datasets((ds_kimi, ds_glm)).shuffle(seed=0)
   print("Mixed:", ds, "→ counts:", Counter(ds("supply")))


pattern = ds(0)
print("n=== Pattern 0 ===")
print("id        :", pattern("id"))
print("class  :", pattern("class"), "/", pattern("subcategory"))
print("process      :", pattern("process"))
print("turns     :", len(pattern("conversations")))
print("system(0) :", pattern("conversations")(0)("worth")(:220), "...n")

Wir installieren alle erforderlichen Bibliotheken und importieren die notwendigen Module, um unsere Umgebung einzurichten. Anschließend laden wir den Datensatz „lambda/hermes-agent-reasoning-traces“ und überprüfen seine Struktur, Felder und Kategorien. Non-compulsory kombinieren wir auch mehrere Datensatzkonfigurationen und untersuchen eine Stichprobe, um das Konversationsformat zu verstehen.

THINK_RE     = re.compile(r"<assume>(.*?)</assume>", re.DOTALL)
TOOL_CALL_RE = re.compile(r"<tool_call>s*({.*?})s*</tool_call>", re.DOTALL)
TOOL_RESP_RE = re.compile(r"<tool_response>s*(.*?)s*</tool_response>", re.DOTALL)


def parse_assistant(worth: str) -> dict:
   ideas = (t.strip() for t in THINK_RE.findall(worth))
   calls = ()
   for uncooked in TOOL_CALL_RE.findall(worth):
       strive:
           calls.append(json.hundreds(uncooked))
       besides json.JSONDecodeError:
           calls.append({"identify": "<malformed>", "arguments": {}})
   last = TOOL_CALL_RE.sub("", THINK_RE.sub("", worth)).strip()
   return {"ideas": ideas, "tool_calls": calls, "last": last}


def parse_tool(worth: str):
   uncooked = TOOL_RESP_RE.search(worth)
   if not uncooked: return {"uncooked": worth}
   physique = uncooked.group(1)
   strive:    return json.hundreds(physique)
   besides: return {"uncooked": physique}


first_gpt = subsequent(t for t in pattern("conversations") if t("from") == "gpt")
p = parse_assistant(first_gpt("worth"))
print("Thought preview :", (p("ideas")(0)(:160) + "...") if p("ideas") else "(none)")
print("Instrument calls       :", ((c.get("identify"), record(c.get("arguments", {}).keys())) for c in p("tool_calls")))

Wir definieren Regex-basierte Parser, um Argumentationsspuren, Toolaufrufe und Toolantworten aus dem Datensatz zu extrahieren. Wir verarbeiten Hilfsmeldungen, um Gedanken, Handlungen und Endergebnisse auf strukturierte Weise zu trennen. Anschließend testen wir den Parser anhand einer Beispielkonversation, um sicherzustellen, dass die Extraktion ordnungsgemäß funktioniert.

N = 3000
sub = ds.choose(vary(min(N, len(ds))))


tool_calls         = Counter()
parallel_widths    = Counter()
thoughts_per_turn  = ()
calls_per_traj     = ()
errors_per_traj    = ()
turns_per_traj     = ()
cat_counts         = Counter()


for ex in sub:
   cat_counts(ex("class")) += 1
   n_calls = n_err = 0
   turns_per_traj.append(len(ex("conversations")))
   for t in ex("conversations"):
       if t("from") == "gpt":
           p = parse_assistant(t("worth"))
           thoughts_per_turn.append(len(p("ideas")))
           if p("tool_calls"):
               parallel_widths(len(p("tool_calls"))) += 1
               for c in p("tool_calls"):
                   tool_calls(c.get("identify", "<unknown>")) += 1
               n_calls += len(p("tool_calls"))
       elif t("from") == "software":
           r = parse_tool(t("worth"))
           blob = json.dumps(r).decrease()
           if "error" in blob or '"exit_code": 1' in blob or "traceback" in blob:
               n_err += 1
   calls_per_traj.append(n_calls)
   errors_per_traj.append(n_err)


print(f"nScanned {len(sub)} trajectories")
print(f"Avg turns/traj      : {np.imply(turns_per_traj):.1f}")
print(f"Avg software calls/traj : {np.imply(calls_per_traj):.1f}")
print(f"% with >=1 error    : {100*np.imply((e>0 for e in errors_per_traj)):.1f}%")
print(f"% parallel turns    : {100*sum(v for okay,v in parallel_widths.gadgets() if okay>1)/max(1,sum(parallel_widths.values())):.1f}%")
print("High 10 instruments        :", tool_calls.most_common(10))


fig, axes = plt.subplots(2, 2, figsize=(13, 9))


high = tool_calls.most_common(15)
axes(0,0).barh((t for t,_ in high)(::-1), (c for _,c in high)(::-1), colour="teal")
axes(0,0).set_title("High 15 instruments by name quantity")
axes(0,0).set_xlabel("calls")


ks = sorted(parallel_widths)
axes(0,1).bar((str(okay) for okay in ks), (parallel_widths(okay) for okay in ks), colour="coral")
axes(0,1).set_title("Instrument-calls per assistant flip (parallel width)")
axes(0,1).set_xlabel("# software calls in a single flip"); axes(0,1).set_ylabel("depend")
axes(0,1).set_yscale("log")


axes(1,0).hist(turns_per_traj, bins=40, colour="steelblue")
axes(1,0).set_title("Dialog size"); axes(1,0).set_xlabel("turns")


cats, vals = zip(*cat_counts.most_common())
axes(1,1).pie(vals, labels=cats, autopct="%1.0f%%", startangle=90)
axes(1,1).set_title("Class distribution")


plt.tight_layout(); plt.present()

Wir führen datensatzweite Analysen durch, um die Instrument-Nutzung, Gesprächslängen und Fehlermuster zu messen. Wir aggregieren Statistiken über mehrere Stichproben hinweg, um das allgemeine Agentenverhalten zu verstehen. Wir erstellen auch Visualisierungen, um Tendencies wie Werkzeughäufigkeit, Parallelanrufe und Kategorieverteilung hervorzuheben.

def render_trace(ex, max_chars=350):
   print(f"n{'='*72}nTASK ({ex('class')} / {ex('subcategory')}): {ex('process')}n{'='*72}")
   for t in ex("conversations"):
       position = t("from")
       if position == "system":
           proceed
       if position == "human":
           print(f"n(USER)n{textwrap.shorten(t('worth'), 600)}")
       elif position == "gpt":
           p = parse_assistant(t("worth"))
           for th in p("ideas"):
               print(f"n(THINK)n{textwrap.shorten(th, max_chars)}")
           for c in p("tool_calls"):
               args = json.dumps(c.get("arguments", {}))(:200)
               print(f"(CALL) {c.get('identify')}({args})")
           if p("last"):
               print(f"n(ANSWER)n{textwrap.shorten(p('last'), max_chars)}")
       elif position == "software":
           print(f"(TOOL_RESPONSE) {textwrap.shorten(t('worth'), 220)}")
   print("="*72)


idx = int(np.argmin(np.abs(np.array(turns_per_traj) - 10)))
render_trace(sub(idx))


def get_tool_schemas(ex):
   strive:    return json.hundreds(ex("instruments"))
   besides: return ()


schemas = get_tool_schemas(pattern)
print(f"nSample 0 has {len(schemas)} instruments obtainable")
for s in schemas(:3):
   fn = s.get("perform", {})
   print(" -", fn.get("identify"), "—", (fn.get("description") or "")(:80))


ROLE_MAP = {"system": "system", "human": "person", "gpt": "assistant", "software": "software"}


def to_openai_messages(conv):
   return ({"position": ROLE_MAP(t("from")), "content material": t("worth")} for t in conv)


example_msgs = to_openai_messages(pattern("conversations"))
print("nFirst 2 OpenAI messages:")
for m in example_msgs(:2):
   print(" ", m("position"), "→", m("content material")(:120).change("n", " "), "...")

Wir entwickeln Dienstprogramme, um vollständige Konversationsspuren in einem lesbaren Format für eine tiefergehende Untersuchung darzustellen. Wir extrahieren außerdem Toolschemata und konvertieren den Datensatz in ein Nachrichtenformat im OpenAI-Stil, um die Kompatibilität mit Trainingspipelines zu gewährleisten. Dies hilft uns, sowohl die Struktur der Instruments als auch die Artwork und Weise, wie Gespräche standardisiert werden können, besser zu verstehen.

from transformers import AutoTokenizer
TOK_ID = "Qwen/Qwen2.5-0.5B-Instruct"
tok = AutoTokenizer.from_pretrained(TOK_ID)


def build_masked(conv, tokenizer, max_len=2048):
   msgs = to_openai_messages(conv)
   for m in msgs:
       if m("position") == "software":
           m("position") = "person"
           m("content material") = "(TOOL OUTPUT)n" + m("content material")
   input_ids, labels = (), ()
   for m in msgs:
       textual content = tokenizer.apply_chat_template((m), tokenize=False, add_generation_prompt=False)
       ids = tokenizer.encode(textual content, add_special_tokens=False)
       input_ids.lengthen(ids)
       labels.lengthen(ids if m("position") == "assistant" else (-100) * len(ids))
   return input_ids(:max_len), labels(:max_len)


ids, lbls = build_masked(pattern("conversations"), tok)
trainable = sum(1 for x in lbls if x != -100)
print(f"nTokenized instance: {len(ids)} tokens, {trainable} trainable ({100*trainable/len(ids):.1f}%)")


think_lens, call_lens, ans_lens = (), (), ()
for ex in sub.choose(vary(min(500, len(sub)))):
   for t in ex("conversations"):
       if t("from") != "gpt": proceed
       p = parse_assistant(t("worth"))
       for th in p("ideas"): think_lens.append(len(th))
       for c in p("tool_calls"): call_lens.append(len(json.dumps(c)))
       if p("last"): ans_lens.append(len(p("last")))


plt.determine(figsize=(10,4))
plt.hist((think_lens, call_lens, ans_lens), bins=40, log=True,
        label=("<assume>", "<tool_call>", "last reply"), stacked=False)
plt.legend(); plt.xlabel("characters"); plt.title("Size distributions (log y)")
plt.tight_layout(); plt.present()


class TraceReplayer:
   def __init__(self, ex):
       self.ex = ex
       self.steps = ()
       pending = None
       for t in ex("conversations"):
           if t("from") == "gpt":
               if pending: self.steps.append(pending)
               pending = {"assume": parse_assistant(t("worth")), "responses": ()}
           elif t("from") == "software" and pending:
               pending("responses").append(parse_tool(t("worth")))
       if pending: self.steps.append(pending)
   def __len__(self): return len(self.steps)
   def play(self, i):
       s = self.steps(i)
       print(f"n── Step {i+1}/{len(self)} ──")
       for th in s("assume")("ideas"):
           print(f" {textwrap.shorten(th, 280)}")
       for c in s("assume")("tool_calls"):
           print(f"  {c.get('identify')}({json.dumps(c.get('arguments', {}))(:140)})")
       for r in s("responses"):
           print(f" {textwrap.shorten(json.dumps(r), 200)}")
       if s("assume")("last"):
           print(f" {textwrap.shorten(s('assume')('last'), 200)}")


rp = TraceReplayer(pattern)
for i in vary(min(3, len(rp))):
   rp.play(i)


TRAIN = False
if TRAIN:
   import torch
   from transformers import AutoModelForCausalLM
   from trl import SFTTrainer, SFTConfig


   train_subset = ds.choose(vary(200))


   def to_text(batch):
       msgs = to_openai_messages(batch("conversations"))
       for m in msgs:
           if m("position") == "software":
               m("position") = "person"; m("content material") = "(TOOL)n" + m("content material")
       batch("textual content") = tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=False)
       return batch


   train_subset = train_subset.map(to_text)


   mannequin = AutoModelForCausalLM.from_pretrained(
       TOK_ID,
       torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
       device_map="auto" if torch.cuda.is_available() else None,
   )


   cfg = SFTConfig(
       output_dir="hermes-sft-demo",
       per_device_train_batch_size=1,
       gradient_accumulation_steps=4,
       max_steps=20,
       learning_rate=2e-5,
       logging_steps=2,
       max_seq_length=1024,
       dataset_text_field="textual content",
       report_to="none",
       fp16=torch.cuda.is_available(),
   )
   SFTTrainer(mannequin=mannequin, args=cfg, train_dataset=train_subset, processing_class=tok).prepare()
   print("Wonderful-tune demo completed.")


print("n Tutorial full. You now have parsers, analytics, plots, a replayer, "
     "tokenized + label-masked SFT examples, and an optionally available coaching hook.")

Wir tokenisieren die Gespräche und wenden Etikettenmaskierung an, sodass nur die Antworten der Assistenten zum Coaching beitragen. Wir analysieren die Längenverteilungen von Begründungen, Werkzeugaufrufen und Antworten, um weitere Erkenntnisse zu gewinnen. Wir implementieren außerdem einen Hint-Replayer, um das Agentenverhalten schrittweise zu durchlaufen und optionally available eine kleine Feinabstimmungsschleife auszuführen.

Abschließend haben wir einen strukturierten Arbeitsablauf entwickelt, um die Argumentationsspuren von Agenten zu analysieren, zu analysieren und effektiv damit zu arbeiten. Wir konnten Gespräche in sinnvolle Komponenten zerlegen, Schritt für Schritt untersuchen, wie Agenten argumentieren, und messen, wie sie während der Problemlösung mit Instruments interagieren. Mithilfe der Visualisierungen und Analysen haben wir Einblicke in allgemeine Muster und Verhaltensweisen im gesamten Datensatz gewonnen. Darüber hinaus haben wir die Daten in ein Format konvertiert, das zum Trainieren von Sprachmodellen geeignet ist, einschließlich der Handhabung der Tokenisierung und Labelmaskierung für Assistentenantworten. Darüber hinaus bietet dieser Prozess eine solide Grundlage für die praktische und skalierbare Untersuchung, Bewertung und Verbesserung von KI-Systemen, die Werkzeuge verwenden.

Schauen Sie sich das an Vollständige Codes mit Pocket book. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 130.000+ ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Möchten Sie mit uns zusammenarbeiten, um Ihr GitHub-Repo ODER Ihre Hugging Face Web page ODER Produktveröffentlichung ODER Ihr Webinar usw. zu bewerben? Vernetzen Sie sich mit uns

eine kleine NumPy-Projektreihe, in der ich es tatsächlich versuche etwas bauen mit NumPy, anstatt nur zufällige Funktionen und Dokumentation durchzugehen. Ich hatte immer das Gefühl, dass der beste Weg zum Lernen darin besteht, etwas zu tun. Deshalb wollte ich in diesem Projekt etwas sowohl Praktisches als auch Persönliches schaffen.

Die Idee conflict einfach: Analysieren Sie meine täglichen Gewohnheiten – Schlaf, Lernstunden, Bildschirmzeit, Bewegung und Stimmung – und sehen Sie, wie sie sich auf meine Produktivität und mein allgemeines Wohlbefinden auswirken. Die Daten sind nicht actual; Es ist fiktiv und über einen Zeitraum von 30 Tagen simuliert. Aber das Ziel ist nicht die Genauigkeit der Daten – es geht darum zu lernen, wie man NumPy sinnvoll nutzt.

Lassen Sie uns den Prozess Schritt für Schritt durchgehen.

Schritt 1 – Laden und Verstehen der Daten

Ich begann damit, ein einfaches NumPy-Array zu erstellen, das 30 Zeilen (eine für jeden Tag) und sechs Spalten enthielt – jede Spalte repräsentierte eine andere Gewohnheitsmetrik. Dann habe ich es als gespeichert .npy Datei, damit ich sie später problemlos laden kann.

# TODO: Import NumPy and cargo the .npy information file
import numpy as np
information = np.load(‘activity_data.npy’)

Nach dem Laden wollte ich bestätigen, dass alles wie erwartet aussah. Additionally habe ich das überprüft Type (um zu wissen, wie viele Zeilen und Spalten es gab) und die Anzahl der Dimensionen (um zu bestätigen, dass es sich um eine 2D-Tabelle und nicht um eine 1D-Liste handelt).

# TODO: Print array form, first few rows, and so forth.
information.form
information.ndim

AUSGABE: 30 Zeilen, 6 Spalten und ndim=2

Ich habe auch die ersten paar Zeilen ausgedruckt, um visuell zu bestätigen, dass jeder Wert in Ordnung conflict – zum Beispiel, dass die Schlafstunden nicht negativ waren oder dass die Stimmungswerte in einem angemessenen Bereich lagen.

# TODO: High 5 rows
information(:5)

Ausgabe:

array((( 1. , 6.5, 5. , 4.2, 20. , 6. ),
( 2. , 7.2, 6. , 3.1, 35. , 7. ),
( 3. , 5.8, 4. , 5.5, 0. , 5. ),
( 4. , 8. , 7. , 2.5, 30. , 8. ),
( 5. , 6. , 5. , 4.8, 10. , 6. )))

Schritt 2 – Validierung der Daten

Bevor ich eine Analyse durchführte, wollte ich sicherstellen, dass die Daten Sinn ergeben. Dies ist etwas, was wir bei der Arbeit mit fiktiven Daten oft überspringen, aber es ist dennoch eine gute Vorgehensweise.

Additionally habe ich nachgeschaut:

• Keine negativen Schlafstunden
• Keine Stimmung hat einen Wert unter 1 oder über 10

Für den Schlaf bedeutete das, die Schlafspalte (Index 1 in meinem Array) auszuwählen und zu prüfen, ob Werte unter Null lagen.

# Ensure values are affordable (no unfavorable sleep)
information(:, 1) < 0

Ausgabe:

array((False, False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False, False,
False, False, False))

Das bedeutet, dass es keine Nachteile gibt. Dann habe ich das Gleiche für die Stimmung gemacht. Ich zählte, um herauszufinden, dass die Stimmungsspalte den Index 5 hatte, und überprüfte, ob einer unter 1 oder über 10 lag.

# Is temper out of vary?
information(:, 5) < 1
information(:, 5) > 10

Wir haben die gleiche Ausgabe erhalten.

Alles sah intestine aus, additionally konnten wir weitermachen.

Schritt 3 – Aufteilen der Daten in Wochen

Ich hatte 30 Tage Daten und wollte sie Woche für Woche analysieren. Der erste Instinkt conflict, NumPys zu verwenden cut up() Funktion, aber das ist fehlgeschlagen, weil 30 nicht gleichmäßig durch 4 teilbar ist. Additionally habe ich stattdessen verwendet np.array_split()was ungleichmäßige Teilungen ermöglicht.

Das hat mir Folgendes gebracht:

• Woche 1 → 8 Tage
• Woche 2 → 8 Tage
• Woche 3 → 7 Tage
• Woche 4 → 7 Tage

# TODO: Slice information into week 1, week 2, week 3, week 4
weekly_data = np.array_split(information, 4)
weekly_data

Ausgabe:

(array((( 1. , 6.5, 5. , 4.2, 20. , 6. ),
( 2. , 7.2, 6. , 3.1, 35. , 7. ),
( 3. , 5.8, 4. , 5.5, 0. , 5. ),
( 4. , 8. , 7. , 2.5, 30. , 8. ),
( 5. , 6. , 5. , 4.8, 10. , 6. ),
( 6. , 7.5, 6. , 3.3, 25. , 7. ),
( 7. , 8.2, 3. , 6.1, 40. , 7. ),
( 8. , 6.3, 4. , 5. , 15. , 6. ))),

array((( 9. , 7. , 6. , 3.2, 30. , 7. ),
(10. , 5.5, 3. , 6.8, 0. , 5. ),
(11. , 7.8, 7. , 2.9, 25. , 8. ),
(12. , 6.1, 5. , 4.5, 15. , 6. ),
(13. , 7.4, 6. , 3.7, 30. , 7. ),
(14. , 8.1, 2. , 6.5, 50. , 7. ),
(15. , 6.6, 5. , 4.1, 20. , 6. ),
(16. , 7.3, 6. , 3.4, 35. , 7. ))),

array(((17. , 5.9, 4. , 5.6, 5. , 5. ),
(18. , 8.3, 7. , 2.6, 30. , 8. ),
(19. , 6.2, 5. , 4.3, 10. , 6. ),
(20. , 7.6, 6. , 3.1, 25. , 7. ),
(21. , 8.4, 3. , 6.3, 40. , 7. ),
(22. , 6.4, 4. , 5.1, 15. , 6. ),
(23. , 7.1, 6. , 3.3, 30. , 7. ))),

array(((24. , 5.7, 3. , 6.7, 0. , 5. ),
(25. , 7.9, 7. , 2.8, 25. , 8. ),
(26. , 6.2, 5. , 4.4, 15. , 6. ),
(27. , 7.5, 6. , 3.5, 30. , 7. ),
(28. , 8. , 2. , 6.4, 50. , 7. ),
(29. , 6.5, 5. , 4.2, 20. , 6. ),
(30. , 7.4, 6. , 3.6, 35. , 7. ))))

Jetzt lagen die Daten in vier Blöcken vor, und ich konnte jeden einzelnen Teil problemlos analysieren.

Schritt 4 – Berechnung der wöchentlichen Kennzahlen

Ich wollte ein Gefühl dafür bekommen, wie sich jede Gewohnheit von Woche zu Woche verändert. Deshalb habe ich mich auf vier Hauptdinge konzentriert:

• Durchschnittlicher Schlaf
• Durchschnittliche Studienstunden
• Durchschnittliche Bildschirmzeit
• Durchschnittlicher Stimmungswert

Ich habe das Array jeder Woche in einer separaten Variablen gespeichert und dann verwendet np.imply() um die Durchschnittswerte für jede Metrik zu berechnen.

Durchschnittliche Schlafstunden

# retailer into variables
week_1 = weekly_data(0)
week_2 = weekly_data(1)
week_3 = weekly_data(2)
week_4 = weekly_data(3)

# TODO: Compute common sleep
week1_avg_sleep = np.imply(week_1(:, 1))
week2_avg_sleep = np.imply(week_2(:, 1))
week3_avg_sleep = np.imply(week_3(:, 1))
week4_avg_sleep = np.imply(week_4(:, 1))

Durchschnittliche Studienstunden

# TODO: Compute common research hours
week1_avg_study = np.imply(week_1(:, 2))
week2_avg_study = np.imply(week_2(:, 2))
week3_avg_study = np.imply(week_3(:, 2))
week4_avg_study = np.imply(week_4(:, 2))

Durchschnittliche Bildschirmzeit

# TODO: Compute common display time
week1_avg_screen = np.imply(week_1(:, 3))
week2_avg_screen = np.imply(week_2(:, 3))
week3_avg_screen = np.imply(week_3(:, 3))
week4_avg_screen = np.imply(week_4(:, 3))

Durchschnittlicher Stimmungswert

# TODO: Compute common temper rating
week1_avg_mood = np.imply(week_1(:, 5))
week2_avg_mood = np.imply(week_2(:, 5))
week3_avg_mood = np.imply(week_3(:, 5))
week4_avg_mood = np.imply(week_4(:, 5))

Um alles leichter lesbar zu machen, habe ich die Ergebnisse dann intestine formatiert.

# TODO: Show weekly outcomes clearly
print(f”Week 1 — Common sleep: {week1_avg_sleep:.2f} hrs, Examine: {week1_avg_study:.2f} hrs, “
f”Display time: {week1_avg_screen:.2f} hrs, Temper rating: {week1_avg_mood:.2f}”)

print(f”Week 2 — Common sleep: {week2_avg_sleep:.2f} hrs, Examine: {week2_avg_study:.2f} hrs, “
f”Display time: {week2_avg_screen:.2f} hrs, Temper rating: {week2_avg_mood:.2f}”)

print(f”Week 3 — Common sleep: {week3_avg_sleep:.2f} hrs, Examine: {week3_avg_study:.2f} hrs, “
f”Display time: {week3_avg_screen:.2f} hrs, Temper rating: {week3_avg_mood:.2f}”)

print(f”Week 4 — Common sleep: {week4_avg_sleep:.2f} hrs, Examine: {week4_avg_study:.2f} hrs, “
f”Display time: {week4_avg_screen:.2f} hrs, Temper rating: {week4_avg_mood:.2f}”)

Ausgabe:

Week 1 – Common sleep: 6.94 hrs, Examine: 5.00 hrs, Display time: 4.31 hrs, Temper rating: 6.50
Week 2 – Common sleep: 6.97 hrs, Examine: 5.00 hrs, Display time: 4.39 hrs, Temper rating: 6.62
Week 3 – Common sleep: 7.13 hrs, Examine: 5.00 hrs, Display time: 4.33 hrs, Temper rating: 6.57
Week 4 – Common sleep: 7.03 hrs, Examine: 4.86 hrs, Display time: 4.51 hrs, Temper rating: 6.57

Schritt 5 – Die Ergebnisse verstehen

Nachdem ich die Zahlen ausgedruckt hatte, tauchten einige Muster auf.

Mein Schlafstunden waren in den ersten zwei Wochen ziemlich konstant (ca. 6,9 Stunden), aber in der dritten Woche stiegen sie sprunghaft auf ca. 7,1 Stunden. Das bedeutet, dass ich im Laufe des Monats „besser geschlafen“ habe. Bis zur vierten Woche waren es ungefähr 7,0 Stunden.

Für Lernstundenes conflict das Gegenteil. In den Wochen eins und zwei waren es durchschnittlich etwa fünf Stunden professional Tag, in der vierten Woche waren es jedoch nur etwa vier Stunden. Grundsätzlich habe ich stark angefangen, aber langsam an Schwung verloren – was sich, ehrlich gesagt, ungefähr richtig anhört.

Dann kam Bildschirmzeit. Das tat ein bisschen weh. In der ersten Woche waren es ungefähr 4,3 Stunden professional Tag, und jede Woche wurden die Werte immer höher. Der klassische Zyklus, bei dem man früh produktiv ist und später im Monat langsam in weitere „Scroll-Pausen“ übergeht.

Endlich conflict es da Stimmung. Mein Stimmungswert begann in der ersten Woche bei etwa 6,5, stieg in der zweiten Woche leicht auf 6,6 und blieb dann für den Relaxation des Zeitraums auf diesem Wert. Es hat sich nicht dramatisch verändert, aber es conflict interessant, einen kleinen Anstieg in der zweiten Woche zu sehen – kurz bevor meine Lernstunden sanken und meine Bildschirmzeit zunahm.

Um die Dinge interaktiv zu gestalten, dachte ich, dass es großartig wäre, sie mit Matplotlib zu visualisieren.

Schritt 6 – Auf der Suche nach Mustern

Nachdem ich nun die Zahlen hatte, wollte ich es wissen Warum In der zweiten Woche stieg meine Laune.

Additionally habe ich die Wochen nebeneinander verglichen. Die zweite Woche hatte im Vergleich zu den späteren Wochen guten Schlaf, viele Lernstunden und relativ wenig Bildschirmzeit.

Das könnte erklären, warum mein Stimmungswert dort seinen Höhepunkt erreichte. Obwohl ich in der dritten Woche mehr schlief, begannen meine Lernstunden zu sinken – vielleicht ruhte ich mich mehr aus, schaffte aber weniger, was meine Stimmung nicht so sehr verbesserte, wie ich erwartet hatte.

Das hat mir an dem Projekt gefallen: Es geht nicht darum, dass die Daten echt sind, sondern darum, wie man das machen kann Verwenden Sie NumPy um Muster, Zusammenhänge und kleine Erkenntnisse zu erforschen. Selbst fiktive Daten können eine Geschichte erzählen, wenn man sie richtig betrachtet.

Schritt 7 – Zusammenfassung und nächste Schritte

In diesem kleinen Projekt habe ich ein paar wichtige Dinge gelernt – sowohl über NumPy als auch über die Strukturierung einer solchen Analyse.

Wir begannen mit einer Rohliste fiktiver Alltagsgewohnheiten, lernten, deren Struktur und Gültigkeit zu überprüfen, sie in sinnvolle Abschnitte (Wochen) aufzuteilen und verwendeten dann einfache NumPy-Operationen, um jedes Section zu analysieren.

Es handelt sich um ein kleines Projekt, das Sie daran erinnert, dass Datenanalyse nicht immer komplex sein muss. Manchmal geht es nur darum, einfache Fragen zu stellen wie „Wie verändert sich meine Bildschirmzeit im Laufe der Zeit?“ oder „Wann fühle ich mich am besten?“

Wenn ich das weiterführen möchte (was ich wahrscheinlich tun werde), gibt es so viele Richtungen, in die ich gehen kann:

• Finden Sie die beste und schlechteste Tage gesamt
• Vergleichen Wochentage vs. Wochenenden
• Oder erstellen Sie sogar einen einfachen „Wohlbefindens-Rating“, der auf der Kombination mehrerer Gewohnheiten basiert

Aber das wird wahrscheinlich für den nächsten Teil der Serie sein.

Im Second bin ich froh, dass ich NumPy auf etwas anwenden konnte, das sich actual und nachvollziehbar anfühlt – nicht nur abstrakte Arrays und Zahlen, sondern auch Gewohnheiten und Emotionen. Das ist die Artwork des Lernens, die hängen bleibt.

Danke fürs Lesen.

Wenn Sie die Serie verfolgen, versuchen Sie, sie anhand Ihrer eigenen fiktiven Daten nachzubilden. Selbst wenn Ihre Zahlen zufällig sind, lernen Sie mit diesem Prozess, wie Sie Arrays wie ein Profi aufteilen, aufteilen und analysieren.

In der Produktion reagieren Sie aktiv auf Benutzeranfragen. Sie möchten jedoch Ihr Modell jetzt verbessern, um einen größeren Teil der Kundenanfragen erfolgreich zu bearbeiten. Wie nähern Sie sich dem?

In diesem Artikel diskutiere ich das Szenario, in dem Sie bereits über eine laufende LLM verfügen und die Leistung analysieren und optimieren möchten. Ich werde die Ansätze diskutieren, die ich benutze, um dort aufzudecken, wo die LLM funktioniert und wo es verbessert werden muss. Darüber hinaus werde ich auch die Instruments besprechen, mit denen ich die Leistung meines LLM verbessern kann, mit Instruments wie dem schnellen Optimierer von Anthropic.

Kurz gesagt, ich verfolge einen dreistufigen Prozess, um die Leistung meines LLM schnell zu verbessern:

1. Analysieren Sie LLM -Ausgänge
2. Iterativ die Bereiche mit dem größten Wert für den Aufwand verbessern
3. Bewerten und iterieren

Inhaltsverzeichnis

Motivation

Meine Motivation für diesen Artikel ist, dass ich mich oft in dem im Intro beschriebenen Szenario befinde. Ich habe bereits meine LLM in Betrieb; Es leistet jedoch nicht wie erwartet oder erreicht die Kundenerwartungen. Durch unzählige Erfahrungen bei der Analyse meiner LLMs habe ich diesen einfachen dreistufigen Prozess erstellt, mit dem ich immer LLMs verbessern kann.

Schritt 1: Analyse von LLM -Ausgängen

Der erste Schritt zur Verbesserung Ihrer LLMs sollte immer darin bestehen, ihre Ausgabe zu analysieren. Um eine hohe Beobachtbarkeit in Ihrer Plattform zu haben, empfehle ich dringend, ein LLM -Supervisor -Software zur Verfolgung zu verwenden, wie z. Langfuse oder PromptLayer. Diese Instruments machen es einfach, alle Ihre LLM -Aufrufe an einem Ort zu sammeln, um die Analyse bereitzustellen.

Ich werde jetzt verschiedene Ansätze diskutieren, die ich bewerbe, um meine LLM -Ausgänge zu analysieren.

Manuelle Inspektion der Rohausgabe

Der einfachste Ansatz zur Analyse Ihrer LLM -Ausgabe besteht darin, viele Ihrer LLM -Aufrufe manuell zu inspizieren. Sie sollten Ihre letzten 50 LLM -Aufrufe sammeln, den gesamten Kontext lesen, den Sie in das Modell eingesperrt haben, und die Ausgabe des bereitgestellten Modells. Ich finde diesen Ansatz überraschend wirksam bei der Aufdeckung von Problemen. Ich habe zum Beispiel entdeckt:

• Duplizierter Kontext (Teil meines Kontexts wurde aufgrund eines Programmierfehlers dupliziert)
• Fehlender Kontext (ich habe nicht alle Informationen, die ich erwartet hatte, in mein LLM gefüttert)
• usw.

Die manuelle Überprüfung der Daten sollte niemals unterschätzt werden. Wenn Sie die Daten gründlich durchsuchen, werden Sie das Datensatz, an dem Sie arbeiten, manuell verstehen, was auf andere Weise schwer zu erhalten ist. Darüber hinaus stelle ich auch fest, dass ich mehr Datenpunkte manuell inspizieren sollte, als ich zunächst Zeit für die Bewertung verbringen möchte.

Nehmen wir beispielsweise an, es dauert 5 Minuten, um ein Beispiel für Eingabe-Output manuell zu überprüfen. Meine Instinct sagt mir oft, dass ich vielleicht 20-30 Minuten dafür verbringen und somit 4-6 Datenpunkte inspizieren soll. Ich stelle jedoch fest, dass Sie normalerweise viel länger für diesen Teil des Prozesses ausgeben sollten. Ich empfehle diesmal mindestens 5x-ing. Anstatt 30 Minuten manuell zu inspizieren, verbringen Sie 2,5 Stunden. Zunächst denken Sie, dass dies viel Zeit ist, um eine manuelle Inspektion auszugeben, aber in der Regel spart es Ihnen auf lange Sicht viel Zeit. Zusätzlich ist 2,5 Stunden im Vergleich zu einem gesamten 3-wöchigen Projekt eine unbedeutende Zeit.

Gruppenanfragen nach Taxonomie

Manchmal erhalten Sie nicht alle Ihre Antworten aus einer einfachen manuellen Analyse Ihrer Daten. In diesen Fällen würde ich zu einer quantitativeren Analyse meiner Daten übergehen. Dies ist im Gegensatz zum ersten Ansatz, den ich für qualitativ halte, da ich jeden Datenpunkt manuell inspiziere.

Die Gruppierung von Benutzeranfragen nach einer Taxonomie ist ein effizienter Ansatz, um besser zu verstehen, was Benutzer von Ihrem LLM erwarten. Ich werde ein Beispiel geben, um dies zu erleichtern, um zu verstehen:

Stellen Sie sich vor, Sie sind Amazon und haben einen Kundendienst LLM, der eingehende Kundenfragen bearbeitet. In diesem Fall wird eine Taxonomie so aussehen wie:

• Rückerstattungsanfragen
• Sprechen Sie mit menschlichen Anfragen
• Fragen zu einzelnen Produkten
• …

Ich würde mich dann die letzten 1000 Benutzeranfragen ansehen und sie manuell in diese Taxonomie kommentieren. Dies wird Ihnen zeigen, welche Fragen am häufigsten sind und welche Sie sich am meisten konzentrieren sollten. Sie werden oft feststellen, dass die Verteilung der Elemente in jeder Kategorie a folgt Pareto -Verteilungmit den meisten Elementen, die zu einigen spezifischen Kategorien gehören.

Darüber hinaus kommentieren Sie, ob eine Kundenanfrage erfolgreich beantwortet wurde oder nicht. Mit diesen Informationen können Sie nun herausfinden, mit welchen Fragen Sie zu kämpfen haben und mit welchen LLM Sie intestine sind. Vielleicht überträgt der LLM Kundenanfragen leicht an Menschen, wenn sie angefordert werden. Es hat jedoch Probleme, sich über Particulars zu einem Produkt zu befragen. In diesem Fall sollten Sie Ihre Bemühungen auf die Verbesserung der Gruppe von Fragen konzentrieren, mit denen Sie am meisten zu kämpfen haben.

LLM als Richter in einem goldenen Datensatz

Ein weiterer quantitativer Ansatz, den ich zur Analyse meiner LLM-Ausgänge verwende, besteht darin, einen goldenen Datensatz mit Eingabe-Output-Beispielen zu erstellen und LLM als Richter zu verwenden. Dies hilft, wenn Sie Änderungen an Ihrem LLM vornehmen.

Wenn Sie das Buyer -Assist -Beispiel von zuvor fortsetzen, können Sie eine Liste von 50 (realen) Benutzeranfragen und die gewünschte Antwort von jedem von ihnen erstellen. Wenn Sie Änderungen an Ihrer LLM vornehmen (Modelversion ändern, mehr Kontext hinzufügen,…), können Sie das neue LLM automatisch im goldenen Datensatz testen und eine LLM als Richter festlegen, ob die Antwort aus dem neuen Modell mindestens so intestine ist wie die Antwort aus dem alten Modell. Auf diese Weise sparen Sie viel Zeit, wenn Sie die LLM -Ausgänge manuell inspizieren, wenn Sie Ihre LLM aktualisieren.

Wenn Sie mehr über LLM als Richter erfahren möchten, können Sie lesen Mein TDS -Artikel zum Thema hier.

Schritt 2: Verbesserung Ihrer LLM iterativ

Sie sind mit Schritt eins fertig und möchten jetzt diese Erkenntnisse verwenden, um Ihre LLM zu verbessern. In diesem Abschnitt diskutiere ich, wie ich mich diesem Schritt nähere, um die Leistung meines LLM effizient zu verbessern.

Wenn ich beispielsweise erhebliche Probleme entdecke, beispielsweise bei der manuellen Überprüfung von Daten ich diese immer zuerst behebe. Dies kann beispielsweise darin bestehen, dass der Kontext des LLM oder Tippfehler in meinen Eingabeaufforderungen unnötiges Geräusch hinzugefügt wird. Wenn ich damit fertig bin, verwende ich weiterhin einige Instruments.

Ein Software, das ich verwende, sind sofortige Optimierer wie z. Anthropics sofortiger Verbesserung. Mit diesen Instruments geben Sie in der Regel Ihre Eingabeaufforderung und einige Beispiele für Eingabe-Ausgänge ein. Sie können beispielsweise die Eingabeaufforderung eingeben, die Sie für Ihre Kundendienstmitarbeiter verwenden, sowie Beispiele für Kundeninteraktionen, bei denen das LLM fehlgeschlagen ist. Der Eingabeaufforderung Optimierer analysiert Ihre Eingabeaufforderung und Beispiele und gibt eine verbesserte Model Ihrer Eingabeaufforderung zurück. Sie werden wahrscheinlich Verbesserungen wie:

• Verbesserte Struktur in Ihrer Eingabeaufforderung beispielsweise mit dem Markdown
• Umgang mit Randfällen. Wenn der Benutzer den Kundensupport -Agenten über völlig nicht verwandte Themen abfragt, z. Der Eingabeaufforderungoptimierer fügt möglicherweise so etwas hinzu: „Wenn die Frage nicht mit Amazon zusammenhängt, teilen Sie dem Benutzer mit, dass Sie nur so konzipiert sind, dass Sie Fragen zu Amazon beantworten“.

Wenn ich quantitativere Daten habe, wie z. Gruppierung von Benutzeranfragen oder a Goldener DatensatzIch analysiere auch diese Daten und erstelle ein Wertschöpfungsdiagramm. Die Wertschöpfungsgrafik zeigt die verschiedenen verfügbaren Verbesserungen, die Sie vornehmen können, z. B.:

• Verbesserte Kantenfallhandhabung in der Systemaufforderung
• Verwenden Sie ein besseres Einbettungsmodell für einen verbesserten Lappen

Anschließend zeichnen Sie diese Datenpunkte in einem 2D -Raster wie unten auf. Sie sollten die Elemente im oberen linken Quadrant natürlich priorisieren, da sie viel Wert bieten und wenig Aufwand erfordern. Normalerweise sind die Elemente jedoch auf einer Diagonale enthalten, bei der ein verbesserter Wert stark mit höheren erforderlichen Anstrengungen korreliert.

Ich stecke alle meine Verbesserungsvorschläge in ein Mehrwert-Effort-Diagramm und wähle dann nach und nach Elemente aus, die so hoch wie möglich und so niedrig wie möglich sind. Dies ist ein tremendous effektiver Ansatz, um die dringendsten Probleme mit Ihrem LLM schnell zu lösen, was sich positiv auf die größte Anzahl von Kunden auswirkt, die Sie für eine bestimmte Menge an Aufwand können.

Schritt 3: Bewerten und iterieren

Der letzte Schritt in meinem dreistufigen Prozess besteht darin, meine LLM und Iterate zu bewerten. Es gibt eine Vielzahl von Techniken, mit denen Sie Ihre LLM bewerten können, von denen ich viele abdeckte Mein Artikel zum Thema.

Vorzugsweise erstellen Sie einige quantitative Metriken für die Leistung Ihrer LLMs und stellen sicher, dass diese Metriken sich von den in Schritt 2 angewendeten Änderungen verbessert haben. Nachdem Sie diese Änderungen angewendet und verurteilt haben, dass sie Ihre LLM verbessert haben, sollten Sie überlegen, ob das Modell intestine genug ist oder ob Sie das Modell weiter verbessern sollten. Meistens arbeite ich nach dem 80% igen Prinzip, was besagt, dass die Leistung von 80% in quick allen Fällen intestine genug ist. Dies ist nicht buchstäblich 80% wie in Genauigkeit. Es unterstreicht eher den Punkt, an dem Sie kein perfektes Modell erstellen müssen, sondern nur ein Modell erstellen, das ist intestine genug.

Abschluss

In diesem Artikel habe ich das Szenario besprochen, in dem Sie bereits eine LLM in der Produktion haben, und Sie möchten Ihre LLM analysieren und verbessern. Ich nähere dieses Szenario, indem ich zuerst die Modelleingaben und -ausgänge analysiere, vorzugsweise durch die vollständige manuelle Inspektion. Nachdem ich sichergestellt habe, dass ich den Datensatz wirklich verstehe und wie sich das Modell verhält, wande ich mich auch in quantitativere Metriken ein, wie beispielsweise die Gruppierung von Abfragen in eine Taxonomie und die Verwendung von LLM als Richter. Anschließend implementiere ich Verbesserungen, die auf meinen Ergebnissen im vorherigen Schritt basieren, und bewerten schließlich, ob meine Verbesserungen wie beabsichtigt funktionieren.

Finden Sie mich in Socials:

Sich in Verbindung setzen

LinkedIn

X / Twitter

Medium

Oder lesen Sie meine anderen Artikel:

Altman Kürzlich geteilt Eine Betonzahl für den Energie- und Wasserverbrauch von Chatgpt -Abfragen. Laut seinem Weblog -Beitrag konsumiert jede Anfrage an ChatGPT etwa 0,34 WH -WH -Elektrizität (0,00034 kWh) und etwa 0,000085 Gallonen Wasser. Das Äquivalent zu dem, was eine hocheffiziente Glühbirne in ein paar Minuten und ungefähr ein Fünftel eines Teelöffels verwendet.

Dies ist das erste Mal, dass OpenAI solche Daten öffentlich geteilt hat, und es fügt einen wichtigen Datenpunkt zu laufenden Debatten über die Umweltauswirkungen großer KI -Systeme hinzu. Die Ankündigung löste eine weit verbreitete Diskussion aus – sowohl unterstützend als auch skeptisch. In diesem Beitrag analysiere ich die Behauptung und packte die Reaktionen in den sozialen Medien aus, um die Argumente auf beiden Seiten zu betrachten.

Was stützt die 0,34 Wh -Behauptung?

Schauen wir uns die Argumente an, die der Nummer von Eröffnung Glaubwürdigkeit verleihen.

1. Unabhängige Schätzungen stimmen mit der Nummer von OpenAI überein

Ein wichtiger Grund, warum manche die Zahl glaubwürdig betrachten, ist, dass sie eng mit früheren Schätzungen von Drittanbietern übereinstimmt. Im Jahr 2025 schätzte das Analysis Institute Institute.ai, dass eine einzige Abfrage an GPT-4O ungefähr 0,0003 kWh Energie verbraucht-die eng mit OpenAIs eigene Schätzung übereinstimmen. Dies setzt voraus, dass GPT-4O eine Architektur der Experten mit 100 Milliarden aktiven Parametern und eine typische Reaktionslänge von 500 Token verwendet. Sie berücksichtigen jedoch keine anderen Faktoren als den Energieverbrauch der GPU -Server und umfassen keine Effektivität der Stromverbrauch (PUE), wie es ansonsten üblich ist.

Eine kürzlich akademische Studie von Jehham et al. (2025) Schätzungen zufolge verwendet GPT-4,1-Nano 0,000454 kWh, O3 0,0039 kWh und GPT-4,5 0,030 kWh für lange Eingabeaufforderungen (ungefähr 7.000 Wörter Eingabe und 1.000 Ausgangswörter).

Die Übereinstimmung zwischen den Schätzungen und dem Datenpunkt von OpenAI legt nahe, dass die Abbildung von OpenAI in einem angemessenen Bereich fällt, zumindest wenn man sich nur auf die Part konzentriert, in der das Modell auf eine Eingabeaufforderung reagiert (als „Inferenz“ bezeichnet).

2. Die Nummer von OpenAI könnte auf Hardwareebene plausibel sein

Es ist wurde gemeldet Diese OpenAI -Server 1 Milliarde Fragen professional Tag. Betrachten wir die Mathematik, wie Chatgpt diese Anzahl von Fragen professional Tag dienen könnte. Wenn dies zutrifft und die Energie professional Abfrage 0,34 WH beträgt, könnte die gesamte tägliche Energie laut einem etwa 340 Megawattstunden betragen Branchenexperte. Er spekuliert, dass dies bedeuten würde, dass OpenAI ChatGPT mit etwa 3.200 Servern unterstützen könnte (unter der Annahme von NVIDIA DGX A100). Wenn 3.200 Server täglich 1 Milliarde Abfragen abschließen müssen, müsste jeder Server rund 4,5 Eingabeaufforderungen professional Sekunde bearbeiten. Wenn wir annehmen, dass eine Instanz der zugrunde liegenden LLM von Chatgpt auf jedem Server bereitgestellt wird und dass die durchschnittliche Eingabeaufforderung zu 500 Ausgangs -Token (ungefähr 375 Wörter gemäß OpenAIs Faustregel) führt, müssten die Server 2.250 Token professional Sekunde erzeugen. Ist das realistisch?

Stojkovic et al. (2024) konnten einen Durchsatz von 6.000 Token professional Sekunde von LAMA-2–70B auf einem NVIDIA DGX H100-Server mit 8 H100-GPUs erzielen.

Jegham et al. (2025) haben jedoch herausgefunden, dass drei verschiedene OpenAI -Modelle im Durchschnitt zwischen 75 und 200 Token professional Sekunde erzeugt wurden. Es ist jedoch unklar, wie sie dazu angekommen sind.

Es scheint additionally, dass wir die Idee nicht ablehnen können, dass 3.200 Server in der Lage sein könnten, täglich 1 Milliarde Fragen zu bearbeiten.

Warum einige Experten skeptisch sind

Trotz der unterstützenden Beweise bleiben viele vorsichtig oder kritisch gegenüber den 0,34 in der Abbildung, was mehrere wichtige Bedenken auswirkt. Schauen wir uns diese an.

1. Die Nummer von OpenAI könnte wichtige Teile des Methods auslassen

Ich vermute, dass die Zahl nur die Energie enthält, die die GPU -Server selbst genutzt haben, und nicht die restlichen Infrastruktur – wie Datenspeicher, Kühlsysteme, Netzwerkausrüstung, Firewalls, Stromumwandlungsverlust oder Sicherungssysteme. Dies ist eine häufige Einschränkung der Energieberichterstattung zwischen Technologieunternehmen.

Zum Beispiel hat Meta in der Vergangenheit auch GPU-Energiezahlen gemeldet. In realen Rechenzentren ist die GPU-Leistung jedoch nur ein Teil des vollständigen Bildes.

2. Die Serverschätzungen scheinen im Vergleich zu Branchenberichten niedrig zu sein

Einige Kommentatoren wie Greenops Advocate Mark Butcher argumentieren, dass 3.200 GPU -Server viel zu niedrig zu sein scheinen, um alle Benutzer von ChatGPT zu unterstützen, insbesondere wenn Sie die globale Nutzung, hohe Verfügbarkeit und andere Anwendungen über das Gelegenheits -Chat überlegen (z. B. Codierung oder Bildanalyse).

Andere Berichte deuten darauf hin, dass OpenAI Zehn oder sogar Hunderttausende von GPUs zur Folge verwendet. Wenn dies zutrifft, könnte der Gesamtenergieverbrauch viel höher sein als die 0,34 WH/Question -Zahl.

3. Mangel an Particulars wirft Fragen auf

Kritiker, z David Myttonweisen auch darauf hin, dass die Aussage von OpenAI fehlt den grundlegenden Kontext. Zum Beispiel:

• Was genau ist eine „durchschnittliche“ Abfrage? Eine einzige Frage oder ein vollständiges Gespräch?
• Gilt diese Zahl nur für ein Modell (z. B. GPT-3,5, GPT-4O) oder einen Durchschnitt über mehrere?
• Enthält es neuere, komplexere Aufgaben wie multimodale Eingaben (z. B. Analyse von PDFs oder Erzeugung von Bildern)?
• Ist die Wasserverbrauchsnummer direkt (für Kühlanger verwendet) oder indirekt (aus Stromquellen wie Wasserkraft)?
• Was ist mit Kohlenstoffemissionen? Das hängt stark vom Standort und dem Energiemix ab.

Ohne Antworten auf diese Fragen ist es schwer zu wissen, wie viel Vertrauen in die Nummer aufgenommen werden kann oder wie man es mit anderen KI -Systemen vergleichen kann.

Perspektiven

Hören Huge Tech endlich unsere Gebete?

Openais Offenlegung erfolgt im Gefolge Nvidias Veröffentlichung von Daten über die verkörperten Emissionen der GPUs und Googles Weblog -Beitrag über die Lebenszyklusemissionen ihrer TPU -{Hardware}. Dies könnte darauf hindeuten, dass die Unternehmen endlich auf die vielen Anrufe reagieren, die für mehr Transparenz getätigt wurden. Zeugen wir den Beginn einer neuen Ära? Oder spielt Sam Altman nur Methods für uns, weil es in seinen finanziellen Interessen liegt, die Klimawirkung seines Unternehmens herunterzuspielen? Ich werde diese Frage als Gedankenexperiment für den Leser hinterlassen.

Inferenz gegen Coaching

Historisch gesehen hat die Zahlen, die wir über den Energieverbrauch der KI gesehen und gemeldet haben Ausbildung KI -Modelle. Und während die Trainingsphase sehr energieintensiv sein kann, können im Laufe der Zeit Milliarden von Abfragen (Inferenz) tatsächlich mehr Energie verbrauchen, als das Modell überhaupt zu trainieren. Mein eigenes Schätzungen schlagen vor Dieses Coaching GPT-4 hat möglicherweise rund 50 bis 60 Millionen kWh Strom verwendet. Mit 0,34 WHOR-pro-Abfrage und 1 Milliarde tägliche Abfragen würde die Energie, die zur Beantwortung von Benutzeranfragen verwendet wird, die Energieverbrauch der Trainingsphase nach 150 bis 200 Tagen übertreffen. Dies verleiht der Idee Glaubwürdigkeit, dass Inferenzergie eine enge Messung wert ist.

Schlussfolgerung: Ein willkommener erster Schritt, aber weit entfernt vom vollständigen Bild

Gerade als wir dachten, die Debatte über Openais Energieverbrauch conflict alt geworden, rührt die notorisch geschlossene Firma sie mit der Offenlegung dieser Zahl auf. Viele freuen sich über die Tatsache, dass OpenAI nun in die Debatte über die Energie- und Wasserverbrauch ihrer Produkte eingetreten ist und hoffen, dass dies der erste Schritt in Richtung größerer Transparenz über die Ressource -Unentschieden und die Klimaauswirkungen von Huge Tech ist. Auf der anderen Seite stehen viele skeptisch gegenüber Openais Figur. Und aus gutem Grund. Es wurde als Klammern in einem Weblog -Beitrag über ein ein ganz anderes Thema offenbart, und es wurde keinerlei Kontext gegeben, wie oben beschrieben.

Obwohl wir vielleicht eine Verschiebung in Richtung mehr Transparenz beobachten, benötigen wir immer noch viele Informationen von OpenAI, um ihre 0,34 WH -Abbildung kritisch zu beurteilen. Bis dahin sollte es nicht nur mit einem Salzkorn, sondern auch mit einer Handvoll eingenommen werden.

Das conflict’s! Ich hoffe, Sie haben die Geschichte genossen. Lass mich wissen, was du denkst!

Folgen Sie mir für mehr über KI und Nachhaltigkeit und können Sie mir gerne folgen LinkedIn.

Zum jetzigen Zeitpunkt beansprucht Fb mehr als 3,07 Milliarden monatlich aktive Benutzer. Das heißt, wenn Sie diesen Artikel lesen, sind Sie wahrscheinlich ein Fb -Benutzer. Aber wie viel von einem Fb -Nutzer sind Sie? Wie viel postest du wirklich? Wir können herausfinden, ob wir Fb -Daten mit Python analysieren!

Insbesondere verwenden wir Python, um dies zu erstellen – ein Diagramm, das zeigt, wie oft wir jeden Monat im Laufe der Zeit gepostet haben:

Für die Zwecke dieses Tutorials gehen wir davon aus, dass Sie mit den Grundlagen von Python und mit Jupyter -Notizbüchern vertraut sind. Dieses Tutorial zur Analyse Ihrer Amazon -Ausgaben Erste.

Schritt 1: Laden Sie Ihre Fb -Daten herunter

Mit Fb können wir so ziemlich alles herunterladen, was wir jemals auf der Web site gemacht haben. Du kannst Laden Sie Ihre Daten hier herunteraber Sie möchten vielleicht nicht alles herunterladen – diese Datei könnte sein massivje nachdem, wie oft Sie Fb verwenden und wie lange Sie dabei waren.

Für dieses Tutorial schauen wir uns speziell in unseren persönlichen Fb -Posts und versuchen Sie die Fragen zu beantworten:

• Wie oft poste ich?
• Verwende ich Fb mehr oder weniger als früher?

Um nur die Daten zu Beiträgen zu erhalten, gehen Sie in die Datendownload -Seite. Ändern Sie das angeforderte Dateiformat von HTML in JSON und wählen Sie dann alles aus den folgenden Optionen ab nur Beiträge und schlagen Datei erstellen.

Fb wird Sie benachrichtigen, wenn Ihre Datei erstellt wurde und zum Obtain bereit ist – es kann eine Weile dauern, abhängig von Ihrer Fb -Geschichte und Ihren Optionen.

Laden Sie die ZIP -Datei herunter, entpacken Sie sie und suchen Sie nach der posts Ordner und eine Datei aufgerufen your_posts_1.json. Das ist die Datei, die wir für dieses Tutorial verwenden werden.

Schritt 2: Importieren und formatieren Sie Ihre Daten

Als nächst Ein Anfängerleitfaden zu Jupyter -Notizbüchern Wenn Sie eine Auffrischung benötigen). Wir werden zunächst die Daten importieren und in einen Datenrahmen lesen.

Der eingebaute pd.read_json() Die Funktion kann unsere JSON -Daten in einem Datenrahmen automatisch interpretieren. (Es ist nicht perfekt, wie Sie sehen werden, aber es wird hier für unsere Zwecke funktionieren).

import pandas as pd

# learn the json file right into a dataframe
df = pd.read_json('your_posts_1.json')

df.head(3)

Wie wir sehen können, ist das nicht perfekt. Einige unserer Säulen haben in jeder Zeile die Unterspalten verschachtelt, die sich noch im JSON-Format befinden. Wenn wir mit diesen Daten arbeiten wollten, müssten wir uns damit befassen.

Aber um unsere Frage hier zu beantworten – Veröffentlichen wir mehr oder weniger als früher auf Fb? – Wir müssen uns wirklich nicht mit den tatsächlichen Put up -Inhalten oder anderen Informationen wie beigefügten Mediendateien befassen. Wir sind nur besorgt um Frequenz – Wie oft wurden neue Beiträge gemacht.

Als Nächst to_datetime(). Wir werden es auch umbenennen 'date' Und lassen Sie einige der unnötigen Spalten nur aus Klarheit fallen – dieser Schritt ist nicht streng notwendig, aber er hilft uns, etwas Einfacheres zu betrachten.

# rename the timestamp column
df.rename(columns={'timestamp': 'date'}, inplace=True)

#drop some pointless columns
df = df.drop(('attachments', 'title', 'tags'), axis=1)

# ensuring it is datetime format
pd.to_datetime(df('date'))

df.head(3)

Jetzt haben wir etwas sauberer, mit dem wir arbeiten können! Wenn wir überprüfen möchten, wie viele Beiträge wir analysieren, könnten wir verwenden df.form die Zeilen zählen.

Es könnte auch eine gute Idee sein, sie zu verwenden df.tail() Um das Ende unseres Datenrahmens zu überprüfen, um sicherzugehen, dass sich dies wirklich über unsere gesamte Fb -Nutzung erstreckt:

print(df.form)
df.tail(3)

(4407, 2)

Bei meinen persönlichen Fb -Daten sieht es so aus, als hätte ich insgesamt über 4.000 Mal gepostet. Meine Daten beginnt Anfang 2005, als ich anscheinend etwas darüber gepostet habe Moist heißer amerikanischer Sommer. Ich conflict 2005 auf dem Faculty, so dass das Timing auscheckt.

Sie können feststellen, dass einige Reihen sagen NaN – Dies waren Beiträge, die nur Bilder enthielten, keinen Textual content. Die Bilder würden in der verknüpft sein 'attachments‚Säule, aber wir haben das fallen gelassen, additionally ist sie hier nicht sichtbar.

Schritt 3: Analysieren Sie Fb -Daten, um Ihre monatliche Postanzahl herauszufinden

Nachdem wir unsere Daten haben, müssen wir sie in ein Format bringen, das uns etwas über die Postfrequenz erzählt. Angesichts der Tatsache, dass wir hier Jahre der Geschichte erstrecken, ist es am sinnvollsten, es zu betrachten. Dies bedeutet, dass wir unsere gruppieren müssen 'date' Spalte nach Monaten und zählen Sie, wie viele Zeilen (dh Posts) jeden Monat zugeordnet sind.

Zum Glück soll Pandas es relativ einfach machen, mit Zeitreihendaten zu arbeiten. Wir müssen hier zwei Dinge tun:

1. Setzen Sie die date Spalte als Index unseres Datenrahmens.
2. Proben Sie die Daten nach Monat erneut erneut und zählen Sie, wie viele Beiträge in jedem Monat stattfinden.

Für den ersten Schritt können wir verwenden set_index(). Der zweite Schritt ist etwas komplexer. Lassen Sie uns additionally in vier separate Schritte aufschlüsseln, um den Code aufzubrechen, den wir schreiben müssen:

1. Wählen Sie die Spalte aus, nach der wir wieder eingeteilt werden möchten – in diesem Fall ist die knowledge Spalte.
2. Benutze die .resample() Funktion mit dem Argument 'MS' (für „Monat Begin“), um unsere Daten nach Monat wiederzuproben.
3. Verwenden .dimension() Um anzugeben, was wir jeden Monat messen möchten – in diesem Fall die Anzahl der Zeilen (dh Posts) mit einem Postdatum, der innerhalb dieses Monats fällt.
4. Weisen Sie die resultierende Serie einer Variablen mit dem Namen zu post_counts.

So sieht das in der Praxis aus:

date
2005-03-01    1
2005-04-01    0
2005-05-01    0
2005-06-01    0
2005-07-01    0
             ..
2020-04-01    2
2020-05-01    5
2020-06-01    7
2020-07-01    6
2020-08-01    3
Freq: MS, Identify: knowledge, Size: 186, dtype: int64

Das sieht toll aus! Wir haben unsere Postzählungen bis zum Monat unterteilt, und wenn wir den Originaldatensatz überprüfen, können wir schnell sehen, dass die Zählungen korrekt sind.

Beachten Sie, dass Monate ohne Beiträge korrekt als als 0 anstatt einfach übersprungen. Das ist einer der Gründe, warum die Verwendung resample()die für die Arbeit mit Zeitreihen konzipiert ist, ist besser für diese Artwork von Aufgabe als so etwas wie zu verwenden groupby()wo es einfach ist, Monate ohne Daten zu überspringen, wenn wir nicht aufpassen.

Schritt 4: Visualisieren Sie Ihre Fb -Nutzung

Wie auch immer, jetzt, wo wir den schwierigen Teil hinter uns haben, ist nur noch der Spaß: Visualisierung! Dazu importieren wir Matplotlib (und verwenden die $matplotlib inline Magie, um unser Diagramm im Jupyter -Notizbuch erscheinen zu lassen. Wir werden auch Seeborn und Numpy importieren, was uns hilft, eine lesbar aussehende Tabelle zu erstellen.

Sobald wir unsere Importe erledigt haben, werden wir verwenden sns.set() Setzen Sie die Größe und Schriftgröße unseres Diagramms. Da wir hier mit vielen Daten arbeiten, werden wir das Diagramm ziemlich groß machen und sicherstellen, dass die Schriftgröße groß genug ist, um lesbar zu sein.

Dann setzen wir die X -Labels für den Index von post_counts (die Daten) und verwenden sns.barplot() So erstellen Sie ein Balkendiagramm. In den Argumenten für sns.barplot()Wir werden die Funktion mit den von uns definierten X -Beschriftungen mitteilen, um die Daten in zu zeichnen post_countsund um die Bar Farbe blau zu machen.

Das allein würde ausreichen, um ein Primary -Diagramm zu erstellen, aber in diesem Fall möchten wir einige zusätzliche Schritte ausführen, um das Diagramm lesbar zu machen. Insbesondere möchten wir die Zeckenpositionen auf der X -Achse bis alle 24 Monate anordnen, damit wir alle zwei Jahre im resultierenden Diagramm eine Häkchen sehen. Wir werden auch die Daten im Diagramm neu formatieren, damit nur das Jahr angezeigt wird.

Notiz: Da dies nicht ist Ein Tutorial über Daten nämlichWir werden nicht in die Tiefe gehen, wie dies als Teil dieses Tutorials funktioniert. Wenn Sie jedoch mehr darüber erfahren möchten, wie Sie großartige Datenvisualisierungen mit Python erstellen möchten, haben wir uns Einführung in die Datenvisualisierung in Python Und Geschichtenerzählen durch Datenvisualisierung Kurse, die Sie kostenlos versuchen können.

%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

# set determine dimension and font dimension
sns.set(rc={'determine.figsize':(40,20)})
sns.set(font_scale=3)

# set x labels
x_labels = post_counts.index

#create bar plot
sns.barplot(x_labels, post_counts, shade="blue")

# solely present x-axis labels for Jan 1 of each different yr
tick_positions = np.arange(10, len(x_labels), step=24)

#reformat date to show yr onlyplt.ylabel("publish counts")
plt.xticks(tick_positions, x_labels(tick_positions).strftime("$Y"))

# show the plot
plt.present()

Hier ist das Diagramm – Sie können klicken, um es in voller Größe anzuzeigen.

Es gibt immer noch einige Möglichkeiten, wie wir dieses Diagramm noch schöner machen könnten, aber für unsere Zwecke ist dies ausreichend, um die Daten zu verstehen und unsere Fb -Posting -Geschichte zu analysieren.

In meinem Fall – das obige Diagramm sind meine persönlichen Fb -Daten – können wir sehen, dass ich in den frühen Tagen nur selten auf Fb gepostet habe. Ich hatte große Überflüsse von Beiträgen – Hunderte professional Monat! – Im Sommer 2007 und im Frühjahr 2009 fiel mit Reisen zusammen.

Meine regelmäßige Nutzung begann sich um 2011 zu erhöhen und erreichte um 2016 die Spitzenwerte. Danach starb sie ab, und ich habe seit einiger Zeit im Jahr 2019 aufgehört, Fb vollständig zu benutzen !

Und denken Sie daran, das ist nur Beiträgenicht Kommentare! Es gibt eine ganz andere JSON -Datei für Kommentare, aber es ist mir peinlich, wie es ist. Wenn Sie Ihre Fb -Datenanalyse weiter abrufen möchten, wäre es ein großartiger nächster Schritt!

Nennen wir es in diesem Tutorial intestine und überprüfen, was wir getan haben:

• Wir haben persönliche Verwendungsdaten von Fb heruntergeladen
• Wir lesen die JSON -Datei in einem Pandas -Datenfreame
• Wir haben die Daten nach Monat abgebrochen und die Anzahl der Beiträge jeden Monat gezählt
• Wir haben die Fb -Nutzung visualisiert und etwas gelernt: Charlie verbrachte früher zu viel Zeit auf Fb.

Wenn Sie gerne solche Projekte durchführen, lesen Sie den interaktiven, in Ihrem Browser von DataQuest Knowledge Science -Kurse! Sie sind eindringlicher und so, viel detaillierter als das, was wir hier behandelt haben. In der Tat haben wir nahtlose Kurssequenzen, die Sie vom Gesamtanfänger zum berufsqualifizierten Bereich bringen können DatenanalystAnwesend Datenwissenschaftleroder Dateningenieur.

Jetzt, da Sie gesehen haben, wie viel Zeit Sie auf Fb verschwendet haben, müssen Sie sich in DataQuest anmelden und einige Ihrer On-line -Zeit damit verbringen, wertvolle berufliche Fähigkeiten zu erstellen? Sie können ein Konto erstellen und kostenlos lernen – keine Kreditkarte erforderlich!