Les outils indispensables aux projets Data Science

Lorsqu'on travaille sur un projet de Data Science, de nombreuses compétences peuvent être requises, des plus théoriques aux plus techniques.
Dans cet article, je vais principalement me concentrer sur certains des outils les plus importants à avoir et avec lesquels travailler, des outils qui permettent un code plus propre et une collaboration plus rapide.

Le sommaire est le suivant :

1. Visual Studio Code
2. Commandes Bash
3. Environnement virtuel
4. Unit Testing

‍

Visual Studio Code

Les tâches quotidiennes d'un Data Scientist tournent essentiellement autour du code. Pour cette raison, il est important d'avoir un bon éditeur capable d'encapsuler de nombreux autres outils. VS Code fait exactement cela ! C'est un outil développé par Microsoft, considéré comme l'un des éditeurs les plus utilisés. Il permet d'exécuter, éditer et debugger votre code, en plus de nombreuses extensions très utiles, telles que :

• Python : « A Visual Studio Code extension with rich support for the Python language, including features such as IntelliSense, linting, debugging, code navigation, code formatting, Jupyter notebook support, refactoring, variable explorer, test explorer, snippets, and more! »

• Gitlens : « GitLens supercharges the Git capabilities built into Visual Studio Code. It helps you to visualize code authorship at a glance via Git blame annotations and code lens, seamlessly navigate and explore Git repositories, gain valuable insights via powerful comparison commands, and so much more. »

• Git Graph : permet de visualiser le graphe de vos branches git et d'effectuer des actions git directement depuis ce même graphe !

• Vscode-icons : ajoute des icônes à votre Visual Studio Code pour une meilleure représentation et visualisation

• Docker : « The Docker extension makes it easy to build, manage, and deploy containerized applications from Visual Studio Code. It also provides one-click debugging of Node.js, Python, and .NET Core inside a container. » Si vous n'êtes pas familier avec Docker, ne vous inquiétez pas pour cette partie.

• Black : une librairie Python de formatage installée par défaut (sinon utilisez pip) qui permet de formater automatiquement votre code à la sauvegarde. Pour cela, vous pouvez ajouter les lignes suivantes au fichier « setting.json » de VS Code

"python.formatting.provider": "black",
"editor.formatOnSave": true

Voici un exemple de formatage de code par Black :

• Better comments : lorsqu'on écrit du code, on ajoute généralement des commentaires pour détailler ses scripts et les expliquer. Cette extension vous aide à les rendre plus agréables et plus compréhensibles. Vous pouvez par exemple utiliser le signe « ! » pour rendre les commentaires rouges et ainsi mieux attirer l'attention.
  Voici un exemple de mise en évidence générée par l'extension :

Pour plus d'informations, n'hésitez pas à visiter le site officiel de VS Code.

‍

Commandes Bash

Les commandes Bash sont très utiles pour naviguer rapidement dans votre système d'exploitation et efficaces pour manipuler des fichiers. Elles prennent aussi tout leur sens lorsqu'on travaille sur une machine virtuelle sans interface graphique, sur un environnement dans le cloud par exemple.

Lorsqu'on travaille avec des commandes Bash, il est important de disposer d'un bon terminal capable d'encapsuler visuellement de nombreux éléments. Voici deux consoles que je recommande :

• Mac : Iterm 2, offre un terminal très agréable visuellement, sur lequel vous pouvez voir des informations sur le current working directory, git, ses branches (project dev) et son statut (jaune : en attente de commit), ainsi que l'environnement virtuel sur lequel vous travaillez (project_env).

• Windows : Cmder, terminal plus enrichi qui permet aussi d'exécuter des commandes linux, très utiles dans certains cas.

N'hésitez pas non plus à jeter un œil à Powerlevel10K ; c'est une fonctionnalité cool à avoir sur son terminal qui offre un meilleur style et une façon de travailler plus efficace et flexible.

Voici une brève liste des lignes de commande les plus utilisées (sur macOS) :

Après avoir installé votre terminal, il est possible de l'utiliser directement dans VS Code, ce qui rend votre travail plus efficace.

‍

Environnement virtuel

Lorsqu'on travaille sur un projet, on souhaite très souvent qu'il soit reproductible sur d'autres machines et dans le cloud. Comme les versions des packages utilisés changent constamment, il est important de mettre en place un environnement privé ou virtuel dans lequel vous pouvez développer votre projet et figer les versions des packages. virtualenv est une librairie Python qui permet de réaliser l'isolation et le versioning évoqués ci-dessus comme suit (vous pouvez aussi utiliser anaconda) :

Lors de la première installation de Python sur votre ordinateur, son environnement par défaut s'appelle « base » ou « global ». Il est important de noter que les environnements virtuels créés ne communiquent pas avec base, ce qui signifie qu'ils sont initialement vides !

Créer et activer un environnement virtuel

#PIP
cd dossier project
pip install virtualenv # if not done before
virtualenv <env>
source <env>/bin/activate

#Anaconda
cd dossier project
conda create -n <env>
conda activate <env>

Installez les packages pip install <packageName> / conda install <packageName> progressivement quand nécessaire, et une fois votre projet stabilisé :

#PIP
pip freeze > packages.txt/

#Anacondaconda env export > packages.yml

Si vous clonez un projet contenant un fichier « packages.txt » ou « environment.yml » pour pouvoir le lancer, vous pouvez :

• Créer et activer d'abord un nouvel environnement virtuel
• Exécuter la commande suivante pour installer tous les packages nécessaires depuis le fichier donné :

#PIP
pip install -r packages.txt/

#Anaconda
conda env create -f environment.yml #No need to create an env before

VS Code & environnements virtuels

Lorsque vous créez un environnement virtuel, il est important de le choisir comme interpréteur. VS Code est capable de le détecter et suggérera son utilisation ; sinon, vous pouvez le choisir ainsi :

• Dans les settings, cliquez sur Command Palette
• Tapez : Python: Select Interpreter
• Choisissez-le dans la liste :

Je préfère personnellement travailler avec Virtualenv et pip plutôt qu'avec Conda, car Virtualenv permet d'installer uniquement les packages nécessaires et optimise l'usage de la mémoire.
Veuillez consulter le site de virtualenv pour plus d'informations.

‍

Unit Testing

L'unit testing est une technique de test logiciel qui exécute une séquence de tests individuels visant à vérifier le bon fonctionnement d'un module développé ou d'une partie de celui-ci. Ces tests prennent tout leur sens lorsqu'on adopte une approche test-driven development dans son projet. Cela consiste à écrire d'abord les tests que votre script devra passer, avant d'en démarrer le développement.

En Python, vous pouvez faire de l'unit testing via le framework pytest, qui convient très bien aux petits comme aux grands projets. Supposons que nous développions une fonction f, qui pour chaque jeu de valeurs (var1,var2,...) doit renvoyer une valeur expected_value.
Après avoir écrit les tests à passer, on développe la fonction puis on écrit un script selon le schéma suivant :

#Import packages
import pytest
import ...

#Create function
def f(var1, var2,...):
	return ...

#Unit tests
@pytest.mark.parametrize(
	"var1, var2,...,expected_result",
	[
		(val1_1, val2_1,...,expected_result_1),
		(val1_2, val2_2,...,expected_result_2),
		...
	]
)
def test_func(var1, var2,..., expected_result):
	assert f(var1,var2,...)==expected_result

Le script ci-dessus testera tous les différents tests (var1_i,var2_i,…) et vérifiera s'ils correspondent à leurs valeurs expected_value_i respectives un par un, en exécutant la ligne de commande suivante :

• Exemple : fonction puissance.
  À titre d'illustration, nous considérerons une fonction simple : la puissance d'un nombre. Le fichier d'unit testing est le suivant :

#Import packages
import pytest
import ...

#Create function
def f(var1, var2,...):
	return ...

#Unit tests
@pytest.mark.parametrize(
	"var1, var2,...,expected_result",
	[
		(val1_1, val2_1,...,expected_result_1),
		(val1_2, val2_2,...,expected_result_2),
		...
	]
)
def test_func(var1, var2,..., expected_result):
	assert f(var1,var2,...)==expected_result

On exécute la ligne de commande suivante :

python -m pytest -v --tb=line --disable-warnings pathtotestfile.py::function

On obtient les résultats suivants :

Les trois tests sont passés. Plus on a de tests, plus le code devient stable !

‍

Conclusion

En tant que Data Scientist, il est très important de maîtriser ces technologies afin de rendre son travail plus efficace et scalable. Des outils comme git sont indispensables et rendent la collaboration puissante et directe.
Je note également que certains de ces outils relèvent d'un choix personnel et peuvent être remplacés tout en faisant le job !
#TEAMVSCODE #TEAMITERM2