ChatGPT è davvero utile per i programmatori Python? In particolare quelli che usano Python per l’elaborazione e la pulizia dei dati e la creazione di modelli di apprendimento automatico? Le “conversazioni” con ChatGTP hanno fatto accendere l’hype nei confronti di questa tecnologia di intelligenza artificiale. Ma cosa si può fare di veramente professionale con questo modello? Vediamo cosa può fare ChatGPT quando si tratta di scrivere del codice dalle specifiche che gli forniamo.
Scrivere codice Python con ChatGPT
Un buon punto di partenza può essere uno script di elaborazione dati di qualche tipo, dal momento che vogliamo fare in modo che ChatGPT scriva alcuni script di apprendimento automatico utilizzando una varietà di librerie Python.
Innanzitutto, facciamo alcuni tentativi di caricare un set di dati; garantire che tutti i valori del set di dati siano valori numerici o convertirli in tal modo; controllo dei valori mancanti e suddividere il set di dati in set di treni e test.
Il prompt
Scrivere uno script Python che esegue le operazioni seguenti:
- carica un dataset da csv su disco a Pandas DataFrame
- assicura che il dataset sia interamente numerico; converti i valori stringa in valori numerici e tieni traccia di questa conversione in un dizionario per fare riferimento in un secondo momento
- verifica la presenza di valori mancanti nel DataFrame e imputa i valori mancanti per qualsiasi record con un valore mancante; elimina completamente un record che ha più di un valore mancante
- suddividi il set di dati in set di test e training
La risposta di ChatGPT
Importa panda come PD
# Carica set di dati da csv a DataFrame
df = pd.read_csv(’dataset.csv’)
# Inizializza il dizionario per tenere traccia delle conversioni da stringa a numeriche
conversioni = {}
# Converti i valori stringa in numerici e traccia le conversioni nel dizionario
per 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(conversioni[col])
# Verificare la presenza di valori mancanti
missing_values = df.isna().sum()
# Imputa i valori mancanti per i record con un valore mancante
for col in missing_values[missing_values == 1].index:
df[col].fillna(df[col].median(), inplace=True)
# Rilascia record con più di un valore mancante
df.dropna(thresh=len(df.columns) – 1, inplace=True)
# Dividi il set di dati in set di test e training
da sklearn.model_selection importazione train_test_split
train_df, test_df = train_test_split(df, test_size=0,2)
Nota: lo script carica il set di dati dal nome file csv ”dataset.csv” e divide il dataframe in set di test e training con rapporto 80/20. Se si desidera utilizzare un nome file o un rapporto diverso, modificare il percorso/rapporto di conseguenza.
Analisi del risultato
ChatGPT ha prodotto uno script Python utile. Ha deciso un nome del set di dati, nonché una percentuale di divisione treno/test, e ha annotato entrambi questi punti e come modificarli se lo si desidera. Nel complesso, missione compiuta.
Ora che abbiamo uno script che fa qualcosa, rifattorizziamolo un po’. Una pietra miliare di una buona codifica è l’uso di funzioni per organizzare logicamente il codice, facilitare il riutilizzo e assicurarsi di non ripetersi.
Il prompt
Riscrivi lo script precedente per utilizzare una serie di funzioni che hanno senso.
La risposta di ChatGTP
Importa panda come PD
da sklearn.model_selection importazione train_test_split
DEF load_and_convert_data(file_path):
# Carica set di dati da csv a DataFrame
df = pd.read_csv(file_path)
# Inizializza il dizionario per tenere traccia delle conversioni da stringa a numeriche
conversioni = {}
# Converti i valori stringa in numerici e traccia le conversioni nel dizionario
per 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(conversioni[col])
Return DF, conversioni
DEF handle_missing_values(DF):
# Verifica la presenza di valori mancanti
missing_values = df.isna().sum()
# Imputa i valori mancanti per i record con un valore mancante
for col in missing_values[missing_values == 1].index:
df[col].fillna(df[col].median(), inplace=True)
# Rilascia record con più di un valore mancante
df.dropna(thresh=len(df.columns) – 1, inplace=True)
ritorno df
def split_data(df, test_size):
return train_test_split(df, test_size=test_size)
# Utilizza le funzioni
file_path = ”dataset.csv”
df, conversioni = load_and_convert_data(file_path)
df = handle_missing_values(df)
train_df, test_df = split_data(df, 0,2)
Qui, abbiamo usato tre funzioni:
- load_and_convert_data(file_path) carica il set di dati CSV e converte i valori stringa in numerici.
- handle_missing_values(df) gestisce i valori mancanti nel set di dati.
- split_data(df, test_size) suddivide il set di dati in set di test e training.
Lo script principale utilizza queste funzioni per caricare, convertire e pulire il set di dati, quindi suddividerlo in set di test e training.
Il percorso del set di dati e il rapporto di test sono input per queste funzioni.
Analisi del risultato
Se guardiamo il primo output di script Python di ChatGPT probabilmente possiamo vedere alcune linee piuttosto ovvie per quanto riguarda quale funzionalità sarebbe separata in funzioni. ChatGPT ha fatto esattamente quello che ci aspettavamo che facesse, in questo senso. Ancora una volta, è stato generato uno script Python competente.
Estensione del nostro codice
Il nostro script è migliorato ora che utilizza alcune funzioni per l’organizzazione. Successivamente, estendiamo leggermente lo script per renderlo in modo che l’utente possa specificare alcuni parametri durante l’esecuzione dello script.
Il prompt
Riscrivere il programma precedente per sollecitare quanto segue dalla riga di comando sotto forma di argomenti e utilizzarli nel programma:
– il percorso/nome del file CSV del dataset
– la dimensione divisa treno/prova
– la soglia per il numero di valori mancanti per record da eliminare dopo la quale eliminare l’intero record, invece di imputare i valori mancanti
La risposta di ChatGPT
Importa panda come PD
import argparse
da sklearn.model_selection importazione train_test_split
DEF load_and_convert_data(file_path):
# Carica set di dati da csv a DataFrame
df = pd.read_csv(file_path)
# Inizializza il dizionario per tenere traccia delle conversioni da stringa a numeriche
conversioni = {}
# Converti i valori stringa in numerici e traccia le conversioni nel dizionario
per 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(conversioni[col])
Return DF, conversioni
handle_missing_values DEF (DF, Soglia):
# Verificare la presenza di valori mancanti
missing_values = df.isna().sum()
# Imputa i valori mancanti per i record con un valore mancante
for col in missing_values[missing_values == 1].index:
df[col].fillna(df[col].median(), inplace=True)
# Elimina record con valore mancante superiore alla soglia
df.dropna(thresh=len(df.columns) – threshold, inplace=True)
ritorno 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=”percorso/nome del file CSV del set di dati”)
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()
# Utilizza le funzioni
df, conversioni = load_and_convert_data(args.file_path)
df = handle_missing_values(df; args.threshold)
train_df, test_df = split_data(df, args.test_size)
In questa versione, abbiamo usato il modulo argparse per prendere gli input del percorso del file, la dimensione della divisione test/treno e la soglia per il numero di valori mancanti per record come argomenti della riga di comando. L’utente dovrà eseguire lo script con gli argomenti corretti, ad esempio: Set di dati script.py Python.csv 0.2 1
Questo eseguirà lo script utilizzando il file ”dataset.csv”, un test_size di 0,2 e una soglia di 1 per i valori mancanti.
Lo script principale usa questi argomenti nelle funzioni per caricare, convertire e pulire il set di dati, quindi suddividerlo in set di test e training.
Vale anche la pena ricordare che, quando si esegue lo script, lo script deve essere eseguito dalla riga di comando, piuttosto che eseguirlo da un IDE.
L’analisi del risultato
Qui non è necessaria molta analisi, dato che ChatGPT ha spiegato abbastanza bene cosa ha fatto con Python.
Conversione del nostro codice in un’app semplificata
Ora vorremmo rendere questo codice ”produzione” pronto. Facciamo in modo che ChatGPT racchiuda queste funzioni in un’app Streamlit.
Il prompt
Riscrivi il programma sopra come un’app Streamlit, consentendo all’utente di fornire gli stessi argomenti degli args della riga di comando sopra.
La risposta di ChatGPT
Importa panda come PD
Importa Streamlit come ST
da sklearn.model_selection importazione train_test_split
DEF load_and_convert_data(file_path):
# Carica set di dati da csv a DataFrame
df = pd.read_csv(file_path)
# Inizializza il dizionario per tenere traccia delle conversioni da stringa a numeriche
conversioni = {}
# Converti i valori stringa in numerici e traccia le conversioni nel dizionario
per 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(conversioni[col])
Return DF, conversioni
def handle_missing_values(df, soglia):
# Verificare la presenza di valori mancanti
missing_values = df.isna().sum()
# Imputa i valori mancanti per i record con un valore mancante
for col in missing_values[missing_values == 1].index:
df[col].fillna(df[col].median(), inplace=True)
# Elimina record con valore mancante superiore alla soglia
df.dropna(thresh=len(df.columns) – threshold, inplace=True)
ritorno df
def split_data(df, test_size):
return train_test_split(df, test_size=test_size)
def main():
st.set_page_config(page_title=”Pre-elaborazione dati”, page_icon=”:guardsman:”, layout=”wide”)
st.title(”Pretrattamento dei dati”)
file_path = st.text_input(”Immettere il percorso/nome del file csv del set di dati: ”)
test_size = st.number_input(”Immettere la dimensione della divisione treno/test (decimale tra 0 e 1): ”, passo=0,01, valore=0,2)
threshold = st.number_input(”Immetti la soglia per il numero di valori mancanti per record: ”, step=1, value=1)
if st.button(”Dati di processo”):
df, conversioni = load_and_convert_data(file_path)
df = handle_missing_values(df; soglia)
train_df, test_df = split_data(df, test_size)
st.success(”Pre-elaborazione dei dati completata!”)
if __name__ == ’__main__’:
main()
Questa versione è un’app Streamlit che consente all’utente di fornire gli stessi argomenti degli argomenti della riga di comando. Utilizza la libreria Streamlit per creare un’app Web interattiva che consente all’utente di immettere il percorso del file, testare/addestrare le dimensioni della divisione e la soglia per il numero di valori mancanti per record. L’utente può quindi fare clic sul pulsante ”Elabora dati” per eseguire lo script e pre-elaborare i dati. Utilizza le stesse funzioni della versione precedente dello script per caricare, convertire e pulire il set di dati, quindi suddividerlo in set di test e training.
Per eseguire lo script, è necessario avere installato Streamlit, è possibile eseguire il comando pip install streamlit nel terminale. Una volta installato, eseguire lo script con il comando streamlit run script.py.
L’analisi del risultato
ChatGPT ha fatto quello che doveva fare: ha preso il nostro funzionamento, funzioni, e con questi ha costruito una semplice app web Streamlit.
ChatGPT è anche bravo a correggere i bug in Python?
ChatGPT di OpenAi può correggere molto bene i bug del software, ma il suo vantaggio principale rispetto ad altri metodi e modelli di intelligenza artificiale è la sua capacità unica di dialogo con gli esseri umani che gli consente di migliorare la correttezza di una risposta.
I ricercatori della Johannes Gutenberg University Mainz e dell’University College London hanno contrapposto ChatGPT di OpenAI alle ”tecniche di riparazione dei programmi automatizzate standard” e a due approcci di apprendimento approfondito alle riparazioni dei programmi: CoCoNut, dai ricercatori dell’Università di Waterloo, in Canada; e Codex, il modello basato su GPT-3 di OpenAI che è alla base del servizio di completamento automatico del codice di programmazione accoppiato Copilot di GitHub.
”Riteniamo che le prestazioni di correzione dei bug di ChatGPT siano competitive rispetto ai comuni approcci di deep learning CoCoNut e Codex e notevolmente migliori dei risultati riportati per gli approcci standard di riparazione del programma”, scrivono i ricercatori in un articolo di arXiv, individuato per la prima volta da New Scientist.
Reinforcement Learning from Human Feedback (RLHF)
I ricercatori hanno testato le prestazioni di ChatGPT utilizzando il benchmark di correzione dei bug QuixBugs. I sistemi di riparazione automatica dei programmi (APR) sembrano essere svantaggiati in quanto sono stati sviluppati prima del 2018.
ChatGPT si basa sull’architettura del trasformatore sviluppata da Google. Anche Codex, CodeBERT di Microsoft Research e il suo predecessore BERT sono tutti basati sul metodo del trasformatore di Google.
OpenAI evidenzia la capacità di dialogo di ChatGPT in esempi di codice di debug in cui può chiedere chiarimenti e ricevere suggerimenti da una persona per arrivare a una risposta migliore. Ha addestrato i grandi modelli linguistici alla base di ChatGPT (GPT-3 e GPT 3.5) utilizzando il reinforcement learning from Human Feedback (RLHF).
Mentre la capacità di ChatGPT di discutere può aiutare ad arrivare a una risposta più corretta, la qualità dei suoi suggerimenti rimane poco chiara, osservano i ricercatori. Ecco perché volevano valutare le prestazioni di correzione dei bug in Python di ChatGPT.
I ricercatori hanno testato ChatGPT contro i problemi di QuixBugs per 40 bug di Python, quindi hanno controllato manualmente se la soluzione suggerita era corretta o meno. Hanno ripetuto la query quattro volte perché c’è una certa casualità nell’affidabilità delle risposte di ChatGPT, come ha scoperto un professore di Wharton dopo aver sottoposto il chatbot a un esame simile a un MBA.
Inoltre: il ruolo dello sviluppatore sta cambiando radicalmente, e queste cifre mostrano come
ChatGPT ha risolto 19 dei 40 bug di Python, mettendolo alla pari con CoCoNut (19) e Codex (21). Ma i metodi APR standard hanno risolto solo 7 dei problemi.
I ricercatori hanno scoperto che il tasso di successo di ChatGPT con le interazioni di follow-up ha raggiunto il 77,5%.
Le implicazioni per gli sviluppatori in termini di sforzo e produttività sono ambigue, tuttavia. Stack Overflow ha recentemente vietato le risposte generate da ChatGPT perché erano di bassa qualità ma dal suono plausibile. Il professore di Wharton ha scoperto che ChatGPT potrebbe essere un ottimo compagno per gli studenti MBA in quanto può svolgere un ruolo di ”consulente intelligente” – uno che produce risposte eleganti ma spesso sbagliate – e promuovere il pensiero critico.
”Questo dimostra che l’input umano può essere di grande aiuto per un sistema APR automatizzato, con ChatGPT che fornisce i mezzi per farlo”, scrivono i ricercatori. ”Nonostante le sue grandi prestazioni, sorge la domanda se il costo mentale richiesto per verificare le risposte di ChatGPT superi i vantaggi offerti.”
