Tutoriel d’analyse exploratoire des données en Python

Comme vous le savez désormais, la bibliothèque Python de manipulation de données pandas sert à transformer les données. Pour celles et ceux qui débutent, cela peut laisser penser que ce package n’est utile que pour le prétraitement. En réalité, c’est loin d’être le cas : pandas est aussi excellent pour explorer vos données et les stocker une fois le prétraitement terminé.

En complément, si vous avez suivi les tutoriels Python de DataCamp ou si vous avez déjà été initié aux bases de SciPy, NumPy, Matplotlib et pandas, il peut être utile de réviser certaines notions acquises.

Le tutoriel du jour va vous présenter des méthodes pour explorer efficacement vos données avec les packages cités afin que vous puissiez commencer à modéliser :

Vous apprendrez d’abord à importer des données, première étape indispensable avant toute analyse.
Si vous n’êtes pas certain de ce qu’est l’analyse exploratoire des données (EDA) et de la différence exacte avec le data mining, cette section vous l’expliquera avant de poursuivre !
Vous obtiendrez ensuite une description de base de vos données : statistiques descriptives, aperçu des premières et dernières lignes du DataFrame, extraction d’échantillons, etc. C’est une excellente manière de se familiariser rapidement avec le jeu de données et de mieux le comprendre.
Après cette première collecte d’informations, il est pertinent d’aller plus loin en interrogeant ou en indexant les données. Cette technique permet de tester des hypothèses simples que vous avez sur le jeu de données.
Une fois les données inspectées, vous repèrerez probablement certaines features utiles à votre analyse : vous verrez lesquelles peuvent l’améliorer grâce au feature engineering et à la sélection de variables.
Vous verrez ensuite qu’une première exploration est nécessaire mais insuffisante : il faut aussi connaître les défis que posent vos données (valeurs manquantes, valeurs aberrantes, etc.) et, bien sûr, comment les traiter, et
Enfin, vous apprendrez à mettre au jour des motifs dans vos données, soit en les visualisant rapidement avec Matplotlib et Bokeh, soit en calculant la corrélation entre attributs via des fonctions dédiées.

Envie de suivre une formation sur pandas ? Découvrez notre cours Data Manipulation with pandas !

Importer les données

Pour commencer l’exploration, il faut d’abord charger vos données. Grâce à la bibliothèque pandas, c’est très simple : importez le package sous pd (convention courante) et utilisez la fonction read_csv() en lui passant l’URL où se trouvent les données ainsi qu’un argument header. Ce dernier permet de s’assurer que la lecture est correcte : la première ligne ne sera pas interprétée comme les noms de colonnes de votre DataFrame.

Vous pouvez également préciser d’autres arguments pour garantir une lecture correcte : le séparateur avec sep ou delimiter, les noms de colonnes avec names, ou encore la colonne à utiliser comme index des lignes avec index_col.

Ce ne sont là que quelques paramètres disponibles pour read_csv(). Consultez la documentation pour le détail complet.

# Import the `pandas` library as `pd`
import pandas as pd

# Load in the data with `read_csv()`
digits = pd.read_csv("http://archive.ics.uci.edu/ml/machine-learning-databases/optdigits/optdigits.tra",
                     header=None)

# Print out `digits`
print(digits)

Ici, nous utilisons read_csv() car les données sont au format CSV. Si vos fichiers utilisent un autre séparateur, envisagez read_table(), read_excel(), read_fwf() ou read_clipboard pour lire respectivement des fichiers délimités généraux, des fichiers Excel, des fichiers à largeur fixe et des données copiées dans le presse-papiers.

Vous pouvez aussi utiliser read_sql() pour lire une requête SQL ou une table de base de données dans un DataFrame. Pour d’autres fonctions d’entrée/sortie, consultez cette section de la documentation pandas.

Qu’est-ce que l’analyse exploratoire des données (EDA) ?

L’EDA sert, d’une part, à répondre à des questions, tester des hypothèses métiers et générer des pistes pour des analyses ultérieures. D’autre part, elle permet aussi de préparer les données à la modélisation. Dans les deux cas, une bonne connaissance de vos données est essentielle pour obtenir les réponses dont vous avez besoin ou développer une intuition pour interpréter les résultats des futurs modèles.

Il existe de nombreuses façons d’y parvenir : décrire sommairement les données, les visualiser, repérer des motifs, identifier les défis liés à l’exploitation des données, etc.

Un concept fréquemment cité à propos de l’EDA est le data profiling. Il consiste à résumer votre jeu de données via des statistiques descriptives. L’objectif est d’employer divers indicateurs pour mieux le comprendre. Le data profiling vise une compréhension solide des données, afin de pouvoir ensuite les interroger et les visualiser sous différents angles. Cela n’exclut pas l’itération : comme il résume le jeu de données, il sert aussi à évaluer la qualité des données. Selon les résultats, vous pourrez décider de corriger, d’écarter ou de traiter différemment certaines données.

Nous approfondirons le data profiling dans un prochain article.

EDA et data mining (DM)

L’EDA se distingue du data mining, bien que les deux soient proches, nombre de techniques EDA ayant été adoptées par le data mining. Leurs objectifs sont proches : l’EDA vise à explorer les données pour faire émerger des caractéristiques intéressantes et des relations entre variables. En EDA, on compare souvent de nombreuses variables avec diverses techniques afin de repérer des motifs systématiques. Le data mining, lui, s’attache à extraire des motifs des données. Ces motifs fournissent des insights sur les relations entre variables, utiles pour améliorer les décisions métiers. Dans les deux cas, on ne part pas d’attentes a priori, ou seulement partielles, sur les relations entre variables.

De manière générale, le data mining est plus orienté application, tandis que l’EDA s’intéresse davantage à la nature fondamentale des phénomènes sous-jacents. En d’autres termes, le data mining se soucie relativement moins d’identifier la nature précise des relations entre variables. Il accepte une approche « boîte noire » de l’exploration, en recourant non seulement à des techniques communes avec l’EDA mais aussi à des méthodes comme les réseaux de neurones pour produire des prédictions valides, sans expliciter les relations exactes sur lesquelles elles reposent.

Description de base des données

Comme évoqué, l’EDA consiste à faire connaissance avec vos données. Une étape élémentaire consiste à en obtenir une description de base. La notion est large : on peut la voir comme une manière rapide d’obtenir quelques informations, une façon simple et lisible de se faire une première idée, etc.

Cette section ne distingue pas ces interprétations : elle présente des moyens rapides et faciles à comprendre pour collecter des informations sur votre DataFrame.

Décrire les données

Par exemple, utilisez describe() pour obtenir plusieurs statistiques sommaires excluant les NaN. Considérez cet exemple avec le célèbre jeu de données Iris. Les données sont déjà chargées dans le bloc DataCamp Light :

iris.describe()

La fonction renvoie l’effectif, la moyenne, l’écart type, les valeurs minimale et maximale ainsi que les quantiles. Bien sûr, de nombreux packages Python fournissent ces statistiques, y compris pandas. describe() n’est qu’une des voies possibles.

Prenez le temps d’approfondir les statistiques descriptives si ce n’est pas déjà fait. Elles aident à évaluer la qualité de vos données. Vous pourrez alors décider de corriger, d’écarter ou de traiter différemment certains éléments. C’est généralement l’étape de data profiling. Elle vise à mieux comprendre les éléments et anomalies des données et à vérifier d’une part leur conformité à la documentation, d’autre part leur adéquation aux besoins métiers.

Remarque : vous reviendrez sur le data profiling au fil de l’EDA, car la qualité des données peut être affectée par les étapes que vous réalisez.

Premières et dernières lignes du DataFrame

Après une vision d’ensemble, examinez de plus près les données elles-mêmes. Avec head() et tail() de pandas, vous consultez facilement les premières et dernières lignes de votre DataFrame.

Inspectez les cinq premières et cinq dernières lignes des données de chiffres manuscrits avec head() et tail() dans le bloc ci-dessous. Les données sont déjà chargées :

# Inspect the first 5 rows of `digits`
first = digits._____(5)

# Inspect the last 5 rows
last = digits.____(5)

Le résultat de head() et tail() reste peu parlant si vous n’êtes pas familier avec ce type de données.

Vous voyez surtout des lignes et colonnes de valeurs numériques. Consultez la description du jeu de données si ce n’est pas déjà fait : elle explique la collecte, et précise le nombre d’attributs et de lignes, utile pour vérifier une importation correcte.

Revenez aussi à votre première observation : des valeurs numériques par ligne. À première vue, rien d’anormal, les entiers paraissent plausibles.

Mais sur un autre dataset (par exemple avec des dates), un rapide coup d’œil aurait pu soulever des questions : « Mes dates ont-elles été lues comme DateTime ? », « Comment le vérifier ? », « Comment changer le type ? ».

Ces questions plus poussées relèvent du data profiling, traité dans un prochain article.

Échantillonnage des données

Avec un jeu de données volumineux, prélever un échantillon est un bon moyen de se faire rapidement une idée. La méthode la plus simple consiste à utiliser sample() de pandas :

# Take a sample of 5
digits.sample(5)

Une autre méthode, un peu plus élaborée, consiste à créer un index aléatoire puis à récupérer des lignes au hasard depuis votre DataFrame. Le code ci-dessous s’appuie sur le module random et sa fonction sample, associés à range() et len(). Notez l’usage de ix pour sélectionner précisément les lignes à inclure dans l’échantillon.

Si l’usage de ix n’est pas clair dans ce contexte, le tutoriel dédié de DataCamp vous sera utile ! Il couvre ces sujets en détail. Consultez le lien ci-dessus.

Passons à la pratique ! Lancez-vous avec l’exercice ci-dessous :

# import `sample` from `random`
from random import ______

# Create a random index
randomIndex = np.array(sample(range(len(______)), 5))

# Get 5 random rows
digitsSample = digits.ix[___________]

# Print the sample
print(____________)

Examiner vos données de plus près : requêtes

Après un premier survol, plongez un peu plus en profondeur en interrogeant les données.

C’est très simple avec la fonction query(), qui permet de tester des hypothèses élémentaires, comme « La longueur des pétales est-elle généralement supérieure à celle des sépales ? » ou « La longueur des pétales est-elle parfois égale à celle des sépales ? ».

# Petal length greater than sepal length?
iris.query('Petal_length > Sepal_length')

# Petal length equals sepal length?
iris.query('Petal_length == Sepal_length')

Vous constaterez que cette hypothèse ne tient pas : la DataFrame renvoyée est vide.

Remarque : l’expression équivalente est iris[iris.Petal_length > iris.Sepal_length].

Les défis de vos données

Après avoir collecté des informations de base, examinez les défis que posent vos données. Si vous avez déjà effectué le data profiling, vous connaissez l’existence de valeurs manquantes, vous avez une idée des valeurs aberrantes, etc.

Cette section décrit des moyens simples d’identifier ces points et explique comment traiter les irrégularités détectées. Notez encore une fois qu’il est normal de revenir à l’étape de data profiling après avoir géré certains défis.

Valeurs manquantes

Lors de l’exploration, vérifiez si le jeu de données contient des valeurs manquantes.

C’est important : des données manquantes peuvent réduire l’expressivité du jeu de données et conduire à des analyses faibles ou biaisées. Concrètement, si certaines features manquent, la probabilité d’erreurs dans une classification ou une prédiction augmente.

Les causes sont multiples : extraction ou import défaillant, collecte incomplète, dysfonctionnements des systèmes sources, non-réponse dans une enquête… Cherchez aussi un éventuel motif dans les données manquantes : le data profiling aide à évaluer la qualité des données. Un prochain article expliquera comment détecter ces motifs.

En bref, les causes varient selon le contexte et peuvent aussi dépendre de votre propre traitement. C’est pour cela que vous avez vérifié vos données dès l’import !

Pour repérer les lignes contenant des valeurs manquantes, utilisez isnull(). Le résultat affiche True ou False dans chaque cellule : True indique une valeur manquante, False une valeur « normale ».

# Identifiy missing values
pd.isnull(______)

Ici, les données semblent complètes : aucune valeur manquante.

Remarque : la description du jeu de données dans le UCI Machine Learning Repository (lien plus haut) indiquait déjà l’absence de valeurs manquantes.

Mais ce ne sera pas toujours le cas. Il faut donc savoir quoi faire face à des valeurs manquantes :

Supprimer les données manquantes : soit l’enregistrement entier, soit en conservant les enregistrements où les features d’intérêt sont présentes. Attention aux biais potentiels. Demandez-vous si la probabilité de données manquantes pour un enregistrement est la même que pour les autres. Si elle ne varie pas selon les enregistrements, la suppression peut être valide.
Imputer les valeurs manquantes : remplacez-les par des valeurs substituées (moyenne, médiane, mode). Réfléchissez à l’imputation globale sur une variable ou conditionnelle sur une autre (par exemple, différencier « femme » et « homme » si pertinent).
Estimer via des modèles (régression, ANOVA, régression logistique, etc.). C’est l’approche la plus complexe.
Remplacer par des valeurs d’enregistrements « proches » (KNN, K-Nearest Neighbors).

Chaque méthode a ses avantages et limites. Considérez le temps, le coût, la nature des données, etc., avant de décider.

Une fois votre décision prise, voyez comment la mettre en œuvre.

Remplir les valeurs manquantes

Si vous retenez l’imputation, plusieurs options s’offrent à vous.

Utilisez fillna() de pandas avec les fonctions de NumPy. Dans l’exemple ci-dessous, vous disposez d’un DataFrame issu d’une enquête salariale. En supposant un contexte homogène et une probabilité de réponse identique pour tous, vous pouvez calculer la moyenne des répondants et l’utiliser pour compléter les valeurs manquantes.

# Import NumPyimport numpy as np# Calculate the meanmean = np.mean(df.Salary)# Replace missing values with the meandf. = df.Salary.fillna(mean)Propulsé par

Vous n’êtes pas obligé de passer une valeur fixe à fillna(). Vous pouvez propager des valeurs non nulles vers l’avant ou l’arrière via l’argument method : utilisez ffill ou bfill.

Supprimer les étiquettes avec valeurs manquantes

Pour exclure les lignes ou colonnes contenant des valeurs manquantes, utilisez dropna() de pandas :

# Drop rows with missing valuesdf.dropna(axis=0)# Drop columns with missing values df.dropna(axis=1)Propulsé par

Interpolation

Vous pouvez aussi interpoler les valeurs manquantes : interpolate() réalise une interpolation linéaire aux points manquants pour « deviner » la valeur la plus probable.

df.interpolate()Propulsé par

Ajoutez l’argument method pour des méthodes plus avancées (polynomiale, cubique). Pour ces méthodes, SciPy doit être installé.

L’interpolation a des limites, notamment si les NaN sont trop éloignés de la dernière observation valide. Dans ce cas, utilisez limit avec un entier positif pour définir le nombre de valeurs à remplir après une valeur non NaN. La direction est par défaut « forward », modifiable avec limit_direction.

Valeurs aberrantes

Comme les valeurs manquantes, vos données peuvent contenir des valeurs très éloignées de la majorité : des « outliers ». Pour les détecter, examinez la distribution de chaque variable avec un boxplot ou réalisez un nuage de points pour repérer celles qui ne se trouvent pas dans la zone « attendue ».

Les causes vont d’erreurs systèmes à des erreurs de saisie/traitement. Évaluez leur impact sur l’analyse : elles modifient des tests statistiques (écart type, moyenne, médiane), peuvent nuire à la normalité et affecter des modèles (régression, ANOVA).

Pour les traiter : suppression, transformation ou imputation. Le choix dépend du contexte. Comprendre la cause est crucial :

Si l’outlier vient d’une erreur de saisie/traitement, la suppression peut être envisagée.
Transformez-les en pondérant les observations ou via un log naturel pour réduire la variance induite.
Comme pour les valeurs manquantes, vous pouvez imputer (médiane, moyenne, mode).

Réutilisez les fonctions décrites plus haut pour gérer les outliers.

Les features de vos données

Remarque : cette étape est itérative avec les autres tâches data science. Vous construisez et validez des modèles, puis ajustez les features et itérez, etc.

Feature engineering

Le feature engineering vise à accroître le pouvoir prédictif des algorithmes d’apprentissage en créant, à partir des données brutes, des variables pertinentes qui faciliteront l’apprentissage. Il s’agit de générer des features additionnelles utiles à partir de celles déjà présentes.

Le feature engineering demande du temps et de l’expérience : il n’est pas toujours évident de savoir quoi faire des données brutes pour améliorer la prédiction. La liste ci-dessous peut vous inspirer :

Factoriser une variable : encodez des variables catégorielles en numériques avec factorize(), comme dans cet exemple :

# Factorize the values 
labels,levels = pd.factorize(iris.Class)

# Save the encoded variables in `iris.Class`
iris.Class = labels

# Print out the first rows
iris.Class.head()

Discrétiser des variables continues : utilisez cut() pour regrouper les valeurs d’une colonne en classes.

# Define your own bins
mybins = range(0, df.age.max(), 10)

# Cut the data with the help of the bins
df['age_bucket'] = pd.cut(df.age, bins=mybins)

# Count the number of values per bucket
df['age_bucket'].value_counts()

Mettre à l’échelle les features : centrez vos données autour de 0. Utilisez le module preprocessing de Scikit-Learn :

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler().fit(X)

rescaledX = scaler.transform(X)

Astuce : explorez de près le module preprocessing de Scikit-Learn, riche en fonctions utiles pour créer de nouvelles features.

Ce ne sont que quelques pistes pour rendre vos données plus prédictives. L’essentiel est de concevoir de nouvelles features ou d’en combiner d’anciennes, puis de tester leur efficacité avec Scikit-Learn.

Sélection de features

La sélection de variables consiste à retenir un sous-ensemble clé de features afin de réduire la dimension du problème d’apprentissage. Cela ressemble à des techniques de réduction dimensionnelle comme la PCA, mais il y a une différence : la PCA combine des attributs corrélés et crée de nouveaux attributs jugés supérieurs aux originaux. La sélection de variables n’agrège pas : elle évalue la qualité et la puissance prédictive et retient le meilleur ensemble.

Pour trouver les variables importantes, utilisez l’algorithme RandomForest : il génère aléatoirement des milliers d’arbres de décision et exclut tour à tour chaque variable lors de l’ajustement. Vous mesurez ainsi l’impact de l’exclusion d’une variable. La bibliothèque Scikit-Learn permet de l’implémenter :

# Import `RandomForestClassifier`
from sklearn.ensemble import RandomForestClassifier

# Isolate Data, class labels and column values
X = iris.iloc[:,0:4]
Y = iris.iloc[:,-1]
names = iris.columns.values

# Build the model
rfc = RandomForestClassifier()

# Fit the model
rfc.fit(X, Y)

# Print the results
print("Features sorted by their score:")
print(sorted(zip(map(lambda x: round(x, 4), rfc.feature_importances_), names), reverse=True))

Vous verrez que l’ensemble de variables le plus pertinent inclut la longueur et la largeur des pétales.

Remarque : vous pouvez aussi visualiser les résultats de la sélection avec Matplotlib :

# Import `pyplot` and `numpy`import matplotlib.pyplot as pltimport numpy as np# Isolate feature importances importance = rfc.feature_importances_# Sort the feature importances sorted_importances = np.argsort(importance)# Insert paddingpadding = np.arange(len(names)-1) + 0.5# Plot the dataplt.barh(padding, importance[sorted_importances], align='center')# Customize the plotplt.yticks(padding, names[sorted_importances])plt.xlabel("Relative Importance")plt.title("Variable Importance")# Show the plotplt.show()Propulsé par

Motifs dans vos données

Prochaine étape de l’exploration : identifier des motifs, notamment des corrélations entre attributs ou dans les données manquantes. La visualisation aide grandement. Et elle peut être interactive avec Bokeh ou Plotly.

Identifier des corrélations avec Matplotlib

Après l’analyse quantitative, adoptez aussi une approche visuelle.

Pour aller vite, utilisez Matplotlib. Un obstacle subsiste : vos données comportent 64 colonnes/features. Avec autant de dimensions, on parle de données « haute dimension ».

Vous verrez dans notre tutoriel de machine learning ce qu’est précisément la dimension, mais retenez que pour visualiser en 2D ou 3D, il faut réduire le nombre de dimensions à deux ou trois.

Il faut donc recourir à des techniques de réduction dimensionnelle, comme l’Analyse en composantes principales (PCA) :

# Import `PCA` from `sklearn.decomposition`
from sklearn.decomposition import ___

# Build the model
pca = PCA(n_components=2)

# Reduce the data, output is ndarray
reduced_data = pca.fit_transform(_______)

# Inspect the shape of `reduced_data`
reduced_data.______

# print out the reduced data
print(_______________)

En inspectant les données réduites, on constate que les colonnes/features ont été ramenées à deux. Le nombre de lignes/observations demeure de 3823. Vos données étant au bon format, place au tracé !

Le choix du bon type de graphique est crucial : lequel retenir ?

Dans ce cas exploratoire, vous cherchez des corrélations possibles entre attributs. Un nuage de points est adapté : il permet d’identifier une relation entre les deux features issues de la réduction.

import matplotlib.pyplot as pltplt.scatter(reduced_data[:,0], reduced_data[:,1], c=labels, cmap = 'viridis')plt.show()Propulsé par

Correlation Python

Identifier des corrélations avec Bokeh

Autre option : Bokeh pour des graphes interactifs. Bokeh est une bibliothèque Python de visualisation interactive conçue pour le web moderne. Idéale avec de grands jeux de données (ou en streaming), elle convient aussi à des données « classiques », comme ci-dessous.

Le code est simple : importez les modules nécessaires, construisez le scatter plot, configurez la sortie par défaut pour écrire dans un fichier quand show() est appelé, puis affichez.

# Import the necessary modulesfrom bokeh.charts import Scatter, output_file, show# Construct the scatter plotp = Scatter(iris, x='Petal_length', y='Petal_width', color="Class", title="Petal Length vs Petal Width",            xlabel="Sepal Length", ylabel="Sepal Width")# Output the file output_file('scatter.html')# Show the scatter plotshow(p)Propulsé par

Le résultat est élégant :

Python data exploration

Notez qu’il s’agit ici d’une image statique ; dans votre notebook ou terminal, le graphique sera interactif. Ce n’est qu’un exemple : parcourez la galerie Bokeh pour plus d’inspiration, ou suivez le cours Interactive Data Visualization with Bokeh de DataCamp.

Identifier des corrélations avec pandas

Les graphes ci-dessus offrent une approche visuelle de la corrélation entre attributs. Mais vous pouvez aussi la mesurer quantitativement. Utilisez pour cela corr() de pandas. Attention : les valeurs NaN/null sont exclues du calcul.

# Pearson correlation
iris.corr()

# Kendall Tau correlation
iris.corr('kendall')

# Spearman Rank correlation
iris.corr('spearman')

Remarque : les deux dernières mesures de corrélation nécessitent un rang préalable des données. Utilisez rank() facilement : pour l’exercice ci-dessus, les données iris ont été classées via iris.rank().

Retenez aussi les hypothèses sous-jacentes : la corrélation de Pearson suppose des variables distribuées normalement, une relation linéaire entre variables et des résidus normalement distribués. La corrélation de Spearman est adaptée à deux variables ordinales ou deux variables liées d’une manière non linéaire.

La corrélation de Kendall Tau mesure le degré de concordance entre deux colonnes de données classées. Spearman mesure le degré d’association entre deux variables. Elles paraissent proches, n’est-ce pas ?

Elles diffèrent toutefois par le calcul. Le coefficient Kendall Tau correspond à (paires concordantes − paires discordantes) / nombre total de paires. Le coefficient de Spearman est basé sur la somme des écarts au carré divisée par n fois n moins 1.

Le coefficient de Spearman est souvent plus grand que celui de Kendall, mais pas toujours : si les écarts sont très importants entre observations, Spearman devient plus petit, ce qui peut être informatif.

Quand utiliser l’un ou l’autre ? Ils testent des aspects différents : Kendall Tau exprime la proportion de paires concordantes relativement aux discordantes, ce que Spearman ne fait pas. On peut aussi soutenir que Kendall Tau est plus intuitif et plus simple à calculer, fournit une meilleure estimation du paramètre de population correspondant et des p-values plus fiables sur petits échantillons.

Astuce : ajoutez print() pour afficher les résultats de corrélations spécifiques entre colonnes.

La suite

Bravo, vous êtes arrivé au bout de ce tutoriel pandas ! Vous maîtrisez désormais des techniques de base pour explorer vos données avec Python.

Pour aller plus loin, notre série de cours pandas est idéale : consultez Data Manipulation with pandas, Reshaping Data with pandas ou Joining Data with pandas.

Si vous souhaitez plutôt approfondir Matplotlib, suivez le tutoriel de visualisation de données en Python de DataCamp, ou passez à la modélisation ! Rendez-vous sur notre tutoriel de machine learning pour découvrir comment construire un modèle capable de reconnaître automatiquement des chiffres manuscrits.

Sujets

Python Science des données Analyse des données

Technologies

Thèmes

Tutoriel d’analyse exploratoire des données en Python

Explorez l'IA

Sujets

Cours Python

Introduction à Python

Python intermédiaire

Contenus associés

Tableaux Python

Tutoriel sur les boucles « for » en Python

Tutoriel Python sur les structures de données

Tutoriel sur les méthodes .append() et .extend() de Python

Séquence de Fibonacci en Python : Apprenez et explorez les techniques de codage

Instructions IF, ELIF et ELSE en Python

Technologies

Thèmes

Cours Python

Introduction à Python

Python intermédiaire