Partage
  • Partager sur Facebook
  • Partager sur Twitter

[Cours] ML supervisé non linéaire

    25 octobre 2017 à 9:26:01

    Bonjour ! Voilà le fil de discussion dédié au cours "Utilisez des modèles supervisés non linéaires" du parcours Data Scientist.
    Dans ce cours, vous apprenez à entraîner des modèles supervisés non-linéaires sur vos données.
    N'hésitez pas à poser vos questions ici et à échanger les uns avec les autres ! Je ferai de mon mieux pour transmettre vos questions aux auteurs du parcours.
    Si vous avez une question concernant le fonctionnement du cours (accès aux exercices, envoi des exercices, inscription au cours…), contactez directement OpenClassrooms à hello@openclassrooms.com
    Bon courage et à bientôt !

    -
    Edité par LucBertrand 25 octobre 2017 à 9:26:33

    • Partager sur Facebook
    • Partager sur Twitter
      29 mai 2019 à 16:16:09

      Bonjour,
      Dans le quiz 1, je ne comprends pas pourquoi la figure 2 représente un modèle linéaire.
      Que signifie : "La linéarité est entre les paramètres à estimer, pas entre les variables indépendantes observées." ?
      Merci d'avance.

      -
      Edité par Christophe Lebrun 29 mai 2019 à 16:30:51

      • Partager sur Facebook
      • Partager sur Twitter
        3 août 2019 à 14:14:24

        Idem ici... Je ne comprends pas la correction.

        Des explications de la part des créateurs du cours seraient les bienvenues.

        • Partager sur Facebook
        • Partager sur Twitter
          31 août 2019 à 0:56:39

          Bonjour

          -
          Edité par moustaphadieng 31 août 2019 à 1:25:57

          • Partager sur Facebook
          • Partager sur Twitter
            27 octobre 2019 à 15:41:49

            Bonjour 

            J'ai un soucis au niveau du TP de la partie "Classifiez vos données avec une SVM à noyau". En effet quand j’exécute le code permettant de visualiser la matrice de Gram avec "plt.pcolor" j'obtiens un graphique vide (voir Capture d'écran). Une idée ?!

            • Partager sur Facebook
            • Partager sur Twitter
              29 octobre 2019 à 15:47:26

              Donne le code de création de kmatrix100.
              • Partager sur Facebook
              • Partager sur Twitter
                29 octobre 2019 à 20:24:02

                Zachee54 a écrit:

                Donne le code de création de kmatrix100.

                Le code de création de kmatrix100 est le même que celui utilisé dans le cours:

                from sklearn import metrics

                kmatrix = metrics.pairwise.rbf_kernel(X_train_std, gamma=0.01)

                kmatrix100 = kmatrix[:100, :100]



                -
                Edité par FreeSisyphe 29 octobre 2019 à 20:25:02

                • Partager sur Facebook
                • Partager sur Twitter
                  30 octobre 2019 à 16:40:15

                  Oui, d'accord, mais on ne sait pas comment tu as défini X_train_std.

                  Le fond de ma question est de savoir si tu es sûr qu'il y a un contenu dans ta matrice, et lequel.

                  • Partager sur Facebook
                  • Partager sur Twitter
                    30 octobre 2019 à 16:54:35

                    Zachee54 a écrit:

                    Oui, d'accord, mais on ne sait pas comment tu as défini X_train_std.

                    Le fond de ma question est de savoir si tu es sûr qu'il y a un contenu dans ta matrice, et lequel.


                    Oui sur d'avoir un contenu dans ma matrice, je n'ai fait qu'appliquer exactement à la lettre le code du cours et voici le contenu de ma matrice:

                    • Partager sur Facebook
                    • Partager sur Twitter
                      30 octobre 2019 à 18:53:15

                      Trouvé : l'échelle du graphique est définie à partir des dimensions de X, alors que kmatrix100 est beaucoup plus petite. Du coup on ne voit rien.

                      Ecris les deux lignes suivantes à la place de celles du cours :

                      plt.xlim([0, kmatrix100.shape[0]])
                      plt.ylim([0, kmatrix100.shape[0]])
                      • Partager sur Facebook
                      • Partager sur Twitter
                        31 octobre 2019 à 1:01:49

                        Zachee54 a écrit:

                        Trouvé : l'échelle du graphique est définie à partir des dimensions de X, alors que kmatrix100 est beaucoup plus petite. Du coup on ne voit rien.

                        Ecris les deux lignes suivantes à la place de celles du cours :

                        plt.xlim([0, kmatrix100.shape[0]])
                        plt.ylim([0, kmatrix100.shape[0]])

                        Bien vu ! Ca marche à merveille... je vous remercie infiniment !
                        • Partager sur Facebook
                        • Partager sur Twitter
                          1 novembre 2019 à 12:44:08

                          Christophe Lebrun du Puytison a écrit:

                          Bonjour,
                          Dans le quiz 1, je ne comprends pas pourquoi la figure 2 représente un modèle linéaire.
                          Que signifie : "La linéarité est entre les paramètres à estimer, pas entre les variables indépendantes observées." ?
                          Merci d'avance.

                          -
                          Edité par Christophe Lebrun du Puytison 29 mai 2019 à 16:30:51

                          Pour moi dans un modèle linéaire, on a les données (x) et les paramètres à estimer (w) qui interviennent uniquement au travers d'une combinaison linéaire (somme w_i * x_i ...). Apres, dans un pb de classification, tu peux avoir a décider de la classification via  f(cette combinaison linéaire) où f n'est pas linéaire (par exemple dans la régression logisitique ca se passe comme ca). Je ne comprends pas trop le terme de 'variables indépendantes observées', surtout le 'indépendantes', mais ca fait référence à la sortie du modèle (aux observations/prédictions donc). Ceci dit je ne suis pas sûr de bien voir quand même pourquoi le deuxième graphe correspond à  un pb non linéaire ... hehe

                          Sinon aussi pour la derniere question du quizz 2. On a ca : 

                          Les réseaux de neurones sont populaires car ils ont la particularité de 

                          • étant donné les bons hyperparamètres, pouvoir approximer n'importe quelle fonction continue (approximateur universel)
                          • avec n'importe quels hyperparamètres et assez de temps et puissance de calcul, pouvoir approximer n'importe quelle fonction continue (approximateur universel)
                          • avec la bonne fonction d'erreur et algorithme de descente de gradient, pouvoir approximer n'importe quelle fonction continue (approximateur universel)

                          C'est un approximateur universel théorique, mais il faut effectivement les bons hyperparamètres (couches, nombre de neurones par couche, etc). 

                          La bonne réponse était la deuxième, mais j'ai bien l'impression que dans le commentaire on dit que la bonne solution est plutôt la première, non ? 

                          -
                          Edité par charox 1 novembre 2019 à 12:45:54

                          • Partager sur Facebook
                          • Partager sur Twitter
                            1 novembre 2019 à 17:55:18

                            L'explication donnée à cette question "La linéarité est entre les paramètres à estimer, pas entre les variables indépendantes observées."est encore plus ambigu que la réponse !

                            J'ai du mal à comprendre la logique derrière cette réponse et encore moins l'explication fourni !!!

                            -
                            Edité par FreeSisyphe 1 novembre 2019 à 17:58:24

                            • Partager sur Facebook
                            • Partager sur Twitter
                              6 novembre 2019 à 11:53:48

                              Comme déjà signalé par certains, il semble bien y avoir une erreur dans la correction de la question 7 du premier Quiz.

                              En effet, comme signalé dans le premier chapitre de la partie 1, dans un espace à 2 dimensions la fonction de décision d'un modèle linéaire est nécessairement une droite. En fait, la spécificité d'un modèle linéaire est d'être incapable de modéliser des objets courbes, on a donc du mal à voir comment un modèle linéaire pourrait modéliser la courbe rouge dans le graphique du milieu.

                              C'est d'autant plus étrange que la correction nous dit que le graphique de droite, comporte lui un modèle non linéaire. Or, d'un point de vu mathématique, les modèle du milieu et de droite sont fortement similaires. Pour celui du milieu c'est une parabole, et pour celui de droite une ellipse (bon c'est plus un patatoïde, mais une ellipse fonctionnerait tout aussi bien et serait plus facile à modéliser), ie. des coniques. Les coniques sont définies par des équations de degré 2 (fonction quadratique) et ne sont donc pas linéaires.

                              • Partager sur Facebook
                              • Partager sur Twitter
                                9 décembre 2020 à 15:28:29

                                Bonjour,

                                dans le noyau gaussien le paramètre gamma est-il lié au paramètre sigma ? Comment ?

                                Merci

                                Jean-Baptiste

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  15 janvier 2021 à 14:03:00

                                  La documentation de scikit-learn montre que le noyau rbf utilisé est \(\exp(-\gamma\|x-x'\|^2)\), donc \(\gamma=\frac{1}{2\sigma^2}\).

                                  -
                                  Edité par Zachee54 15 janvier 2021 à 14:03:39

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    11 février 2022 à 13:15:10

                                    Bonjour à tous,

                                    je suis également assez perplexe de l'explication donnée. En effet, je ne comprends pas ce que "linéarité des paramètres à estimer" veut dire.

                                    Petite spéculation : peut-être l'auteur du quizz voulait dire que les données peuvent être séparées par deux droites ??

                                    Je voulais aussi rebondir sur cette question du quizz :

                                    => Cela ne me parait pas correct; j'ai justement pu créer un perceptron une-couche qui a appris cette fonction. (en utilisant une fonction d'activation en sigmoide - le seuil marche aussi et converge hyper vite)

                                    Je mets le code ici :

                                    import numpy as np
                                    import matplotlib.pyplot as plt
                                    
                                    ETA = 0.1
                                    TEST_DATA_SIZE = 30000
                                    
                                    # Construction des données d'entrainement pour un LOGICAL AND 
                                    # Construire TEST_DATA_SIZE x 4 données d'entrainement
                                    input  = []
                                    output = []
                                    for i in range(0,TEST_DATA_SIZE):
                                        input.insert(0, [[0, 0], [0, 1], [1, 0], [1, 1]])
                                        output.insert(0, [0, 0, 0, 1])
                                    
                                    X = np.concatenate(input)
                                    y = np.concatenate(output)    
                                    
                                    # Valeurs initiales des poids
                                    w_0 = np.random.randint(0,10)
                                    w_1 = np.random.randint(0,10)
                                    w_2 = np.random.randint(0,10)
                                    
                                    # Fonction d'activation 1 : seuil
                                    def seuil(x):
                                        return 1 if x > 0 else 0
                                    
                                    # Fonction d'activation 1 : sigmoide
                                    def sigmoid(x):
                                        return 1 / ( 1 + np.exp(-x) )
                                    
                                    # x doit être le vecteur à p composantes
                                    # on cacule ici le nouveau w_j (pour la jième composante)
                                    def compute_new_w_j( j, old_w_j, x,  expected, predicted, eta ):
                                        """ Calculer la nouvelle valeur de w_j (poids/coefficient à appliquer à la composante j du vecteur x dans la combinaison linéaire)
                                        Paramètre : 
                                        j : le numéro de la composante (compris entre 0 et p=nb de composante d'un vecteur)
                                        old_w_j : ancienne valeur de w_j
                                        x : le vecteur x actuellement en cours d'itération
                                        expected : la valeur attendue pour ce vecteur x
                                        predicted : la valeur calculée par le perceptron pour cette itération = l'image de x par la fonction d'activation 
                                        eta : le pas de vitesse d'apprentissage
                                        """    
                                        if j == 0 :
                                            return old_w_j - eta * (  predicted - expected   )* 1
                                        else:
                                            return old_w_j - eta * ( predicted - expected  )* x[j - 1]
                                    
                                    def activation_function(w0, w1, w2, x1, x2):
                                        """ Calculer la fonction d'activation pour le vecteur x = (x1,x2) ayant les poids/coefficients w0, w1 et w2
                                        """    
                                        linear_combi = w0 + w1 * x1 + w2 * x2
                                        return sigmoid(linear_combi)
                                        #return seuil(linear_combi)
                                        #return linear_combi (identité)
                                    
                                    # Etat initial
                                    print("--- initial  -----------")
                                    print( "Valeur de w_0 : {}".format(w_0))
                                    print( "Valeur de w_1 : {}".format(w_1))
                                    print( "Valeur de w_2 : {}".format(w_2))
                                    print('\n')
                                    
                                    # Gardons un oeil sur les résultats des fonctions d'activation, pour voir si elles convergent
                                    arr_0_0 = []
                                    arr_0_1 = []
                                    arr_1_0 = []
                                    arr_1_1 = []
                                    
                                    # Itérations
                                    for i in range(0,X.shape[0]):
                                    
                                        # Calcul des nouveaux poids
                                        new_w_0 = compute_new_w_j( 0, w_0, X[i], y[i], activation_function( w_0, w_1 , w_2, X[i][0], X[i][1]), eta=ETA )
                                        new_w_1 = compute_new_w_j( 1, w_1, X[i], y[i], activation_function( w_0, w_1 , w_2, X[i][0], X[i][1]), eta=ETA )
                                        new_w_2 = compute_new_w_j( 2, w_2, X[i], y[i], activation_function( w_0, w_1 , w_2, X[i][0], X[i][1]), eta=ETA )
                                    
                                        # Mise à jour des poids
                                        w_0 = new_w_0
                                        w_1 = new_w_1
                                        w_2 = new_w_2
                                    
                                        # Stocker dans les tableaux arr_*_* les résultats actuels de la fonction d'activation
                                        arr_0_0.insert(len(arr_0_0), activation_function( w_0, w_1 , w_2, 0 , 0 ))
                                        arr_0_1.insert(len(arr_0_1), activation_function( w_0, w_1 , w_2, 0 , 1 ))
                                        arr_1_0.insert(len(arr_1_0), activation_function( w_0, w_1 , w_2, 1 , 0 ))
                                        arr_1_1.insert(len(arr_1_1), activation_function( w_0, w_1 , w_2, 1 , 1 ))    
                                    
                                    # Etat final
                                    print("--- final  -----------")
                                    print( "Valeur de w_0 : {}".format(w_0))
                                    print( "Valeur de w_1 : {}".format(w_1))
                                    print( "Valeur de w_2 : {}".format(w_2))
                                    print('\n')
                                    
                                    print( "ET (0,0) vaut :",activation_function( w_0, w_1 , w_2, 0 , 0 ))
                                    print( "ET (0,1) vaut :",activation_function( w_0, w_1 , w_2, 0 , 1 ))
                                    print( "ET (1,0) vaut :",activation_function( w_0, w_1 , w_2, 1 , 0 ))
                                    print( "ET (1,1) vaut :",activation_function( w_0, w_1 , w_2, 1 , 1 ))    
                                    
                                    # Affichage de la convergence
                                    plt.figure()
                                    plt.plot( list(range(0,len(arr_0_0))), arr_0_0 ) 
                                    plt.plot( list(range(0,len(arr_0_1))), arr_0_1 ) 
                                    plt.plot( list(range(0,len(arr_1_0))), arr_1_0 ) 
                                    plt.plot( list(range(0,len(arr_1_1))), arr_1_1 ) 
                                    plt.legend(['0 ET 0', '0 ET 1', '1 ET 0', '1 ET 1' ])
                                    
                                    
                                    fig = plt.figure()
                                    ax = plt.axes()
                                    
                                    ax.scatter(0,0,color='blue')
                                    ax.scatter(0,1,color='blue')
                                    ax.scatter(1,0,color='blue')
                                    ax.scatter(1,1,color='red')
                                    
                                    
                                    x = np.linspace(0,1)
                                    y =( - w_1 * x - w_0 ) / w_2
                                    ax.plot(x,y)
                                    
                                    plt.show()

                                    Et au passage, je pense qu'il y a une coquille dans la règle de mise à jour des poids :

                                    Il faut échanger de place y(i) et f(x(i)) - car sinon vous vous éloignez du poids optimal pour expliquer x(i)...

                                    Christophe

                                    -
                                    Edité par ChristopheNaciri 11 février 2022 à 13:21:50

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      19 mars 2022 à 22:51:57

                                      Bonjour,

                                      En effet certaines réponses du quizz peuvent interpeller.

                                      - En essayant de donner du sens à la réponse pas très intuitive qui est donnée à la question 7, on pourrait se dire (à posteriori!) que:
                                      si Y = a*X, Y est linéaire suivant la variable X et linéaire suivant le paramètre a
                                      si Y = a*X², Y est non-linéaire suivant la variable X et linéaire suivant le paramètre a
                                      si Y = a²*X, Y est linéaire suivant la variable X et non-linéaire suivant le paramètre a

                                      Le 2e graphique montre une forme parabolique similaire à Y = a * X² donc linéaire suivant le(s) paramètre(s). Par exemple en posant Z=X² on obtient un modèle linéaire Y = a * Z

                                      Le 3e graphique est du type Y² + X² = a (en simplifiant) et donc l'équation de la courbe de séparation est Y = +/-racine(a - X²) qui n'est pas linéaire en a.


                                      - Pour la question sur la modélisation de "AND", apparemment il est possible de trouver des perceptrons qui modélisent la fonction. Contrairement à la fonction XOR on peut tracer une droite qui sépare les 2 classes, par exemple x1 + x2 -1.5 = 0
                                      Si on considère un perceptron avec 2 unités en entrée et une unité en sortie avec les paramètres w1=1.0, w2=1.0 et b=-1.5 + une fonction d'activation de type seuil qui donne 1 si x>=0 et 0 si x<0:
                                      1 + 1 -> 1.0*1 + 1.0*1 - 1.5 =  0.5 -> 1
                                      1 + 0 -> 1.0*1 + 1.0*0 - 1.5 = -0.5 -> 0
                                      0 + 1 -> 1.0*0 + 1.0*1 - 1.5 = -0.5 -> 0
                                      0 + 0 -> 1.0*0 + 1.0*0 - 1.5 = -1.5 -> 0

                                      • Partager sur Facebook
                                      • Partager sur Twitter

                                      [Cours] ML supervisé non linéaire

                                      × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                      • Editeur
                                      • Markdown