-
Edité par RichardChazal1 19 novembre 2019 à 4:44:57

RichardChazal1 a écrit:

Effectivement, je suis très léger en programmation python. J'avoue ne rien avoir compris au cours "apprendre à programmer en python". Et je n'utilise que python 3 avec Anaconda.

Je vois mal comment tu vas pouvoir suivre ce cours et les autres cours Data sans bonnes notions de Python.
Tu devrais sans doute concentrer tes efforts là-dessus, ça te fera gagner du temps ensuite sur les cours Data.

Python est vraiment un langage très simple, au point que beaucoup de collégiens de 12 ans commencent par ce langage. En bossant le cours Python tu devrais y arriver. Sinon, prends un autre cours sur internet. Le tutoriel officiel est bien fait.

RichardChazal1 a écrit:

Le KNN est supposé prendre ses folds, et faire 4 versus 1 à chaque fois, et je dois collecter les résultats ? Or, comme les folds ne sont pas définis en terme de dataframe, je ne peux pas répéter 5 instructions de KNN...

Inspire-toi des exemples de la documentation officielle (user guide, API...).

Voilà ce que dit l'énoncé :

Vous comparerez les performances à l’aide d’une baseline naïve

Et voilà ce que dit le cours sur les approches "naïves" : https://openclassrooms.com/fr/courses/4297211-evaluez-et-ameliorez-les-performances-dun-modele-de-machine-learning/4308281-comparez-votre-algorithme-a-des-approches-de-regression-naives#/id/r-4334395

Je veux pas dire, mais je t'ai déjà signalé en long, en large et en travers que "Naive Bayes" n'est pas une "baseline naïve". Et je t'ai expliqué pourquoi.

RichardChazal1 a écrit:

Si c'est utiliser la librairie, ça va, mais si c'est créer la fonction...

Quand l'énoncé dit "à implémenter vous-même", c'est sans ambiguïté : tu es censé écrire la fonction.

Tu l'as bien fait pour l'activité précédente, non ? Donc c'est faisable.

Zachee54 a écrit:

RichardChazal1 a écrit:

Effectivement, je suis très léger en programmation python. J'avoue ne rien avoir compris au cours "apprendre à programmer en python". Et je n'utilise que python 3 avec Anaconda.

Je vois mal comment tu vas pouvoir suivre ce cours et les autres cours Data sans bonnes notions de Python.
Tu devrais sans doute concentrer tes efforts là-dessus, ça te fera gagner du temps ensuite sur les cours Data.

Python est vraiment un langage très simple, au point que beaucoup de collégiens de 12 ans commencent par ce langage. En bossant le cours Python tu devrais y arriver. Sinon, prends un autre cours sur internet. Le tutoriel officiel est bien fait.

RichardChazal1 a écrit:

Le KNN est supposé prendre ses folds, et faire 4 versus 1 à chaque fois, et je dois collecter les résultats ? Or, comme les folds ne sont pas définis en terme de dataframe, je ne peux pas répéter 5 instructions de KNN...

Inspire-toi des exemples de la documentation officielle (user guide, API...).

Voilà ce que dit l'énoncé :

Vous comparerez les performances à l’aide d’une baseline naïve

Et voilà ce que dit le cours sur les approches "naïves" : https://openclassrooms.com/fr/courses/4297211-evaluez-et-ameliorez-les-performances-dun-modele-de-machine-learning/4308281-comparez-votre-algorithme-a-des-approches-de-regression-naives#/id/r-4334395

Je veux pas dire, mais je t'ai déjà signalé en long, en large et en travers que "Naive Bayes" n'est pas une "baseline naïve". Et je t'ai expliqué pourquoi.

RichardChazal1 a écrit:

Si c'est utiliser la librairie, ça va, mais si c'est créer la fonction...

Quand l'énoncé dit "à implémenter vous-même", c'est sans ambiguïté : tu es censé écrire la fonction.

Tu l'as bien fait pour l'activité précédente, non ? Donc c'est faisable.

Ces collégiens doivent être plus doués que moi. Je connais quelques langages simples (Papyrus, HTML...). J'ai fait pas mal de petits cours en python (celui avec les citations de San Antonio, entre autres, je bidouille des scripts python pour Renpy). J'ai réussi l'activité du cours "initiation au machine learning" et autres cours de ce niveau utilisant python. J'ai échoué au cours libraires pythons pour les data sciences sur le problème de monty hall et la conversion de dates. Voilà mon niveau.

Je n'ai pas réussi à compléter la première activité du cours : si la boucle que tu m'as donné en exemple m'a aidé à construire celle qu'il faut pour tester le nombre de voisins et récupérer l'accuracy, mais je suis coincé avec les kfolds : je pense que je dois faire d'abord la boucle qui permet de tester les 5 kfolds, et imbriquer dedans la boucle qui teste le nombre de voisins (ainsi, pour chaque kfold, je teste tous les voisins), mais je ne sais pas comment je peux appeler les kfolds générés par cette fonction, et les utiliser avec l'algo.

Concernant la baseline naive, tu l'as dit, j'ai compris... et je suis coincé : autant pour un problème de régression, un régression linéaire aura fait l'affaire, autant pour une classification, je ne sais pas quoi utiliser...

Dans ce cas, très clairement, tu as besoin de bosser le Python avant d'aller plus loin. L'initiation au machine learning n'était pas une initiation au Python.

RichardChazal1 a écrit:

Concernant la baseline naive, tu l'as dit, j'ai compris... et je suis coincé : autant pour un problème de régression, un régression linéaire aura fait l'affaire, autant pour une classification, je ne sais pas quoi utiliser...

Bonjour

Après avoir bossé la syntaxe de python, j'ai réussi à créer une fonction basée sur Kfolds (5 folds, non randomisés), qui prend comme entrées une liste des voisins et le nombre de folds à créer, et me sors la moyenne des accuracy (ainsi que l'accuracy pour chaque fold) pour chaque nombre de voisins.

Je ne sais pas encore automatiser la sélection du meilleur nombre de voisins en fonction de la meilleur accuracy moyenne... devons nous implémenter cela aussi ?

Autre chose : ma fonction et gridsearchCV ne fournissent pas les mêmes résultats... quelle marge d'erreur est tolérée (nombres de voisins, accuracy ?).

Cordialement

-
Edité par RichardChazal1 10 décembre 2019 à 1:19:08

Bonjour,

Oui, il faut implémenter la sélection du meilleur k par validation croisée.

Si ta fonction ne donne pas la même chose que GridSearchCV, c'est sans doute dû à la constitution des folds. Par défaut, il utilise un StratifiedKFold.

On ne parle pas de marge d'erreur parce que chacun fait quelque chose de différent, et qu'on ne va pas comparer avec GridSearchCV. L'important, c'est que ta démarche et ton analyse soient correctes.

Bon, évidemment, si tu donnes le même KFold et le même scoring à GridSearchCV et qu'il te renvoie complètement autre chose que ta fonction, c'est peut-être qu'il y a une erreur quelque part...

Zachee54 a écrit:

Bonjour,

Oui, il faut implémenter la sélection du meilleur k par validation croisée.

Si ta fonction ne donne pas la même chose que GridSearchCV, c'est sans doute dû à la constitution des folds. Par défaut, il utilise un StratifiedKFold.

On ne parle pas de marge d'erreur parce que chacun fait quelque chose de différent, et qu'on ne va pas comparer avec GridSearchCV. L'important, c'est que ta démarche et ton analyse soient correctes.

Bon, évidemment, si tu donnes le même KFold et le même scoring à GridSearchCV et qu'il te renvoie complètement autre chose que ta fonction, c'est peut-être qu'il y a une erreur quelque part...

ça y est, ma fonction donne non seulement le détail, mais aussi la meilleure accuracy moyenne et le nombre de voisins correspondants.

Il y avait une erreur liée à l'absence de purge des listes entre chaque itération de boucle for.

Niveaux résultats, j’obtiens certes des résultats différents ce ceux du TP, mais ma fonction et gridsearchCV donne le même nombre de voisins que gridsearchCV, et un résultat d'accuracy identique à 0.01 ou 0.001 près, en cross validation et en prédiction. Je pense donc que c'est bon...

Je vais pouvoir donc finaliser le fichier avant de l'envoyer...

Concernant la seconde activité :

- comment optimiser le naive bayses ? Et peut-on recycler et adapter la fonction gridsearchCV faite pour la première activité ?

Combien de fois faudra-t-il te dire qu'il s'agit d'une baseline naïve, pas d'une Naive Bayes ?

Si tu avais compris la différence entre les deux, tu ne te poserais même pas la question.

Je renonce à t'expliquer davantage ce que je t'ai déjà répété de trop nombreuses fois.

Bonjour à tous,

Dans l'activité "implémenter une validation croisée", je n'arrive pas à obtenir les mêmes résultats que dans le TP précédents. J'en suis même très loin.

Là où dans le TP on trouve un score maximisé pour un hyperparamètre autour de 70%. Avec mon implémentation je trouve un score quasi identique pour tous les hyperparamètres de 40-41%.

Pourtant, j'ai l'impression que ma logique est bonne. Mon code est ci-dessous (il s'execute à la suite du TP en se basant sur les X et Y déjà normalisés).

Si quelqu'un voit d'où peut venir mon problème j'en serais reconnaissant car là je sèche !

Merci d'avance.

from sklearn.model_selection import KFold
from sklearn.model_selection import train_test_split

def recherche_grille(n_fold, list_hyperpara):
    #creation du KFold
    kf = KFold(n_splits=n_fold, shuffle=False)
    #creation d'un tableau qui stockera le score pour chaque hyperparamètre
    result = []
    for p in list_hyperpara:
        #creation d'une ligne qui alimentera le tableau result avec le p et le score moyen des folds
        ligne = []
        ligne.append(p)
        #creation du tableau qui stockera le score de chaque combinaison de fold pour en faire la moyenne
        result_int = []
        #validation croisée du kNN
        for train, test in kf.split(X_train_std, y_train):
            Xtrain, Xtest, ytrain, ytest = X[train], X[test], y[train], y[test]
            kNN = neighbors.KNeighborsClassifier(p)
            kNN.fit(Xtrain, ytrain)
            result_int.append(kNN.score(Xtest, ytest))
        ligne.append(np.mean(result_int))
        result.append(ligne)
    return result



#utilisation de la fonction
hyper_p = [3, 5, 7, 9, 11, 13, 15]
nfold = 5

recherche_grille(nfold,hyper_p)

-
Edité par CédricD5 1 février 2020 à 23:13:35

Tu utilises X_train_std à la ligne 16, puis X à la ligne 17.
La ligne 16 sert seulement à sélectionner des index ; seule compte la taille de X_train_std, les valeurs sont ignorées.
Ton KNN est entraîné et testé avec les données Xtrain et Xtest que tu définis à la ligne 17, et qui viennent de X... c'est-à-dire qu'elles ne sont pas standardisées.

J'ajoute que tu as le même problème avec y_train à la ligne 16 qui devient y à la ligne 17. Mais en l'occurrence c'est sans importance car ce paramètre est ignoré par KFold. Tu peux même le supprimer dans la ligne 16.

Merci beaucoup pour ta réponse ! Ça n'était en effet que ça.

Je pensais que ce fameux X était lié au KFold, je n'avais pas saisie ce fonctionnement.

Après modification je retrouve en effet les résultats du TP. Parfait !

Bonjour,

J'utilise une validation croisée avec 10 folds créés par la méthode

1) kfold = StratifiedKFold(n_splits=10)

2) Je sépare mes données train/test:

X_train, X_test, Y_train, Y_test = model_selection.train_test_split(X, y, test_size=0.3 )

3) Ensuite pour plusieurs classifiers, je moyenne l’indicateur Accuracy obtenu sur chacun de ces 10 folds.;

cross_val_score(classifier, X_train, y=Y_train, scoring='accuracy', cv=kfold, n_jobs=4))

Pour un classifier auquel je m’intéresse j'obtiens un accuracy moyen de  0,62.

Pour confirmer ceci, je lance une prédiction du classifieur:

Y_pred_train = classifier.predict(X_train)

print(metrics.classification_report(Y_train, classifier.predict(X_train)))

Me renvoie:

        precision    recall  f1-score   support

           0       0.92      0.96      0.94      2523
           1       0.95      0.89      0.92      1923

    accuracy                           0.93      4446
   macro avg       0.93      0.93      0.93      4446
weighted avg       0.93      0.93      0.93      4446

On voit que l'accuracy ne matche pas avec celle trouvée c-dessous.

Comment l'expliquer svp? J'avoue n'avoir plus confiance ....

Merci.

Théo

Théoriquement c'est normal que l'accuracy ne matche pas parce que dans cross_val_score tu entraînes le classifieur sur des sous-ensembles du jeu d'entraînement, tandis qu'à la fin tu l'entraînes sur l'ensemble du jeu d'entraînement. Mais là, l'écart est effectivement trop important pour être crédible...

Tu peux copier tout le code stp ?

Bonjour à tous,

Je vous contacte car il me semble avoir détecté une erreur dans la correction de la question n°4 du questionnaire de fin de partie 2 du cours. (ici)

La correction stipule : "Le taux de faux négatif est de un moins la sensibilité. Pour une spécificité supérieure à 0.8, la sensibilité est supérieure à 0.95 et donc le taux de faux négatif doit être inférieure à 1 - 0.95 = 0.0.5. "

Or sur le graphe à notre disposition nous avons "1-spécificité" en abscisse et non pas "spécificité".

Du coup, j'aurais plutôt dis : "Le taux de faux négatif est de un moins la sensibilité. Pour une spécificité supérieure à 0.8, (1-spécificité) est inférieur à 0.2, ce qui nous indique sur le graphe que la sensibilité est inférieure à 0.7, et donc que le taux de faux négatif  (1-sensibilité) sera égal au minimum à 0.3 "

Ce qui concrètement dans le QCM donnerait une réponse juste de 0.3 et non 0.

Quelqu'un pourrait vérifier si je dis n'importe quoi ?

Par avance merci (et merci également à la créatrice du cours).

Bonjour,

J'ai une question concernant la standardisation des variables. Ci-dessous le bout de code extrait du cours

# standardisation des données d'entrainement
from sklearn import preprocessing
std_scale = preprocessing.StandardScaler().fit(X_train)
X_train_std = std_scale.transform(X_train)
# On applique les mêmes transformations aux données de test
X_test_std = std_scale.transform(X_test)

Je ne comprends pas pourquoi on utilise la variable std_scale pour standardiser X_test. Cela veut dire qu'il faut utiliser les paramètres de standardisation calculés sur X_train? Dans ce cas, pourquoi ne pas normaliser sur X au lieu de X_train? Avec std_scale = preprocessing.StandardScaler().fit(X).

J'ai vu également qu'il existe la méthode fit_transform. "X_train_std = preprocessing.StandardScaler().fit_transform(X_train)" est-il équivalent à "X_train_std = preprocessing.StandardScaler().fit.tranform(X_train)"?

Merci d'avance!

Hello,

Rien de rigoureux dans ma réponse, mais intuitivement, j'aurais dis que si tu calcules tes paramètres de standardisation sur ton dataset entier, eh bien quelque-part tu "contamines" ton x_test avec de l'information qui provient de ton x_train, et inversement.

Et en gros ça me semblerait bête de vouloir entraîner un modèle sur x_train, et l'évaluer sur ses prédictions de x_test , si ton x_train a déjà été modifié en fonction des données de x_test...

Concernant tes interrogations sur les méthodes du StandardScaler() : tout est dans la doc sklearn 😊

En gros la méthode .fit_transform() te permet de récupérer directement tes données standardisées :

from sklearn.preprocessing import StandardScaler()

x_train_std = StandardScaler().fit_transform(x_train) 

Au lieu par exemple de :

from sklearn.preprocessing import StandardScaler()

scaler = StandardScaler()
scaler.fit(xtrain) # requis pour .transform() ensuite
xtrain_std = scaler.transform(xtrain)

 La syntaxe que tu utilises dans ton message.. :

x_train_std = StandardScaler().fit.transform(x_train)

 ..te renverra une erreur !!

-
Edité par KJC 5 juin 2020 à 13:41:07

C'est exactement ça. On entraîne le modèle uniquement avec x_train, le but étant de voir si le modèle est ensuite capable de réagir correctement sur des données qu'il n'a jamais vu auparavant, comme x_test.

Le modèle consiste en deux choses : 1°) un preprocessing (par exemple une standardisation des données) 2°) un traitement (régression linéaire, etc).
Le preprocessing fait partie du traitement, parce que si tes données x_test sont peu nombreuses et pas assez représentatives (très petites par exemple), il ne faudrait pas que tu les mettes à l'échelle en ne te fiant qu'à elles-mêmes : tu risquerais de les traiter comme des valeurs élevées alors qu'il faut au contraire tenir compte du fait qu'elles sont petites, comparées aux données d'entraînement.

Le Scaler, comme la régression, est donc entraîné sur x_train et on voit ensuite ce que ça donne quand on applique ce Scaler et cette régression à x_test. Si ça donne quelque chose de correct, on peut considérer que le modèle fonctionne sur toutes les données. Sinon, c'est que le modèle est biaisé.

-
Edité par Zachee54 15 juin 2020 à 10:25:50

Bonjour

Je suis en train de suivre ce cours et je suis troublé par la question 4 du quizz de la partie 2.

Les abscisses des points de la courbe correspondent-ils à la spécificité (ce que semble indiquer la réponse) ou bien à 1 moins celle-ci (ce que semble indiquer le graphique) ? Le raisonnement (et la réponse) ne sont alors pas les mêmes...

Merci d'avance

bonjour, 

pour le cours Evaluez les performances d'un modele de machine learning

au chapitre Sélectionnez le nombre de voisins dans un kNN

une fois que l'on obtien les prédictions, partons sur le knn 15 (le plus satisfaisant au moment de mon test)

y_pred = clf.predict(X_test_std)
print("\nSur le jeu de test : {:.3f}".format(metrics.accuracy_score(y_test, y_pred)))

nous avons plusieurs méthode permettant d'obtenir le score et pourtant je ne retrouve pas les même valeurs

print(metrics.accuracy_score(y_test, y_pred)) # donne environ 0.6854166666666667


knn = neighbors.KNeighborsClassifier(15)
knn.fit(X_train_std, y_train)
print(knn.score(X_test_std, y_test)) # donne aussi environ 0.6854166666666667


print(r2_score(y_test, y_pred))# ne donne pas comme les deux précédentes méthodes : -0.2680417781976596

savez vous pourquoi

-
Edité par SandrineSuire 19 juin 2020 à 16:11:38

Il y a plusieurs façon d'évaluer un modèle. Comme pour dire que quelqu'un est "plus gros" que quelqu'un d'autre, tu peux choisir soit le tour de taille, soit le poids, soit...

R² n'est pas tellement un score adapté pour le KNN. D'où le sors-tu ?

Pour plus d'info : https://scikit-learn.org/stable/modules/model_evaluation.html#r2-score

Bonjour à tous.

dans ce cours, j'en suis au premier exercice: "Entrainez-vous: implémentez une validation croisée".

J'ai vu que comme d'autres ici, je n'avais pas bien saisi ce qu'il fallait faire, ou plutôt ce qu'on avait le droit d'utiliser ou non pour notre fonction. quoiqu'il en soit j'ai tenté une réponse au mieux de mes capacités .

Je n'ai pas trouvé de correction pour cette exercice. C'est un peu dommage parce que je n'arrive pas à trouver les mêmes résultats entre le cours et ma fonction.

Si quelqu'un à un peu de temps, et voit ce que je n'ai pas compris ou mal fait, je l'en remercie d'avance.

ma fonction qui prend bien en paramètres les hyper-para et le nombre de folds et retourne normalement les scores pour chaque hyper-para (ou plutôt la moyenne des scores pour chaque folds par paramètres):

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import KFold
import statistics

def custom_gridsearch(hpara, nb_folds):
    score_results = []
    hparam_accuracy = []
    #split training data en nb_folds
    #split_X = np.array_split(X_train_std, nb_folds)
    kf = KFold(n_splits = nb_folds)
    kf.split(X_train_std, ytrain)
    
    #boucle for pour chaque elt de hpara:
    for para in hpara:
        #boucle pour entrainer le modele knn sur tous folds sauf une, alternativement.
        for test, train in  kf.split(X_train_std, ytrain):
            Kneigh = KNeighborsClassifier(n_neighbors = para)
            Kneigh.fit(X_train_std[train], ytrain[train])
            sc = Kneigh.score(X_train_std[test], ytrain[test])
            #stocker le score dans une liste (append).
            score_results.append(sc)

        #recuperer le score moyen pour un para et le stocker dans la liste def
        hparam_accuracy.append(statistics.mean(score_results))

    #retourner la liste des scores moyens pour chaque para
    return hparam_accuracy

pour un test avec 5 folds et les hyper-para du cours:

hyper_params = [3,5,7,9,11,13,15]

custom_gridsearch(hyper_params, 5)

résultats:

[0.685438946528332,
 0.6864446578212291,
 0.6913227420856611,
 0.6947671214086193,
 0.6972808758978452,
 0.698696295557329,
 0.7006651536312849]

n'hésitez pas à me dire où j'ai été nul ;).

Bonjour j'ai implémenter plusieurs solutions pour  la première éval: https://openclassrooms.com/fr/courses/4297211-evaluez-les-performances-dun-modele-de-machine-learning

cependant aucune d'entre elle ne donne les valeurs exactes du score du GridSearchCV (parfois a quelques pouième près) , quelqu'un aurait-il une solution à proposer que je vois ce qui fait défaut à mon code?

A mon stade c'est frustrant de ne pas avoir de correction quand on a passé beaucoup de temps sur le problème et que la solution exacte nous échappe...