Différence entre fit et fit_transform dans les modèles scikit_learn?

Je suis débutant en science des données et je ne comprends pas la différence entre les méthodes fitet les fit_transformméthodes de scikit-learn. Quelqu'un peut-il simplement expliquer pourquoi nous pourrions avoir besoin de transformer des données?

Qu'est-ce que cela signifie d'ajuster le modèle sur les données d'apprentissage et de le transformer pour tester les données? Cela signifie-t-il, par exemple, convertir des variables qualitatives en nombres dans un train et transformer un nouvel ensemble de fonctionnalités pour tester des données?

Pour centrer les données (faites en sorte qu’elles aient une moyenne et une unité d’erreur standard), vous soustrayez la moyenne puis divisez le résultat par l’écart type.

Vous faites cela sur l'ensemble de données d'entraînement. Mais vous devez ensuite appliquer la même transformation à votre ensemble de tests (par exemple, lors de la validation croisée) ou à de nouveaux exemples obtenus avant la prévision. Mais vous devez utiliser les deux mêmes paramètres, et σ (valeurs), que vous avez utilisés pour centrer le jeu d’entraînement.$\mu$$\sigma$

Par conséquent, chaque transformation de sklearn fit()calcule simplement les paramètres (par exemple, et σ dans le cas de StandardScaler ) et les enregistre dans un état d'objet interne. Vous pouvez ensuite appeler sa méthode pour appliquer la transformation à un ensemble d'exemples particulier.$\mu$$\sigma$transform()

fit_transform()$x$$x'$fit()transform()

L'explication suivante est basée sur fit_transformde la Imputerclasse, mais l'idée est la même pour fit_transformd'autres classes de scikit_learn aiment MinMaxScaler.

transformremplace les valeurs manquantes par un nombre. Par défaut, ce nombre représente la moyenne des colonnes de certaines données que vous avez choisies. Prenons l'exemple suivant:

imp = Imputer()
# calculating the means
imp.fit([[1, 3], [np.nan, 2], [8, 5.5]])

Maintenant, les imputateurs ont appris à utiliser une moyenne (1 + 8) / 2 = 4,5 pour la première colonne et une moyenne (2 + 3 + 5,5) / 3 = 3,5 pour la deuxième colonne lorsque celle-ci est appliquée à une donnée à deux colonnes:

X = [[np.nan, 11], 
     [4,      np.nan], 
     [8,      2],
     [np.nan, 1]]
print(imp.transform(X))

on a

[[4.5, 11], 
 [4, 3.5],
 [8, 2],
 [4.5, 1]]

Ainsi, fitl'imputer calcule les moyennes des colonnes à partir de certaines données et les transformapplique à certaines données (ce qui remplace simplement les valeurs manquantes par les moyennes). Si ces deux données sont identiques (c'est-à-dire les données permettant de calculer les moyennes et les données auxquelles les moyennes sont appliquées), vous pouvez utiliser fit_transformce qui est fondamentalement un fitsuivi de a transform.

Maintenant vos questions:

Pourquoi avons-nous besoin de transformer des données?

"Pour diverses raisons, de nombreux ensembles de données du monde réel contiennent des valeurs manquantes, souvent codées sous forme de blancs, de NaN ou d'autres espaces réservés. De tels ensembles de données sont toutefois incompatibles avec les estimateurs scikit-learn qui supposent que toutes les valeurs d'un tableau sont numériques" ( source )

Qu'est-ce que cela signifie d'ajuster le modèle sur les données d'apprentissage et de le transformer pour tester les données?

L' fitimputer d'un imputer n'a rien à voir avec fitutilisé dans l'ajustement de modèle. Donc, en utilisant des imputateurs fitsur les données d'entraînement calcule simplement la moyenne de chaque colonne de données d'entraînement. L'utilisation transformde données de test remplace ensuite les valeurs manquantes des données de test par des moyennes calculées à partir des données d'apprentissage.

En termes simples, fit_transform signifie effectuer un calcul, puis une transformation (calculant la moyenne des colonnes à partir de certaines données, puis remplaçant les valeurs manquantes). Donc, pour la formation, vous devez à la fois calculer et transformer.

Mais pour le jeu de tests, Machine learning applique la prévision basée sur ce qui a été appris au cours de la formation. Ainsi, il n’a pas besoin de calculer, il effectue simplement la transformation.

Ces méthodes sont utilisées pour les transformations de jeux de données dans scikit-learn:

Prenons un exemple pour la mise à l'échelle de valeurs dans un jeu de données:

Ici, la méthode d' ajustement , lorsqu'elle est appliquée à l'ensemble de données d'apprentissage, apprend les paramètres du modèle (par exemple, la moyenne et l'écart type). Nous devons ensuite appliquer la méthode de transformation sur le jeu de données d'apprentissage pour obtenir le jeu de données d'apprentissage transformé (mis à l'échelle). Nous pourrions également effectuer ces deux étapes en une seule étape en appliquant fit_transform à l'ensemble de données d'apprentissage.

Alors pourquoi avons-nous besoin de deux méthodes distinctes: ajuster et transformer ?

En pratique, nous avons besoin d'un ensemble de données de formation et de test distinct. C'est dans ce cas qu'avoir une méthode d' ajustement et de transformation distincte est utile. Nous appliquons fit sur le jeu de données d'apprentissage et utilisons la méthode de transformation sur le jeu de données d'apprentissage et le jeu de données de test. Ainsi, la formation ainsi que le jeu de données de test sont ensuite transformés (mis à l'échelle) à l'aide des paramètres de modèle appris lors de l'application de la méthode d' ajustement au jeu de données de formation.

Exemple de code:

scaler = preprocessing.StandardScaler().fit(X_train)
scaler.transform(X_train) 
scaler.transform(X_test) 

Ce n'est pas une réponse technique, mais j'espère que cela aidera à renforcer notre intuition:

Premièrement, tous les estimateurs sont formés (ou "ajustés") à certaines données de formation. Cette partie est assez simple.

Deuxièmement, tous les estimateurs scikit-learn peuvent être utilisés dans un pipeline et l’idée d’un pipeline est que les données transitent par le pipeline. Une fois ajustées à un niveau particulier du pipeline, les données sont transmises à la prochaine étape du pipeline, mais il est évident que les données doivent être modifiées (transformées) d’une manière ou d’une autre; sinon, vous n'auriez pas besoin de cette étape dans le pipeline. La transformation est donc un moyen de transformer les données pour répondre aux besoins de la prochaine étape du pipeline.

Si vous n'utilisez pas de pipeline, je pense toujours qu'il est utile de penser à ces outils d'apprentissage automatique de cette manière, car même le classificateur le plus simple remplit toujours une fonction de classification. Il prend en entrée des données et produit une sortie. C'est aussi un pipeline; juste un très simple.

En résumé, fit effectue la formation, transform modifie les données du pipeline afin de les transmettre à la prochaine étape du pipeline et fit_transform effectue à la fois l'adaptation et la transformation en une étape éventuellement optimisée.

$V_1$$V_2$$V_1$$V_2$

En venant à une autre question, vous construisez d'abord le modèle dans l'ensemble d'apprentissage (le modèle apprend les modèles ou le comportement de vos données à partir de l'ensemble d'apprentissage) et lorsque vous exécutez le même modèle dans l'ensemble de test, il essaie d'identifier les modèles ou comportements similaires. une fois identifié, il tire ses conclusions et donne les résultats en conséquence

Considérez une tâche qui nécessite de normaliser les données. Par exemple, nous pouvons utiliser une normalisation min-max ou une normalisation z-score. Il existe certains paramètres inhérents au modèle. Les valeurs minimales et maximales dans la normalisation min-max et l'écart moyen et standard dans la normalisation du score z. La fonction fit () calcule les valeurs de ces paramètres.

La fonction de transformation applique les valeurs des paramètres aux données réelles et donne la valeur normalisée.

La fonction fit_transform () effectue les deux dans la même étape.

Notez que la même valeur est obtenue que nous effectuions en 2 étapes ou en une seule étape.

"fit" calcule la moyenne et std à utiliser pour une mise à l'échelle ultérieure . (juste un calcul), rien ne vous est donné .

"transform" utilise une moyenne et std calculées précédemment pour mettre automatiquement à l'échelle les données (soustrayez la moyenne de toutes les valeurs puis divisez-la par std).

"fit_transform" fait les deux en même temps. Donc, vous pouvez le faire avec 1 ligne de code au lieu de 2.

Maintenant, regardons cela en pratique:

Pour l' ensemble de formation X , nous effectuons "fit_transform" car nous devons calculer mean et std, puis l'utiliser pour mettre à l'échelle automatiquement les données. Pour le jeu de test X , eh bien, nous avons déjà la moyenne et la std, nous ne faisons donc que la partie "transformation".

C'est super simple. Tu te débrouilles bien. Continuez votre bon travail mon ami :-)