Empfohlene Nutzung NSDT-SzeneneditorHelfen Sie dabei, schnell eine 3D-Anwendungsszene zu erstellen, die zweimal bearbeitet werden kann

chatgpt hat sich zu einem Schweizer Taschenmesser entwickelt, das in einer Vielzahl von Anwendungen eingesetzt werden kann, und es gibt viel Raum, ChatGPT in datenwissenschaftliche Arbeitsabläufe zu integrieren.

Wenn Sie jemals ein Modell für maschinelles Lernen anhand eines realen Datensatzes trainiert haben, wissen Sie, dass die Schritte der Datenbereinigung und -vorverarbeitung für den Aufbau eines zuverlässigen Modells für maschinelles Lernen sehr wichtig sind. In dieser Anleitung erfahren Sie, wie Sie ChatGPT verwenden, um diese Aufgaben an einem Beispieldatensatz auszuführen.

Wir verwenden den Bankmarketingdatensatz aus dem UCI-Repository für maschinelles Lernen und fordern ChatGPT auf, Folgendes zu tun:

• Rufen Sie den Datensatz ab und laden Sie ihn
• Suchen Sie nach fehlenden Werten
• Kodierung kategorialer Variablen

Anschließend können Sie sich bei Ihrem OpenAI-Konto anmelden und eine neue ChatGPT-Sitzung starten. Wenn Sie möchten, können Sie auch in google Colab programmieren.

Es gibt verschiedene Versionen des Datensatzes. Wir werden die Datei bankfull.csv verwenden.

Hinweis: Heute führen wir eine Datenbereinigung und Vorverarbeitung an einem realen Datensatz durch. Schreiben Sie Code, um Folgendes zu tun: 1. Ziehen Sie den Bankmarketing-Datensatz aus dem UCI-Repository für maschinelles Lernen. Verwenden Sie eine Bibliothek wie „requests“ oder „urllib“. 2. Laden Sie die ZIP-Datei herunter, entpacken Sie den Inhalt und lesen Sie die Datei „bank is full.csv“ in einen Pandas-Datenrahmen (Daten genannt).

Der Code zum Abrufen und Einlesen des Datensatzes lautet wie folgt:

import pandas as pd
import urllib
import zipfile

# URL of the dataset
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/00222/bank.zip"

# Fetch and extract the dataset
urllib.request.urlretrieve(url, "bank.zip")

with zipfile.ZipFile("bank.zip", "r") as zip_ref:
    zip_ref.extractall()

# Load the dataset into a pandas DataFrame
data = pd.read_csv("bank-full.csv", delimiter=";",skipinitialspace=True)

Lassen Sie uns den Datensatz besser verstehen.

# Display the first few rows of the dataset
print(data.head())

Dies gibt aus:

Abgeschnittene Ausgabe von data.head()

Hinweis: Verwenden Sie Pandas, um die Abmessungen eines Datenrahmens, beschreibende Statistiken für Spalten und die Datentypen verschiedener Spalten abzurufen.

Dieser Schritt erfordert keine Aufforderung an ChatGPT, da die Pandas-Methode sehr einfach ist.

# Get the dimensions of the dataset (rows, columns)
print(data.shape)

Output >>> (45211, 17)

Wir haben über 45.000 Datensätze und 16 Features (da 17 auch Ausgabeetiketten enthält).

# Get statistical summary of numerical columns
print(data.describe())

Abgeschnittene Ausgabe von data.describe()

Hilfreich ist es auch, sich einen Überblick über die Datentypen der verschiedenen Spalten zu verschaffen. Wenn wir kategoriale Variablen kodieren, werden wir sie uns genauer ansehen.

# Check data types of each column
print(data.dtypes)

Output >>>

age           int64
job          object
marital      object
education    object
default      object
balance       int64
housing      object
loan         object
contact      object
day           int64
month        object
duration      int64
campaign      int64
pdays         int64
previous      int64
poutcome     object
y            object
dtype: object

Bisher haben wir uns den Marketingdatensatz der Bank angesehen. Das Ausgabeetikett gibt an, ob der Kunde ein Festgeld abonniert. Dieser Datensatz enthält mehrere Elemente wie Alter, Monat, Bildung, Familienstand, Ergebnisse früherer Kampagnen usw.

Hinweis: Ich möchte die Anzahl der fehlenden Werte in jeder Spalte wissen. Bitte geben Sie mir den Code dazu. Benutze Pandas.

# Check for missing values in each column
missing_values = data.isnull().sum()
print(missing_values)

Hier ist die Ausgabe:

Output >>>

age          0
job          0
marital      0
education    0
default      0
balance      0
housing      0
loan         0
contact      0
day          0
month        0
duration     0
campaign     0
pdays        0
previous     0
poutcome     0
y            0
dtype: int64

In dieser Version des Bankmarketing-Datensatzes (enthält über 45.000 Datensätze) fehlen keine Werte. In der Praxis fehlen jedoch in den meisten realen Datensätzen Werte. Für den Umgang mit fehlenden Werten sollten Sie eine geeignete Imputationstechnik verwenden.

Als optionale Übung könnten Sie hier einen Schritt hinzufügen, der ChatGPT dazu auffordert, eine kleine Teilmenge von Werten aus einer Teilmenge der Spalten zu löschen, damit Sie üben können, wie mit fehlenden Werten umgegangen wird.

Der nächste Schritt besteht darin, die kategorialen Variablen im Datensatz zu kodieren. Wir beginnen damit, eine Liste aller kategorialen Spalten zu erhalten.

Hinweis: Geben Sie Code an, um eine Liste aller kategorialen Spalten in diesem Datensatz zu erhalten.

# Count the number of categorical variables
categorical_columns = data.select_dtypes(include=['object']).columns
print(categorical_columns)
num_categorical_variables = len(categorical_columns)

# Display the count
print("Number of categorical variables:", num_categorical_variables)

Die Liste der kategorialen Spalten enthält auch die Ausgabebezeichnungen j. Aber konzentrieren wir uns zunächst auf die anderen kategorialen Variablen.

Output >>>
Index(['job', 'marital', 'education', 'default', 'housing', 'loan', 'contact',
       'month', 'poutcome', 'y'],
      dtype='object')
Number of categorical variables: 10

Schauen Sie sich die Werte kategorialer Variablen genauer an

Schauen wir uns als Nächstes die Werte an, die jede kategoriale Variable annimmt.

Hinweis: Ich möchte wissen, welche verschiedenen Werte jede kategoriale Variable annimmt. Geben Sie Pandas den Code dafür.

# Get the different values and their counts for each categorical column
categorical_columns = ['job', 'marital', 'education', 'default', 'housing', 'loan', 'contact', 'month', 'poutcome']
for column in categorical_columns:
    value_counts = data[column].value_counts()
    print(f"Column: {column}")
    print(value_counts,"\n")

Die Ausgabe ist schwer zu analysieren:

Output >>>

Column: job
blue-collar      9732
management       9458
technician       7597
admin.           5171
services         4154
retired          2264
self-employed    1579
entrepreneur     1487
unemployed       1303
housemaid        1240
student           938
unknown           288
Name: job, dtype: int64 

...
...
...
Column: poutcome
unknown    36959
failure     4901
other       1840
success     1511
Name: poutcome, dtype: int64 

Visualisieren Sie Werte kategorialer Variablen

Lassen Sie uns ChatGPT auffordern, eine Visualisierung zu erstellen, die es einfacher macht, die Werte zu verstehen, die eine kategoriale Variable annimmt.

Hinweis: Ich möchte ein Diagramm, das die von jeder kategorialen Variablen angenommenen Werte zeigt. Ausgabebezeichnung y ausschließen. Alle anderen kategorialen Variablen sind enthalten.

Lass uns anfangen!

import matplotlib.pyplot as plt

# Get the different values and their counts for each categorical column
categorical_columns = ['job', 'marital', 'education', 'default', 'housing', 'loan', 'contact', 'month', 'poutcome']

# Set up the subplot grid
fig, axes = plt.subplots(3, 3, figsize=(10,8))

# Iterate over each categorical column and plot the value counts
for i, column in enumerate(categorical_columns):
    row = i // 3
    col = i % 3
    value_counts = data[column].value_counts()
    ax = axes[row, col]
    value_counts.plot(kind='bar', ax=ax)
    ax.set_xlabel(column)
    ax.set_ylabel('Count')
    ax.set_title(f'{column.title()} Value Counts')

# Adjust spacing between subplots
plt.tight_layout()

# Show the plot
plt.show()

der Wert der kategorialen Variablen

One-Hot-Kodierung

Für eine Teilmenge kategorialer Spalten können wir One-Hot-Codierung verwenden.

Hinweis: Ein Pandas-Code zum Durchführen einer One-Hot-Codierung für eine Liste von Spalten.

Wir verwenden die folgenden Spalten von Pandas bis One-Hot-Codierung:get_dummies

# Select the categorical columns (excluding education and poutcome)
categorical_columns = ['job', 'marital', 'default', 'housing', 'loan', 'contact']

# Perform one-hot encoding
encoded_data = pd.get_dummies(data, columns=categorical_columns)

Hinweis: Ich möchte die ersten Zeilen neu hinzugefügter Spalten ausdrucken. Schreiben Sie Code, um dasselbe zu tun.

# Select the newly added columns
new_columns = encoded_data.columns.difference(data.columns)

# Print the head of the newly added columns
print(encoded_data[new_columns].head())

Abgeschnittene Ausgabe encoded_data[’new_colums‘].Kopf()

Definieren Sie benutzerdefinierte Zuordnungen

Für Spalten mit Variablen wie „education“ und „poutcome“ (vorherige Ergebnisse) ist es besser, anstelle einer One-Hot-Codierung eine benutzerdefinierte Karte zu verwenden, um einen gewissen Vergleich zwischen Werten zu ermöglichen.

Wenn wir außerdem One-Hot-Codierung verwenden, um eine kategoriale Variable zu codieren, nimmt die Variable k neue Spalten mit k unterschiedlichen Werten an. Für eine kategoriale Spalte wie „Monat“ wäre dies übertrieben, ohne viele Informationen hinzuzufügen.

In beiden Fällen definieren wir also eine benutzerdefinierte Karte und transformieren dann die Werte. Wir können ChatGPT zur Eingabe eines generischen Codeausschnitts auffordern, den wir dann ändern können, um Zuordnungen für bestimmte Spalten zu definieren.

Hinweis: Ich möchte eine benutzerdefinierte Zuordnung erstellen, um einige kategoriale Variablen zu kodieren. Geben Sie mir zunächst einen generischen Codeausschnitt, der eine benutzerdefinierte Zuordnung von eindeutigen Werten in einer kategorialen Spalte zu einer Reihe verschiedener Ausgabewerte definiert. Diese Zuordnung sollten wir dann nutzen, um die Werte in der Spalte zu transformieren.

# Define the custom mapping dictionary
custom_mapping = {
    'category1': 'value1',
    'category2': 'value2',
    'category3': 'value3',
    # Add more categories and corresponding values as needed
}

# Specify the categorical column
categorical_column = 'column_name'  # Replace 'column_name' with the actual column name

# Perform the mapping using the custom mapping dictionary
data[categorical_column] = data[categorical_column].map(custom_mapping)

Für die Spalte „Monat“ konvertieren wir die Monatszeichenfolge wie folgt:

# Define the mapping dictionary for months
month_mapping = {
    'jan': 1,
    'feb': 2,
    'mar': 3,
    'apr': 4,
    'may': 5,
    'jun': 6,
    'jul': 7,
    'aug': 8,
    'sep': 9,
    'oct': 10,
    'nov': 11,
    'dec': 12
}

# Map the values in the month column
encoded_data['month'] = encoded_data['month'].map(month_mapping)

Ordnen wir die Spalten „Ergebnisse“ und „Bildung“ wie folgt numerischen Werten zu:

# Define the custom mapping for poutcome and education
poutcome_mapping = {
    'unknown': 0,
    'failure': 1,
    'other': 2,
    'success': 3
}

education_mapping = {
    'unknown': 0,
    'primary': 1,
    'secondary': 2,
    'tertiary': 3
}

# Perform ordinal encoding using pandas map
encoded_data['poutcome'] = encoded_data['poutcome'].map(poutcome_mapping)
encoded_data['education'] = encoded_data['education'].map(education_mapping)

# Select the newly added columns
new_columns = ['month','poutcome', 'education']

# Print the head of the newly added columns
print(encoded_data[new_columns].head(10))

Kodieren Sie das Ausgabeetikett

Wir ordnen auch die Ausgabebezeichnungen „Ja“ und „Nein“ den Werten 1 bzw. 0 zu.

encoded_data['y'] = encoded_data['y'].replace({'no': 0, 'yes': 1})
print(encoded_data['y'])

Output >>>

0        0
1        0
2        0
3        0
4        0
        ..
45206    1
45207    1
45208    1
45209    0
45210    0
Name: y, Length: 45211, dtype: int64

Denken Sie daran, dass wir für die Spalten „Unterkunft“, „Standard“ und „Darlehen“ eine One-Hot-Codierung verwendet haben. Da diese Spalten auch die Werte „Ja“ und „Nein“ annehmen, können Sie „Ja“ und „Nein“ auch den Werten 1 und 0 zuordnen.

Visualisieren Sie die Verteilung von Klassenbezeichnungen

Es ist auch hilfreich, die Verteilung der Klassenbezeichnungen zu untersuchen, damit wir bei Bedarf Klassenungleichgewichte beim Erstellen des Modells berücksichtigen können.

Hinweis: Ich möchte die Verteilung von Klassenbezeichnungen verstehen. Bitte geben Sie mir den Code, um einen geeigneten Plot zu generieren.

Hier ist der Code zum Generieren eines Zähldiagramms in Seaborn:

import seaborn as sns
import matplotlib.pyplot as plt

# Plot the distribution of output labels
sns.countplot(data=data, x='y')
plt.xlabel('Output Label')
plt.ylabel('Count')
plt.title('Output Label Distribution')
plt.show()

Verteilung von Klassenlabels

Wir sehen, dass es ein Klassenungleichgewicht gibt. Daher sollten Sie beim Erstellen eines Modells sicherstellen, dass Sie eine geeignete Resampling-Methode verwenden, um Klassenungleichgewichte zu berücksichtigen.

Obwohl die Datenbereinigung und Vorverarbeitung den Aufwand des Entwicklers erfordert, versuchen wir, eine allgemeine Schrittfolge zu finden, die für einfache Datensätze einigermaßen gut funktioniert.

Hinweis: Können Sie mir eine generische Datenbereinigungs- und Vorverarbeitungspipeline geben, die auf dem basiert, was wir bisher gemacht haben? Erhalten Sie grundlegende Informationen zu einem Datensatz, prüfen Sie fehlende Werte und behandeln Sie diese, identifizieren Sie kategoriale Spalten und kodieren Sie kategoriale Spalten. Benutze einfach Pandas.

Das ist:

import pandas as pd

# Load the dataset into a DataFrame
data = pd.read_csv('data.csv')

# Step 1: Basic Info
print(data.info())

# Step 2: Missing Values
missing_values = data.isnull().sum()
print(missing_values)

# Step 3: Handle Missing Values
# Identify columns with missing values
columns_with_missing_values = missing_values[missing_values > 0].index

# Impute missing values using fillna() or other suitable method
data[columns_with_missing_values] = data[columns_with_missing_values].fillna(data[columns_with_missing_values].mean())

# Step 4: Get Categorical Columns
categorical_columns = data.select_dtypes(include=['object']).columns

# Step 5: Encode Categorical Columns
# Perform ordinal encoding or one-hot encoding using pandas' get_dummies() function
encoded_data = pd.get_dummies(data, columns=categorical_columns)

# Print the encoded data
print(encoded_data.head())

Es zeigt sich, dass die Synergie von datenwissenschaftlichem Fachwissen mit ChatGPT dazu beitragen kann, die Datenbereinigung und -vorverarbeitung einfacher und schneller zu gestalten. Da Sie nun über einen vorverarbeiteten Datensatz verfügen, können Sie noch einen Schritt weiter gehen und ein einfaches Vorhersagemodell auf Basis dieses Bankmarketing-Datensatzes erstellen.

Ursprünglicher Link:So verwenden Sie ChatGPT für die automatische Datenbereinigung und -vorverarbeitung (mvrlink.com)