Curso
Entendendo o ChatGPT
1 h
434.5K
Todo mundo já ouviu falar da popularidade do ChatGPT e de como as pessoas estão usando a ferramenta para turbinar a produtividade. Se você está começando, vale a pena criar uma conta e testar o demo gratuito do ChatGPT para experimentar tudo o que ele pode fazer. Também recomendamos o nosso curso Introduction to ChatGPT para aprender boas práticas de criação de prompts eficazes e explorar casos de uso comuns de negócios com essa poderosa ferramenta de IA.
Neste tutorial, você vai aprender como usar o ChatGPT para conduzir um projeto de ciência de dados de ponta a ponta. Vamos usar diferentes prompts para criar um plano de projeto, escrever código em Python, fazer pesquisa e depurar a aplicação. Além disso, você vai ver dicas de como escrever prompts eficazes para o ChatGPT. Se ficou curioso sobre como usar IA para diferentes objetivos, confira nosso guia com projetos de inteligência artificial para todos os níveis.
Usando o ChatGPT em um projeto de ciência de dados de ponta a ponta
Neste projeto, vamos usar os Loan Data do DataLab e planejar o projeto de ciência de dados em torno desse dataset.
O ChatGPT faz cerca de 80% do trabalho aqui. Nossa missão é dominar a engenharia de prompts para acertar nos detalhes — e, para isso, temos o nosso excelente ChatGPT Cheat Sheet for Data Science, com mais de 60 prompts para tarefas de ciência de dados em SQL, R e Python.
Planejamento do projeto
Esta é a parte mais importante: analisamos recursos e objetivos para definir a melhor estratégia.
Acesse chat.openai.com e inicie um novo chat. Em seguida, mencione o dataset de empréstimos disponível e peça para o ChatGPT sugerir os passos para montar um projeto genérico de portfólio de ponta a ponta.
Prompt: “Tenho um dataset de empréstimos com 9500 linhas e 14 colunas: ['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']. Você pode listar os passos que devo seguir para desenvolver um projeto de ponta a ponta para o meu portfólio?”
Recebemos a lista, mas esquecemos de mencionar o problema de desbalanceamento de classes e o objetivo do projeto, que é prever com precisão “empréstimo não quitado”.
Prompt atualizado: “Inclua questões de desbalanceamento de classes e foque em prever com precisão se um empréstimo não será quitado, em vez de prever se será quitado.”
Além disso, não vamos fazer monitoramento de modelo e queremos construir um app com Gradio e fazer o deploy no Hugging Face Spaces.
Prompt atualizado: “Vamos criar um web app usando Gradio e fazer o deploy no Spaces, e não vamos monitorar o modelo em produção.”
GIF do autor | Lista final de etapas do projeto
Recebemos uma lista com 9 etapas, como mostrado acima, e uma explicação detalhada de como abordar cada uma delas.
Veja as tarefas que vamos seguir neste tutorial:
- Limpeza e pré-processamento dos dados. Tratar valores ausentes, converter variáveis categóricas em numéricas, aplicar escala/normalização e lidar com outliers ou anomalias. Além disso, é importante tratar o desbalanceamento de classes fazendo oversampling da classe minoritária (empréstimos não totalmente pagos) ou undersampling da classe majoritária (empréstimos totalmente pagos).
- Análise exploratória de dados (EDA). Explorar o dataset para obter insights, como distribuições de variáveis, correlações e padrões.
- Engenharia de atributos (feature engineering). Criar novos atributos ou transformar os existentes para melhorar o poder preditivo do modelo.
- Seleção de modelos. Testar diferentes modelos, como árvores de decisão, random forest, regressão logística ou máquinas de vetores de suporte (SVM).
- Treinamento e avaliação do modelo. Treinar o(s) modelo(s) e avaliar o desempenho com métricas como acurácia, precisão, recall e F1 score.
- Ajuste de hiperparâmetros. Ajustar hiperparâmetros do modelo escolhido para melhorar a performance.
- Criação do web app com Gradio. Depois de selecionar o melhor modelo, criar um app com Gradio.
- Deploy do web app no Spaces. Após criar o app com Gradio, fazer o deploy no Spaces.
- Testes do web app. Testar para garantir que está funcionando como esperado.
Análise exploratória de dados (EDA)
A EDA envolve manipulação de dados, análise estatística e visualização. Podemos resolvê-la com um prompt de acompanhamento pedindo código Python para análise exploratória no nosso dataset.
Prompt de acompanhamento: “Escreva um código em Python para carregar e realizar análise exploratória (EDA) no dataset de empréstimos”
O bot entende o contexto e gera o código em Python com comentários e uma explicação detalhada de como funciona.
GIF do autor | Código Python para EDA
- Carregar e exibir o dataset como um DataFrame do 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()
- Exibir o número de linhas e colunas e o resumo estatístico das variáveis numéricas.
# 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- Exibir valores ausentes em cada coluna. Como podemos ver, não há nenhum.
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- Visualizar a distribuição da variável alvo “not.fully.paid”.
sns.countplot(x="not.fully.paid", data=loan_df)
plt.show()
- Visualizar a correlação entre variáveis.
corr = loan_df.corr()
sns.heatmap(corr, annot=True, cmap="coolwarm")
plt.show()
- Entender a distribuição dos propósitos do empréstimo.
sns.countplot(x="purpose", data=loan_df)
plt.xticks(rotation=90)
plt.show()
- Entender a distribuição das taxas de juros por propósito do empréstimo.
sns.boxplot(x="purpose", y="int.rate", data=loan_df)
plt.xticks(rotation=90)
plt.show()Engenharia de atributos
Em vez de focar primeiro em pré-processamento e limpeza, vamos realizar feature engineering para simplificar o pré-processamento.
Prompt de acompanhamento: “Escreva um código em Python para realizar feature engineering”
Recebemos uma solução válida, mas com trechos irrelevantes, então enviamos um prompt atualizado para ajustar o código.
Prompt atualizado: “adicione apenas a parte de 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"
]O ChatGPT sugeriu duas novas features: “installment_to_income_ratio” e “credit_history”.
Pré-processamento e balanceamento dos dados
Mais uma vez, o ChatGPT já entende o contexto do projeto. Não precisamos explicar tudo de novo. Vamos apenas pedir o código em Python para limpeza e pré-processamento.
Prompt de acompanhamento: “Agora escreva um código em Python para limpar e pré-processar o dataset”
- Remover colunas desnecessárias e converter variáveis categóricas em numéricas.
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'])- Aplicar escala às variáveis numéricas com StandardScaler.
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])- Tratar desbalanceamento de classes usando oversampling do 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()Como podemos ver, conseguimos balancear as classes com sucesso.
0 8045
1 8045
Name: not.fully.paid, dtype: int64Seleção de modelos
Nesta etapa, pedimos ao ChatGPT para treinar vários modelos e realizar a seleção de modelo.
Prompt de acompanhamento: “Escreva um código em Python para seleção de modelos. Teste decision trees, random forests, logistic regression e support vector machines (SVM). Observação: inclua apenas a parte de seleção de modelos.”
Ele gerou o script em Python para dividir o dataset em treino e teste, treinar os modelos especificados e exibir métricas de acurácia.
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))O Random Forest teve desempenho bem superior aos demais.
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%Ajuste de hiperparâmetros e avaliação do modelo
Vamos selecionar o modelo de melhor desempenho e fazer a avaliação. Especificamos o uso de acurácia, precisão, recall e F1 score como métricas e validação cruzada para garantir estabilidade.
Prompt de acompanhamento: “Selecione RandomForestClassifier e escreva um código em Python para avaliação do modelo. Use acurácia, precisão, recall e F1 como métricas e validação cruzada para garantir que o modelo não esteja overfitting nos dados de treino.”
Depois, vamos atualizar o código para incluir ajuste de hiperparâmetros e salvar o melhor modelo.
Prompt atualizado: “inclua também o ajuste de hiperparâmetros no código acima e salve o modelo de melhor desempenho”
A versão final usa GridSearchCV para ajuste de hiperparâmetros com cinco folds e métrica f1 para encontrar a melhor configuração.
Em seguida, o ChatGPT incluiu o código para selecionar o melhor modelo, avaliar no conjunto de teste e exibir os melhores hiperparâmetros.
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)Temos um modelo estável com acurácia de 89,35. Precisão e recall ficaram próximos.
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}Por fim, vamos salvar o modelo com joblib.
import joblib
# Save the best model to disk
joblib.dump(best_model, 'loan_classifier.joblib')Você encontra o código-fonte com as saídas neste workbook do DataLab; é só criar sua própria cópia para editar e executar direto no navegador, sem instalar nada no computador.
Criando um web app com Gradio
Agora vem a parte mais divertida. Vamos usar apenas prompts para criar um web app totalmente personalizável que recebe entradas numéricas e exibe resultados usando um modelo de machine learning.
O ChatGPT já conhece o contexto, então basta pedir o código de um app Gradio para nosso classificador de empréstimos.
Prompt de acompanhamento: “Escreva o código em Python para criar um web app em Gradio para o classificador de empréstimos. Não vamos usar as colunas ['credit.policy', 'days.with.cr.line', 'purpose'].”
Peça ao ChatGPT para incluir apenas a parte do app em Gradio, sem o treinamento, apenas o script de inferência.
Prompt atualizado: “inclua apenas a parte do app em gradio.”
O código retornado exibia a probabilidade da classe, mas queremos mostrar os rótulos de classificação.
Prompt atualizado: “modifique o código para mostrar a classificação em vez das probabilidades.”
Ao executar, vimos alguns avisos e erros. Dá para melhorar informando os erros ao ChatGPT.
É importante entender as limitações do ChatGPT. Ele foi treinado em dados antigos; se você esperar que ele atualize o código com a API mais recente, vai se frustrar. Em vez disso, consulte a documentação do Gradio e atualize o código manualmente.
Prompt que falhou: “atualize o código do Gradio usando component de gradio.components”
No app do Gradio, carregamos o modelo salvo, recebemos entradas dos usuários e exibimos as previsões.
Aprenda como o Gradio funciona lendo a 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()Salve o código acima no arquivo `app.py` e inicie o app no navegador executando `python app.py` no terminal.
GIF do autor | App de classificador de aprovação de empréstimo
Apesar de o app funcionar, o ChatGPT não considerou que escalonamos as variáveis numéricas. Em vez de pedir para atualizar o código, volte e salve os parâmetros do StandardScaler.
scalar = joblib.load('std_scaler.bin')Depois, carregue o scaler no app com joblib.
input_array = [list(input_dict.values())]
scaled_array = scalar.transform(input_array)
prediction = model.predict(scaled_array)[0]Por que fazer isso manualmente? Se você pedir ao ChatGPT para modificar uma única linha, ele pode alterar o código inteiro e até trocar nomes de variáveis.
Sim, o ChatGPT não é perfeito — e não vai substituir um desenvolvedor.
Fazendo deploy do web app no Spaces
Você pode simplesmente pedir ao ChatGPT um passo a passo para fazer deploy de um app Gradio no Hugging Face Spaces, e ele listará as etapas necessárias.
Prompt: “how to deploy gradio app to huggingface spaces.”
- Acesse o site da Hugging Face, clique na sua foto de perfil no canto superior esquerdo e selecione a opção “New Space”.
Imagem do autor
- Defina o nome e o tipo de licença para criar o repositório do app.
- Clique em Files and Versions > + Add file > Upload files para enviar arquivos ao repositório.
- Arraste app.py, o modelo e os arquivos do scaler e clique em “Commit change to main” para salvar a alteração com uma mensagem de commit. É semelhante ao Git.
Imagem do autor
Se ocorrer um erro de runtime, provavelmente você esqueceu de adicionar o arquivo requirements.txt. Vá em Files and Versions > + Add file > Create a new file, informe o nome do arquivo e liste as bibliotecas Python com versões, como no exemplo abaixo.
Imagem do autor
Seu app está pronto. Ajuste as entradas pelos sliders e veja se o cliente deve ou não receber o empréstimo.
Você pode testar o demo ao vivo em um Space da Hugging Face por kingabzpro.
Imagem do autor | Loan Classifier
Dicas para escrever prompts eficazes no ChatGPT
Engenharia de prompts pode ser desafiadora em projetos reais. É preciso entender o que dá para automatizar e quando é melhor intervir e corrigir o ChatGPT.
Aqui vão algumas dicas para melhorar sua experiência com o ChatGPT sem comprometer o projeto.
- Escreva prompts claros e objetivos. Explique em detalhes o que você precisa logo no começo.
- Crie histórico do projeto. O ChatGPT é um chatbot; para entender bem o contexto, estabeleça um histórico na conversa.
- Insista e itere. Não existe um padrão único de prompt. Comece com um prompt base e vá refinando com prompts de acompanhamento.
- Mencione erros de código. Se rodar o código localmente e surgir erro, mencione o erro no prompt seguinte. O ChatGPT costuma aprender com o feedback e trazer uma solução melhor.
- Faça ajustes manualmente. Como o ChatGPT foi treinado com dados antigos, não espere que ele sugira APIs mais novas. Quando possível, faça ajustes manuais — o código gerado não é perfeito.
- Use para tarefas comuns. As chances de sucesso aumentam quando você pede tarefas corriqueiras.
- Use para aprender algo novo. Peça explicações ou tutoriais “como fazer”. Ele fornece passos simples que resolvem o problema — é especialmente útil para quem tem alguma dificuldade de aprendizagem.
Se você se interessa por ChatGPT e pela API da OpenAI, inscreva-se no webinar: Getting Started with the OpenAI API and ChatGPT. Você vai aprender a realizar tarefas de geração de linguagem e código com a API da OpenAI e muito mais.
Conclusão
Construir um classificador de aprovação de empréstimos é apenas um entre muitos exemplos de uso do ChatGPT em projetos de ciência de dados. Dá para gerar dados sintéticos, rodar queries SQL, criar relatórios analíticos, pesquisar modelos de machine learning e muito mais. A IA generativa veio para ficar — e para facilitar nosso dia a dia. Em vez de passar semanas ou meses em um projeto, você pode desenvolver, testar e fazer deploy de aplicações de ciência de dados em poucas horas.
Neste tutorial, aprendemos a usar o ChatGPT para planejamento de projeto, análise de dados, limpeza e pré-processamento, seleção de modelos, otimização de hiperparâmetros e criação e deploy de aplicações web.
Há um porém ao usar o ChatGPT: você precisa ter experiência em análise estatística e programação em Python para entender as etapas do projeto; sem isso, você fica no escuro. Comece sua jornada em ciência de dados com a trilha de carreira Data Scientist with Python e desenvolva as habilidades necessárias para se destacar como cientista de dados.
