Bonjour ! Dans la dernière leçon, nous avons achevé notre étude du machine learning classique en apprenant à construire des pipelines robustes avec Scikit-learn. Vous avez vu comment un objet Pipeline peut encapsuler une série d'étapes de prétraitement et un modèle, simplifiant ainsi l'entraînement, l'évaluation et le déploiement.
Cette idée d'enfermer des données et des fonctionnalités dans un "objet" unique est un concept puissant et central en programmation. Aujourd'hui, nous faisons un pas de côté par rapport aux modèles de machine learning pour nous plonger dans ce concept fondamental, qui est un prérequis absolu pour aborder le deep learning.
Bienvenue dans le module sur la Programmation Orientée Objet (POO) et les bases de PyTorch. Notre objectif pour cette leçon est d'apprendre à définir et instancier une simple classe Python avec des attributs et des méthodes. Nous n'allons plus seulement utiliser des objets fournis par des bibliothèques comme Scikit-learn, mais apprendre à créer les nôtres. Cette compétence est la pierre angulaire sur laquelle nous construirons nos premiers réseaux de neurones dans PyTorch.
1. Qu'est-ce qu'un "Objet" ?
Jusqu'à présent, vous avez manipulé de nombreux types de données : des chaînes de caractères, des listes, des dictionnaires, et surtout, des tableaux NumPy et des DataFrames Pandas. Chacun de ces éléments est un objet en Python. Un objet est une structure qui regroupe deux choses :
- Des données (Attributs) : Ce sont les caractéristiques ou les propriétés de l'objet. Par exemple, un tableau NumPy a des attributs comme
.shape(sa forme) et.dtype(le type de données qu'il contient). - Des fonctionnalités (Méthodes) : Ce sont les actions que l'objet peut effectuer. Par exemple, une liste a une méthode
.append()pour y ajouter un élément, et un tableau NumPy a une méthode.sum()pour calculer la somme de ses éléments.
La Programmation Orientée Objet (POO) est une manière de programmer qui consiste à organiser son code autour de ces objets. Plutôt que d'avoir des données d'un côté et des fonctions qui opèrent sur ces données de l'autre, on les regroupe dans des unités logiques.
2. Classes et Instances : Le Plan et la Réalisation
Pour créer nos propres types d'objets, nous utilisons une classe. Une classe est comme un plan ou un modèle (blueprint). Elle ne contient pas de données réelles, mais elle définit la structure : quels attributs un objet de ce type doit avoir, et quelles méthodes il peut exécuter.
Une instance est un objet concret créé à partir du plan de la classe. Si la classe Chien est le plan, alors chaque chien individuel, avec son propre nom et son propre âge, est une instance de cette classe.
L'article suivant de Real Python donne une excellente introduction à ces concepts.
Object-Oriented Programming (OOP) in Python
Cet article est une référence très complète sur la POO en Python.
Pour commencer, lisez la section d'introduction "What Is Object-Oriented Programming in Python?" pour vous familiariser avec l'idée de modéliser des choses du monde réel. Ensuite, parcourez la section "Classes vs Instances", qui approfondit la distinction cruciale entre le plan (la classe) et l'objet réel (l'instance).
3. Définir une Classe en Python : __init__ et self
Créons notre première classe. En Python, nous utilisons le mot-clé class. La vidéo suivante de Corey Schafer est l'une des meilleures introductions pour les débutants sur ce sujet. Nous allons la regarder en plusieurs parties.
Python OOP Tutorial 1: Classes and Instances
Cette vidéo de Corey Schafer décompose la création de classes de manière très claire et progressive.
Pour commencer, regardez l'introduction où il explique pourquoi utiliser des classes et comment elles servent de "blueprint". Ensuite, regardez la partie où il crée une classe simple et explique la différence entre la classe et plusieurs instances uniques de cette classe.
Comme vous l'avez vu, une classe vide n'est pas très utile. Nous devons lui dire comment initialiser ses attributs. Pour cela, on utilise une méthode spéciale appelée __init__ (prononcez "dunder init", pour double underscore).
__init__ est le constructeur de la classe. C'est une méthode qui est appelée automatiquement chaque fois que vous créez une nouvelle instance. Son rôle est de mettre en place l'état initial de l'objet, c'est-à-dire d'assigner les valeurs à ses attributs.
Vous remarquerez que son premier paramètre est toujours self.
selffait référence à l'instance spécifique qui est en train d'être créée. Quand vous écrivezself.name = name, vous dites "attache la valeur de la variablenameà l'attributnamede cette instance particulière".
Continuons avec la vidéo de Corey Schafer pour voir cela en action.
Python OOP Tutorial 1: Classes and Instances
Continuons avec la vidéo de Corey Schafer.
Regardez attentivement la section où il introduit la méthode __init__. Il y explique comment cette méthode permet de définir les attributs (comme le prénom, le nom, le salaire) automatiquement lors de la création d'une instance. Notez bien comment self.first = first relie l'argument passé à la création de l'objet à un attribut de l'instance.
Maintenant que nous avons une classe avec un constructeur, nous pouvons créer des instances (on parle aussi d'instancier une classe) en appelant la classe comme une fonction et en lui passant les arguments requis par __init__ (sauf self, qui est géré automatiquement par Python).
class Employee:
def __init__(self, first, last, pay):
self.first = first
self.last = last
self.pay = pay
self.email = first.lower() + '.' + last.lower() + '@company.com'
# Instanciation : création de deux objets Employee distincts
emp_1 = Employee('Corey', 'Schafer', 50000)
emp_2 = Employee('Test', 'User', 60000)
# Accéder aux attributs avec la notation pointée
print(emp_1.email)
print(emp_2.first)
Cet exemple de code illustre ce que vous venez de voir : emp_1 et emp_2 sont deux objets indépendants, chacun avec ses propres attributs first, last, pay et email.
4. Définir des Comportements : Les Méthodes
Maintenant que nos objets ont des données (attributs), donnons-leur des comportements (méthodes). Une méthode est simplement une fonction définie à l'intérieur d'une classe. Tout comme __init__, son premier paramètre doit être self, ce qui lui donne accès aux attributs de l'instance sur laquelle elle est appelée.
Retournons à notre exemple Employee pour créer une méthode plus utile.
Python OOP Tutorial 1: Classes and Instances
C'est la dernière partie de la vidéo que nous allons regarder pour cette leçon.
Regardez la section où il ajoute une méthode full_name à la classe Employee. Observez comment la méthode utilise self.first et self.last pour fonctionner. Il explique aussi une erreur très courante : oublier self comme premier paramètre d'une méthode. C'est un point crucial à comprendre.
Voici le code mis à jour avec la méthode full_name:
class Employee:
def __init__(self, first, last, pay):
self.first = first
self.last = last
self.pay = pay
self.email = first.lower() + '.' + last.lower() + '@company.com'
# Définition d'une méthode
def full_name(self):
return f'{self.first} {self.last}'
emp_1 = Employee('Corey', 'Schafer', 50000)
# Appeler la méthode sur l'instance
# Remarquez les parenthèses, car c'est un appel de fonction !
print(emp_1.full_name())
5. Mise en pratique
Il est temps de mettre en pratique ce que vous avez appris. L'article de Real Python que vous avez consulté plus tôt propose un excellent exercice.
Object-Oriented Programming (OOP) in Python
Retournons à l'article de Real Python pour un exercice pratique.
Lisez l'énoncé de l'exercice "Create a Car Class". Essayez de le résoudre par vous-même dans votre environnement de programmation. Vous devez créer une classe Car avec des attributs pour la couleur et le kilométrage, puis créer deux instances et afficher leurs informations. Une fois que vous avez essayé, vous pouvez comparer votre solution avec celle proposée dans la section "Solution".
6. Pourquoi est-ce si important pour le Deep Learning ?
Vous vous demandez peut-être pourquoi nous faisons ce détour par la POO. La raison est simple : les bibliothèques de deep learning comme PyTorch sont entièrement construites sur ce paradigme.
Dans PyTorch, un réseau de neurones n'est rien d'autre qu'une classe que vous définissez. Cette classe contiendra :
- Des attributs : les différentes couches de votre réseau (couches de convolution, couches linéaires, etc.).
- Des méthodes : une méthode principale, souvent nommée
forward, qui définit comment les données d'entrée traversent les couches pour produire une sortie.
En apprenant à créer vos propres classes, vous vous préparez directement à structurer, construire et personnaliser vos propres modèles de deep learning.
Introduction to Object Oriented Programming
Cet article de "Python Like You Mean It" renforce le lien entre la POO et les bibliothèques scientifiques.
Lisez la dernière partie de cette page, qui commence par cette phrase. Elle souligne explicitement que des bibliothèques comme PyTorch et TensorFlow reposent sur la capacité des utilisateurs à définir des classes personnalisées.
Conclusion
Félicitations ! Vous avez fait vos premiers pas dans le monde de la programmation orientée objet en Python, une compétence fondamentale pour tout développeur, et essentielle pour vos objectifs en deep learning.
Points clés à retenir :
- Une classe est un plan pour créer des objets.
- Une instance est un objet concret créé à partir d'une classe.
- La méthode
__init__est le constructeur, appelé lors de la création d'une instance pour initialiser ses attributs (données). - Le paramètre
selffait référence à l'instance elle-même, donnant accès à ses attributs et méthodes. - Les méthodes sont des fonctions définies dans une classe qui définissent les comportements de ses objets.
Dans la prochaine leçon, nous explorerons le concept d'héritage. Vous apprendrez comment une classe peut hériter des attributs et des méthodes d'une autre classe "parente". C'est précisément ce mécanisme qui vous permettra de créer vos propres modèles de réseaux de neurones en héritant des fonctionnalités de base fournies par PyTorch.