Créaction d'une classe complète

L'objectif ici est d'illustrer les avantages de la programmation orientée objet sur l'exemple de la régression logistique.

Nous allons faire appel à numpy pour le calcul matricielle et créer une classe LogisticRegression. Fixons l'architecture de notre classe comme suit

import numpy as np
class LogisticRegression:
    def __init__(self, learning_rate=0.01, num_iter=100, fit_intercept=True, verbose=False): ## constructeur 
        self.learning_rate = learning_rate  # le pas de la descente du gradient
        self.num_iter = num_iter  #  nombre iterations de la descente du gradient
        self.fit_intercept = fit_intercept  # boolean qui indique si on ajoute la colonne de 1 aux variables explicatives
        self.verbose = verbose  # affichage ou pas de la perte durant l'entrainement

    def _add_intercept(self, X): ## ajouter une colonne de 1  a X. 
        pass 
        
    def _logit(self, z):  ## calcul de 1/(1+e^(-z)) pour tout un vecteur z 
        '''
          ecrire une description de la fonction ici 
        '''

        pass 

    def _loss(self, g, y): ## calcul de la perte  à partir de la fonction g evaluee sur X et y 
        '''
         ecrire une description de la fonction ici 
        '''

        pass 

    def train(self, X, y):   ## fonction entrainement 
        '''
         ecrire une description de la fonction ici 
        '''
        # 1. tester si on doit ajouter ou pas la colonner de 1 (si oui appeler la methode _add_intercept(X))
        
        # 2. initialiser weights (les coefficients de regression) a 0

        # 3 boucle for sur iterations 
             # 3.1 calculer le vecteur z des produits scalaires <beta, x> sur toutes les lignes de x, utiliser np.dot 

             # 3.2 calculer le vecteur g correspondant a la fonction logit appliquee a z

             # 3.3 calculer le gradient 

             # 3.4 mettre a jour les coefficients de regression via une descente du gradient

             # 3.5 affichage : si verbose est oui et chaque 100 iteration : afficher la perte

        
        pass

    def predict_prob(self, X):  ## calcul des probabilites predites pour un jeu de donnees test 
        
        # Attention tester s'il faut ajouter une colonne de 1 
        # retourner les logit calcules
        pass 
    
    def predict(self, X, threshold): ## prediction de la classe 0 ou 1
        # tester si les proba predites depassent le seuil threshold ou pas
        pass 

Test sur un jeu de données réel

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.datasets import load_breast_cancer
help(load_breast_cancer)

X, y = load_breast_cancer(return_X_y=True)  # load the dataset

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = 42)  # split the dataset
X_train_scaled = (X_train - np.average(X_train, 0))/np.std(X_train)
X_test_scaled = (X_test - np.average(X_test, 0))/np.std(X_test)

1. Créer un objet LogisticRegression avec learning_rate = 0.01, num_iter = 10000 et verbose = True.
2. Estimation des paramètres sur le jeu de données X_train_scaled et y_train.
3. Calculer le taux de bon classement du jeu de données test X_test_scaled et y_test.