Google Bard pour les projets de data science

La dernière version de Bard, propulsée par le modèle PaLM 2, améliore les performances en raisonnement, en code et en multilingue. Contrairement à ChatGPT, vous devez adapter vos consignes à Bard pour obtenir des réponses de haute qualité.

Cet article explique comment tirer parti du nouveau Bard pour construire un projet de data science de bout en bout. Vous apprendrez à formuler des prompts efficaces pour générer des idées et du code pour l’expérimentation et le développement.

Lisez notre article Bard vs ChatGPT pour la data science pour une comparaison détaillée entre Google Bard et ChatGPT, notre article général ChatGPT vs Google Bard, et découvrez aussi notre tutoriel ChatGPT pour les projets de data science pour une autre approche.

Planification du projet

La phase de planification est essentielle dans tout projet, car elle en conditionne la réussite. Durant cette étape, nous analysons les ressources et objectifs disponibles et élaborons un plan décrivant les étapes à suivre pour atteindre nos buts.

Pour créer une trame de projet, nous allons formuler un prompt détaillé pour Bard incluant toutes les informations pertinentes pour développer notre application de détection des fake news. Il intégrera des détails clés, comme le jeu de données que nous utiliserons — le dataset Fake News Classification issu de l’article WELFake — ainsi que des directives qui guideront l’équipe tout au long du développement.

Prompt : \«\ Agissez en tant que Data Science Manager et définissez un plan pour un projet de détection des fake news de bout en bout. Nous disposons déjà du dataset FakeNewsDetection comprenant 72 134 lignes et 4 colonnes : [Unnamed: 0, title, text, et label (0 = fake, 1 = real)].\ \»

Bien que la trame générique pose de bonnes bases, quelques étapes clés manquent. Nous pouvons les ajouter via un prompt de suivi.

Prompt de suivi : \«\ Ajoutez des étapes comme l’EDA, la sélection de modèle, l’optimisation des hyperparamètres, une webapp Streamlit et un déploiement sur Streamlit Cloud. Proposez un plan de projet consolidé.\ \»

Il semble que Bard n’ait pas compris que nous avons déjà un jeu de données et que la collecte n’est pas nécessaire. Vous pouvez écrire un prompt de suivi pour affiner la proposition.

Prompt de suivi : \«\ Nous disposons déjà des données, supprimez l’étape de collecte dans le plan de projet.\ \»

Voici la trame du projet de détection des fake news :

\n
1. Prétraitement des données
\n
2. Analyse exploratoire des données (EDA)
\n
3. Extraction de features
\n
4. Sélection de modèle
\n
5. Optimisation des hyperparamètres
\n
6. Entraînement et évaluation du modèle
\n
7. Webapp Streamlit
\n
8. Déploiement sur Streamlit Cloud
\n

Le plan de projet inclut une explication détaillée de chaque étape pour construire notre application de détection des fake news, ainsi que des méthodes recommandées pour optimiser les résultats. Il propose également un agenda hebdomadaire précisant tâches clés et jalons.

Si la rédaction de prompts vous pose problème ou vous paraît fastidieuse, pas d’inquiétude. Téléchargez notre antisèche de prompt engineering, qui donne accès à plus de 60 prompts conçus par des experts pour différents travaux de data science.

Bard pour le prétraitement des données

À cette étape, nous allons charger, nettoyer et réaliser de l’ingénierie des features sur le dataset.

Chargement des données

Changez maintenant de personnage : passez de Data Manager à Data Scientist pour rédiger un prompt de chargement des données.

Prompt : \«\ Agissez en Data Scientist confirmé et écrivez du code Python pour charger cinq mille échantillons aléatoires depuis le dataset du projet ci‑dessus.\ \»

Remarque : nous réduisons l’échantillon pour entraîner et optimiser les modèles plus rapidement.

import pandas as pd\n\n# Load the dataset\ndf = pd.read_csv(\"fake-news-classification/WELFake_Dataset.csv\")\n\n# Get 5 thousand random samples\ndf = df.sample(n=5000, random_state=42)\n\n# Print the first 5 rows of the data\ndf.head()Propulsé par

Nettoyage des données

Pour garantir un dataset propre et prêt pour l’analyse, nous allons donner à Bard des instructions précises sur les fonctions de nettoyage requises.

Prompt : \«\ Écrivez une fonction Python pour nettoyer le dataset. La fonction doit supprimer les valeurs manquantes, retirer la colonne \"Unnamed: 0\", nettoyer le texte et enlever les stopwords.\ \»

Pour corriger d’éventuels bogues ou erreurs, nous allons demander à Bard de résoudre l’erreur liée aux stopwords. Il comprendra le problème et proposera une version améliorée du code.

Prompt mis à jour : \«\ Résolvez l’erreur avec les stopwords.\ \»

import nltk\nnltk.download('stopwords')Propulsé par

from nltk.corpus import stopwords\n\ndef clean_dataset(df):\n\n  # Drop missing values\n  df = df.dropna()\n    \n  # Drop Unnamed column\n  df = df.drop([\"Unnamed: 0\"], axis=1)\n\n  # Clean text\n  df['text'] = df['text'].str.lower()\n  df[\"Text\"] = df[\"Text\"].str.replace(\"[^a-zA-Z]\", \" \")\n\n  # Remove stopwords\n  stopword = set(stopwords.words('english'))\n  df['text'] = df['text'].apply(lambda x: ' '.join([word for word in x.split() if word not in stopword]))\n\n  return df\n\ndf = clean_dataset(df)\ndf.head()Propulsé par

Nous avons désormais un dataset plutôt propre.

Ingénierie des features

Pour que Bard génère un code optimal, mieux vaut donner des consignes précises plutôt que des questions vagues. Par exemple, si nous demandons à Bard d’exécuter une fonction spécifique, comme \«\ combiner la longueur des deux colonnes de texte\ \», il produira un code de meilleure qualité, adapté aux besoins du projet.

Prompt : \«\ Écrivez maintenant une fonction Python pour effectuer de l’ingénierie des features. Mettez la colonne title en minuscules et combinez text et title, calculez la longueur du texte combiné, comptez les mots uniques, etc.\ \»

def feature_engineering(df):\n\n  # Lower the title column\n  df['title'] = df['title'].str.lower()\n\n  # Combine text and title\n  df['combined'] = df['title'] + ' ' + df['text']\n\n  # Length of the combined text\n  df['combined_length'] = df['combined'].str.len()\n\n  # Count unique words\n  df['unique_words'] = df['text'].apply(lambda x: len(set(x.split())))\n\n  return df\n\n# Perform feature engineering\ndf = feature_engineering(df)\n\n# Print the first few rows of the DataFrame with the new features\ndf.head()Propulsé par

Nous avons créé trois nouvelles features que nous utiliserons pour l’analyse.

Bard pour l’analyse exploratoire (EDA)

Pour l’EDA, nous demanderons à Bard de créer certaines visualisations indispensables à l’exploration des données.

Prompt : \«\ Écrivez du code Python pour réaliser l’EDA du projet ci‑dessus. Incluez un histogramme comparant la longueur du texte combiné fake vs real, la distribution des labels et un nuage de mots.\ \»

Nous allons ajouter un prompt de suivi pour définir les bornes des classes.

Prompt de suivi : \«\ Mettez à jour le code EDA avec `np.linspace` pour créer des intervalles de 0 à 200 avec 40 classes.\ \»

import matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\n\nbins = np.linspace(0, 200, 40)\n# Histogram of the length of fake vs real news articles\nplt.hist(df['combined_length'].where(df['label'] == 1),bins, alpha=0.5, label='Real')\nplt.hist(df['combined_length'].where(df['label'] == 0),bins, alpha=0.5, label='Fake')\nplt.xlabel('Combined Text Length')\nplt.ylabel('Number of Articles')\nplt.legend()\nplt.show()Propulsé par

Il semble que les fake news aient une longueur de texte supérieure aux articles réels.

# Label distribution\nplt.pie(df['label'].value_counts(), labels=['Fake', 'Real'], autopct='%1.1f%%')\nplt.show()Propulsé par

La distribution des labels est assez équilibrée ; il n’est pas nécessaire d’appliquer un rééquilibrage de classes.

from wordcloud import WordCloud\n\nwc = WordCloud(max_words=100, background_color='white')\nwc.generate(' '.join(df[df['label'] == 0]['combined']))\nplt.imshow(wc)\nplt.axis('off')\nplt.title('Word cloud of fake news articles')\nplt.show()Propulsé par

wc = WordCloud(max_words=100, background_color='white')\nwc.generate(' '.join(df[df['label'] == 1]['combined']))\nplt.imshow(wc)\nplt.axis('off')\nplt.title('Word cloud of real news articles')\nplt.show()Propulsé par

Les articles réels mettent davantage en avant des mots comme \«\ trump\ \» et \«\ said\ \» que les fake news.

Extraction de features avec Bard

Ici, nous allons écrire un prompt pour convertir la colonne \«\ text\ \» en vecteurs et scinder le dataset en ensembles d’entraînement et de test.

Prompt : \«\ Convertissez la colonne text en vecteurs et découpez le dataset en jeux d’entraînement et de test.\ \»

from sklearn.feature_extraction.text import TfidfVectorizer\nfrom sklearn.model_selection import train_test_split\n\n# Convert the text column into vectors\nvectorizer = TfidfVectorizer()\nX = vectorizer.fit_transform(df['text'])\n\n# Split the dataset into training and testing datasets\nX_train, X_test, y_train, y_test = train_test_split(X, df['label'], test_size=0.25)Propulsé par

Bard pour la sélection de modèle

Maintenant que le contexte est posé, vous pouvez poser des questions directes.

Prompt : \«\ Procédez à la sélection de modèle.\ \»

from sklearn.linear_model import LogisticRegression\nfrom sklearn.svm import SVC\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.metrics import accuracy_score\n\n# Train the models\nmodels = [LogisticRegression(), SVC(), DecisionTreeClassifier(), RandomForestClassifier()]\nfor model in models:\n    model.fit(X_train, y_train)\n\n# Evaluate the models\npredictions = []\nfor model in models:\n    predictions.append(model.predict(X_test))\n\n# Calculate the accuracy of the models\naccuracies = []\nfor predictions in predictions:\n    accuracies.append(accuracy_score(y_test, predictions))\n\n# Print the accuracy of the models\nprint(\"Accuracy of LogisticRegression:\", accuracies[0])\nprint(\"Accuracy of SVC:\", accuracies[1])\nprint(\"Accuracy of DecisionTreeClassifier:\", accuracies[2])\nprint(\"Accuracy of RandomForestClassifier:\", accuracies[3])Propulsé par

Accuracy of LogisticRegression: 0.9024979854955681\nAccuracy of SVC: 0.91941982272361\nAccuracy of DecisionTreeClassifier: 0.8767123287671232\nAccuracy of RandomForestClassifier: 0.8863819500402901\nPropulsé par

D’après notre analyse, tous les modèles testés s’en sortent correctement. Toutefois, le Support Vector Classifier (SVC) obtient la meilleure précision parmi les modèles évalués.

Réglage des hyperparamètres avec Bard

Nous avons demandé à Bard d’écrire du code d’optimisation des hyperparamètres qui enregistre le meilleur modèle et l’objet vectorizer pour le déploiement.

Prompt : \«\ Écrivez du code Python pour l’optimisation des hyperparamètres de SVC. Enregistrez aussi le meilleur modèle et le vectorizer avec Joblib.\ \»

from sklearn.svm import SVC\nfrom sklearn.model_selection import GridSearchCV\nfrom sklearn.metrics import accuracy_score,f1_score, classification_report, confusion_matrix\n\nimport joblib\n\n# Create a RandomForestClassifier model\nsvm = SVC()\n\n# Create the hyperparameter grid\nparam_grid = {'C': [1, 10, 100], 'gamma': [0.01, 0.1, 1]}\n\n# Create the GridSearchCV object\ngrid = GridSearchCV(SVC(), param_grid, cv=5)\n\n\n# Fit the GridSearchCV object to the training data\ngrid.fit(X_train, y_train)\n\n# Print the best parameters\nprint(grid.best_params_)Propulsé par

{'C': 10, 'gamma': 0.1}Propulsé par

# Predict the labels of the testing data using the best model\ny_pred = grid.predict(X_test)\n\n# Calculate the accuracy of the best model\naccuracy = accuracy_score(y_test, y_pred)\n\n# Print the accuracy of the best model\nprint(\"Accuracy of the best model:\", accuracy)Propulsé par

La précision s’est légèrement améliorée.

Accuracy of the best model: 0.9298952457695407Propulsé par

Le modèle et le vectorizer enregistrés seront utilisés pour l’inférence.

# Save the best model\njoblib.dump(grid.best_estimator_, 'best_model.pkl')\n# Save the TfidfVectorizer\njoblib.dump(vectorizer, 'tfidf_vectorizer.pkl')Propulsé par

Évaluation du modèle avec Bard

La précision ne suffit pas pour un modèle de classification. Il faut aussi mesurer le f1‑score, le recall, la precision et la matrice de confusion.

Prompt : \«\ Écrivez du code Python pour l’évaluation du modèle. Incluez un classification report, une confusion matrix et le f1 score.\ \»

print(classification_report(y_test, y_pred))Propulsé par

D’après le rapport, notre modèle est assez stable sur le jeu de test.

              precision    recall  f1-score   support\n\n           0       0.94      0.92      0.93       620\n           1       0.92      0.94      0.93       621\n\n    accuracy                           0.93      1241\n   macro avg       0.93      0.93      0.93      1241\nweighted avg       0.93      0.93      0.93      1241Propulsé par

# Plot the confusion matrix\nprint(confusion_matrix(y_test, y_pred))Propulsé par

[[572  65]\n [ 37 567]]Propulsé par

# Calculate the F1 score\nf1_score = f1_score(y_test, y_pred, average='weighted')\n\n# Print the F1 score\nprint(\"F1 score:\", f1_score)Propulsé par

F1 score: 0.9298892365447746Propulsé par

Utiliser Bard pour une webapp Streamlit

Une fois satisfaits des résultats, nous allons développer une application qui convertit le texte saisi en vecteur, le passe au modèle et affiche le résultat.

Avant cela, nous devons créer un dépôt GitHub.

Clonez le dépôt et enregistrez tous les composants essentiels de l’application. Cette étape garantit leur conservation et facilite le versioning de l’app et du modèle.

git clone https://github.com/kingabzpro/Fake-News-DataCamp-Project.gitPropulsé par

Rédigez un prompt générique pour développer une app qui prédit si une news est réelle ou fausse.

Prompt : \«\ Écrivez un fichier Python séparé pour créer une web app avec Streamlit afin de prédire si une news est (0 = fake, 1 = real). Incluez uniquement la partie app Streamlit.\ \»

Créez ensuite un fichier app.py et collez-y le code généré par Bard. Une fois fait, lancez l’application avec la commande streamlit run app.py.

Remarque : assurez-vous de disposer de tous les packages Python requis pour exécuter l’app Streamlit.

On dirait que Bard n’a pas chargé le vectorizer. Nous pouvons écrire un prompt de suivi pour corriger cela.

Prompt de suivi : \«\ Ajoutez le chargement du Vectorizer et du Model dans le fichier de l’app via joblib.\ \»

L’app ne fonctionne pas correctement ; ajoutons un bouton d’exécution pour résoudre ce point.

Prompt de suivi : \«\ Ajoutez aussi un bouton pour lancer l’inférence.\ \»

import streamlit as st\nimport joblib\n\n# Load the vectorizer\nvectorizer = joblib.load(\"tfidf_vectorizer.pkl\")\n\n# Load the model\nmodel = joblib.load(\"best_model.pkl\")\n\n# Create a title\nst.title(\"Predict Fake News\")\n\n# Input text\ntext = st.text_input(\"Enter the news article:\")\n\n# Button to run inference\nif st.button(\"Predict\"):\n\n    # Convert the text to a vector\n    vector = vectorizer.transform([text])\n\n    # Predict the label\n    label = model.predict(vector)[0]\n\n    # Display the label\n    if label == 0:\n        st.write(\"The news article is fake.\")\n    else:\n        st.write(\"The news article is real.\")Propulsé par

Nous avons construit avec succès une app Streamlit qui accepte un texte en entrée et prédit l’authenticité des articles de presse.

Utiliser Bard pour le déploiement sur Streamlit Cloud

Pour déployer l’app dans le cloud, demandons l’aide de Bard. Il suffit de pousser notre code vers le dépôt GitHub et de le connecter au serveur Streamlit.

Prompt : \«\ Aidez‑moi à déployer une app sur Streamlit Community Cloud.\ \»

1. Créez un fichier requirements.txt et ajoutez tous les packages Python nécessaires, comme \«\ scikit-learn\ \».

2. Ajoutez les fichiers avec Git, validez (commit) et poussez vers le serveur distant. Assurez‑vous d’avoir inclus le modèle, le vectorizer, app.py et requirements.txt.

3. Rendez‑vous sur share.streamlit.io, cliquez sur \«\ New app\ \», sélectionnez le dépôt GitHub et renseignez les informations requises sur l’application.

Et voilà. Notre app est déployée et accessible au public sur Streamlit (fake-news-detector.streamlit.app).

Conclusion

Des outils d’IA comme ChatGPT, Bard et Claude nous aident à exceller dans nos tâches quotidiennes de data science. En tirant parti de leurs capacités, nous gagnons en efficacité et en maîtrise, et abordons plus sereinement des problèmes de données complexes.

Dans cet article, nous avons exploré la puissance de la nouvelle version de Bard pour développer des projets de data science complets, de bout en bout. Vous pouvez aussi consulter notre guide Utiliser ChatGPT pour les projets de data science ou suivre un cours complet sur ChatGPT : Introduction to ChatGPT, et découvrir les bonnes pratiques pour rédiger des prompts.