ChatGPT als Python Programméierungsassistent

ChatGPT vun OpenAI ass … Dir wësst schonn. Dir hutt genuch doriwwer gelies, an Aféierung sinn net méi néideg. Wann Dir geschitt net wësse wat ChatGPT ass, kuckt dëst als éischt, a kommt dann zréck fir weiderzemaachen.

Gespréicher mat ChatGPT kënne begeeschtert sinn, och erliichtert. Awer loosst eis kucken wéi hëllefräich et tatsächlech ka sinn.

Loosst eis kucken wat ChatGPT ka maachen wann et drëm geet e puer Code ze schreiwen aus Spezifikatioune déi mir ubidden. Mir fänken einfach un a bauen vun do aus.

Ech hu geduecht datt eng gutt Plaz fir unzefänken en Datenveraarbechtungsskript vun enger Zort war. Well ech wëlles hunn ChatGPT e puer Maschinnléiere Scripten duerno mat enger Vielfalt vu Python Bibliothéiken ze schreiwen, huet dëst ausgesinn wéi eng raisonnabel Plaz fir ze starten.

D’Zil

Als éischt wollt ech e puer Versuche maachen fir en Dataset ze lueden; sécherstellen datt all Datasetwäerter numeresch Wäerter sinn, oder se konvertéieren fir esou ze sinn; iwwerpréift fir fehlend Wäerter; an opzedeelen den Dataset an Zuch- an Testsets.

De Prompt

Schreift e Python Skript deen déi folgend mécht:
– lued en Dataset vu csv op Disk op Pandas DataFrame
– garantéiert datt den Dataset ganz numeresch ass; konvertéiert Stringwäerter op numeresch a verfollegt dës Konversioun an engem Wierderbuch fir spéider Referenz
– iwwerpréift fir fehlend Wäerter am DataFrame an imputéiert fehlend Wäerter fir all Rekord deen ee fehlende Wäert huet; fällt ganz e Rekord dee méi wéi ee fehlende Wäert huet
– splitt den Dataset an Test- an Trainingssets

D’Äntwert

import pandas as pd

# Load dataset from csv to DataFrame
df = pd.read_csv('dataset.csv')

# Initialize dictionary to track string to numeric conversions
conversions = {}

# Convert string values to numeric and track conversions in dictionary
for col in df.columns:
    if df[col].dtype == object:
        conversions[col] = {val: i for i, val in enumerate(df[col].unique())}
        df[col] = df[col].map(conversions[col])

# Check for missing values
missing_values = df.isna().sum()

# Impute missing values for records with one missing value
for col in missing_values[missing_values == 1].index:
    df[col].fillna(df[col].median(), inplace=True)

# Drop records with more than one missing value
df.dropna(thresh=len(df.columns) - 1, inplace=True)

# Split dataset into test and training sets
from sklearn.model_selection import train_test_split
train_df, test_df = train_test_split(df, test_size=0.2)

Bemierkung: d’Skript lued den Dataset vum csv Dateinumm “dataset.csv” a splitt den Dateframe an Test- an Trainingssets mat 80/20 Verhältnis. Wann Dir en anere Dateinumm oder Verhältnis benotze wëllt, ännert de Wee / Verhältnis deementspriechend.

D’Analyse

ChatGPT huet en nëtzlecht Skript produzéiert. Et huet en Datasetnumm decidéiert, souwéi en Zuch / Test Split Prozentsaz, a bemierkt souwuel dës Punkten a wéi se se änneren wann Dir wëllt. Insgesamt ass d’Missioun erfëllt.

D’Zil

Elo wou mir e Skript hunn deen eppes mécht, loosst eis et e bëssen refaktoréieren. E Grondsteen vu gudder Kodéierung ass d’Benotzung vu Funktiounen fir Äre Code logesch z’organiséieren, d’Wiederverwendung z’erliichteren an ze garantéieren datt Dir Iech selwer net widderhëlt.

De Prompt

Schreift de Skript uewendriwwer fir eng Serie vu Funktiounen ze benotzen déi Sënn maachen

D’Äntwert

import pandas as pd
from sklearn.model_selection import train_test_split

def load_and_convert_data(file_path):
    # Load dataset from csv to DataFrame
    df = pd.read_csv(file_path)
    
    # Initialize dictionary to track string to numeric conversions
    conversions = {}
    
    # Convert string values to numeric and track conversions in dictionary
    for col in df.columns:
        if df[col].dtype == object:
            conversions[col] = {val: i for i, val in enumerate(df[col].unique())}
            df[col] = df[col].map(conversions[col])
    
    return df, conversions

def handle_missing_values(df):
    # Check for missing values
    missing_values = df.isna().sum()
    
    # Impute missing values for records with one missing value
    for col in missing_values[missing_values == 1].index:
        df[col].fillna(df[col].median(), inplace=True)
    
    # Drop records with more than one missing value
    df.dropna(thresh=len(df.columns) - 1, inplace=True)
    
    return df

def split_data(df, test_size):
    return train_test_split(df, test_size=test_size)

# Use the functions
file_path = "dataset.csv"
df, conversions = load_and_convert_data(file_path)
df = handle_missing_values(df)
train_df, test_df = split_data(df, 0.2)

Hei hunn ech dräi Funktiounen benotzt:

1. load_and_convert_data(file_path) lued d’csv-Datesette an konvertéiert d’Stringwäerter op numeresch.
2. handle_missing_values ​​(df) handhabt déi fehlend Wäerter am Dataset.
3. split_data (df, test_size) deelt den Dataset an Test- an Trainingssets.

D’Haaptskript benotzt dës Funktiounen fir d’Dateset ze lueden, ze konvertéieren an ze botzen, se dann an Test- an Zuchsets opzedeelen.

De Wee vum Dataset an den Testverhältnis sinn Input fir dës Funktiounen.

D’Analyse

Wann Dir den éischte Skriptoutput vum ChatGPT kuckt, kënnt Dir wahrscheinlech e puer zimlech offensichtlech Linnen gesinn, déi Dir zéie wéi wäit wéi eng Funktionalitéit a Funktiounen getrennt wier. Ech hu sécherlech. ChatGPT huet genau gemaach wat ech erwaart hunn et ze maachen, an dëser Hisiicht. Erëm, e kompetente Skript gouf generéiert.

D’Zil

OK, eise Skript gesäit e bësse besser aus elo datt et e puer Funktiounen fir Organisatioun benotzt. Als nächst, loosst eis de Skript liicht verlängeren fir et sou ze maachen datt de Benotzer e puer Parameteren spezifizéiere kann wärend de Skript leeft.

De Prompt

Schreift den uewe genannte Programm fir déi folgend vun der Kommandozeil a Form vun Argumenter ze froen, a benotzt se am Programm:
– de Wee/Numm vun der Csv-Datei Datei
– den Zuch / Test Split Gréisst
– d’Schwell fir d’Zuel vu fehlend Wäerter pro Rekord ze falen, duerno de ganze Rekord erofzesetzen, anstatt déi fehlend Wäerter ze imputéieren

D’Äntwert

import pandas as pd
import argparse
from sklearn.model_selection import train_test_split

def load_and_convert_data(file_path):
    # Load dataset from csv to DataFrame
    df = pd.read_csv(file_path)
    
    # Initialize dictionary to track string to numeric conversions
    conversions = {}
    
    # Convert string values to numeric and track conversions in dictionary
    for col in df.columns:
        if df[col].dtype == object:
            conversions[col] = {val: i for i, val in enumerate(df[col].unique())}
            df[col] = df[col].map(conversions[col])
    
    return df, conversions

def handle_missing_values(df, threshold):
    # Check for missing values
    missing_values = df.isna().sum()
    
    # Impute missing values for records with one missing value
    for col in missing_values[missing_values == 1].index:
        df[col].fillna(df[col].median(), inplace=True)
    
    # Drop records with more than threshold missing value
    df.dropna(thresh=len(df.columns) - threshold, inplace=True)
    
    return df

def split_data(df, test_size):
    return train_test_split(df, test_size=test_size)

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument("file_path", help="path/name of the dataset csv file")
    parser.add_argument("test_size", help="train/test split size", type=float)
    parser.add_argument("threshold", help="threshold for the number of missing values per record", type=int)
    args = parser.parse_args()
    
    # Use the functions
    df, conversions = load_and_convert_data(args.file_path)
    df = handle_missing_values(df, args.threshold)
    train_df, test_df = split_data(df, args.test_size)

An dëser Versioun hunn ech den argparse Modul benotzt fir d’Inputen vum Dateiwee, Test / Zuch Splitgréisst a Schwell fir d’Zuel vu fehlend Wäerter pro Rekord als Kommandozeil Argumenter ze huelen. De Benotzer muss de Skript mat de richtegen Argumenter lafen, zum Beispill:

python script.py dataset.csv 0.2 1

Dëst féiert de Skript mat der Datei “dataset.csv”, eng test_size vun 0.2 an eng Schwell vun 1 fir déi fehlend Wäerter.

D’Haaptskript benotzt dës Argumenter an de Funktiounen fir d’Dateset ze lueden, ze konvertéieren an ze botzen, an dann an Test- an Zuchsets opzedeelen.

Et ass och derwäert ze erwähnen datt wann Dir de Skript leeft, de Skript soll vun der Kommandozeil lafen, anstatt et vun enger IDE ze lafen.

D’Analyse

Éierlech gesot, net vill Analyse ass hei gebraucht, well ChatGPT erkläert huet wat et ganz gutt gemaach huet. Ech wäert tatsächlech eppes hei notéieren wat ech net virdru gemaach hunn, a ginn ChatGPT e Patt op de Réck fir seng Kommentaren, déi expressiv a präzis ass.

D’Zil

Loosst eis elo soen, mir wollten dëse Code “Produktioun” fäerdeg maachen (humor mech). Loosst eis ChatGPT kréien fir dës Funktiounen an enger Streamlit App ze wéckelen.

De Prompt

Schreift den uewe genannte Programm als Streamlit App ëm, wat de Benotzer erlaabt déiselwecht Argumenter ze bidden wéi an der Kommandozeil args uewen

D’Äntwert

import pandas as pd
import streamlit as st
from sklearn.model_selection import train_test_split

def load_and_convert_data(file_path):
    # Load dataset from csv to DataFrame
    df = pd.read_csv(file_path)
    
    # Initialize dictionary to track string to numeric conversions
    conversions = {}
    
    # Convert string values to numeric and track conversions in dictionary
    for col in df.columns:
        if df[col].dtype == object:
            conversions[col] = {val: i for i, val in enumerate(df[col].unique())}
            df[col] = df[col].map(conversions[col])
    
    return df, conversions

def handle_missing_values(df, threshold):
    # Check for missing values
    missing_values = df.isna().sum()
    
    # Impute missing values for records with one missing value
    for col in missing_values[missing_values == 1].index:
        df[col].fillna(df[col].median(), inplace=True)
    
    # Drop records with more than threshold missing value
    df.dropna(thresh=len(df.columns) - threshold, inplace=True)
    
    return df

def split_data(df, test_size):
    return train_test_split(df, test_size=test_size)

def main():
    st.set_page_config(page_title="Data Preprocessing", page_icon=":guardsman:", layout="wide")
    st.title("Data Preprocessing")
    
    file_path = st.text_input("Enter the path/name of the dataset csv file: ")
    test_size = st.number_input("Enter the train/test split size (decimal between 0 and 1): ", step=0.01, value=0.2)
    threshold = st.number_input("Enter the threshold for the number of missing values per record: ", step=1, value=1)
    
    if st.button("Process Data"):
        df, conversions = load_and_convert_data(file_path)
        df = handle_missing_values(df, threshold)
        train_df, test_df = split_data(df, test_size)
        st.success("Data preprocessing completed!")

if __name__ == '__main__':
    main()

Dës Versioun ass eng Streamlit App déi de Benotzer erlaabt déiselwecht Argumenter wéi Kommandozeil Argumenter ze bidden. Et benotzt d’Streamlit-Bibliothéik fir eng interaktiv Web-App ze kreéieren déi de Benotzer erlaabt de Dateiwee anzeginn, d’Test / Zuch Splitgréisst an d’Schwell fir d’Zuel vu fehlend Wäerter pro Rekord. De Benotzer kann dann op de “Process Data” Knäppchen klickt fir de Skript auszeféieren an d’Donnéeën virzebeaarbechten. Et benotzt déiselwecht Funktiounen wéi déi viregt Versioun vum Skript fir d’Dateset ze lueden, ze konvertéieren an ze botzen, an dann an Test- an Zuchsets opzedeelen.

Fir de Skript auszeféieren, musst Dir Streamlit installéiert hunn, Dir kënnt de Kommando pip installéieren streamlit an Ärem Terminal lafen. Eemol installéiert, fuert de Skript mam Kommando aus streamlit run script.py.

D’Analyse

Et huet gemaach wat et soll maachen. ChatGPT huet eis Fonctionnement … Funktiounen geholl an eng einfach Streamlit Web App mat hinnen gebaut.

D’Streamlit Web App erstallt mam Skript generéiert vum ChatGPT

ChatGPT huet eng perfekt kompetent Aarbecht gemaach fir ze kreéieren, ze refactoréieren, ze verlängeren an e Wrapper ronderëm en einfachen Datevirveraarbechtung Python Skript ze addéieren, dee mir wollte fir eis ze schreiwen, aus de Spezifikatioune déi mir geliwwert hunn. Och wann et net déi komplexst vu Programmer duerch e Wäitschoss war, war et e Schrëtt an d’Richtung datt ChatGPT wierklech nëtzlech wier andeems hien als Programméierungsassistent handelt. D’Resultater schloen d’Mark bei all Schrëtt.

D’nächst Kéier wäerte mir e manner triviale Programm mat e puer verstäerkter Komplexitéit an zousätzlech Ufuerderunge bauen. Ech sinn opgereegt ze gesinn wéi gutt ChatGPT ënner Drock leeft. Hoffentlech sidd Dir och.

Matthew Mayo (@mattmayo13) ass en Datewëssenschaftler an de Chefredakter vu KDnuggets, déi seminal Online Data Science a Machine Learning Ressource. Seng Interesse leien an der natierlecher Sproochveraarbechtung, Algorithmus Design an Optimiséierung, oniwwerwaacht Léieren, neural Netzwierker, an automatiséiert Approche fir Maschinnléieren. Matthew hält e Master Ofschloss an Informatik an en Diplom Diplom am Datemining. Hien kann um editor1 bei kdnuggets erreecht ginn[dot]com.