Corso
Understanding ChatGPT
1 ore
436.5K
Tutti conosciamo la popolarità di ChatGPT e come le persone lo usano per aumentare la produttività. Ma se sei alle prime armi, vale la pena registrarti a una demo gratuita di ChatGPT e sperimentare tutto ciò che può fare. Dovresti anche seguire il nostro corso Introduction to ChatGPT per imparare le best practice nella scrittura di prompt efficaci ed esplorare i casi d’uso aziendali più comuni per sfruttare questo potente strumento di IA.
In questo tutorial impareremo a usare ChatGPT per lavorare su un progetto di data science end‑to‑end. Useremo vari prompt per creare un outline del progetto, scrivere codice Python, condurre ricerche e fare il debug dell’applicazione. Inoltre, vedremo consigli su come scrivere prompt efficaci per ChatGPT. Se ti intriga usare l’IA per scopi diversi, dai un’occhiata alla nostra guida sui progetti di intelligenza artificiale per tutti i livelli.
Usare ChatGPT per un progetto di data science end‑to‑end
Nel progetto useremo i Loan Data di DataLab e pianificheremo il progetto di data science intorno a questo dataset.
ChatGPT fa l’80% del lavoro: dobbiamo solo padroneggiare la prompt engineering per ottenere tutto nel modo giusto, e per questo abbiamo il nostro fantastico ChatGPT Cheat Sheet for Data Science. Include oltre 60 prompt per attività di data science basate su SQL, R e Python.
Pianificazione del progetto
È la parte più importante del progetto, in cui valutiamo le risorse disponibili e gli obiettivi per definire una strategia ottimale.
Puoi andare su chat.openai.com e avviare una nuova chat. Dopo di che, menzioneremo il dataset di prestiti disponibile e chiederemo a ChatGPT di proporre i passaggi per costruire un progetto generico end‑to‑end per il portfolio.
Prompt: “Ho un dataset di prestiti composto da 9500 righe e 14 colonne: ['credit.policy', 'purpose', 'int.rate', 'installment', 'log.annual.inc','dti', 'fico', 'days.with.cr.line', 'revol.bal', 'revol.util', 'inq.last.6mths', 'delinq.2yrs', 'pub.rec', 'not.fully.paid']. Puoi elencare i passaggi da seguire per sviluppare un progetto end‑to‑end per il mio portfolio?”
Abbiamo ottenuto l’elenco, ma ci siamo dimenticati di menzionare il problema di sbilanciamento delle classi e l’obiettivo del progetto, che è prevedere con precisione “prestito non rimborsato”.
Prompt aggiornato: “Includi per favore i problemi di sbilanciamento delle classi e prevedi con precisione se un prestito non verrà rimborsato piuttosto che se verrà rimborsato.”
Inoltre, non siamo interessati al monitoring del modello e vogliamo creare un’app con Gradio e distribuirla su Hugging Face Spaces.
Prompt aggiornato: “Creeremo un’app web usando Gradio e la distribuiremo su Spaces e non faremo il monitoraggio del modello in produzione.”
Gif dell’autore | Elenco finale dei passaggi coinvolti in un progetto
Abbiamo ottenuto un elenco di 9 passaggi, come mostrato sopra, e una spiegazione dettagliata di come affrontare ciascuno di essi.
Ecco l’elenco delle attività che seguiremo in questo tutorial:
- Pulizia e preprocessing dei dati. Gestire i valori mancanti, convertire le variabili categoriche in numeriche, scalare/normalizzare i dati e gestire eventuali outlier o anomalie nei dati. Inoltre, vorrai affrontare lo sbilanciamento delle classi sovracampionando la classe minoritaria (prestiti non completamente rimborsati) o sottocampionando la classe maggioritaria (prestiti completamente rimborsati).
- Analisi esplorativa dei dati (EDA). Esplorare il dataset per ricavare insight, come distribuzioni delle variabili, correlazioni tra variabili e identificazione di eventuali pattern nei dati.
- Feature engineering. Creare nuove feature o trasformare quelle esistenti per migliorare la capacità predittiva del modello.
- Selezione del modello. Provare diversi modelli, come alberi decisionali, random forest, regressione logistica o support vector machine (SVM).
- Addestramento e valutazione del modello. Addestrare il modello selezionato sui dati e valutarne le prestazioni usando varie metriche come accuracy, precision, recall e F1‑score.
- Tuning degli iperparametri. Ottimizzare gli iperparametri del modello selezionato per migliorarne le prestazioni.
- Creazione dell’app web con Gradio. Una volta selezionato il modello migliore, puoi creare un’app web con Gradio.
- Deployment dell’app web su Spaces. Una volta creata l’app con Gradio, puoi distribuirla su Spaces.
- Test dell’app web. Testala per assicurarti che funzioni come previsto.
Analisi esplorativa dei dati (EDA)
L’EDA riguarda manipolazione dei dati, analisi statistiche e visualizzazione. Possiamo completarla scrivendo un prompt di follow‑up per generare codice Python per l’EDA sul nostro dataset.
Prompt di follow‑up: “Scrivi un codice Python per caricare ed eseguire l’analisi esplorativa dei dati (EDA) sul dataset dei prestiti”
Il bot capirà il contesto e proporrà codice Python con commenti e una spiegazione dettagliata del funzionamento.
Gif dell’autore | Codice Python per l’EDA
- Caricare e visualizzare il dataset come dataframe Pandas.
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
loan_df = pd.read_csv("loan_data.csv")
loan_df.head()
- Mostrare il numero di righe e colonne e il riassunto statistico per le variabili numeriche.
# Display the number of rows and columns in the dataset
print("Number of rows and columns:", loan_df.shape)
# Display summary statistics for numerical variables
print(loan_df.describe())Number of rows and columns: (9578, 14)
credit.policy int.rate ... pub.rec not.fully.paid
count 9578.000000 9578.000000 ... 9578.000000 9578.000000
mean 0.804970 0.122640 ... 0.062122 0.160054
std 0.396245 0.026847 ... 0.262126 0.366676
min 0.000000 0.060000 ... 0.000000 0.000000
25% 1.000000 0.103900 ... 0.000000 0.000000
50% 1.000000 0.122100 ... 0.000000 0.000000
75% 1.000000 0.140700 ... 0.000000 0.000000
max 1.000000 0.216400 ... 5.000000 1.000000- Mostrare i valori mancanti in ogni colonna. Come possiamo vedere, non ne abbiamo.
print(loan_df.isnull().sum())credit.policy 0
purpose 0
int.rate 0
installment 0
log.annual.inc 0
dti 0
fico 0
days.with.cr.line 0
revol.bal 0
revol.util 0
inq.last.6mths 0
delinq.2yrs 0
pub.rec 0
not.fully.paid 0- Visualizzare la distribuzione della variabile target “not.fully.paid”.
sns.countplot(x="not.fully.paid", data=loan_df)
plt.show()
- Visualizzare la correlazione tra le variabili.
corr = loan_df.corr()
sns.heatmap(corr, annot=True, cmap="coolwarm")
plt.show()
- Capire la distribuzione dello scopo del prestito.
sns.countplot(x="purpose", data=loan_df)
plt.xticks(rotation=90)
plt.show()
- Capire la distribuzione dei tassi di interesse per scopo del prestito.
sns.boxplot(x="purpose", y="int.rate", data=loan_df)
plt.xticks(rotation=90)
plt.show()Feature engineering
Invece di fare preprocessing e pulizia dei dati, eseguiremo del feature engineering per semplificare il compito di preprocessing.
Prompt di follow‑up: “Scrivi un codice Python per eseguire il feature engineering”
Abbiamo ottenuto la soluzione giusta, ma includeva codice irrilevante, quindi abbiamo scritto un prompt aggiornato per modificare il codice.
Prompt aggiornato: “aggiungi solo la parte di feature engineering.”
# Perform feature engineering
loan_df["installment_to_income_ratio"] = (
loan_df["installment"] / loan_df["log.annual.inc"]
)
loan_df["credit_history"] = (loan_df["delinq.2yrs"] + loan_df["pub.rec"]) / loan_df[
"fico"
]ChatGPT ha suggerito due nuove feature: “installment_to_income_ratio” e “credit_history”.
Preprocessing e bilanciamento dei dati
Ancora una volta, ChatGPT conosce il contesto del progetto. Non dobbiamo spiegare tutto da capo. Quindi gli chiederemo semplicemente di scrivere un codice Python per pulire e preprocessare i dati.
Prompt di follow‑up: “Ora scrivi un codice Python per pulire e preprocessare il dataset”
- Eliminare le colonne non necessarie e convertire le variabili categoriche in numeriche.
from sklearn.preprocessing import LabelEncoder, StandardScaler
loan_df = loan_df.drop(['credit.policy', 'days.with.cr.line', 'purpose'], axis=1)
# Convert categorical variables to numerical using LabelEncoder
le = LabelEncoder()
loan_df['not.fully.paid'] = le.fit_transform(loan_df['not.fully.paid'])- Scalare le feature numeriche usando lo Standard Scaler.
scaler = StandardScaler()
numerical_cols = ['int.rate', 'installment', 'log.annual.inc', 'dti', 'fico', 'revol.bal', 'revol.util', 'inq.last.6mths', 'delinq.2yrs', 'pub.rec','credit_history','installment_to_income_ratio']
loan_df[numerical_cols] = scaler.fit_transform(loan_df[numerical_cols])- Gestire lo sbilanciamento delle classi usando il metodo di oversampling di imblearn.
from imblearn.over_sampling import SMOTE
sm = SMOTE(random_state=42)
X = loan_df.drop('not.fully.paid', axis=1)
y = loan_df['not.fully.paid']
X_resampled, y_resampled = sm.fit_resample(X, y)
loan_df = pd.concat([X_resampled, y_resampled], axis=1)
loan_df['not.fully.paid'].value_counts()Come possiamo vedere, abbiamo bilanciato con successo le classi.
0 8045
1 8045
Name: not.fully.paid, dtype: int64Selezione del modello
In questa parte abbiamo chiesto a ChatGPT di addestrare i dati su vari modelli per il compito di selezione del modello.
Prompt di follow‑up: “Scrivi un codice Python di follow‑up per la selezione del modello. Prova decision trees, random forests, logistic regression o support vector machines (SVM). Nota: includi solo la parte di selezione del modello.”
Ha generato lo script Python per suddividere il dataset in training e test e addestrare i modelli specificati, mostrando le metriche di accuratezza.
from sklearn.model_selection import train_test_split
# Split the dataset into training and testing sets
X = loan_df.drop('not.fully.paid', axis=1)
y = loan_df['not.fully.paid']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Fit and evaluate decision tree classifier
dt = DecisionTreeClassifier(random_state=42)
dt.fit(X_train, y_train)
dt_score = dt.score(X_test, y_test)
print("Decision Tree Classifier Accuracy: {:.2f}%".format(dt_score*100))
# Fit and evaluate random forest classifier
rf = RandomForestClassifier(random_state=42)
rf.fit(X_train, y_train)
rf_score = rf.score(X_test, y_test)
print("Random Forest Classifier Accuracy: {:.2f}%".format(rf_score*100))
# Fit and evaluate logistic regression classifier
lr = LogisticRegression(random_state=42)
lr.fit(X_train, y_train)
lr_score = lr.score(X_test, y_test)
print("Logistic Regression Classifier Accuracy: {:.2f}%".format(lr_score*100))
# Fit and evaluate support vector machine classifier
svm = SVC(random_state=42)
svm.fit(X_train, y_train)
svm_score = svm.score(X_test, y_test)
print("Support Vector Machine Classifier Accuracy: {:.2f}%".format(svm_score*100))L’algoritmo Random Forest ha superato nettamente gli altri modelli.
Decision Tree Classifier Accuracy: 81.21%
Random Forest Classifier Accuracy: 89.14%
Logistic Regression Classifier Accuracy: 61.32%
Support Vector Machine Classifier Accuracy: 66.54%Tuning degli iperparametri e valutazione del modello
Selezioneremo il modello con prestazioni migliori ed eseguiremo la valutazione. Abbiamo specificato l’uso di accuracy, precision, recall e F1‑score come metriche e la cross‑validation per garantire la stabilità del modello.
Prompt di follow‑up: “Seleziona RandomForestClassifier e scrivi un codice Python per la valutazione del modello. Usa accuracy, precision, recall e F1‑score come metriche e la cross‑validation per assicurarti che il modello non stia overfittando sui dati di training.”
Aggiorneremo il Python per aggiungere il tuning degli iperparametri e salvare il modello con prestazioni migliori.
Prompt aggiornato: “includi anche il tuning degli iperparametri nel codice sopra e salva il modello con prestazioni migliori”
La versione finale del codice usa GridSearchCV per il tuning degli iperparametri con cinque split di cross‑validation e utilizza la metrica f1 per la valutazione al fine di trovare i migliori iperparametri.
Dopodiché, ChatGPT ha aggiunto automaticamente il codice per selezionare il modello migliore per la valutazione sul set di test e ha mostrato gli iperparametri più performanti.
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
# Define the parameter grid for hyperparameter tuning
param_grid = {
'n_estimators': [100, 200, 300],
'max_depth': [10, 20, 30, None],
'min_samples_split': [2, 5, 10],
'min_samples_leaf': [1, 2, 4]
}
# Perform grid search with cross-validation to find the best hyperparameters
grid_search = GridSearchCV(rf, param_grid, cv=5, scoring='f1')
grid_search.fit(X_train, y_train)
# Get the best model and its hyperparameters
best_model = grid_search.best_estimator_
best_params = grid_search.best_params_
# Evaluate the best model on the testing set
y_pred = best_model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
# Print the results
print("Random Forest Classifier Evaluation Results:")
print("Accuracy: {:.2f}%".format(accuracy * 100))
print("Precision: {:.2f}%".format(precision * 100))
print("Recall: {:.2f}%".format(recall * 100))
print("F1 Score: {:.2f}%".format(f1 * 100))
print("Best hyperparameters:", best_params)Abbiamo un modello stabile con un’accuracy dell’89,35. Sia precision che recall sono simili.
Random Forest Classifier Evaluation Results:
Accuracy: 89.35%
Precision: 89.92%
Recall: 88.33%
F1 Score: 89.12%
Best hyperparameters: {'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 300}Infine, salveremo il modello usando joblib.
import joblib
# Save the best model to disk
joblib.dump(best_model, 'loan_classifier.joblib')Puoi trovare il codice sorgente con gli output in questo workbook DataLab; puoi facilmente crearne una copia tua per modificare ed eseguire il codice nel browser, senza dover installare nulla sul computer.
Creare un’app web con Gradio
Ora arriva la parte più divertente. Useremo solo i prompt per creare un’app web completamente personalizzabile che accetta input numerici e mostra i risultati usando un modello di machine learning.
ChatGPT conosce già il contesto, quindi dobbiamo solo chiedergli di scrivere un’app web Gradio per il classificatore dei prestiti.
Prompt di follow‑up: “Scrivi il codice Python per creare un’app web Gradio per i classificatori di dati sui prestiti. Non stiamo usando le colonne ['credit.policy', 'days.with.cr.line', 'purpose'].”
Chiedi a ChatGPT di includere solo la parte dell’app Gradio invece dell’addestramento e poi dello script di inferenza.
Prompt aggiornato: “includi solo la parte dell’app gradio.”
Il codice ottenuto mostra la probabilità della classe predetta, mentre vogliamo mostrare le etichette di classificazione.
Prompt aggiornato: “modifica il codice per mostrare la classificazione invece delle probabilità di classe.”
Dopo aver eseguito il codice, abbiamo visto diversi avvisi ed errori. Puoi migliorarlo menzionando gli errori a ChatGPT.
Dobbiamo capire i limiti di ChatGPT. È stato addestrato su un dataset vecchio e, se ti aspetti che aggiorni il codice con le API più recenti, andrai a sbattere. Invece, dobbiamo leggere la documentazione di Gradio e aggiornare manualmente il codice.
Prompt non riuscito: “aggiorna il codice Gradio con componenti da gradio.components”
Nell’app Gradio carichiamo il modello salvato e otteniamo gli input dagli utenti per mostrare le predizioni del modello.
Scopri come funziona Gradio leggendo i Gradio Docs.
import gradio as gr
import joblib
# Load the trained model
model = joblib.load("loan_classifier.joblib")
def predict_loan_status(
int_rate,
installment,
log_annual_inc,
dti,
fico,
revol_bal,
revol_util,
inq_last_6mths,
delinq_2yrs,
pub_rec,
installment_to_income_ratio,
credit_history,
):
input_dict = {
"int.rate": int_rate,
"installment": installment,
"log.annual.inc": log_annual_inc,
"dti": dti,
"fico": fico,
"revol.bal": revol_bal,
"revol.util": revol_util,
"inq.last.6mths": inq_last_6mths,
"delinq.2yrs": delinq_2yrs,
"pub.rec": pub_rec,
"installment_to_income_ratio": installment_to_income_ratio,
"credit_history": credit_history,
}
# Convert the dictionary to a 2D array
input_array = [list(input_dict.values())]
prediction = model.predict(input_array)[0]
if prediction == 0:
return "Loan fully paid"
else:
return "Loan not fully paid"
inputs = [
gr.Slider(0.06, 0.23, step=0.01, label="Interest Rate"),
gr.Slider(100, 950, step=10, label="Installment"),
gr.Slider(7, 15, step=0.1, label="Log Annual Income"),
gr.Slider(0, 40, step=1, label="DTI Ratio"),
gr.Slider(600, 850, step=1, label="FICO Score"),
gr.Slider(0, 120000, step=1000, label="Revolving Balance"),
gr.Slider(0, 120, step=1, label="Revolving Utilization"),
gr.Slider(0, 10, step=1, label="Inquiries in Last 6 Months"),
gr.Slider(0, 20, step=1, label="Delinquencies in Last 2 Years"),
gr.Slider(0, 10, step=1, label="Public Records"),
gr.Slider(0, 5, step=0.1, label="Installment to Income Ratio"),
gr.Slider(0, 1, step=0.01, label="Credit History"),
]
outputs = [gr.Label(num_top_classes=2)]
title = "Loan Approval Classifier"
description = (
"Enter the details of the loan applicant to check if the loan is approved or not."
)
gr.Interface(
fn=predict_loan_status,
inputs=inputs,
outputs=outputs,
title=title,
description=description,
).launch()Puoi salvare il codice sopra nel file `app.py` e avviare l’app nel browser eseguendo lo script `python app.py` nel terminale.
Gif dell’autore | App classificatore approvazione prestito
Anche se la nostra app funziona, ChatGPT si è completamente perso il fatto che abbiamo scalato le feature numeriche. Quindi, invece di chiedere di aggiornare il codice, puoi tornare indietro e salvare i parametri dello Standard Scaler.
scalar = joblib.load('std_scaler.bin')Dopodiché, carica lo scaler nella tua app usando joblib.
input_array = [list(input_dict.values())]
scaled_array = scalar.transform(input_array)
prediction = model.predict(scaled_array)[0]Quindi, perché lo facciamo manualmente? Se chiedi a ChatGPT di modificare una singola riga, potrebbe cambiare l’intero codice e persino i nomi delle variabili.
Sì, ChatGPT non è perfetto e non sostituirà mai uno sviluppatore.
Deployment dell’app web su Spaces
Puoi semplicemente chiedere a ChatGPT di insegnarti il modo semplice per distribuire un’app Gradio su Hugging Face Spaces, e ti elencherà i passaggi necessari.
Prompt: “how to deploy gradio app to huggingface spaces.”
- Vai sul sito di Hugging Face e clicca sull’immagine del tuo profilo in alto a sinistra per selezionare l’opzione “New Space”.
Immagine dell’autore
- Aggiungi il nome e il tipo di licenza per creare il repository dell’app.
- Clicca sulla scheda Files and Versions > + Add file > Upload files per aggiungere file al repository.
- Trascina i file app.py, model e scaler e clicca sul pulsante “Commit change to main'' e salva il commit con un messaggio. Simile a Git.
Immagine dell’autore
Se riscontri un errore a runtime, è perché ti sei dimenticato di aggiungere anche il file requirements.txt. Seleziona Files and Versions > + Add file > Create a new file e aggiungi il nome del file e le librerie Python con le versioni come mostrato sotto.
Immagine dell’autore
La tua app è pronta. Puoi modificare gli input con gli slider e prevedere se il cliente dovrebbe ottenere un prestito oppure no.
Puoi provare la demo live su uno Space di Hugging Face di kingabzpro.
Immagine dell’autore | Loan Classifier
Consigli per scrivere prompt efficaci per ChatGPT
La prompt engineering è insidiosa quando la si usa per progetti reali. Dobbiamo capire le regole su cosa possiamo fare e quando dobbiamo intervenire per correggere ChatGPT.
Ecco alcuni consigli per migliorare l’esperienza con ChatGPT senza compromettere il progetto.
- Scrivi sempre prompt chiari e concisi. Assicurati di spiegare fin dall’inizio in dettaglio ciò di cui hai bisogno.
- Crea una storia del progetto. ChatGPT è un chatbot, quindi per comprendere efficacemente il contesto ha bisogno che tu stabilisca una storia.
- Continua a provare. Non esiste uno standard per scrivere prompt. Parti da un prompt base e miglioralo progressivamente con prompt di aggiornamento di follow‑up.
- Menziona gli errori di codice. Se esegui il codice in locale e si genera un errore, prova a menzionarlo nel prompt di follow‑up. ChatGPT imparerà immediatamente dall’errore e proporrà una soluzione migliore.
- Fai modifiche manuali. ChatGPT è stato addestrato su dati vecchi e, se ti aspetti che proponga idee o comandi API nuovi, rimarrai deluso. Prova a fare modifiche manuali al tuo codice quando possibile, perché il codice generato non è perfetto.
- Usalo per compiti comuni. Le probabilità di successo con ChatGPT sono maggiori se chiedi compiti comuni.
- Usalo per imparare qualcosa di nuovo. Chiedi sempre a ChatGPT di spiegare cose nuove o per tutorial “come fare”. Ti fornirà un elenco di passaggi semplici per portare a termine il lavoro. È molto utile se hai difficoltà di apprendimento.
Se ti interessano ChatGPT e le API di OpenAI, iscriviti al webinar: Getting Started with the OpenAI API and ChatGPT. Imparerai a svolgere attività di generazione di linguaggio e codice usando le API di OpenAI e molto altro.
Conclusione
Sviluppare un classificatore di approvazione prestiti è solo uno dei tanti esempi di uso di ChatGPT per progetti di data science. Possiamo usarlo per generare dati sintetici, eseguire query SQL, creare report di analisi dei dati, fare ricerca di machine learning e molto altro. L’IA generativa è qui per restare e renderà la nostra vita più semplice. Invece di passare settimane o mesi su un progetto, puoi sviluppare, testare e distribuire applicazioni di data science in poche ore.
In questo tutorial abbiamo imparato a usare ChatGPT per la pianificazione del progetto, l’analisi dei dati, la pulizia e il preprocessing, la selezione del modello, l’ottimizzazione degli iperparametri e la creazione e il deployment di applicazioni web.
C’è un trucco nell’usare ChatGPT. Devi avere esperienza con l’analisi statistica e la programmazione in Python per comprendere i diversi compiti del progetto; senza di essa, cammini alla cieca. Inizia il tuo percorso nella data science seguendo il career track Data Scientist with Python e acquisisci le competenze professionali di cui hai bisogno per avere successo come data scientist.
Argomenti
