Partage
  • Partager sur Facebook
  • Partager sur Twitter

[Cours] Initiez-vous au machine learning

Découvrez les bases du machine learning

    13 novembre 2019 à 11:44:05

    Charles-HenriDupire a écrit:

    bonjour, 

    est-ce que ton fichier est bien dans le même dossier que ton fichier notebook? Sinon il faut soit le déplacer, soit mettre le chemin absolu à la place de 'house.csv'


    Merci Charles-Henri, ça marche désormais
    • Partager sur Facebook
    • Partager sur Twitter
      11 décembre 2019 à 15:42:27

      Bonjour,

      J'ai fini ce cours et ai décidé de faire l'activité à la fin. J'ai voulu (peut être est-ce là l'erreur) appliquer la méthode des plus proches voisins à cet exemple.
      Et les erreurs que je trouve sont énormes (95%). En reprenant bêtement le code j'ai trouvé que ça ne passait pas pour le knn.fit() car je n'avais pas de array-like en entrée. Si qqn a une idée d'où vient mon problème je suis preneuse! bonne journée et merci d'avance :)

      import numpy as np
      import pandas as pd
      import matplotlib.pyplot as plt




      # On charge le dataset
      house_data = pd.read_csv('house.csv')
      x=house_data['surface']
      y=house_data['loyer']
      from sklearn.model_selection import train_test_split
      xtrain, xtest, ytrain, ytest = train_test_split(x, y, train_size=0.8)
      xtrain=xtrain.values.reshape(-1,1)
      xtest=xtest.values.reshape(-1,1)


      #Méthode plus proches voisins
      from sklearn import neighbors
      knn = neighbors.KNeighborsClassifier(n_neighbors=3)
      knn.fit(xtrain, ytrain)
      error = 1 - knn.score(xtest, ytest)
      print('Erreur: %f' % error)

      • Partager sur Facebook
      • Partager sur Twitter
        12 décembre 2019 à 11:17:02

        Vous utilisez un classifieur alors qu'il s'agit d'un problème d'estimation.
        Classifier, c'est mettre dans des cases : "ceci est un chat", "ceci est un hélicoptère", etc.
        Estimer, c'est donner une valeur : "ceci vaut environ 120 €".

        Si vous avez 5 voisins qui valent 120, 120, 180, 183, 190, alors votre KNeighborsClassifier va renvoyer "120" parce que c'est le résultat le plus fréquent. Un estimateur KNN aurait renvoyé une moyenne ou une médiane, c'est-à-dire environ 180.
        Votre classifieur fait ça parce qu'il considère que les nombres sont des classes (= des cases, des boîtes...), et celle qui est la plus représentée est 120. Donc il vous dit : "Ceci est un '120' ".

        Je vous laisse trouver le bon estimateur à utiliser. Il n'est pas dans le cours, il faut le chercher dans la doc.

        NB : Au-delà de ça, ça n'a pas de sens de vouloir utiliser un KNN sur les arrondissements. La proximité des numéros d'arrondissements n'implique pas une proximité des loyers.
        Mais il est un peu difficile à ce stade de trouver par soi-même un modèle pertinent. Vous ne serez pas pénalisée pour avoir utilisé un KNN.

        • Partager sur Facebook
        • Partager sur Twitter
          20 décembre 2019 à 10:23:13

          BenjaminHannache a écrit:

          Bonjour à tous,

          Je suis resté bloqué quelque temps au chapitre "TP Entrainez le modèle des plus proches voisins KNN."

          En effet, La commande "mnist = fetch_mldata('MNIST original', data_home='./scikit_learn_data')" ne permettait pas récupérer le dataset : donc impossible réaliser le TP.

          Le problème est apparu plusieurs fois, (cf le forum Open Classroom et le Github de Scikit Learn) , car la source du data set est injoignable.

          J'ai donc trouvé une source alternative ici :https://github.com/amplab/datascience-sp14/raw/master/lab7/mldata/mnist-original.mat

          En plaçant le fichier dans le repertoire './scikit_learn_data/mddata', ca fonctionne ! (nom du dossier à adapter en fonction de celui que vous spécifiez en appelant la fonction fetch_mldata.

          -
          Edité par BenjaminHannache 22 juillet 2018 à 15:48:55

          A ce propos, j'aurai des questions à propos de l'activité du cours clustering, mais il n'y a apparemment pas de forum dédié...

          • Partager sur Facebook
          • Partager sur Twitter
            10 janvier 2020 à 0:03:46

            Bonjour,

            je suis débutant en codage python et je me suis intéressé à ce mooc. J'utilise Jupyter.

            Voici le code que j'ai pu élaboré pour l'instant pour l'exercice de l'activité qui concerne le dataset, prix, surface, arrondissement à faire évoluer.

            Je trouve que les notions dans ce mooc ne sont pas très accessibles, j'ai l'impression de faire sans comprendre et ce faisant, je ne peux expliquer pourquoi j'obtiens tel ou tel résultat.

            Par exemple mon nuage de point est bizarre et j'ai une droite à la base de mon axe.

            Aussi, ca serait vraiment sympathique si quelqu'un pouvait m'expliquer point par point la démarche, son effet sur le dataset, comment se deroule sa transcription sur python ainsi que la notion de training et testing (que je comprends via le cours mais je ne comprends pas la ligne de code et son implication par rapport au graphique et au dataset).

            Merci aux bonnes âmes qui voudront bien m'expliquer.

            Al

            import numpy as np
            import pandas as pd
            import matplotlib.pyplot as plt
            house_data=pd.read_csv(r'house_data.csv')
            plt.plot(house_data['surface'], house_data['arrondissement'], house_data['price'], 'ro', markersize=2)
            
            
            plt.show()
            
            
            X = np.matrix([np.ones(house_data.shape[0]), house_data['surface'].to_numpy(), house_data['arrondissement'].to_numpy()]).T
            y = np.matrix(house_data['price']).T
            
            from sklearn.model_selection import train_test_split
             
                
            xtrain, xtest, ytrain, ytest = train_test_split(X, y, train_size=0.8)
            
            theta = np.linalg.inv(xtrain.T.dot(xtrain)).dot(xtrain.T).dot(ytrain)
             
            print(theta)


            • Partager sur Facebook
            • Partager sur Twitter
              10 janvier 2020 à 9:37:28

              Tu donnes 3 arguments à ta fonction plot : les surfaces, les arrondissements et les loyers.
              À en croire la documentation, ce n'est pas une syntaxe habituelle. Mais je suppose qu'il te représente :

              • les loyers en fonction de la surface (ok, c'est ce qui est dans le cours)
              • les numéros d'arrondissements en fonction de la surface, ce qui n'a aucun intérêt et qui te dessine une série de points très proche de l'axe des abscisses (car les numéros d'arrondissements sont des petits nombres).

              Le problème est que tu ne sais probablement pas toi-même ce que tu veux représenter. À quoi te sert-il d'avoir les arrondissements sur l'axe des ordonnées ??!?
              Si tu veux une visualisation, il vaut mieux que tu fasses un graphique différent pour chaque arrondissement. Et encore, ce n'est peut-être pas très utile.

              Ensuite, ne te prends pas la tête avec linalg. Utilise les modèles scikit-learn !
              Tu en trouves déjà un certain nombre dans le cours, et si tu es curieux tu peux en trouver d'autres tout aussi simples dans la documentation. Par exemple une régression quadratique ?

              La suite du parcours data scientist te permettra d'apprendre à manipuler de nombreux autres modèles. Ce n'est pas encore l'objectif de ce cours.

              La fonction train_test_split te fait une partition des données. Elle renvoie un tableau de 4 valeurs [X_train, X_test, y_train, y_test].
              En Python, on peut faire une affectation mutiple c'est-à-dire que ta ligne est équivalente à :

              split = train_test_split(X, y, train_size=0.8)
              xtrain = split[0]
              xtest = split[1]
              ytrain = split[2]
              ytest = split[3]
              • Partager sur Facebook
              • Partager sur Twitter
                7 mai 2020 à 12:44:52

                Bonjour, dans la partie 3 on donne la fonctionne du maximum de vraissemblance

                https://openclassrooms.com/fr/courses/4011851-initiez-vous-au-machine-learning/4120981-construisez-un-modele-statistique#/id/r-4121037

                https://openclassrooms.com/fr/courses/4011851-initiez-vous-au-machine-learning/4120981-construisez-un-modele-statistique#/id/r-4121038

                L(θ) est la vraisemblance d'un jeu d'observations.

                Est ce que ce jeu, c'est celui qui est donné par le Data Scientist au tout départ?

                Vu qu'on doit trouver son maximum, la fonction L(teta) est donc une courbe et non pas une droite dans le cas de la modélisation par le maximum de vraisemblance ?

                Merci

                • Partager sur Facebook
                • Partager sur Twitter
                  11 mai 2020 à 9:30:49

                  Le jeu d'observations est bien le jeu de départ.

                  La fonction \(L\) n'est ni une courbe ni une droite. Une courbe ou une droite servent à représenter une fonction de 1 paramètre (comme les graphiques que tu fais au lycée, où le paramètre s'appelle \(x\)). Ici, \(L\) a autant de paramètres qu'en nécessite le modèle : \(\theta\) est un vecteur \((\theta_{0}, \theta_{1},... \theta_{i})\).

                  Si le modèle est parfait, c'est-à-dire si le vecteur \(\theta\) contient les meilleures valeurs possibles et que le modèle permet de représenter complètement la réalité, alors \(L(\theta) = 1\). Ce n'est que de la théorie, en pratique \(L\) est rarement une fonction connue.

                  -
                  Edité par Zachee54 11 mai 2020 à 9:32:19

                  • Partager sur Facebook
                  • Partager sur Twitter
                    17 mai 2020 à 1:59:21

                    Bonjour,

                    pour la solution du tp final il me semble qu'il y a problème de ( In 205 )

                    list out of range

                    possiblement corrigé par 

                    final_pred.append(lrs[int(4.0 if val["arrondissement"] == 10 else val["arrondissement"] - 1)].predict([[val["surface"]]])[0][0])

                    -
                    Edité par YannChapron 17 mai 2020 à 2:01:15

                    • Partager sur Facebook
                    • Partager sur Twitter
                      16 juin 2021 à 15:27:32

                      Bonjour,

                      Je n'ai pas trouvé de réponses alors je vous sollicite ici.

                      dans le chapitre "Entrainez votre premier k-NN", lorsqu'il s'agit d'échantillonner "pour faciliter le travail", le code me retourne une KeyError assez longue et que je n'arrive pas à comprendre du tout. du coup pas de solution...

                      la ligne problématique est celle-ci:

                      sample = np.random.randint(70000, size=5000)
                      data = mnist.data[sample]
                      target = mnist.target[sample]

                      apparemment le:

                      data = mnist.data[sample]
                      

                      ne lui plait pas du tout.

                      l'erreur, si ça peut aider quelqu'un qui parle la langue:

                      KeyError                                  Traceback (most recent call last)
                      <ipython-input-17-fc73512e1844> in <module>
                            1 sample = np.random.randint(70000, size=5000)
                      ----> 2 data = mnist.data[sample]
                            3 target = mnist.target[sample]
                      
                      ~\anaconda3\lib\site-packages\pandas\core\frame.py in __getitem__(self, key)
                         3028             if is_iterator(key):
                         3029                 key = list(key)
                      -> 3030             indexer = self.loc._get_listlike_indexer(key, axis=1, raise_missing=True)[1]
                         3031 
                         3032         # take() does not accept boolean indexers
                      
                      ~\anaconda3\lib\site-packages\pandas\core\indexing.py in _get_listlike_indexer(self, key, axis, raise_missing)
                         1264             keyarr, indexer, new_indexer = ax._reindex_non_unique(keyarr)
                         1265 
                      -> 1266         self._validate_read_indexer(keyarr, indexer, axis, raise_missing=raise_missing)
                         1267         return keyarr, indexer
                         1268 
                      
                      ~\anaconda3\lib\site-packages\pandas\core\indexing.py in _validate_read_indexer(self, key, indexer, axis, raise_missing)
                         1306             if missing == len(indexer):
                         1307                 axis_name = self.obj._get_axis_name(axis)
                      -> 1308                 raise KeyError(f"None of [{key}] are in the [{axis_name}]")
                         1309 
                         1310             ax = self.obj._get_axis(axis)
                      
                      KeyError: "None of [Int64Index([37625, 63879, 51467, 12210, 18150,  1241, 26752, 64967, 36158,\n             8782,\n            ...\n            31246, 66050, 23081, 21274,  5536, 53878, 32002, 60630, 69784,\n            34042],\n           dtype='int64', length=5000)] are in the [columns]"

                      J'ai essayé une autre manière d'échantillonner adapté d'un poste sur stackoverflow:

                      from numpy.random import default_rng
                      rng = default_rng()
                      sample = rng.choice(70000, size=5000, replace = False)

                      mais ça n'a rien changé. Merci d'avance pour l'aide.



                      • Partager sur Facebook
                      • Partager sur Twitter
                        17 juin 2021 à 12:17:36

                        EDIT DE MON MESSAGE A LA SUITE /!\

                        Hello tout le monde, 

                        Je suis dans la même situation que adneneguessoum1 et je pense que ça vient du fait de pas comprendre exactement comment manipuler mnist.data.... Parce que même extraire 1 seul tableau (donc une seule image), j'ai du mal... Si quelqu'un comprend pourquoi. Peut être que la librairie a changée? 

                        Merci d'avance également pour l'aide :) 

                        PS : je sais pas si tu as vu ici : "https://mrmint.fr/mnist-knn-handwritten-tutorial", ils modifient le set de données pour le manipuler différemment perso ça me convient pas tellement mais c'est une piste. 

                        EDIT :

                        Je reviens pour montrer la solution que j'ai trouvé et qui fonctionne chez moi. j'ai du changer la gestion de "mnist" pour que tout fonctionne. je suis passé en np.array, mais fonctionne également avec panda. 

                        from sklearn.datasets import fetch_openml
                        mnist = fetch_openml('mnist_784', version=1)
                        #%%
                        sample = np.random.randint(70000, size=5000)
                        
                        data_size = mnist.data.shape[0]
                        sample = np.random.randint(data_size, size=int(data_size*0.1))
                        
                        #Je transforme en np.array pour manipuler. Fonctionne également en panda data=pd.DataFrame(mnist['data'].iloc[sample])
                        data=np.array(mnist['data'].iloc[sample])
                        target = np.array(mnist['target'].iloc[sample])
                        #%%
                        #séparer training (80%) et testing set (20)
                        from sklearn.model_selection import train_test_split
                        xtrain, xtest,ytrain, ytest = train_test_split(data, target, train_size = 0.8)
                        #premier classifieur 3-NN : 
                        from sklearn import neighbors
                        knn = neighbors.KNeighborsClassifier(n_neighbors=3)
                        knn.fit(xtrain, ytrain)
                        error = 1 - knn.score(xtest, ytest)
                        print('Erreur: %f' % error)
                        #Optimisation du score sur les données
                        errors = []
                        for k in range(2,15):
                            knn = neighbors.KNeighborsClassifier(n_neighbors=k)
                            errors.append(100*(1 - knn.fit(xtrain, ytrain).score(xtest, ytest)))
                            
                        plt.plot(range(2,15), errors, '+-')
                        
                        #%%
                        # On récupère le classifieur le plus performant
                        knn = neighbors.KNeighborsClassifier(4)
                        knn.fit(xtrain, ytrain)
                        
                        # On récupère les prédictions sur les données test
                        predicted = knn.predict(xtest)
                        
                        # On redimensionne les données sous forme d'images
                        images = np.array(xtest).reshape((-1, 28, 28))
                        
                        # On selectionne un echantillon de 12 images au hasard
                        select = np.random.randint(images.shape[0], size=12)
                        
                        # On affiche les images avec la prédiction associée
                        fig,ax = plt.subplots(3,4)
                        
                        for index, value in enumerate(select):
                            plt.subplot(3,4,index+1)
                            plt.axis('off')
                            plt.imshow(images[value],cmap=plt.cm.gray_r,interpolation="nearest")
                            plt.title('Predicted: {}'.format( predicted[value]) )
                        
                        plt.show()

                        Bonne continuation :)




                        -
                        Edité par AlexandreSouchaud 17 juin 2021 à 16:19:34

                        • Partager sur Facebook
                        • Partager sur Twitter
                          26 juillet 2021 à 12:26:15

                          Cours excellent et facile, je l'ai apprécié
                          • Partager sur Facebook
                          • Partager sur Twitter

                          Apprendre, apprendre et apprendre encore

                            19 octobre 2021 à 17:44:04

                            Bonsoir è tous,

                            pour quoi on met un T majuscule sur les observations ou prédictions dans la formule de regression liniaire ici: https://openclassrooms.com/fr/courses/4011851-initiez-vous-au-machine-learning/4121986-programmez-votre-premiere-regression-lineaire#/id/r-4122047

                            • Partager sur Facebook
                            • Partager sur Twitter
                              21 octobre 2021 à 11:30:17

                              Bonjour,

                              quelqu'un peut il m'expliquer ces lignes de code dans la correction du TP sur les loyers :

                              final_pred = []
                              
                              for idx,val in xtest.iterrows():
                                  final_pred.append(lrs[int(val["arrondissement"]-1)].predict([[val["surface"]]])[0][0])


                              Je comprends qu'on va stocker dans la liste final_pred les valeurs prédites pour le prix, mais c'est 

                              lrs[int(val["arrondissement"]-1)]

                              qui me pose problème et d'où sort le -1 ?

                              D'autant plus que quand j'exécute le code, j'ai une erreur "list index out of range"

                              Merci d'avance pour votre aide !

                              • Partager sur Facebook
                              • Partager sur Twitter
                                24 novembre 2021 à 11:30:31

                                Aghiles Gharbi a écrit:

                                Bonsoir è tous,

                                pour quoi on met un T majuscule sur les observations ou prédictions dans la formule de regression liniaire ici: https://openclassrooms.com/fr/courses/4011851-initiez-vous-au-machine-learning/4121986-programmez-votre-premiere-regression-lineaire#/id/r-4122047


                                C'est parce qu'on doit transposer le vecteur. Par convention ce sont des vecteurs colonnes, et pour les mettre en premier terme d'une multiplication matricielle il faut les considérer comme des vecteurs lignes. C'est tout.

                                Marie-FranceLaroche-Barthet a écrit:

                                Je comprends qu'on va stocker dans la liste final_pred les valeurs prédites pour le prix, mais c'est 

                                lrs[int(val["arrondissement"]-1)]

                                qui me pose problème et d'où sort le -1 ?

                                lrs est une liste de régressions linéaires. On en a créée une par arrondissement. Elle est donc indexée de 0 à n-1, où n est le nombre d'arrondissements.

                                Le problème est que les arrondissements, eux, sont numérotés de 1 à n. Donc il faut enlever 1 pour que cela corresponde aux index de lrs.

                                Ça suppose que les régressions dans lrs aient été créées dans l'ordre croissant des numéros d'arrondissement. Et là, j'ai un doute sur la correction parce qu'à la lecture rapide je ne vois pas de clause de tri au moment de créer lrs...

                                -
                                Edité par Zachee54 24 novembre 2021 à 11:39:38

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  29 novembre 2021 à 12:17:13

                                  Après avoir galérer à trouver comment importer le dataset mnist, je me permets de vous partager la solution. Je ne suis pas aller plus loin en cherchant à quoi est dû la différence entre le code donné dans le cours et cette solution :

                                  from sklearn.datasets import fetch_openml
                                  
                                  # Load data from https://www.openml.org/d/554
                                  data, target = fetch_openml("mnist_784", version=1, return_X_y=True)
                                  data = data / 255.0

                                  La sortie du jeu de données n'est plus manipulable par "mnist.data" et "mnist.target", mais tout simplement par "data" et "target". De plus, lors de l'échantillonnage, le code du cours m'a aussi renvoyé une erreur. Après quelques essaies, voici la solution que j'ai trouvé :

                                  data = data[data.index.isin(sample)]
                                  target = target[target.index.isin(sample)]

                                  Enfin, la dernière erreur apparue se trouve dans le code d'affichage des prédictions. Cela me renvoyait comme erreur que dataframe n'avait pas d'attribut "reshape". Après des recherches google, voici comment je l'ai corrigé. 

                                  # On redimensionne les données sous forme d'images
                                  images = xtest.values.reshape((-1, 28, 28))

                                  Sinon tout le reste était correct.

                                  Voilà, si ça peut aider certains à ne pas perdre trop de temps comme moi...

                                  • Partager sur Facebook
                                  • Partager sur Twitter

                                  Blandine DUCLOS

                                  Étudiante en formation Data Scientist

                                  [Cours] Initiez-vous au machine learning

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