Python >> Tutoriel Python >  >> Python

Développer des projets de science des données en Python :un guide pour débutants

Lorsque vous avez déjà une certaine expérience avec Python, la création de votre propre portefeuille de projets de science des données est le meilleur moyen de présenter vos compétences à des employeurs potentiels. Mais par où commencer pour développer votre tout premier projet Python ?

Tout d'abord, pourquoi développer un projet de science des données ?

La création de votre propre projet de science des données dans un langage tel que Python présente un certain nombre d'avantages en termes de développement de carrière :

  • Étudier. La meilleure façon d'apprendre est de faire. Bien sûr, vous devrez peut-être d'abord suivre des cours d'introduction pour comprendre les bases de Python si vous êtes un débutant complet. Ensuite, vous pouvez apprendre par vous-même en définissant un problème intéressant et en travaillant sur une solution à l'aide de didacticiels, de documentation et de forums en ligne.
  • Pratiquer. Les projets sont une excellente occasion de mettre en pratique les compétences que vous avez acquises. En développant vos propres projets, vous pouvez appliquer vos connaissances nouvellement acquises à certaines tâches du monde réel. C'est aussi une excellente occasion de vous tester :êtes-vous prêt à créer votre propre projet à partir de zéro ?
  • Démonstration de vos compétences. Même pour un poste d'entrée de gamme, les entreprises de science des données préfèrent souvent les candidats ayant au moins une certaine exposition à un langage comme Python. Un projet est le meilleur moyen de mettre en valeur vos compétences en science des données.
  • Montrez votre motivation et votre dévouement. Lorsque vous terminez votre propre projet sans aucune incitation externe, cela montre à vos employeurs potentiels que vous êtes vraiment passionné par la poursuite d'une carrière en science des données. Du point de vue de l'employeur, les employés motivés sont un excellent investissement.

Et bien sûr, si vous choisissez un bon projet, vous vous amuserez aussi. Quiconque aime coder vous dira qu'il est impossible de résoudre des problèmes réels tout en se salissant les mains.

5 étapes pour créer votre propre projet de science des données

Prêt à commencer? Nous couvrirons les étapes suivantes dans ce petit exemple de projet :

  1. Définir le projet
  2. Préparer les données
  3. Exploration et visualisation des données
  4. Créer un modèle de machine learning
  5. Présenter vos résultats

1. Définir le projet

Chaque projet de science des données commence par un objectif bien défini :Que voulez-vous réaliser avec ce projet ? Vous pouvez appliquer une logique similaire lors du développement de votre premier projet Python pour votre portfolio :quelles compétences souhaitez-vous démontrer avec ce projet ?

Les compétences en science des données recherchées par les employeurs incluent, mais ne sont pas limitées à :

  • Nettoyage et traitement des données
  • Analyse exploratoire des données
  • Apprentissage automatique
  • Interprétation des résultats

Par exemple, pour démontrer vos compétences en matière de nettoyage des données, vous pouvez prendre des données désordonnées du monde réel et les préparer pour analyse. Si vous souhaitez pratiquer l'analyse exploratoire des données et l'apprentissage automatique, il est possible de trouver des ensembles de données en ligne déjà prétraités et prêts à être analysés.

Nous adopterons ici la deuxième approche, qui nous permet de démontrer plus efficacement les principes de développement de projets de science des données. Nous allons donc utiliser le fameux Boston Housing jeu de données, qui est disponible en ligne mais peut également être chargé à partir de scikit-learn bibliothèque. L'un des avantages de l'utilisation d'un ensemble de données populaire est qu'à la fin du projet, vous pourrez voir comment votre modèle fonctionne par rapport à ceux des autres. Il vous suffit de consulter le classement de Kaggle.

L'objectif de ce projet exploratoire est de prédire les prix des logements en utilisant les 13 caractéristiques (par exemple, le taux de criminalité, la population de la région, le nombre de pièces par logement) et les 506 échantillons disponibles dans l'ensemble de données.

2. Préparation des données

Nous allons commencer par importer les bibliothèques d'analyse et de visualisation de données suivantes :

  • NumPy
  • pandas
  • Matplotlib
  • né de la mer

Si vous n'êtes pas familier avec l'un d'entre eux, nous couvrons la plupart d'entre eux dans notre cours d'introduction à Python.

# Importing libraries
import numpy as np
import pandas as pd

import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

L'étape suivante consiste à charger le Boston Housing jeu de données de scikit-learn bibliothèque et explorez son contenu :

# Loading dataset
from sklearn.datasets import load_boston
boston_housing = load_boston()
print(boston_housing.keys())
dict_keys(['data', 'target', 'feature_names', 'DESCR'])

Comme vous pouvez le voir dans la liste des clés, l'ensemble de données contient des données (valeurs de 13 caractéristiques), cible (prix de l'immobilier), feature noms et DESCR (description).

Dans la description, vous trouverez une explication détaillée de toutes les fonctionnalités de cet ensemble de données :

print (boston_housing.DESCR)
Boston House Prices dataset
===========================

Notes
------
Data Set Characteristics:

	:Number of Instances: 506 

	:Number of Attributes: 13 numeric/categorical predictive

	:Median Value (attribute 14) is usually the target

	:Attribute Information (in order):
		- CRIM per capita crime rate by town
		- ZN proportion of residential land zoned for lots over 25,000 sq.ft.
		- INDUSproportion of non-retail business acres per town
		- CHAS Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)
		- NOXnitric oxides concentration (parts per 10 million)
		- RM average number of rooms per dwelling
		- AGEproportion of owner-occupied units built prior to 1940
		- DISweighted distances to five Boston employment centres
		- RADindex of accessibility to radial highways
		- TAXfull-value property-tax rate per $10,000
		- PTRATIOpupil-teacher ratio by town
		- B1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town
		- LSTAT% lower status of the population
		- MEDV Median value of owner-occupied homes in $1000's

	:Missing Attribute Values: None

Il est maintenant temps de créer un DataFrame avec toutes les fonctionnalités et une variable cible :

# Creating dataframe with features
boston_df = pd.DataFrame(boston_housing.data, columns = boston_housing.feature_names)
# Adding target variable to the dataset
boston_df['MEDV'] = boston_housing.target

boston_df.head()

Dans la première étape, nous avons créé un DataFrame avec des caractéristiques uniquement, puis nous avons ajouté une variable cible :les prix des logements (MEDV ).

Une dernière chose :C'est toujours une bonne idée de vérifier votre nouveau jeu de données avec le info() et describe() fonctions.

boston_df.info()

RangeIndex: 506 entries, 0 to 505
Data columns (total 14 columns):
CRIM 506 non-null float64
ZN 506 non-null float64
INDUS506 non-null float64
CHAS 506 non-null float64
NOX506 non-null float64
RM 506 non-null float64
AGE506 non-null float64
DIS506 non-null float64
RAD506 non-null float64
TAX506 non-null float64
PTRATIO506 non-null float64
B506 non-null float64
LSTAT506 non-null float64
MEDV 506 non-null float64
dtypes: float64(14)
memory usage: 55.4 KB
boston_df.describe()

Super! Vous avez montré comment créer un DataFrame et préparer les données brutes pour l'analyse. Continuons maintenant avec une analyse exploratoire des données.

3. Explorer et visualiser les données

Puisqu'il s'agit d'un projet de science des données destiné à présenter vos compétences à des employeurs potentiels, vous souhaiterez peut-être dessiner plusieurs graphiques de différents types pour afficher vos données dans un format intuitif et compréhensible.

Répartition des prix. Nous pouvons commencer par regarder la distribution de notre variable cible (prix de l'immobilier) :

sns.set_style(\"darkgrid\")
plt.figure (figsize=(10,6))

# Distribution of the target variable
sns.distplot(boston_df['MEDV'], axlabel = 'Median value of owner-occupied homes in $1000')

Ce graphique montre que les maisons de la région de Boston dans les années 1970 étaient évaluées en moyenne entre 20 000 et 25 000 $, allant d'un minimum de 5 000 $ à un maximum de 50 000 $.

Matrice de corrélation. Voyons maintenant comment cette variable cible est corrélée à nos caractéristiques, ainsi que la façon dont nos caractéristiques sont corrélées les unes aux autres. Pour cette tâche, nous allons d'abord créer un nouveau DataFrame avec des corrélations, puis visualisez-le à l'aide d'une carte thermique :

# Correlation matrix
boston_corr = boston_df.corr()

plt.figure (figsize=(10,6))
sns.heatmap(boston_corr, annot = True, cmap = 'coolwarm')

Cette matrice de corrélation montre que la valeur médiane des maisons (MEDV ) a :

  • Forte corrélation négative (-0,74) avec la part de la population de statut inférieur (LSTAT ).
  • Forte corrélation positive (0,7) avec le nombre moyen de pièces par logement (RM ).

Parcelles conjointes. Nous pouvons maintenant approfondir les relations entre ces variables en utilisant des tracés conjoints du seaborn bibliothèque. Ces graphiques montrent la distribution de chaque variable ainsi que la relation entre les variables. Par exemple, vérifions si les prix des logements sont susceptibles de dépendre linéairement de la part de la population de statut inférieur dans la région :

# Jointplots for high correlations - lower status population
plt.figure (figsize=(10,10))
sns.jointplot(x = 'LSTAT', y = 'MEDV', data = boston_df, kind = 'reg', size = 10, color = 'orange')

En utilisant le reg facultatif paramètre, nous pouvons voir dans quelle mesure un modèle de régression linéaire s'adapte à nos données. Dans ce cas, notre hypothèse d'une relation linéaire entre les variables (LSTAT et MEDV ) est tout à fait plausible, car les points de données semblent se trouver sur une ligne droite.

Nous pouvons également utiliser d'autres types de graphiques conjoints pour visualiser les relations entre deux variables. Étudions comment les prix des maisons sont liés au nombre de pièces à l'aide d'un plan à joint hexagonal :

# Jointplots for high correlations - number of rooms
plt.figure (figsize=(10,10))
sns.jointplot(x = 'RM', y = 'MEDV', data = boston_df, kind = 'hex', color = 'green', size = 10)

Comme vous pouvez le voir sur le graphique ci-dessus, les exemples de cas incluent de nombreuses maisons de 6 pièces et un prix d'environ 20 000 $. De plus, il ressort clairement de cette visualisation qu'un nombre plus élevé de chambres est associé à un prix plus élevé. Cette relation peut être approchée avec un modèle de régression linéaire.

Vous pouvez réfléchir à d'autres façons d'explorer davantage cet ensemble de données. Mais en attendant, passons à la partie machine learning de notre projet. Plus précisément, voyons comment nous pouvons modéliser la relation entre nos caractéristiques et la variable cible afin que les prévisions du modèle sur les prix des logements soient aussi précises que possible.

4. Créer un modèle d'apprentissage automatique

Tout d'abord, nous devons préparer notre ensemble de données pour cette partie du projet. En particulier, nous devons séparer nos caractéristiques de la variable cible, puis diviser l'ensemble de données en un ensemble d'apprentissage (75 %) et un ensemble de test (25 %). Nous allons entraîner nos modèles sur l'ensemble d'apprentissage, puis évaluer leurs performances sur les données invisibles :l'ensemble de test.

# Preparing the dataset
X = boston_df.drop(['MEDV'], axis = 1)
Y = boston_df['MEDV']	
# Splitting into training and test sets
from sklearn.model_selection import train_test_split

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.25, random_state=100)	

Régression linéaire. Maintenant, nous sommes prêts à former notre premier modèle. Nous allons commencer par le modèle le plus simple :la régression linéaire :

# Training the Linear Regression model
from sklearn.linear_model import LinearRegression

lm = LinearRegression()
lm.fit(X_train, Y_train)
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)

Dans le code ci-dessus, nous avons importé le LinearRegression modèle du scikit-learn bibliothèque et formé sur notre ensemble de données. Évaluons maintenant le modèle à l'aide de deux métriques courantes :

  • Erreur quadratique moyenne (RMSE )
  • R au carré (r2_score )
# Evaluating the Linear Regression model for the test set
from sklearn.metrics import mean_squared_error, r2_score
predictions = lm.predict(X_test)
RMSE_lm = np.sqrt(mean_squared_error(Y_test, predictions))
r2_lm = r2_score(Y_test, predictions)

print('RMSE_lm = {}'.format(RMSE_lm))
print('R2_lm = {}'.format(r2_lm))
RMSE_lm = 5.213352900070844
R2_lm = 0.7245555948195791

Ce modèle nous donne un RMSE d'environ 5,2. De plus, une valeur R au carré de 0,72 signifie que ce modèle linéaire explique 72 % de la variation totale de la variable de réponse. Ce n'est pas mal du premier coup. Voyons si nous pouvons obtenir de meilleures performances avec un autre modèle.

Forêt aléatoire. C'est un algorithme un peu plus avancé, mais son implémentation en Python est encore assez simple. Vous pouvez tester le nombre d'estimateurs et également définir un état aléatoire pour obtenir des résultats cohérents :

# Training the Random Forest model
from sklearn.ensemble import RandomForestRegressor

rf = RandomForestRegressor(n_estimators = 10, random_state = 100)
rf.fit(X_train, Y_train)
RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,
max_features='auto', max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=1, min_samples_split=2,
min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=1,
oob_score=False, random_state=100, verbose=0, warm_start=False)
# Evaluating the Random Forest model for the test set
predictions_rf = rf.predict(X_test)
RMSE_rf = np.sqrt(mean_squared_error(Y_test, predictions_rf))
r2_rf = r2_score(Y_test, predictions_rf)

print('RMSE_rf = {}'.format(RMSE_rf))
print('R2_rf = {}'.format(r2_rf))
RMSE_rf = 3.4989580001214895
R2_rf = 0.8759270334224734

Cela ressemble à une forêt aléatoire est un bien meilleur modèle de notre Boston Housing jeu de données :l'erreur est inférieure (RMSE =3,5), et la part de la variation expliquée est significativement plus élevée (R au carré de 0,88).

5. Présenter vos découvertes

C'est ça! Il est maintenant temps de partager votre projet avec le monde.

Si vous utilisiez Jupyter Notebook en tant qu'IDE Python, vous pouvez partager le bloc-notes directement, mais de préférence, enregistrez-le sous forme de fichier PDF afin qu'il soit plus accessible. Une autre option consiste à partager vos projets Python via GitHub.

N'oubliez pas d'inclure des commentaires détaillés sur vos conclusions. Dessiner des intrigues attrayantes et significatives ou construire des modèles d'apprentissage automatique sont des compétences importantes, mais un scientifique des données devrait être capable de raconter une histoire basée sur toutes les intrigues et tous les modèles utilisés. Alors, utilisez chacun de vos projets comme une opportunité de démontrer vos capacités à découvrir des modèles et à tirer des conclusions basées sur des données brutes.

Si vous pensez avoir besoin de conseils supplémentaires avant de développer votre premier projet avec Python, consultez notre cours Introduction à Python pour la science des données. Il couvre de nombreux concepts nécessaires pour développer des projets réussis non seulement pendant votre processus d'étude, mais également lors de la résolution de problèmes réels sur votre lieu de travail.