les pandas dataframe colonnes de mise à l'échelle avec sklearn

J'ai une pandas dataframe avec un mélange de colonnes de type, et j'aimerais appliquer sklearn de min_max_scaler de certaines colonnes. Idéalement, j'aimerais faire ces transformations en place, mais n'avez pas trouvé un moyen de le faire encore. J'ai écrit le code suivant qui fonctionne:

import pandas as pd
import numpy as np
from sklearn import preprocessing

scaler = preprocessing.MinMaxScaler()

dfTest = pd.DataFrame({'A':[14.00,90.20,90.95,96.27,91.21],'B':[103.02,107.26,110.35,114.23,114.68], 'C':['big','small','big','small','small']})
min_max_scaler = preprocessing.MinMaxScaler()

def scaleColumns(df, cols_to_scale):
    for col in cols_to_scale:
        df[col] = pd.DataFrame(min_max_scaler.fit_transform(pd.DataFrame(dfTest[col])),columns=[col])
    return df

dfTest

    A   B   C
0    14.00   103.02  big
1    90.20   107.26  small
2    90.95   110.35  big
3    96.27   114.23  small
4    91.21   114.68  small

scaled_df = scaleColumns(dfTest,['A','B'])
scaled_df

A   B   C
0    0.000000    0.000000    big
1    0.926219    0.363636    small
2    0.935335    0.628645    big
3    1.000000    0.961407    small
4    0.938495    1.000000    small

Je suis curieux de savoir si c'est la meilleur/le plus efficace pour faire cette transformation. Est-il une manière que je pourrais utiliser df.appliquer ce serait mieux?

Je suis aussi surpris de voir que je ne peux pas avoir le code suivant fonctionne:

bad_output = min_max_scaler.fit_transform(dfTest['A'])

Si je passe tout un dataframe pour le scaler cela fonctionne:

dfTest2 = dfTest.drop('C', axis = 1) good_output = min_max_scaler.fit_transform(dfTest2) good_output

Je suis confus pourquoi le passage d'une série à l'écailleur échoue. Dans mon travail plein de code ci-dessus, j'espérais juste passer d'une série à l'écailleur puis définissez le dataframe colonne = à l'échelle de la série. J'ai vu cette question posée à quelques autres endroits, mais je n'ai pas trouvé une bonne réponse. Toute aide pour comprendre ce qui se passe ici serait grandement apprécié!

Cela fonctionne si vous faites cela bad_output = min_max_scaler.fit_transform(dfTest['A'].values)? accéder à la values attribut retourne un tableau numpy, pour quelque raison que parfois la scikit learn api correctement appeler la bonne méthode qui rend les pandas retourne un tableau numpy et parfois ça ne marche pas.
Des Pandas dataframes sont assez complexes, des objets avec des conventions qui ne correspondent pas à scikit-learn conventions. Si vous avez tout convertir des tableaux NumPy, scikit-learn devient beaucoup plus facile de travailler avec.
bad_output = in_max_scaler.fit_transform(dfTest['A'].values) ne fonctionne pas non plus. @larsmans - ouais j'avais pensé à aller vers le bas de cette route, il semble juste comme une corvée. Je ne sais pas si c'est un bug ou pas que les Pandas pouvez passer en plein dataframe à un sklearn fonction, mais pas une série. Ma compréhension d'un dataframe est que c'est un dict de la série. À lire dans le "Python pour l'Analyse des Données" livre, il affirme que les pandas est construit sur le haut de numpy pour le rendre facile à utiliser dans NumPy centrée sur applicatations.

InformationsquelleAutor flyingmeatball | 2014-07-09

134

Je ne sais pas si les versions précédentes de pandas empêché de cela, mais maintenant l'extrait de code suivant fonctionne parfaitement pour moi et produit exactement ce que vous voulez sans avoir à utiliser apply
```
>>> import pandas as pd
>>> from sklearn.preprocessing import MinMaxScaler


>>> scaler = MinMaxScaler()

>>> dfTest = pd.DataFrame({'A':[14.00,90.20,90.95,96.27,91.21],
                           'B':[103.02,107.26,110.35,114.23,114.68],
                           'C':['big','small','big','small','small']})

>>> dfTest[['A', 'B']] = scaler.fit_transform(dfTest[['A', 'B']])

>>> dfTest
          A         B      C
0  0.000000  0.000000    big
1  0.926219  0.363636  small
2  0.935335  0.628645    big
3  1.000000  0.961407  small
4  0.938495  1.000000  small
```
- Neat! Plus version généralisée df[df.columns] = scaler.fit_transform(df[df.columns])
- Je sais que c'est un retard de commentaire à partir de la date originale, mais pourquoi il y a deux crochets dans dfTest[['A', 'B']]? Je peux voir qu'il ne fonctionne pas avec un seul support, mais ne pouvait pas comprendre la raison.
- L'extérieur des parenthèses sont des pandas typique sélecteur de crochets, de raconter des pandas pour sélectionner une colonne, à partir du dataframe. Les parenthèses indiquent une liste. Vous êtes de passage de l'une à l'pandas sélecteur. Si vous venez d'utiliser des crochets - avec un nom de colonne, suivie par une autre, séparés par une virgule - pandas interprète cela comme si vous essayez de sélectionner une colonne à partir d'un dataframe avec multi-niveau des colonnes (MultiIndex) et va jeter un keyerror.
- pour ajouter à @ken réponse si vous voulez voir exactement comment les pandas implémente cette indexation logique et pourquoi un n-uplet de valeurs doit être interprété différemment d'une liste, vous pouvez regarder comment DataFrames mettre en œuvre les __getitem__ méthode. Plus précisément, vous pouvez vous ouvrir ipython et ne pd.DataFrame.__getitem__?? ; après l'importation de pandas que le pd, bien sûr 😉
- Cela fonctionne très bien, cependant lorsque j'essaie de faire scaler.fit() et scaler.transform() sur deux lignes distinctes, je reçois le redoutable SettingWithCopyWarning. Quelqu'un a une idée pourquoi?
- Une note pratique: pour ceux qui utilisent le train/données de test se divise, vous aurez envie de adaptera uniquement sur les données d'entraînement, pas vos données de test.
- df[df.columns] = scaler.fit_transform(df[df.columns]) - parfait @citynorman!
- À l'échelle de tous, mais les horodateurs de la colonne, de combiner avec columns =df.columns.drop('timestamps') df[df.columns] = scaler.fit_transform(df[df.columns]
- pouvez-vous fournir une référence pour pourquoi?
InformationsquelleAutor LetsPlayYahtzee

Comme ça?

dfTest = pd.DataFrame({
           'A':[14.00,90.20,90.95,96.27,91.21],
           'B':[103.02,107.26,110.35,114.23,114.68], 
           'C':['big','small','big','small','small']
         })
dfTest[['A','B']] = dfTest[['A','B']].apply(
                           lambda x: MinMaxScaler().fit_transform(x))
dfTest

    A           B           C
0   0.000000    0.000000    big
1   0.926219    0.363636    small
2   0.935335    0.628645    big
3   1.000000    0.961407    small
4   0.938495    1.000000    small

Je reçois un tas de DeprecationWarnings lorsque j'exécute ce script. Comment doit-il être mis à jour?
La réponse ci-dessous fonctionne sans avertissements
Voir @LetsPlayYahtzee la réponse ci-dessous
Une version plus simple: dfTest[['A','B']] = dfTest[['A','B']].appliquer(MinMaxScaler().fit_transform)

InformationsquelleAutor Eric Czech

9

Comme il est mentionné dans le pir commentaire - la .apply(lambda el: scale.fit_transform(el)) méthode génère le message d'avertissement suivant:

DeprecationWarning: Passage de tableaux 1d données est obsolète dans 0.17
et raise ValueError dans de 0,19. Remodeler vos données à l'aide de
X. remodeler(-1, 1) si vos données ont une fonction unique ou X. remodeler(1, -1)
si elle contient un seul échantillon.

La conversion de vos colonnes pour les tableaux numpy devrait faire l'affaire (je préfère StandardScaler):

~~from sklearn.preprocessing import StandardScaler scale = StandardScaler() dfTest[['A','B','C']] = scale.fit_transform(dfTest[['A','B','C']].as_matrix())~~

-- Modifier Novembre 2018 (Testé pour les pandas 0.23.4)--

De Rob Murray mentionne dans les commentaires, dans le courant (v0.23.4) la version de pandas .as_matrix() retourne FutureWarning. Par conséquent, il doit être remplacé par .values:
```
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()

scaler.fit_transform(dfTest[['A','B']].values)
```
-- Modifier Mai 2019 (Testé pour les pandas 0.24.2)--

Comme joelostblom mentionne dans les commentaires, "Depuis 0.24.0, il est recommandé d'utiliser .to_numpy() au lieu de .values."

Mis à jour exemple:
```
import pandas as pd
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
dfTest = pd.DataFrame({
               'A':[14.00,90.20,90.95,96.27,91.21],
               'B':[103.02,107.26,110.35,114.23,114.68],
               'C':['big','small','big','small','small']
             })
dfTest[['A', 'B']] = scaler.fit_transform(dfTest[['A','B']].to_numpy())
dfTest
      A         B      C
0 -1.995290 -1.571117    big
1  0.436356 -0.603995  small
2  0.460289  0.100818    big
3  0.630058  0.985826  small
4  0.468586  1.088469  small
```
- utilisation .values en place de .as_matrix() comme as_matrix() donne maintenant un FutureWarning.
- Depuis 0.24.0, il est recommandé d'utiliser .to_numpy() au lieu de .values.
- Cela pourrait-il fonctionner avec .apply?
InformationsquelleAutor Low Yield Bond
6

Vous pouvez le faire en utilisant pandas seulement:
```
In [235]:
dfTest = pd.DataFrame({'A':[14.00,90.20,90.95,96.27,91.21],'B':[103.02,107.26,110.35,114.23,114.68], 'C':['big','small','big','small','small']})
df = dfTest[['A', 'B']]
df_norm = (df - df.min()) / (df.max() - df.min())
print df_norm
print pd.concat((df_norm, dfTest.C),1)

          A         B
0  0.000000  0.000000
1  0.926219  0.363636
2  0.935335  0.628645
3  1.000000  0.961407
4  0.938495  1.000000
          A         B      C
0  0.000000  0.000000    big
1  0.926219  0.363636  small
2  0.935335  0.628645    big
3  1.000000  0.961407  small
4  0.938495  1.000000  small
```
- Je sais que je peux le faire seulement dans les pandas, mais vous souhaitez peut-être, éventuellement, d'en appliquer un autre sklearn méthode qui n'est pas aussi facile à écrire moi-même. Je suis plus intéressé à comprendre pourquoi l'application d'une série ne fonctionne pas comme je l'espérais que je suis arrivée avec un strictement solution plus simple. Ma prochaine étape sera d'exécuter un RandomForestRegressor, et je veux m'assurer de comprendre comment les Pandas et sklearn travailler ensemble.
- Cette réponse est dangereux parce que df.max() - df.min() peut être 0, conduisant à une exception. En outre, df.min() est calculée deux fois, ce qui est inefficace. Notez que df.ptp() est équivalent à df.max() - df.min().
InformationsquelleAutor CT Zhu
6
```
df = pd.DataFrame(scale.fit_transform(df.values), columns=df.columns, index=df.index)
```
Cela devrait fonctionner sans l'amortissement des avertissements.

InformationsquelleAutor athlonshi

Vous devez vous connecter pour publier un commentaire.