Ich habe einen Datenrahmen in Pandas, in dem jede Spalte einen anderen Wertebereich hat. Beispielsweise:

df:

A     B   C
1000  10  0.5
765   5   0.35
800   7   0.09

Irgendeine Idee, wie ich die Spalten dieses Datenrahmens normalisieren kann, wobei jeder Wert zwischen 0 und 1 liegt?

Meine gewünschte Ausgabe ist:

A     B    C
1     1    1
0.765 0.5  0.7
0.8   0.7  0.18(which is 0.09/0.5)

Sie können das Paket sklearn und die zugehörigen Vorverarbeitungsprogramme verwenden, um die Daten zu normalisieren.

import pandas as pd
from sklearn import preprocessing

x = df.values #returns a numpy array
min_max_scaler = preprocessing.MinMaxScaler()
x_scaled = min_max_scaler.fit_transform(x)
df = pd.DataFrame(x_scaled)

Weitere Informationen finden Sie in der Scikit-Learn- Dokumentation zur Vorverarbeitung von Daten: Skalieren von Funktionen auf einen Bereich.

Ein einfacher Weg mit Pandas : (hier möchte ich die mittlere Normalisierung verwenden)

normalized_df=(df-df.mean())/df.std()

Min-Max-Normalisierung verwenden:

normalized_df=(df-df.min())/(df.max()-df.min())

Bearbeiten: Um einige Bedenken auszuräumen, muss gesagt werden, dass Pandas im obigen Code automatisch die colomn-weise Funktion anwendet.

Basierend auf diesem Beitrag: /stats/70801/how-to-normalize-data-to-0-1-range

Sie können Folgendes tun:

def normalize(df):
    result = df.copy()
    for feature_name in df.columns:
        max_value = df[feature_name].max()
        min_value = df[feature_name].min()
        result[feature_name] = (df[feature_name] - min_value) / (max_value - min_value)
    return result

Sie müssen sich keine Sorgen machen, ob Ihre Werte negativ oder positiv sind. Und die Werte sollten gut zwischen 0 und 1 verteilt sein.

Ihr Problem ist eigentlich eine einfache Transformation, die auf die Spalten wirkt:

def f(s):
    return s/s.max()

frame.apply(f, axis=0)

Oder noch knapper:

   frame.apply(lambda x: x/x.max(), axis=0)

Wenn Sie das sklearn-Paket verwenden möchten, können Sie die Spalten- und Indexnamen mithilfe von Pandas locwie folgt beibehalten :

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler() 
scaled_values = scaler.fit_transform(df) 
df.loc[:,:] = scaled_values

Einfach ist schön:

df["A"] = df["A"] / df["A"].max()
df["B"] = df["B"] / df["B"].max()
df["C"] = df["C"] / df["C"].max()

Sie können eine Liste von Spalten erstellen, die Sie normalisieren möchten

column_names_to_normalize = ['A', 'E', 'G', 'sadasdsd', 'lol']
x = df[column_names_to_normalize].values
x_scaled = min_max_scaler.fit_transform(x)
df_temp = pd.DataFrame(x_scaled, columns=column_names_to_normalize, index = df.index)
df[column_names_to_normalize] = df_temp

Ihr Pandas-Datenrahmen wird jetzt nur in den gewünschten Spalten normalisiert

Allerdings , wenn Sie das wollen gegenüber , wählen Sie eine Liste der Spalten , dass Sie NICHT TUN normalisieren möchten, können Sie einfach eine Liste aller Spalten erstellen , und dass nicht Gewünschten entfernen

column_names_to_not_normalize = ['B', 'J', 'K']
column_names_to_normalize = [x for x in list(df) if x not in column_names_to_not_normalize ]

Die Lösung von Sandman und Praveen ist sehr gut. Das einzige Problem dabei ist, dass diese Methode einige Anpassungen erfordert, wenn Sie kategoriale Variablen in anderen Spalten Ihres Datenrahmens haben.

Meine Lösung für diese Art von Problem lautet wie folgt:

 from sklearn import preprocesing
 x = pd.concat([df.Numerical1, df.Numerical2,df.Numerical3])
 min_max_scaler = preprocessing.MinMaxScaler()
 x_scaled = min_max_scaler.fit_transform(x)
 x_new = pd.DataFrame(x_scaled)
 df = pd.concat([df.Categoricals,x_new])

Ich denke, dass ein besserer Weg, dies bei Pandas zu tun, gerecht ist

df = df/df.max().astype(np.float64)

Bearbeiten Wenn in Ihrem Datenrahmen negative Zahlen vorhanden sind, sollten Sie stattdessen verwenden

df = df/df.loc[df.abs().idxmax()].astype(np.float64)

Beispiel für verschiedene Standardisierungen in Python.

Eine Referenz finden Sie in diesem Wikipedia-Artikel: https://en.wikipedia.org/wiki/Unbiased_estimation_of_standard_deviation

Beispieldaten

import pandas as pd
df = pd.DataFrame({
               'A':[1,2,3],
               'B':[100,300,500],
               'C':list('abc')
             })
print(df)
   A    B  C
0  1  100  a
1  2  300  b
2  3  500  c

Normalisierung mit Pandas (Gibt unvoreingenommene Schätzungen)

Bei der Normalisierung subtrahieren wir einfach den Mittelwert und dividieren durch die Standardabweichung.

df.iloc[:,0:-1] = df.iloc[:,0:-1].apply(lambda x: (x-x.mean())/ x.std(), axis=0)
print(df)
     A    B  C
0 -1.0 -1.0  a
1  0.0  0.0  b
2  1.0  1.0  c

Normalisierung mit sklearn (Gibt voreingenommene Schätzungen, die sich von Pandas unterscheiden)

Wenn Sie dasselbe tun, erhalten sklearnSie eine VERSCHIEDENE Ausgabe!

import pandas as pd

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()


df = pd.DataFrame({
               'A':[1,2,3],
               'B':[100,300,500],
               'C':list('abc')
             })
df.iloc[:,0:-1] = scaler.fit_transform(df.iloc[:,0:-1].to_numpy())
print(df)
          A         B  C
0 -1.224745 -1.224745  a
1  0.000000  0.000000  b
2  1.224745  1.224745  c

Macht voreingenommene Schätzungen von sklearn maschinelles Lernen weniger leistungsfähig?

NEIN.

Die offizielle Dokumentation von sklearn.preprocessing.scale besagt, dass die Verwendung eines voreingenommenen Schätzers die Leistung von Algorithmen für maschinelles Lernen UNMÖGLICHERWEISE beeinträchtigt und wir sie sicher verwenden können.

From official documentation:
We use a biased estimator for the standard deviation,
equivalent to numpy.std(x, ddof=0). 
Note that the choice of ddof is unlikely to affect model performance.

Was ist mit MinMax-Skalierung?

Bei der MinMax-Skalierung gibt es keine Standardabweichungsberechnung. Das Ergebnis ist also sowohl bei Pandas als auch bei Scikit-Learn gleich.

import pandas as pd
df = pd.DataFrame({
               'A':[1,2,3],
               'B':[100,300,500],
             })
(df - df.min()) / (df.max() - df.min())
     A    B
0  0.0  0.0
1  0.5  0.5
2  1.0  1.0


# Using sklearn
from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler() 
arr_scaled = scaler.fit_transform(df) 

print(arr_scaled)
[[0.  0. ]
 [0.5 0.5]
 [1.  1. ]]

df_scaled = pd.DataFrame(arr_scaled, columns=df.columns,index=df.index)
print(df_scaled)
     A    B
0  0.0  0.0
1  0.5  0.5
2  1.0  1.0

Möglicherweise möchten Sie, dass einige Spalten normalisiert werden und die anderen unverändert bleiben, wie bei einigen Regressionsaufgaben, bei denen Datenbeschriftungen oder kategoriale Spalten unverändert bleiben. Ich empfehle Ihnen daher diese pythonische Methode (eine Kombination aus @ shg- und @ Cina-Antworten):

features_to_normalize = ['A', 'B', 'C']
# could be ['A','B'] 

df[features_to_normalize] = df[features_to_normalize].apply(lambda x:(x-x.min()) / (x.max()-x.min()))

Es ist nur einfache Mathematik. Die Antwort sollte so einfach wie unten sein.

normed_df = (df - df.min()) / (df.max() - df.min())

def normalize(x):
    try:
        x = x/np.linalg.norm(x,ord=1)
        return x
    except :
        raise
data = pd.DataFrame.apply(data,normalize)

Aus dem Dokument von Pandas kann die DataFrame-Struktur eine Operation (Funktion) auf sich selbst anwenden.

DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)

Wendet die Funktion entlang der Eingabeachse von DataFrame an. An Funktionen übergebene Objekte sind Serienobjekte mit einem Index, der entweder den Index des DataFrames (Achse = 0) oder die Spalten (Achse = 1) enthält. Der Rückgabetyp hängt davon ab, ob übergebene Funktionsaggregate oder das Reduktionsargument, wenn der DataFrame leer ist.

Sie können eine benutzerdefinierte Funktion anwenden, um den DataFrame zu bedienen.

Die folgende Funktion berechnet den Z-Score:

def standardization(dataset):
  """ Standardization of numeric fields, where all values will have mean of zero 
  and standard deviation of one. (z-score)

  Args:
    dataset: A `Pandas.Dataframe` 
  """
  dtypes = list(zip(dataset.dtypes.index, map(str, dataset.dtypes)))
  # Normalize numeric columns.
  for column, dtype in dtypes:
      if dtype == 'float32':
          dataset[column] -= dataset[column].mean()
          dataset[column] /= dataset[column].std()
  return dataset

So machen Sie es spaltenweise mit Listenverständnis:

[df[col].update((df[col] - df[col].min()) / (df[col].max() - df[col].min())) for col in df.columns]

Sie können die Funktion pandas.DataFrame.transform 1 einfach folgendermaßen verwenden :

df.transform(lambda x: x/x.max())

df_normalized = df / df.max(axis=0)

Sie können dies in einer Zeile tun

DF_test = DF_test.sub(DF_test.mean(axis=0), axis=1)/DF_test.mean(axis=0)

Es nimmt den Mittelwert für jede Spalte und subtrahiert ihn dann (Mittelwert) von jeder Zeile (der Mittelwert einer bestimmten Spalte subtrahiert nur von ihrer Zeile) und dividiert nur durch den Mittelwert. Schließlich erhalten wir den normalisierten Datensatz.

Pandas führt standardmäßig eine spaltenweise Normalisierung durch. Versuchen Sie den folgenden Code.

X= pd.read_csv('.\\data.csv')
X = (X-X.min())/(X.max()-X.min())

Die Ausgabewerte liegen im Bereich von 0 und 1.