Certificación disponible
Course
Introducción a ChatGPT
1 hr
195.9K
Guía para utilizar ChatGPT en proyectos de ciencia de datos
Aprende a utilizar ChatGPT en un proyecto real de ciencia de datos de extremo a extremo. Lo utilizaremos para la planificación del proyecto, el análisis de datos, el preprocesamiento de datos, la selección del modelo, el ajuste de hiperparámetros, el desarrollo de una aplicación web y su despliegue en los Spaces.
Actualizado 11 sept 2024 · 17 min leer
Todos conocemos la popularidad de ChatGPT y cómo la gente lo utiliza para aumentar su productividad. Pero si eres nuevo, vale la pena que te registres en una demo gratuita de ChatGPT y experimentes todo lo que puede hacer. También deberías seguir nuestro curso Introducción a ChatGPT para aprender las mejores prácticas para elaborar avisos eficaces y explorar casos de uso empresarial comunes para aprovechar esta potente herramienta de IA.
En este tutorial, aprenderemos cómo podemos utilizar ChatGPT para trabajar en un proyecto de ciencia de datos de principio a fin. Utilizaremos varias indicaciones para crear un esquema de proyecto, escribir código Python, investigar y depurar la aplicación. Además, aprenderemos consejos para escribir mensajes ChatGPT eficaces. Si te intriga utilizar la IA para distintos fines, consulta nuestra guía sobre proyectos de inteligencia artificial para todos los niveles.
Utilizar ChatGPT para un proyecto integral de ciencia de datos
En el proyecto, utilizaremos Datos de Préstamo de DataLab y planificaremos el proyecto de ciencia de datos en torno a ellos.
ChatGPT hace el 80 por ciento del trabajo aquí, sólo tenemos que dominar la ingeniería rápida para hacerlo todo bien, y para eso, tenemos nuestra increíble ChatGPT Cheat Sheet for Data Science. Viene con más de 60 preguntas ChatGPT para tareas de ciencia de datos basadas en SQL, R y Python.
Planificación de proyectos
Es la parte más importante del proyecto, en la que examinamos los recursos disponibles y los objetivos para elaborar una estrategia óptima.
Puedes ir a chat.openai.com e iniciar un nuevo chat. Después, mencionaremos el conjunto de datos de préstamos disponible y pediremos a ChatGPT que proponga los pasos para construir un proyecto de cartera genérica de extremo a extremo.
Prompt: "Tengo un conjunto de datos de préstamos que consta de 9500 filas y 14 columnas: ['póliza.crédito', 'finalidad', 'tipo.int', 'cuota', 'log.anual.inc','dti', 'fico', 'days.with.cr.line', 'revol.bal', 'revol.util', 'inq.last.6mths", "delinq.2yrs", "pub.rec", "not.fully.paid"]. ¿Puedes enumerar los pasos que tengo que seguir para desarrollar un proyecto integral para mi cartera?".
Conseguimos la lista, pero olvidamos mencionar el problema del desequilibrio de clases y el objetivo del proyecto, que es predecir con exactitud el "préstamo no devuelto".
Prompt actualizado: "Por favor, incluye cuestiones de desequilibrio de clases y predice con exactitud si un préstamo no se devolverá en lugar de si se devuelve".
De nuevo, no estamos interesados en la supervisión de modelos, y queremos crear una aplicación Gradio y desplegarla en Huggingface Spaces.
Prompt actualizado: "Crearemos una aplicación web utilizando Gradio y la desplegaremos en Spaces y no supervisaremos el modelo en la producción".
Gif de Autor | Lista final de los pasos de un proyecto
Obtuvimos una lista de 9 pasos, como se muestra arriba, y una explicación detallada de cómo debemos abordar cada paso.
Esta es la lista de tareas que vamos a seguir en este tutorial:
- Limpieza y preprocesamiento de datos. Tratar los valores que faltan, convertir las variables categóricas en variables numéricas, escalar/normalizar los datos y tratar cualquier valor atípico o anomalía en los datos. Además, querrás abordar el problema del desequilibrio de clases sobremuestreando la clase minoritaria (préstamos que no están totalmente pagados) o submuestreando la clase mayoritaria (préstamos que están totalmente pagados).
- Análisis exploratorio de datos (AED). Explorar el conjunto de datos para comprenderlos mejor, como las distribuciones de las variables, las correlaciones entre variables y la identificación de patrones en los datos.
- Ingeniería de funciones. Crear nuevas características o transformar las existentes para mejorar el poder predictivo del modelo.
- Selección de modelo. Prueba varios modelos, como árboles de decisión, bosques aleatorios, regresión logística o máquinas de vectores de soporte (SVM).
- Formación y evaluación de modelos. Entrenar el modelo seleccionado en los datos y evaluar su rendimiento utilizando varias métricas como la exactitud, la precisión, la recuperación y la puntuación F1.
- Ajuste de hiperparámetros. Afinar los hiperparámetros del modelo seleccionado para mejorar su rendimiento.
- Crear la aplicación web con Gradio. Una vez que hayas seleccionado el mejor modelo, puedes crear una aplicación web utilizando Gradio.
- Despliega la aplicación web en Spaces. Una vez que hayas creado la aplicación web con Gradio, puedes desplegarla en Spaces.
- Probar la aplicación web. Pruébalo para asegurarte de que funciona como es debido.
Análisis Exploratorio de Datos (AED)
El análisis exploratorio de datos consiste en la manipulación de datos, el análisis estadístico y la visualización de datos. Podemos completarlo escribiendo una indicación de seguimiento sobre la escritura de código Python para el análisis exploratorio de datos en nuestro conjunto de datos.
Pregunta de seguimiento: "Por favor, escribe un código Python para cargar y realizar un análisis exploratorio de datos (AED) en el conjunto de datos del préstamo"
El robot entenderá el contexto y propondrá código Python con comentarios y una explicación detallada de cómo funciona.
Gif de Autor | Código Python para EDA
- Cargar y mostrar el conjunto de datos como marco de datos 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()
- Mostrar el número de filas y columnas y el resumen estadístico de las variables 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- Mostrar los valores que faltan en cada columna. Como podemos ver, no tenemos ninguno.
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- Visualización de la distribución de la variable objetivo "no.totalmente.pagado"
sns.countplot(x="not.fully.paid", data=loan_df)
plt.show()
- Visualizar la correlación entre variables.
corr = loan_df.corr()
sns.heatmap(corr, annot=True, cmap="coolwarm")
plt.show()
- Comprender la distribución de la finalidad del préstamo.
sns.countplot(x="purpose", data=loan_df)
plt.xticks(rotation=90)
plt.show()
- Comprender la distribución de los tipos de interés según la finalidad del préstamo.
sns.boxplot(x="purpose", y="int.rate", data=loan_df)
plt.xticks(rotation=90)
plt.show()Ingeniería de funciones
En lugar de preprocesar y limpiar los datos, realizaremos ingeniería de rasgos para simplificar la tarea de preprocesado.
Pregunta de seguimiento: "Escribe un código Python para realizar ingeniería de características"
Conseguimos la solución correcta, pero incluía código irrelevante, así que tuvimos que escribir un aviso de actualización para modificar el código.
Pregunta actualizada: "añade sólo la parte de ingeniería de características".
# 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 sugerido dos nuevas funciones: "relación cuota_a_ingreso" e "historial_crédito".
Preprocesamiento y Equilibrio de los Datos
De nuevo, ChatGPT conoce el contexto del proyecto. No tenemos que volver a explicarlo todo. Así que simplemente le pediremos que escriba un código Python para limpiar y preprocesar los datos.
Pregunta de seguimiento: "Ahora escribe un código python para limpiar y preprocesar el conjunto de datos"
- Eliminando columnas innecesarias y convirtiendo las variables categóricas en 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'])- Escala los rasgos numéricos utilizando el Escalador estándar.
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])- Tratamiento del desequilibrio de clases mediante el método de sobremuestreo de 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 vemos, hemos conseguido equilibrar la clase.
0 8045
1 8045
Name: not.fully.paid, dtype: int64Selección del modelo
En esta parte, hemos pedido a ChatGPT que entrene los datos en varios modelos para una tarea de selección de modelos.
Pregunta de seguimiento: " Escribe un código python de seguimiento para la selección de modelos. Prueba con árboles de decisión, bosques aleatorios, regresión logística o máquinas de vectores de soporte (SVM). Nota: incluye sólo la parte de selección de modelo".
Ha generado el script Python para dividir el conjunto de datos en uno de entrenamiento y otro de prueba, y entrenar el conjunto de datos en modelos especificados para mostrar las métricas de precisión.
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))El algoritmo Random Forest ha superado significativamente a los demás modelos.
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 y evaluación de modelos
Seleccionaremos el modelo con mejores resultados y realizaremos la evaluación del modelo. Hemos especificado el uso de la exactitud, la precisión, el recuerdo y la puntuación F1 como métricas y la validación cruzada para garantizar la estabilidad del modelo.
Pregunta de seguimiento: " Selecciona RandomForestClassifier y escribe un código python para la evaluación del modelo. Utiliza la exactitud, la precisión, la recuperación y la puntuación F1 como métrica y la validación cruzada para asegurarte de que el modelo no se ajusta en exceso a los datos de entrenamiento".
Actualizaremos el Python para añadir tareas de ajuste de hiperparámetros y guardar el modelo de mejor rendimiento.
Pregunta actualizada: "incluye también el ajuste de hiperparámetros en el código anterior y guarda el modelo de mejor rendimiento"
La versión final del código utiliza GridSearchCV para el ajuste de hiperparámetros con cinco divisiones de validación cruzada y utiliza la métrica f1 para la evaluación con el fin de encontrar los mejores hiperparámetros.
Después, ChatGPT añadió automáticamente el código para seleccionar el mejor modelo para la evaluación del modelo en el conjunto de pruebas y mostró los hiperparámetros de mejor rendimiento.
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)Tenemos un modelo estable con una puntuación de 89,35 de precisión. Tanto la precisión como la recuperación son similares.
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}Al final, guardaremos el modelo utilizando joblib.
import joblib
# Save the best model to disk
joblib.dump(best_model, 'loan_classifier.joblib')Puedes encontrar el código fuente con los resultados en este libro de trabajo de DataLab; puedes crear fácilmente tu propia copia para editar y ejecutar el código en el navegador, todo ello sin tener que instalar nada en tu ordenador.
Crear una Web App con Gradio
Ahora viene la parte más divertida. Sólo utilizaremos indicaciones para crear una aplicación web totalmente personalizable que tomará datos numéricos y mostrará los resultados utilizando un modelo de aprendizaje automático.
ChatGPT ya conoce el contexto, así que sólo tenemos que pedirle que escriba una aplicación web de Gradio para el clasificador de datos de préstamos.
Pregunta de seguimiento: "Escribe el código Python para crear una aplicación web Gradio para clasificadores de datos de préstamos. No estamos utilizando las columnas ['política.de.crédito', 'días.con.línea.cr', 'finalidad']".
Pide a ChatGPT que sólo incluya la parte de la app Gradio en lugar de la formación y luego el script de inferencia.
Pregunta actualizada: "sólo incluye la parte de la aplicación gradio".
El código que tenemos muestra la probabilidad de clase predictiva, y nosotros queremos mostrar las etiquetas de clasificación.
Pregunta actualizada: "modifica el código para mostrar la clasificación en lugar de las probabilidades de clase".
Tras ejecutar el código, hemos visto múltiples advertencias y errores. Puedes mejorarlo mencionando los errores a ChatGPT.
Tenemos que comprender las limitaciones del ChatGPT. Se entrenó con un conjunto de datos antiguo, y si esperas que actualice el código con la API más reciente, te darás contra la pared. En su lugar, debemos leer la documentación de Gradio y actualizar el código manualmente.
Pregunta fallida: "actualiza el código de Gradio con el componente de gradio.components"
En la app Gradio, estamos cargando el modelo guardado y obteniendo las entradas de los usuarios para mostrar las predicciones del modelo.
Aprende cómo funciona Gradio leyendo los Documentos de Gradio.
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()Puedes guardar el código anterior en el archivo `app.py` e iniciar la aplicación en el navegador ejecutando el script `python app.py` en el terminal.
Gif de Autor | Aplicación clasificadora de aprobación de préstamos
Aunque nuestra aplicación funciona bien, ChatGPT ha pasado completamente por alto que hemos escalado las características numéricas. Así, en lugar de pedir que se actualice el código, puedes volver atrás y guardar los parámetros escalares estándar.
scalar = joblib.load('std_scaler.bin')Después, carga el escalar en tu aplicación utilizando joblib.
input_array = [list(input_dict.values())]
scaled_array = scalar.transform(input_array)
prediction = model.predict(scaled_array)[0]Entonces, ¿por qué lo hacemos manualmente? Si le pides a ChatGPT que modifique una sola línea, podría modificar todo el código e incluso los nombres de las variables.
Sí, ChatGPT no es perfecto, y nunca sustituirá a un desarrollador.
Desplegar la aplicación web en Spaces
Sólo tienes que pedir a ChatGPT que te enseñe la forma sencilla de desplegar una aplicación gradio en Hugging Face Spaces, y te indicará los pasos necesarios.
Pregunta: "cómo desplegar la aplicación gradio en los espacios huggingface".
- Ve al sitio web de Hugging Face y haz clic en tu foto de perfil, arriba a la izquierda, para seleccionar la opción "Nuevo espacio".
Imagen del autor
- Añade el nombre y el tipo de licencia para crear el repositorio de aplicaciones.
- Haz clic en la pestaña Archivos y Versiones > + Añadir archivo > Subir archivos para añadir archivos al repositorio.
- Arrastra los archivos app.py, model y scaler y haz clic en el botón "Commit change to main'' y guarda el commit con un mensaje de commit. Similar a Git.
Imagen del autor
Si te encuentras con un error de ejecución, es porque olvidaste añadir también el archivo requirements.txt. Selecciona la pestaña Archivos y versiones > + Añadir archivo > Crea un nuevo archivo y añade el nombre del archivo y las bibliotecas Python con las versiones, como se muestra a continuación.
Imagen del autor
Tu aplicación está lista. Puedes cambiar la entrada mediante controles deslizantes y predecir si el cliente debe obtener un préstamo o no.
Puedes probar la demostración en vivo en un Espacio Cara Abrazada por kingabzpro.
Imagen del Autor | Clasificador de Préstamos
Consejos para escribir prompts de ChatGPT eficaces
La ingeniería Prompt es complicada cuando se trata de utilizarla en proyectos de la vida real. Tenemos que entender las normas sobre lo que podemos hacer o dónde tenemos que intervenir para corregir el ChatGPT.
Aquí tienes algunos consejos sobre cómo puedes mejorar tu experiencia con ChatGPT sin comprometer el proyecto.
- Escribe siempre indicaciones claras y concisas. Asegúrate de explicarlo todo con detalle sobre lo que necesitas al principio.
- Crea un historial de un proyecto. ChatGPT es un chatbot, así que para que comprenda eficazmente el contexto, necesitas establecer la historia.
- Sigue intentándolo. No hay una forma estándar de escribir los avisos. Tienes que empezar con un estímulo base y seguir mejorando los trajes escribiendo estímulos de actualización de seguimiento.
- Menciona los errores de código. Si ejecutas el código en tu máquina local y da error, intenta mencionar el error en el indicador de seguimiento. ChatGPT aprenderá inmediatamente del error e ideará una solución mejor.
- Realiza los cambios manualmente. ChatGPT se entrenó con datos antiguos, y si esperas que se le ocurra una idea o un nuevo comando API, te decepcionará. Intenta hacer cambios manuales en tu código siempre que sea posible, porque el código generado no es perfecto.
- Utilízalo para tareas comunes. Hay más posibilidades de éxito con ChatGPT si pides tareas comunes.
- Utilízalo para aprender algo nuevo. Pide siempre a ChatGPT que te explique cosas nuevas o tutoriales sobre "cómo hacer". Te proporcionará una lista de pasos sencillos que te permitirán realizar el trabajo. Es bastante útil si tienes dificultades de aprendizaje.
Si estás interesado en ChatGPT y la API OpenAI, inscríbete en el seminario web: Primeros pasos con la API OpenAI y ChatGPT. Aprenderás a realizar tareas de generación de lenguaje y código utilizando la API OpenAI y mucho más.
Conclusión
Desarrollar un clasificador de aprobación de préstamos es uno de los muchos ejemplos de uso de ChatGPT para proyectos de ciencia de datos. Podemos utilizarlo para generar datos sintéticos, ejecutar consultas SQL, crear informes de análisis de datos, realizar investigaciones de aprendizaje automático y mucho más. La IA generativa ha llegado para quedarse, y nos hará la vida más fácil. En lugar de dedicar semanas y meses a un proyecto, puedes desarrollar, probar y desplegar aplicaciones de ciencia de datos en horas.
En este tutorial, hemos aprendido a utilizar ChatGPT para la planificación de proyectos, el análisis de datos, la limpieza y el preprocesamiento de datos, la selección de modelos, la optimización de hiperparámetros y la creación y despliegue de aplicaciones web.
Utilizar ChatGPT tiene truco. Necesitas tener experiencia con el análisis estadístico y la codificación en Python para comprender las distintas tareas del proyecto; sin ella, caminas a ciegas. Comienza tu andadura en la ciencia de datos cursando la carrera de Científico de Datos con Python y adquiere las habilidades que necesitas para tener éxito como científico de datos.
Curso ChatGPT
Aprende a utilizar ChatGPT. Descubre las mejores prácticas para redactar avisos y explora casos de uso empresarial habituales para la potente herramienta de IA.
Ver más