Datensätze und suchen nach schnellen Erkenntnissen ohne zu viel manuellem Schleifen. Sie sind richtig gekommen.
Im Jahr 2025 enthalten Datensätze häufig Millionen von Zeilen und Hunderten von Spalten, was die manuelle Analyse nahe bei unmöglicher macht. Lokale Großsprachenmodelle können Ihre Rohdatenfream -Statistiken in Sekunden in polierte, lesbare Berichte verwandeln – im schlimmsten Fall Minuten. Dieser Ansatz beseitigt den mühsamen Prozess der Analyse von Daten von Hand und dem Schreiben von Exekutivberichten, insbesondere wenn sich die Datenstruktur nicht ändert.
Pandas kümmert sich um das starke Anheben der Datenextraktion, während LLMs Ihre technischen Ausgänge in präsentierbare Berichte umwandeln. Sie müssen noch Funktionen schreiben, die Schlüsselstatistiken aus Ihren Datensätzen ziehen, aber es ist eine einmalige Anstrengung.
In diesem Leitfaden wird davon ausgegangen, dass Ollama lokal installiert ist. Wenn Sie dies nicht tun, können Sie immer noch LLM-Anbieter von Drittanbietern verwenden, aber ich werde nicht erklären, wie man sich mit ihren APIs verbindet.
Inhaltsverzeichnis:
- Datensatzeinführung und Erkundung
- Der langweilige Teil: Extrahieren von Zusammenfassungsstatistiken
- Der coole Teil: Arbeiten mit LLMs
- Was Sie verbessern könnten
Datensatzeinführung und Erkundung
Für diesen Leitfaden benutze ich die MBA -Zulassungsdatensatz von Kaggle. Laden Sie es herunter, wenn Sie folgen möchten.
Der Datensatz ist unter dem lizenziert Apache 2.0 LizenzDies bedeutet, dass Sie es sowohl für persönliche als auch für kommerzielle Projekte frei verwenden können.
Um loszulegen, benötigen Sie ein paar Python -Bibliotheken, die auf Ihrem System installiert sind.
Sobald Sie alles installiert haben, importieren Sie die erforderlichen Bibliotheken in ein neues Skript oder ein Notizbuch:
import pandas as pd
from langchain_ollama import ChatOllama
from typing import LiteralDataset -Laden und Vorverarbeitung
Beginnen Sie mit dem Laden des Datensatzes mit Pandas. Dieser Snippet lädt die CSV -Datei, druckt grundlegende Informationen zur Datensatzform und zeigt, wie viele fehlende Werte in jeder Spalte vorhanden sind:
df = pd.read_csv("information/MBA.csv")
# Primary dataset information
print(f"Dataset form: {df.form}n")
print("Lacking worth stats:")
print(df.isnull().sum())
print("-" * 25)
df.pattern(5)
Da die Datenreinigung nicht im Mittelpunkt dieses Artikels liegt, werde ich die Vorverarbeitung minimal behalten. Der Datensatz hat nur einige fehlende Werte, die Aufmerksamkeit erfordern:
df("race") = df("race").fillna("Unknown")
df("admission") = df("admission").fillna("Deny")Das warfare’s! Mal sehen, wie man als nächstes von diesem zu einem aussagekräftigen Bericht wechselt.
Der langweilige Teil: Extrahieren von Zusammenfassungsstatistiken
Selbst mit all den Fortschritten in der KI -Fähigkeit und -verfügbarkeit möchten Sie Ihren gesamten Datensatz wahrscheinlich nicht an einen LLM -Anbieter senden. Es gibt ein paar gute Gründe warum.
Es könnte verbrauchen viel zu viele Tokenwas direkt zu höheren Kosten führt. Verarbeitung großer Datensätze können sich lange Zeit nehmenVor allem, wenn Sie Modelle lokal auf Ihrer eigenen {Hardware} ausführen. Möglicherweise haben Sie es auch zu tun Wise Daten Das sollte Ihre Organisation nicht verlassen.
Einige manuelle Arbeiten sind noch der richtige Weg.
Dieser Ansatz erfordert, dass Sie eine Funktion schreiben, die Schlüsselelemente und Statistiken aus Ihrem Pandas -Datenframe extrahiert. Sie müssen diese Funktion für verschiedene Datensätze von Grund auf schreiben, aber die Kernidee überträgt sich leicht zwischen Projekten.
Der get_summary_context_message() Die Funktion nimmt einen Datenrahmen auf und gibt eine formatierte Multi-Line-Zeichenfolge mit einer detaillierten Zusammenfassung zurück. Folgendes beinhaltet es:
- Gesamtantragszahl und Geschlechtsverteilung
- Internationaler gegen den Inlandsbewerber Zusammenbruch
- GPA- und GMAT -Rating -Quartilstatistik
- Zulassungsquoten nach akademischem Main (sortiert nach Tarif)
- Zulassungsraten der Arbeitsindustrie (Prime 8 Branchen)
- Berufserfahrungsanalyse mit kategorialen Aufschlüssen
- Key-Erkenntnisse, in denen die Prime-Performing-Kategorien hervorgehoben werden
Hier ist der vollständige Quellcode für die Funktion:
def get_summary_context_message(df: pd.DataFrame) -> str:
"""
Generate a complete abstract report of MBA admissions dataset statistics.
This perform analyzes MBA software information to offer detailed statistics on
applicant demographics, tutorial efficiency, skilled backgrounds, and
admission charges throughout varied classes. The abstract consists of gender and
worldwide standing distributions, GPA and GMAT rating statistics, admission
charges by tutorial main and work trade, and work expertise impression evaluation.
Parameters
----------
df : pd.DataFrame
DataFrame containing MBA admissions information with the next anticipated columns:
- 'gender', 'worldwide', 'gpa', 'gmat', 'main', 'work_industry', 'work_exp', 'admission'
Returns
-------
str
A formatted multi-line string containing complete MBA admissions
statistics.
"""
# Primary software statistics
total_applications = len(df)
# Gender distribution
gender_counts = df("gender").value_counts()
male_count = gender_counts.get("Male", 0)
female_count = gender_counts.get("Feminine", 0)
# Worldwide standing
international_count = (
df("worldwide").sum()
if df("worldwide").dtype == bool
else (df("worldwide") == True).sum()
)
# GPA statistics
gpa_data = df("gpa").dropna()
gpa_avg = gpa_data.imply()
gpa_25th = gpa_data.quantile(0.25)
gpa_50th = gpa_data.quantile(0.50)
gpa_75th = gpa_data.quantile(0.75)
# GMAT statistics
gmat_data = df("gmat").dropna()
gmat_avg = gmat_data.imply()
gmat_25th = gmat_data.quantile(0.25)
gmat_50th = gmat_data.quantile(0.50)
gmat_75th = gmat_data.quantile(0.75)
# Main evaluation - admission charges by main
major_stats = ()
for main in df("main").distinctive():
major_data = df(df("main") == main)
admitted = len(major_data(major_data("admission") == "Admit"))
complete = len(major_data)
fee = (admitted / complete) * 100
major_stats.append((main, admitted, complete, fee))
# Kind by admission fee (descending)
major_stats.type(key=lambda x: x(3), reverse=True)
# Work trade evaluation - admission charges by trade
industry_stats = ()
for trade in df("work_industry").distinctive():
if pd.isna(trade):
proceed
industry_data = df(df("work_industry") == trade)
admitted = len(industry_data(industry_data("admission") == "Admit"))
complete = len(industry_data)
fee = (admitted / complete) * 100
industry_stats.append((trade, admitted, complete, fee))
# Kind by admission fee (descending)
industry_stats.type(key=lambda x: x(3), reverse=True)
# Work expertise evaluation
work_exp_data = df("work_exp").dropna()
avg_work_exp_all = work_exp_data.imply()
# Work expertise for admitted college students
admitted_students = df(df("admission") == "Admit")
admitted_work_exp = admitted_students("work_exp").dropna()
avg_work_exp_admitted = admitted_work_exp.imply()
# Work expertise ranges evaluation
def categorize_work_exp(exp):
if pd.isna(exp):
return "Unknown"
elif exp < 2:
return "0-1 years"
elif exp < 4:
return "2-3 years"
elif exp < 6:
return "4-5 years"
elif exp < 8:
return "6-7 years"
else:
return "8+ years"
df("work_exp_category") = df("work_exp").apply(categorize_work_exp)
work_exp_category_stats = ()
for class in ("0-1 years", "2-3 years", "4-5 years", "6-7 years", "8+ years"):
category_data = df(df("work_exp_category") == class)
if len(category_data) > 0:
admitted = len(category_data(category_data("admission") == "Admit"))
complete = len(category_data)
fee = (admitted / complete) * 100
work_exp_category_stats.append((class, admitted, complete, fee))
# Construct the abstract message
abstract = f"""MBA Admissions Dataset Abstract (2025)
Whole Purposes: {total_applications:,} individuals utilized to the MBA program.
Gender Distribution:
- Male candidates: {male_count:,} ({male_count/total_applications*100:.1f}%)
- Feminine candidates: {female_count:,} ({female_count/total_applications*100:.1f}%)
Worldwide Standing:
- Worldwide candidates: {international_count:,} ({international_count/total_applications*100:.1f}%)
- Home candidates: {total_applications-international_count:,} ({(total_applications-international_count)/total_applications*100:.1f}%)
Tutorial Efficiency Statistics:
GPA Statistics:
- Common GPA: {gpa_avg:.2f}
- twenty fifth percentile: {gpa_25th:.2f}
- fiftieth percentile (median): {gpa_50th:.2f}
- seventy fifth percentile: {gpa_75th:.2f}
GMAT Statistics:
- Common GMAT: {gmat_avg:.0f}
- twenty fifth percentile: {gmat_25th:.0f}
- fiftieth percentile (median): {gmat_50th:.0f}
- seventy fifth percentile: {gmat_75th:.0f}
Main Evaluation - Admission Charges by Tutorial Background:"""
for main, admitted, complete, fee in major_stats:
abstract += (
f"n- {main}: {admitted}/{complete} admitted ({fee:.1f}% admission fee)"
)
abstract += (
"nnWork Business Evaluation - Admission Charges by Skilled Background:"
)
# Present prime 8 industries by admission fee
for trade, admitted, complete, fee in industry_stats(:8):
abstract += (
f"n- {trade}: {admitted}/{complete} admitted ({fee:.1f}% admission fee)"
)
abstract += "nnWork Expertise Affect on Admissions:nnOverall Work Expertise Comparability:"
abstract += (
f"n- Common work expertise (all candidates): {avg_work_exp_all:.1f} years"
)
abstract += f"n- Common work expertise (admitted college students): {avg_work_exp_admitted:.1f} years"
abstract += "nnAdmission Charges by Work Expertise Vary:"
for class, admitted, complete, fee in work_exp_category_stats:
abstract += (
f"n- {class}: {admitted}/{complete} admitted ({fee:.1f}% admission fee)"
)
# Key insights
best_major = major_stats(0)
best_industry = industry_stats(0)
abstract += "nnKey Insights:"
abstract += (
f"n- Highest admission fee by main: {best_major(0)} at {best_major(3):.1f}%"
)
abstract += f"n- Highest admission fee by trade: {best_industry(0)} at {best_industry(3):.1f}%"
if avg_work_exp_admitted > avg_work_exp_all:
abstract += f"n- Admitted college students have barely extra work expertise on common ({avg_work_exp_admitted:.1f} vs {avg_work_exp_all:.1f} years)"
else:
abstract += "n- Work expertise reveals minimal distinction between admitted and all candidates"
return abstractWenn Sie die Funktion definiert haben, rufen Sie sie einfach auf und drucken Sie die Ergebnisse aus:
print(get_summary_context_message(df))
Lassen Sie uns nun zum lustigen Teil übergehen.
Der coole Teil: Arbeiten mit LLMs
Hier werden die Dinge interessant und Ihre manuelle Datenextraktionsarbeit zahlt sich aus.
Python -Helferfunktion für die Arbeit mit LLMs
Wenn Sie angemessene {Hardware} haben, empfehle ich dringend, lokale LLMs für einfache Aufgaben wie diese zu verwenden. Ich benutze Ollama und die neueste Model der Mistral -Modell Für die tatsächliche LLM -Verarbeitung.
Wenn Sie über OpenAI -API so etwas wie Chatgpt verwenden möchten, können Sie das trotzdem tun. Sie müssen nur die folgende Funktion ändern, um Ihre API -Style einzurichten und die entsprechende Instanz von Langchain zurückzugeben.
Unabhängig von der Possibility, die Sie auswählen, ein Anruf an get_llm() Mit einer Testnachricht sollte kein Fehler zurückgeben:
def get_llm(model_name: str = "mistral:newest") -> ChatOllama:
"""
Create and configure a ChatOllama occasion for native LLM inference.
This perform initializes a ChatOllama shopper configured to connect with a
native Ollama server. The shopper is about up with deterministic output
(temperature=0) for constant responses throughout a number of calls with the
identical enter.
Parameters
----------
model_name : str, optionally available
The title of the Ollama mannequin to make use of for chat completions.
Should be a legitimate mannequin title that's obtainable on the native Ollama
set up. Default is "mistral:newest".
Returns
-------
ChatOllama
A configured ChatOllama occasion prepared for chat completions.
"""
return ChatOllama(
mannequin=model_name, base_url="http://localhost:11434", temperature=0
)
print(get_llm().invoke("take a look at").content material)
Zusammenfassung
Hier können Sie kreativ werden und ultraspezifische Anweisungen für Ihre LLM schreiben. Ich habe beschlossen, die Dinge für Demonstrationszwecke Licht zu halten, aber ich kann mir gerne hier experimentieren.
Es gibt keine einzige richtige oder falsche Eingabeaufforderung.
Was auch immer Sie tun, stellen Sie sicher, dass die Formatargumente mit lockigen Klammern enthalten sind. Diese Werte werden später dynamisch gefüllt:
SUMMARIZE_DATAFRAME_PROMPT = """
You're an skilled information analyst and information summarizer. Your job is to absorb complicated datasets
and return user-friendly descriptions and findings.
You got this dataset:
- Title: {dataset_name}
- Supply: {dataset_source}
This dataset was analyzed in a pipeline earlier than it was given to you.
These are the findings returned by the evaluation pipeline:
<context>
{context}
</context>
Primarily based on these findings, write an in depth report in {report_format} format.
Give the report a significant title and separate findings into sections with headings and subheadings.
Output solely the report in {report_format} and nothing else.
Report:
"""Zusammenfassung der Python -Funktion
Mit der Eingabeaufforderung und der get_llm() Funktionen erklärt, das einzige, was noch übrig ist, ist, die Punkte zu verbinden. Der get_report_summary() Funktion nimmt Argumente auf, die die Format -Platzhalter in der Eingabeaufforderung füllen, und ruft dann die LLM mit dieser Eingabeaufforderung auf, einen Bericht zu erstellen.
Sie können zwischen Markdown- oder HTML -Formaten wählen:
def get_report_summary(
dataset: pd.DataFrame,
dataset_name: str,
dataset_source: str,
report_format: Literal("markdown", "html") = "markdown",
) -> str:
"""
Generate an AI-powered abstract report from a pandas DataFrame.
This perform analyzes a dataset and generates a complete abstract report
utilizing a big language mannequin (LLM). It first extracts statistical context
from the dataset, then makes use of an LLM to create a human-readable report within the
specified format.
Parameters
----------
dataset : pd.DataFrame
The pandas DataFrame to research and summarize.
dataset_name : str
A descriptive title for the dataset that will likely be included within the
generated report for context and identification.
dataset_source : str
Details about the supply or origin of the dataset.
report_format : {"markdown", "html"}, optionally available
The specified output format for the generated report. Choices are:
- "markdown" : Generate report in Markdown format (default)
- "html" : Generate report in HTML format
Returns
-------
str
A formatted abstract report.
"""
context_message = get_summary_context_message(df=dataset)
immediate = SUMMARIZE_DATAFRAME_PROMPT.format(
dataset_name=dataset_name,
dataset_source=dataset_source,
context=context_message,
report_format=report_format,
)
return get_llm().invoke(enter=immediate).content materialDie Verwendung der Funktion ist unkompliziert – geben Sie einfach den Datensatz, seinen Namen und die Quelle über. Das Berichtsformat standardisch für Markdown:
md_report = get_report_summary(
dataset=df,
dataset_name="MBA Admissions (2025)",
dataset_source="https://www.kaggle.com/datasets/taweilo/mba-admission-dataset"
)
print(md_report)
Der HTML -Bericht ist genauso detailliert, könnte aber ein Styling gebrauchen. Vielleicht könnten Sie die LLM auch darum bitten, damit umzugehen!
Was Sie verbessern könnten
Ich hätte dies leicht in eine 30-minütige Lektüre verwandeln können, indem ich jedes Element der Pipeline optimierte, aber ich habe es für Demonstrationszwecke einfach gehalten. Sie müssen hier jedoch nicht aufhören (und sollten nicht).
Hier sind die Dinge, die Sie verbessern können, um diese Pipeline noch leistungsfähiger zu machen:
- Schreiben Sie eine Funktion, die den Bericht (Markdown oder HTML) direkt in die Festplatte speichert. Auf diese Weise können Sie den gesamten Prozess automatisieren und Berichte nach einem Zeitplan ohne manuelle Intervention erstellen.
- In der Eingabeaufforderung, Bitten Sie das LLM, dem HTML -Bericht das CSS -Styling hinzuzufügen Damit es besser aussehen lässt. Sie können sogar die Markenfarben und Schriftarten Ihres Unternehmens zur Verfügung stellen, um die Konsistenz in allen Ihren Datenberichten aufrechtzuerhalten.
- Erweitern Sie die Eingabeaufforderung, spezifischere Anweisungen zu befolgen. Möglicherweise möchten Sie Berichte, die sich auf bestimmte Geschäftsmetriken konzentrieren, einer bestimmten Vorlage folgen oder Empfehlungen basieren, die auf den Ergebnissen basieren.
- Erweitern
get_llm()Funktion, damit es kann Verbinden Sie sich sowohl mit Ollama als auch mit anderen Anbietern Wie OpenAI, Anthropic oder Google. Auf diese Weise können Sie je nach Ihren Anforderungen zwischen lokalen und Cloud-basierten Modellen wechseln. - Machen Sie buchstäblich alles in der Funktion get_summary_context_message (), da sie als Grundlage für alle dient Kontextdaten, die dem LLM zur Verfügung gestellt wurden. Hier können Sie kreativ mit Function -Engineering, statistischen Analysen und Datenerkenntnissen werden, die für Ihren spezifischen Anwendungsfall von Bedeutung sind.
Ich hoffe, dieses minimale Beispiel hat Sie auf dem richtigen Weg gesetzt, um Ihre eigenen Datenberichterstattungs -Workflows zu automatisieren.