google traduit http://scikit-learn.org/0.18/modules/preprocessing.html [scikit-learn 0.18 User Guide 4. Dataset Conversion](http://qiita.com/nazoking@github/items/267f2371757516f8c168#4-%E3%83%87%E3%83%BC%E3%82%BF À partir de% E3% 82% BB% E3% 83% 83% E3% 83% 88% E5% A4% 89% E6% 8F% 9B)
Le package sklearn.preprocessing fournit des fonctions utilitaires communes et des classes de transformation pour transformer des vecteurs de caractéristiques bruts en représentations adaptées aux estimateurs en aval.
La ** standardisation ** de l'ensemble de données est une exigence commune ** de nombreux estimateurs d'apprentissage automatique implémentés dans scikit-learn. Si les caractéristiques individuelles ne ressemblent pas à des données distribuées normalement, c'est-à-dire avec une distribution gaussienne avec ** moyenne nulle et variance unitaire **, elles peuvent se comporter mal. En pratique, il ignore la forme de la distribution, supprime la valeur moyenne de chaque entité, transforme les données vers le centre et divise l'entité non stationnaire par l'écart type pour la mise à l'échelle. Par exemple, dans de nombreux éléments utilisés dans l'apprentissage des fonctions d'objectif d'algorithme (comme le noyau RBF des machines à vecteurs de support et les normalisateurs l1 et l2 des modèles linéaires), toutes les caractéristiques sont centrées sur zéro et distribuées dans le même ordre. Supposons que vous ayez. Si la variance d'une caractéristique est supérieure à celle d'une autre, elle peut dominer la fonction objectif et l'estimateur peut ne pas apprendre correctement des autres caractéristiques comme prévu. scale Cette fonction fonctionne sur un seul jeu de données de type tableau. Il fournit un moyen rapide et facile d'effectuer des opérations.
>>> from sklearn import preprocessing
>>> import numpy as np
>>> X = np.array([[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]])
>>> X_scaled = preprocessing.scale(X)
>>> X_scaled
array([[ 0. ..., -1.22..., 1.33...],
[ 1.22..., 0. ..., -0.26...],
[-1.22..., 1.22..., -1.06...]])
La variance moyenne et unitaire des données mises à l'échelle est nulle.
>>>
>>> X_scaled.mean(axis=0)
array([ 0., 0., 0.])
>>> X_scaled.std(axis=0)
array([ 1., 1., 1.])
De plus, le module preprocessing est une classe utilitaire [StandardScaler](http://scikit-learn.org/0.18/modules/generated/sklearn.preprocessing.StandardScaler.html#sklearn.preprocessing.StandardScaler] qui implémente l'API Transformer. ) Pour calculer la moyenne et l'écart type de l'ensemble d'apprentissage afin que la même transformation puisse être réappliquée ultérieurement à l'ensemble de test. Par conséquent, cette classe est utilisée aux premiers stades de sklearn.pipeline.Pipeline. Convient à.
Les instances de Scaler peuvent être utilisées pour de nouvelles données et transformées de la même manière que les ensembles d'apprentissage.
Soit with_mean = False ou with_std = False dans StandardScaler Vous pouvez désactiver le centrage ou la mise à l'échelle en le transmettant au constructeur.
Une autre norme est une fonction de mise à l'échelle qui permet à une valeur minimale et maximale donnée d'être comprise entre zéro et un, ou la valeur absolue maximale de chaque entité à être mise à l'échelle à une taille d'unité. y a-t-il. Il s'agit soit de MinMaxScaler ou [MaxAbsScaler](http: // scikit-learn) Cela peut être réalisé en utilisant .org / 0.18 / modules / generated / sklearn.preprocessing.MaxAbsScaler.html # sklearn.preprocessing.MaxAbsScaler). Les motivations pour utiliser cette mise à l'échelle incluent la robustesse à de très petits écarts-types des fonctionnalités et la conservation de zéro entrée de données rares. Ce qui suit est un exemple de mise à l'échelle d'une matrice de données de jouet à la plage «[0, 1]».
>>> X_train = np.array([[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[ 0.5 , 0. , 1. ],
[ 1. , 0.5 , 0.33333333],
[ 0. , 1. , 0. ]])
Vous pouvez appliquer la même instance du transformateur à certaines nouvelles données de test qui ne sont pas visibles lors de l'appel d'appareillage. Les mêmes opérations de mise à l'échelle et de décalage sont appliquées pour correspondre aux transformations effectuées sur les données d'apprentissage.
>>> X_test = np.array([[ -3., -1., 4.]])
>>> X_test_minmax = min_max_scaler.transform(X_test)
>>> X_test_minmax
array([[-1.5 , 0. , 1.66666667]])
En examinant les attributs du scaler, vous pouvez trouver la nature exacte des transformations apprises dans les données d'entraînement.
>>> min_max_scaler.scale_
array([ 0.5 , 0.5 , 0.33...])
>>> min_max_scaler.min_
array([ 0. , 0.5 , 0.33...])
MinMaxScaler reçoit un feature_range = (min, max) Si tel est le cas, la formule complète serait:
X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
X_scaled = X_std / (max - min) + min
MaxAbsScaler fonctionne beaucoup, mais les données d'entraînement sont Divisez et mettez à l'échelle la valeur maximale de chaque caractéristique afin qu'elle soit dans la plage [-1, 1]. Cela signifie des données qui sont déjà au centre de données nulles ou éparses.
Voici comment utiliser les données de l'exemple précédent avec ce scaler:
>>> X_train = np.array([[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]])
...
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs # doctest +NORMALIZE_WHITESPACE^
array([[ 0.5, -1. , 1. ],
[ 1. , 0. , 0. ],
[ 0. , 1. , -0.5]])
>>> X_test = np.array([[ -3., -1., 4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. , 2. ]])
>>> max_abs_scaler.scale_
array([ 2., 1., 2.])
Tout comme l'échelle, les modules sont une fonction utile minmax_scale si vous ne souhaitez pas créer d'objets. .minmax_scale) et maxabs_scale sont fournis.
Centrer des données clairsemées est rarement utile car il détruit la structure clairsemée des données. Cependant, les caractéristiques peuvent être à différentes échelles.
MaxAbsScaler et maxabs_scale /modules/generated/sklearn.preprocessing.maxabs_scale.html#sklearn.preprocessing.maxabs_scale) est spécialement conçu pour la mise à l'échelle des données éparses et est la méthode recommandée. Cependant, scale et StandardScaler /0.18/modules/generated/sklearn.preprocessing.StandardScaler.html#sklearn.preprocessing.StandardScaler) accepte la matrice scipy.sparse comme entrée tant que with_mean = False est explicitement passé au constructeur. peut faire. Sinon, il centrera et étendra tranquillement la matrice creuse, allouant involontairement une quantité excessive de mémoire et plantant, entraînant une ValueError. RobustScaler ne peut pas rendre l'entrée fragmentée, mais la méthode transform Peut être utilisé dans des matrices clairsemées.
Le scaler accepte les deux formats Compressed Sparse Rows et Compressed Sparse Columns (voir scipy.sparse.csr_matrix et scipy.sparse.csc_matrix). Les autres entrées de matrice clairsemée sont ** converties en matrices CSR **. Nous vous recommandons de choisir la représentation CSR ou CSC en amont pour éviter des copies mémoire inutiles.
Enfin, si vous vous attendez à ce que les données du centre soient suffisamment petites, une autre option consiste à convertir explicitement l'entrée en un tableau en utilisant la méthode toarray de la matrice creuse.
La mise à l'échelle avec la moyenne et la distribution des données peut ne pas fonctionner correctement si les données contiennent un grand nombre de valeurs aberrantes. Dans de tels cas, à la place, robust_scale et RobustScaler Vous pouvez utiliser (: //scikit-learn.org/0.18/modules/generated/sklearn.preprocessing.RobustScaler.html#sklearn.preprocessing.RobustScaler). Ils utilisent des estimateurs plus robustes pour le centre et l'étendue de vos données.
--Référence:
whiten = True entre les valeurs de fonction Supprimez en outre la corrélation linéaire de.
--Échelle de la variable cible dans la régression
--scale et StandardScaler sont des tableaux unidimensionnels prêts à l'emploi. Ceci est très utile pour mettre à l'échelle les variables cible / réponse utilisées pour la régression.Si vous avez une matrice de noyau pour le noyau $ K $ qui calcule le produit scalaire dans l'espace de fonctionnalités défini par la fonction $ phi $, alors KernelCenterer .KernelCenterer.html # sklearn.preprocessing.KernelCenterer) peut transformer la matrice du noyau pour inclure le produit interne dans l'espace de fonctionnalités défini par $ phi $, puis supprimer la moyenne dans cet espace.
** La normalisation ** est un ** processus qui met à l'échelle des échantillons individuels pour avoir un standard unitaire. Ce processus est utile pour quantifier la similitude des paires d'échantillons en utilisant des formats secondaires tels que les produits scalaires et d'autres noyaux. Cette hypothèse est à la base du modèle d'espace vectoriel (https://en.wikipedia.org/wiki/Vector_Space_Model) souvent utilisé dans le contexte de la classification et du clustering de texte. La fonction normalize utilise la norme «l1» ou «l2». Il fournit un moyen rapide et facile d'effectuer cette opération sur des ensembles de données tels qu'un seul tableau.
>>> X = [[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]]
>>> X_normalized = preprocessing.normalize(X, norm='l2')
>>> X_normalized
array([[ 0.40..., -0.40..., 0.81...],
[ 1. ..., 0. ..., 0. ...],
[ 0. ..., 0.70..., -0.70...]])
Le module preprocessing utilise également l'API Transformer pour implémenter la même opération dans la classe utilitaire [Normalizer](http://scikit-learn.org/0.18/modules/generated/sklearn.preprocessing.Normalizer.html# sklearn.preprocessing.Normalizer) (même si la méthode fit n'aide pas dans ce cas, cette opération est sans état car elle traite l'échantillon indépendamment).
Par conséquent, cette classe convient pour une utilisation précoce de sklearn.pipeline.Pipeline.
>>> normalizer = preprocessing.Normalizer().fit(X) # fit does nothing
>>> normalizer
Normalizer(copy=True, norm='l2')
L'instance de normalisation peut être utilisée comme n'importe quel transformateur dans le vecteur échantillon.
>>> normalizer.transform(X)
array([[ 0.40..., -0.40..., 0.81...],
[ 1. ..., 0. ..., 0. ...],
[ 0. ..., 0.70..., -0.70...]])
>>> normalizer.transform([[-1., 1., 0.]])
array([[-0.70..., 0.70..., 0. ...]])
scipy.sparse comme entrée.La binarisation d'entités est le processus de seuillage d'entités numériques pour obtenir des valeurs booléennes. Ceci est utile pour les estimations probabilistes en aval qui supposent que les données d'entrée sont distribuées selon la distribution multivariée de Bernoulli (https://en.wikipedia.org/wiki/Bernoulli_distribution). Par exemple, c'est le cas de sklearn.neural_network.BernoulliRBM. De plus, l'utilisation de valeurs de caractéristiques binaires (pour simplifier l'inférence probabiliste), même si les comptages normalisés (comme la fréquence des termes) et les caractéristiques valorisées TF-IDF fonctionnent en fait un peu mieux. , Commun dans la communauté du traitement de texte. Utilisez des valeurs de caractéristiques binaires, même si les comptages normalisés ou les fonctionnalités classées TF-IDF fonctionnent souvent légèrement mieux. Pour Normalizer, la classe d'utilitaire [Binarizer](http: // scikit-learn) .org / 0.18 / modules / generated / sklearn.preprocessing.Binarizer.html # sklearn.preprocessing.Binarizer) est [sklearn.pipeline.Pipeline](http://scikit-learn.org/0.18/modules/generated/sklearn. Il est destiné à être utilisé dans les premières étapes de pipeline.Pipeline.html # sklearn.pipeline.Pipeline). La méthode «fit» ne fait rien car chaque échantillon est traité indépendamment des autres échantillons.
>>> X = [[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]]
>>> binarizer = preprocessing.Binarizer().fit(X) # fit does nothing
>>> binarizer
Binarizer(copy=True, threshold=0.0)
>>> binarizer.transform(X)
array([[ 1., 0., 1.],
[ 1., 0., 0.],
[ 0., 1., 0.]])
Vous pouvez ajuster le seuil de Binarizer.
>>> binarizer = preprocessing.Binarizer(threshold=1.1)
>>> binarizer.transform(X)
array([[ 0., 0., 1.],
[ 1., 0., 0.],
[ 0., 0., 0.]])
Pour les classes StandardScaler et Normalizer, le module preprocessing est une fonction compagnon [binarize](http://scikit-learn.org/0.18/modules/generated/sklearn.preprocessing." Qui est utilisée lorsque l'API de conversion n'est pas nécessaire. binarize.html # sklearn.preprocessing.binarize) est fourni.
Dans de nombreux cas, les caractéristiques sont classées plutôt que des valeurs continues. Par exemple, [" homme "," femme "], [" d'Europe "," des États-Unis "," d'Asie "], [" utilise Firefox "," utilise Chrome "," utilise Safari ", "utilise Internet Explorer"] Ces fonctionnalités peuvent être efficacement codées sous forme d'entiers. Par exemple, [" homme "," des Etats-Unis "," utilise Internet Explorer "] est [0,1,3] [" femme "," d'Asie "," utilise Chrome "] est `[ 1, 2, 1] ».
Ces représentations entières attendent une entrée continue et interprètent les catégories comme ordonnées, de sorte qu'elles ne peuvent pas être utilisées directement avec l'estimateur scicit-learn (souvent un ensemble indésirable de navigateurs est arbitrairement ordonné. J'ai fait).
[OneHotEncoder](http://scikit-learn.org/0.18/modules/generated/sklearn.preprocessing.OneHotEncoder.html# sklearn.preprocessing.OneHotEncoder) consiste à utiliser le codage one-to-K ou one-hot mis en œuvre. Cet estimateur convertit chaque caractéristique de catégorie avec «m» valeurs possibles en «m» caractéristiques binaires, ne laissant qu'une seule active.
Continuez avec l'exemple ci-dessus:
>>> enc = preprocessing.OneHotEncoder()
>>> enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])
OneHotEncoder(categorical_features='all', dtype=<... 'numpy.float64'>,
handle_unknown='error', n_values='auto', sparse=True)
>>> enc.transform([[0, 1, 3]]).toarray()
array([[ 1., 0., 0., 1., 0., 0., 0., 0., 1.]])
Par défaut, le nombre de valeurs que chaque entité peut prendre est automatiquement estimé à partir du jeu de données. Vous pouvez le spécifier explicitement en utilisant le paramètre n_values. L'ensemble de données comprend deux sexes, trois continents possibles et quatre navigateurs Web. Transformez ensuite les points de données pour qu'ils correspondent à votre estimation. En conséquence, les deux premiers chiffres encodent le sexe, le troisième chiffre vers le continent et les quatre derniers vers le navigateur Web.
Notez que vous devez définir explicitement n_values si vos données d'entraînement peuvent ne pas avoir de fonctionnalités catégoriques. Par exemple
>>> enc = preprocessing.OneHotEncoder(n_values=[2, 3, 4])
>>> #Notez que les valeurs de catégorie pour les 2e et 3e entités sont manquantes
>>> enc.fit([[1, 2, 3], [0, 2, 0]])
OneHotEncoder(categorical_features='all', dtype=<... 'numpy.float64'>,
handle_unknown='error', n_values=[2, 3, 4], sparse=True)
>>> enc.transform([[1, 0, 0]]).toarray()
array([[ 0., 1., 1., 0., 0., 1., 0., 0., 0.]])
"Chargement de fonctionnalités depuis [dicts](http://qiita.com/nazoking@github/items/b270288fa38aed0a71bf#421-dicts%E3%81%8B%E3%82%89%E3%81%AE%E7%" 89% B9% E5% BE% B4% E9% 87% 8F% E3% 81% AE% E3% 83% AD% E3% 83% BC% E3% 83% 89) ".
Pour diverses raisons, de nombreux ensembles de données du monde réel contiennent des valeurs manquantes et sont souvent codés en tant qu'espaces réservés tels que des blancs, NaN, etc. Cependant, ces ensembles de données sont incompatibles avec l'estimation scicit-learn, qui suppose que toutes les valeurs du tableau sont numériques, toutes significatives et conservées. La stratégie de base pour utiliser un ensemble de données incomplet consiste à supprimer la ligne et / ou la colonne entière contenant la valeur manquante. Cependant, cela entraînera une perte de données (même si elles sont incomplètes). Une meilleure stratégie consiste à remplacer les valeurs manquantes, c'est-à-dire à les déduire de parties connues des données. Imputer La classe est la moyenne ou la médiane des lignes ou des colonnes avec des valeurs manquantes. Ou utilisez les valeurs les plus fréquentes pour fournir un moyen de base d'attribuer les valeurs manquantes. Cette classe autorise également différents encodages de valeurs manquantes. L'extrait de code suivant montre comment utiliser la moyenne des colonnes contenant des valeurs manquantes (axe 0) pour remplacer les valeurs manquantes codées comme «np.nan».
>>> import numpy as np
>>> from sklearn.preprocessing import Imputer
>>> imp = Imputer(missing_values='NaN', strategy='mean', axis=0)
>>> imp.fit([[1, 2], [np.nan, 3], [7, 6]])
Imputer(axis=0, copy=True, missing_values='NaN', strategy='mean', verbose=0)
>>> X = [[np.nan, 2], [6, np.nan], [7, 6]]
>>> print(imp.transform(X))
[[ 4. 2. ]
[ 6. 3.666...]
[ 7. 6. ]]
La classe Imputer prend également en charge les matrices creuses.
>>> import scipy.sparse as sp
>>> X = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
>>> imp = Imputer(missing_values=0, strategy='mean', axis=0)
>>> imp.fit(X)
Imputer(axis=0, copy=True, missing_values=0, strategy='mean', verbose=0)
>>> X_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
>>> print(imp.transform(X_test))
[[ 4. 2. ]
[ 6. 3.666...]
[ 7. 6. ]]
Notez que les valeurs manquantes sont ici codées 0, elles sont donc implicitement stockées dans la matrice. Par conséquent, ce format convient lorsqu'il y a plus de valeurs manquantes que les valeurs observées. Vous pouvez utiliser Imputer dans votre pipeline pour créer un estimateur composite prenant en charge la substitution. Voir Saisir les valeurs manquantes avant de créer un estimateur (http://scikit-learn.org/0.18/auto_examples/missing_values.html#sphx-glr-auto-examples-missing-values-py) S'il vous plaît
Il est souvent utile d'ajouter de la complexité au modèle, compte tenu des caractéristiques non linéaires des données d'entrée. Une utilisation simple et courante est les fonctionnalités polymorphes, qui vous permettent d'obtenir des termes d'ordre supérieur et d'interaction pour les fonctionnalités. Implémenté dans PolynomialFeatures:
>>> import numpy as np
>>> from sklearn.preprocessing import PolynomialFeatures
>>> X = np.arange(6).reshape(3, 2)
>>> X
array([[0, 1],
[2, 3],
[4, 5]])
>>> poly = PolynomialFeatures(2)
>>> poly.fit_transform(X)
array([[ 1., 0., 1., 0., 0., 1.],
[ 1., 2., 3., 4., 6., 9.],
[ 1., 4., 5., 16., 20., 25.]])
La fonctionnalité de X a été convertie de $ (X_1, X_2) $ en $ (1, X_1, X_2, X_1 ^ 2, X_1X_2, X_2 ^ 2) $. Si vous n'avez besoin que du terme d'interaction entre les fonctionnalités, vous pouvez l'obtenir avec le paramètre ʻinteract_only = True`.
>>> X = np.arange(9).reshape(3, 3)
>>> X
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> poly = PolynomialFeatures(degree=3, interaction_only=True)
>>> poly.fit_transform(X)
array([[ 1., 0., 1., 2., 0., 0., 2., 0.],
[ 1., 3., 4., 5., 12., 15., 20., 60.],
[ 1., 6., 7., 8., 42., 48., 56., 336.]])
La fonctionnalité de X a été convertie de $ (X_1, X_2, X_3) $ en $ (1, X_1, X_2, X_3, X_1X_2, X_1X_3, X_2X_3, X_1X_2X_3) $. La fonction polygone est polypoly [fonction noyau](http://qiita.com/nazoking@github/items/2b16be7f7eac940f2e6a#146-%E3%82%AB%E3%83%BC%E3%83%8D%E3%83 Lors de l'utilisation de% AB% E9% 96% A2% E6% 95% B0), la méthode du noyau (https://en.wikipedia.org/wiki/Kernel_method) (par exemple, sklearn.svm.SVC, sklearn.decomposition.KernelPCA Notez qu'il est utilisé implicitement dans /modules/generated/sklearn.decomposition.KernelPCA.html#sklearn.decomposition.KernelPCA)). Régression de crête utilisant les entités polynomiales créées [Interpolation polygonale](http://scikit-learn.org/0.18/auto_examples/linear_model/plot_polynomial_interpolation.html#sphx-glr-auto-examples-linear-model-plot Voir -polynomial-interpolation-py).
Dans de nombreux cas, vous souhaiterez transformer vos fonctions Python existantes en transformateurs pour vous aider à nettoyer et traiter vos données. Vous pouvez implémenter un transformateur à partir de n'importe quelle fonction à l'aide de FunctionTransformer (http://scikit-learn.org/0.18/modules/generated/sklearn.preprocessing.FunctionTransformer.html#sklearn.preprocessing.FunctionTransformer). Par exemple, pour créer un transformateur qui applique des transformations de journal dans votre pipeline:
>>> import numpy as np
>>> from sklearn.preprocessing import FunctionTransformer
>>> transformer = FunctionTransformer(np.log1p)
>>> X = np.array([[0, 1], [2, 3]])
>>> transformer.transform(X)
array([[ 0. , 0.69314718],
[ 1.09861229, 1.38629436]])
Pour un exemple de code complet sur la façon d'utiliser FunctionTransformer pour sélectionner des fonctionnalités personnalisées, consultez Sélectionner des colonnes à l'aide de FunctionTransformer (http://scikit-learn.org/0.18/auto_examples/preprocessing/plot_function_transformer.html#). sphx-glr-auto-examples-preprocessing-plot-function-transformer-py) ".
[scikit-learn 0.18 User Guide 4. Dataset Conversion](http://qiita.com/nazoking@github/items/267f2371757516f8c168#4-%E3%83%87%E3%83%BC%E3%82%BF À partir de% E3% 82% BB% E3% 83% 83% E3% 83% 88% E5% A4% 89% E6% 8F% 9B)
© 2010 --2016, développeurs scikit-learn (licence BSD).
Recommended Posts