La última versión de Bard, impulsada por el modelo PaLM 2, ofrece un mejor rendimiento en razonamiento, programación y capacidades multilingües. A diferencia de ChatGPT, debes adaptar tu entrada a Bard para obtener respuestas de alta calidad.
En este post vemos cómo sacar partido al nuevo Bard para crear un proyecto de ciencia de datos de extremo a extremo. Aprenderás a diseñar prompts eficaces que generen ideas y código para la experimentación y el desarrollo.
Lee nuestro artículo Bard vs ChatGPT para ciencia de datos para encontrar una comparación detallada entre Google Bard y ChatGPT, nuestro artículo general ChatGPT vs Google Bard, y echa un vistazo también a nuestro tutorial ChatGPT para proyectos de ciencia de datos como alternativa.
Planificación del proyecto
La fase de planificación es clave en cualquier proyecto, ya que sienta las bases de su éxito. En esta etapa analizamos con detalle los recursos disponibles y los objetivos, y desarrollamos un plan de proyecto que marca los pasos necesarios para alcanzarlos.
Para crear un esquema del proyecto, redactaremos un prompt detallado para Bard que incluya toda la información relevante sobre el desarrollo de nuestra aplicación de detección de noticias falsas. Incluirá detalles clave, como el conjunto de datos que usaremos, que es el dataset Fake News Classification del artículo WELFake, así como las directrices del proyecto que guiarán a nuestro equipo durante todo el desarrollo.
Prompt: “Actúa como Data Science Manager y desarrolla planes para un proyecto de detección de noticias falsas de extremo a extremo. Ya tenemos el dataset FakeNewsDetection con 72.134 filas y 4 columnas: [Unnamed: 0, title, text y ;abel (0 = fake y 1 = real)].”
Aunque el esquema genérico del proyecto es una buena base, faltan algunos pasos críticos. Podemos añadirlos con un prompt de seguimiento.
Prompt de seguimiento: “Añade pasos como EDA, selección de modelo, optimización de hiperparámetros, webapp en Streamlit y despliegue en Streamlit Cloud. Proporciona un plan de proyecto unificado.”
Parece que Bard no termina de entender que ya contamos con un dataset y no necesitamos la parte de recopilación de datos. Puedes escribir un prompt de seguimiento para afinar.
Prompt de seguimiento: “Ya tenemos los datos, así que elimina el paso de recopilación de datos del plan del proyecto.”
Aquí tienes el esquema del proyecto de detección de noticias falsas:
- Preprocesamiento de datos
- Análisis exploratorio de datos (EDA)
- Extracción de características
- Selección de modelo
- Optimización de hiperparámetros
- Entrenamiento y evaluación del modelo
- Webapp con Streamlit
- Despliegue en Streamlit Cloud
El plan del proyecto incluye una explicación detallada de cada paso para construir nuestra aplicación de detección de noticias falsas, así como metodologías recomendadas para optimizar resultados. Además, incorpora una agenda semanal con tareas y hitos clave.
Si te cuesta redactar prompts o te sientes abrumado, tenemos algo para ti. Descarga nuestra chuleta de prompt engineering, con más de 60 prompts creados por expertos para distintas tareas de ciencia de datos.
Bard para el preprocesamiento de datos
En este paso cargaremos, limpiaremos y haremos ingeniería de características sobre el dataset.
Carga de datos
Ahora cambiaremos el rol de Data Manager a Data Scientist para escribir un prompt que cargue los datos.
Prompt: “Actúa como un Data Scientist profesional y escribe código en Python para cargar cinco mil muestras aleatorias del dataset para el proyecto anterior.”
Nota: estamos reduciendo la muestra para entrenar y optimizar los modelos más rápido.
import pandas as pd
# Load the dataset
df = pd.read_csv("fake-news-classification/WELFake_Dataset.csv")
# Get 5 thousand random samples
df = df.sample(n=5000, random_state=42)
# Print the first 5 rows of the data
df.head()
Limpieza de datos
Para asegurarnos de que el dataset quede bien limpio y listo para el análisis, daremos a Bard instrucciones específicas sobre las funciones de limpieza necesarias.
Prompt: “Ahora, escribe una función en Python para limpiar el dataset. La función debe eliminar valores faltantes, quitar la columna \"Unnamed: 0\", limpiar el texto y eliminar stopwords.”
Para solucionar posibles bugs o errores en el código, pediremos a Bard que resuelva el error de las stopwords. Identificará el fallo y generará una versión mejorada del código.
Prompt actualizado: “Resuelve el error con las stopwords”
import nltk
nltk.download('stopwords')from nltk.corpus import stopwords
def clean_dataset(df):
# Drop missing values
df = df.dropna()
# Drop Unnamed column
df = df.drop(["Unnamed: 0"], axis=1)
# Clean text
df['text'] = df['text'].str.lower()
df["Text"] = df["Text"].str.replace("[^a-zA-Z]", " ")
# Remove stopwords
stopword = set(stopwords.words('english'))
df['text'] = df['text'].apply(lambda x: ' '.join([word for word in x.split() if word not in stopword]))
return df
df = clean_dataset(df)
df.head()Tenemos un dataset bastante limpio.
Ingeniería de características
Para que Bard genere un código óptimo, es importante dar instrucciones concretas y no preguntas genéricas. Por ejemplo, si pedimos una función específica, como “combina la longitud de ambas columnas de texto”, podrá generar un código de mayor calidad y ajustado a las necesidades del proyecto.
Prompt: “Ahora, escribe una función en Python para realizar ingeniería de características. Pasa a minúsculas la columna title y combina text y title, calcula la longitud combinada de ambas columnas de texto, cuenta las palabras únicas y más.”
def feature_engineering(df):
# Lower the title column
df['title'] = df['title'].str.lower()
# Combine text and title
df['combined'] = df['title'] + ' ' + df['text']
# Length of the combined text
df['combined_length'] = df['combined'].str.len()
# Count unique words
df['unique_words'] = df['text'].apply(lambda x: len(set(x.split())))
return df
# Perform feature engineering
df = feature_engineering(df)
# Print the first few rows of the DataFrame with the new features
df.head()Hemos creado tres nuevas características que usaremos para el análisis.
Bard para el análisis exploratorio de datos (EDA)
En la parte de EDA, pediremos a Bard que cree ciertas visualizaciones clave para explorar los datos.
Prompt: “Escribe código en Python para realizar el análisis exploratorio de datos (EDA) del proyecto anterior. Incluye un histograma que compare la longitud combinada en fake vs real, la distribución de etiquetas y una nube de palabras.”
Escribiremos un prompt de seguimiento para añadir los bordes de los bins.
Prompt de seguimiento: “Actualiza el código de EDA con `np.linspace` para crear bordes de bins de 0 a 200 con 40 de ancho de bin.”
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
bins = np.linspace(0, 200, 40)
# Histogram of the length of fake vs real news articles
plt.hist(df['combined_length'].where(df['label'] == 1),bins, alpha=0.5, label='Real')
plt.hist(df['combined_length'].where(df['label'] == 0),bins, alpha=0.5, label='Fake')
plt.xlabel('Combined Text Length')
plt.ylabel('Number of Articles')
plt.legend()
plt.show()Parece que las noticias falsas tienen una longitud de texto mayor que las reales.
# Label distribution
plt.pie(df['label'].value_counts(), labels=['Fake', 'Real'], autopct='%1.1f%%')
plt.show()La distribución de etiquetas es bastante equilibrada, así que no hace falta balancear clases.
from wordcloud import WordCloud
wc = WordCloud(max_words=100, background_color='white')
wc.generate(' '.join(df[df['label'] == 0]['combined']))
plt.imshow(wc)
plt.axis('off')
plt.title('Word cloud of fake news articles')
plt.show()
wc = WordCloud(max_words=100, background_color='white')
wc.generate(' '.join(df[df['label'] == 1]['combined']))
plt.imshow(wc)
plt.axis('off')
plt.title('Word cloud of real news articles')
plt.show()
Las noticias reales muestran palabras más destacadas como “trump” y “said” en comparación con las falsas.
Extracción de características con Bard
En esta parte, escribiremos un prompt para convertir la columna “text” en vectores y dividir el dataset en entrenamiento y prueba.
Prompt: “Convierte la columna de texto en vectores y divide el dataset en conjuntos de entrenamiento y prueba.”
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
# Convert the text column into vectors
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(df['text'])
# Split the dataset into training and testing datasets
X_train, X_test, y_train, y_test = train_test_split(X, df['label'], test_size=0.25)Bard para la selección de modelo
Con el contexto necesario ya definido, ahora puedes hacer preguntas directas.
Prompt: “Realiza la selección de modelo.”
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
# Train the models
models = [LogisticRegression(), SVC(), DecisionTreeClassifier(), RandomForestClassifier()]
for model in models:
model.fit(X_train, y_train)
# Evaluate the models
predictions = []
for model in models:
predictions.append(model.predict(X_test))
# Calculate the accuracy of the models
accuracies = []
for predictions in predictions:
accuracies.append(accuracy_score(y_test, predictions))
# Print the accuracy of the models
print("Accuracy of LogisticRegression:", accuracies[0])
print("Accuracy of SVC:", accuracies[1])
print("Accuracy of DecisionTreeClassifier:", accuracies[2])
print("Accuracy of RandomForestClassifier:", accuracies[3])Accuracy of LogisticRegression: 0.9024979854955681
Accuracy of SVC: 0.91941982272361
Accuracy of DecisionTreeClassifier: 0.8767123287671232
Accuracy of RandomForestClassifier: 0.8863819500402901
Según nuestro análisis, todos los modelos probados rinden bastante bien. Sin embargo, el modelo Support Vector Classifier (SVC) logró la mayor precisión entre los evaluados.
Ajuste de hiperparámetros con Bard
Le pedimos a Bard que escribiera un código de ajuste de hiperparámetros que guarde el mejor modelo y el vectorizador para el despliegue.
Prompt: ”Escribe código en Python para la optimización de hiperparámetros de SVC. Además, guarda el mejor modelo y el vectorizador usando Joblib.”
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score,f1_score, classification_report, confusion_matrix
import joblib
# Create a RandomForestClassifier model
svm = SVC()
# Create the hyperparameter grid
param_grid = {'C': [1, 10, 100], 'gamma': [0.01, 0.1, 1]}
# Create the GridSearchCV object
grid = GridSearchCV(SVC(), param_grid, cv=5)
# Fit the GridSearchCV object to the training data
grid.fit(X_train, y_train)
# Print the best parameters
print(grid.best_params_){'C': 10, 'gamma': 0.1}# Predict the labels of the testing data using the best model
y_pred = grid.predict(X_test)
# Calculate the accuracy of the best model
accuracy = accuracy_score(y_test, y_pred)
# Print the accuracy of the best model
print("Accuracy of the best model:", accuracy)La precisión ha mejorado ligeramente.
Accuracy of the best model: 0.9298952457695407El modelo y el vectorizador guardados se usarán para ejecutar la inferencia.
# Save the best model
joblib.dump(grid.best_estimator_, 'best_model.pkl')
# Save the TfidfVectorizer
joblib.dump(vectorizer, 'tfidf_vectorizer.pkl')Evaluación del modelo con Bard
La precisión no basta para un modelo de clasificación. Hay que evaluarlo también con f1-score, recall, precisión y la matriz de confusión.
Prompt: ”Escribe código en Python para evaluar el modelo. Incluye classification report, confusion matrix y f1 score.”
print(classification_report(y_test, y_pred))Según el informe, nuestro modelo es bastante estable en el conjunto de prueba.
precision recall f1-score support
0 0.94 0.92 0.93 620
1 0.92 0.94 0.93 621
accuracy 0.93 1241
macro avg 0.93 0.93 0.93 1241
weighted avg 0.93 0.93 0.93 1241# Plot the confusion matrix
print(confusion_matrix(y_test, y_pred))[[572 65]
[ 37 567]]# Calculate the F1 score
f1_score = f1_score(y_test, y_pred, average='weighted')
# Print the F1 score
print("F1 score:", f1_score)F1 score: 0.9298892365447746Uso de Bard para una webapp en Streamlit
Tras validar los resultados, desarrollaremos una app que convierta el texto de entrada en vectores, lo pase por un modelo y muestre el resultado.
Antes, tenemos que crear un repositorio en GitHub.
Clona el repositorio y guarda todos los componentes esenciales de la aplicación. Este paso asegura su custodia y permite versionar tanto la app como el modelo.
git clone https://github.com/kingabzpro/Fake-News-DataCamp-Project.gitEscribe un prompt genérico para desarrollar una app que prediga si una noticia es real o falsa.
Prompt: “Escribe un archivo de Python independiente para crear una web app con Streamlit que prediga si la noticia es (0 = fake o 1 = real). Incluye solo la parte de la app de Streamlit.”
A continuación, crea un archivo app.py y pega en él el código de Bard. Después, puedes ejecutar la aplicación con el comando streamlit run app.py.
Nota: asegúrate de contar con todos los paquetes de Python necesarios para ejecutar la app de Streamlit.
Parece que Bard no cargó el vectorizador. Podemos escribir un prompt de seguimiento para solucionarlo.
Prompt de seguimiento: “Añade la carga del Vectorizer y el Modelo en el archivo de la app usando joblib.”
La app no funciona bien, así que añadiremos un botón de ejecución para resolverlo.
Prompt de seguimiento: “Añade también un botón para ejecutar la inferencia.”
import streamlit as st
import joblib
# Load the vectorizer
vectorizer = joblib.load("tfidf_vectorizer.pkl")
# Load the model
model = joblib.load("best_model.pkl")
# Create a title
st.title("Predict Fake News")
# Input text
text = st.text_input("Enter the news article:")
# Button to run inference
if st.button("Predict"):
# Convert the text to a vector
vector = vectorizer.transform([text])
# Predict the label
label = model.predict(vector)[0]
# Display the label
if label == 0:
st.write("The news article is fake.")
else:
st.write("The news article is real.")Hemos creado con éxito una app en Streamlit que acepta texto y devuelve predicciones sobre la autenticidad de las noticias.
Uso de Bard para el despliegue en Streamlit Cloud
Para desplegar la app en la nube, pediremos ayuda a Bard. Resulta que solo necesitamos subir el código al repositorio de GitHub y conectarlo con el servidor de Streamlit.
Prompt: “Ayúdame a desplegar una app en Streamlit Community Cloud.”
1. Crea un archivo requirements.txt y añade todos los paquetes de Python necesarios, como “scikit-learn”.
2. Añade los archivos con Git, haz commit y push al servidor remoto. Asegúrate de incluir el modelo, el vectorizador, app.py y requirements.txt.
3. Ve a share.streamlit.io, haz clic en “New app”, selecciona el repositorio de GitHub y añade la información requerida sobre la aplicación.
Y listo. Nuestra app está desplegada y disponible públicamente en Streamlit (fake-news-detector.streamlit.app).
Conclusión
Herramientas de IA como ChatGPT, Bard y Claude nos permiten rendir al máximo en nuestras tareas diarias de ciencia de datos. Al aprovechar sus capacidades, mejoramos nuestra eficiencia y soltura, y somos capaces de abordar con facilidad retos de datos complejos.
En este post hemos explorado el potencial de la nueva versión de Bard para desarrollar proyectos de ciencia de datos integrales de extremo a extremo. También puedes consultar nuestra guía sobre usar ChatGPT en proyectos de ciencia de datos o hacer un curso completo de ChatGPT: Introduction to ChatGPT, y descubrir buenas prácticas para redactar prompts.
