Wie konvertiere ich Daten von einem Scikit-Learn Bunch-Objekt in einen Pandas DataFrame?

from sklearn.datasets import load_iris
import pandas as pd
data = load_iris()
print(type(data))
data1 = pd. # Is there a Pandas method to accomplish this?

Manuell können Sie den pd.DataFrameKonstruktor verwenden, indem Sie ein numpy-Array ( data) und eine Liste der Namen der Spalten ( columns) angeben . Um alles in einem DataFrame zu haben, können Sie die Features und das Ziel in einem Numpy-Array verketten mit np.c_[...](beachten Sie Folgendes []):

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris

# save load_iris() sklearn dataset to iris
# if you'd like to check dataset type use: type(load_iris())
# if you'd like to view list of attributes use: dir(load_iris())
iris = load_iris()

# np.c_ is the numpy concatenate function
# which is used to concat iris['data'] and iris['target'] arrays 
# for pandas column argument: concat iris['feature_names'] list
# and string list (in this case one string); you can make this anything you'd like..  
# the original dataset would probably call this ['Species']
data1 = pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                     columns= iris['feature_names'] + ['target'])

from sklearn.datasets import load_iris
import pandas as pd

data = load_iris()
df = pd.DataFrame(data.data, columns=data.feature_names)
df.head()

Dieses Tutorial könnte von Interesse sein: http://www.neural.cz/dataset-exploration-boston-house-pricing.html

Die Lösung von TOMDLt ist nicht generisch genug für alle Datensätze in scikit-learn. Zum Beispiel funktioniert es nicht für den Boston Housing-Datensatz. Ich schlage eine andere Lösung vor, die universeller ist. Sie müssen auch kein Numpy verwenden.

from sklearn import datasets
import pandas as pd

boston_data = datasets.load_boston()
df_boston = pd.DataFrame(boston_data.data,columns=boston_data.feature_names)
df_boston['target'] = pd.Series(boston_data.target)
df_boston.head()

Als allgemeine Funktion:

def sklearn_to_df(sklearn_dataset):
    df = pd.DataFrame(sklearn_dataset.data, columns=sklearn_dataset.feature_names)
    df['target'] = pd.Series(sklearn_dataset.target)
    return df

df_boston = sklearn_to_df(datasets.load_boston())

Nur als Alternative, dass ich meinen Kopf viel einfacher umwickeln könnte:

data = load_iris()
df = pd.DataFrame(data['data'], columns=data['feature_names'])
df['target'] = data['target']
df.head()

Anstatt von Anfang an zu verketten, erstellen Sie einfach einen Datenrahmen mit der Matrix der Features und fügen Sie dann einfach die Zielspalte mit Daten ['whatvername'] hinzu und holen Sie sich die Zielwerte aus dem Datensatz

Ich habe 2 Stunden gebraucht, um das herauszufinden

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris

iris = load_iris()
##iris.keys()


df= pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                 columns= iris['feature_names'] + ['target'])

df['species'] = pd.Categorical.from_codes(iris.target, iris.target_names)

Holen Sie sich die Art für meine Pandas zurück

Verwenden Sie andernfalls Seaborn-Datensätze, bei denen es sich um tatsächliche Pandas-Datenrahmen handelt:

import seaborn
iris = seaborn.load_dataset("iris")
type(iris)
# <class 'pandas.core.frame.DataFrame'>

Vergleichen Sie mit Scikit-Lerndatensätzen:

from sklearn import datasets
iris = datasets.load_iris()
type(iris)
# <class 'sklearn.utils.Bunch'>
dir(iris)
# ['DESCR', 'data', 'feature_names', 'filename', 'target', 'target_names']

Das funktioniert bei mir.

dataFrame = pd.dataFrame(data = np.c_[ [iris['data'],iris['target'] ],
columns=iris['feature_names'].tolist() + ['target'])

Eine andere Möglichkeit, Features und Zielvariablen zu kombinieren, kann die Verwendung von np.column_stack( Details ) sein.

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris

data = load_iris()
df = pd.DataFrame(np.column_stack((data.data, data.target)), columns = data.feature_names+['target'])
print(df.head())

Ergebnis:

   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)     target
0                5.1               3.5                1.4               0.2     0.0
1                4.9               3.0                1.4               0.2     0.0 
2                4.7               3.2                1.3               0.2     0.0 
3                4.6               3.1                1.5               0.2     0.0
4                5.0               3.6                1.4               0.2     0.0

Wenn Sie die Zeichenfolgenbezeichnung für benötigen target, können Sie diese verwenden, replaceindem Sie target_namesin dictionaryeine neue Spalte konvertieren und diese hinzufügen:

df['label'] = df.target.replace(dict(enumerate(data.target_names)))
print(df.head())

Ergebnis:

   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)     target  label 
0                5.1               3.5                1.4               0.2     0.0     setosa
1                4.9               3.0                1.4               0.2     0.0     setosa
2                4.7               3.2                1.3               0.2     0.0     setosa
3                4.6               3.1                1.5               0.2     0.0     setosa
4                5.0               3.6                1.4               0.2     0.0     setosa

Grundsätzlich brauchen Sie die "Daten", und Sie haben sie im Scikit-Haufen, jetzt brauchen Sie nur noch das "Ziel" (Vorhersage), das sich ebenfalls im Haufen befindet.

Sie müssen diese beiden also nur zusammenfassen, um die Daten zu vervollständigen

  data_df = pd.DataFrame(cancer.data,columns=cancer.feature_names)
  target_df = pd.DataFrame(cancer.target,columns=['target'])

  final_df = data_df.join(target_df)

Ab Version 0.23 können Sie mit dem as_frameArgument direkt einen DataFrame zurückgeben . Laden Sie beispielsweise den Iris-Datensatz:

from sklearn.datasets import load_iris
iris = load_iris(as_frame=True)
df = iris.data

Nach meinem Verständnis unter Verwendung der vorläufigen Versionshinweise funktioniert dies für die Datensätze Brustkrebs, Diabetes, Ziffern, Iris, Linnerud, Wein und Kalifornien.

Update: 2020

Sie können den Parameter verwenden as_frame=True, um Pandas-Datenrahmen abzurufen.

Wenn der Parameter as_frame verfügbar ist (z. B. load_iris)

from sklearn import datasets
X,y = datasets.load_iris(return_X_y=True) # numpy arrays

dic_data = datasets.load_iris(as_frame=True)
print(dic_data.keys())

df = dic_data['frame'] # pandas dataframe data + target
df_X = dic_data['data'] # pandas dataframe data only
ser_y = dic_data['target'] # pandas series target only
dic_data['target_names'] # numpy array

Wenn der Parameter as_frame NICHT verfügbar ist (z. B. load_boston)

from sklearn import datasets

fnames = [ i for i in dir(datasets) if 'load_' in i]
print(fnames)

fname = 'load_boston'
loader = getattr(datasets,fname)()
df = pd.DataFrame(loader['data'],columns= loader['feature_names'])
df['target'] = loader['target']
df.head(2)

Hier ist eine Funktion für die Konvertierung, um die beste Antwort zu finden und meinen Kommentar anzusprechen

def bunch_to_dataframe(bunch):
  fnames = bunch.feature_names
  features = fnames.tolist() if isinstance(fnames, np.ndarray) else fnames
  features += ['target']
  return pd.DataFrame(data= np.c_[bunch['data'], bunch['target']],
                 columns=features)

Was auch immer TomDLT antwortete, es funktioniert möglicherweise nicht für einige von Ihnen, weil

data1 = pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                 columns= iris['feature_names'] + ['target'])

weil iris ['feature_names'] Ihnen ein numpy-Array zurückgibt. In einem numpy-Array können Sie ein Array und eine Liste ['target'] nicht mit nur dem Operator + hinzufügen. Daher müssen Sie es zuerst in eine Liste konvertieren und dann hinzufügen.

Du kannst tun

data1 = pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                 columns= list(iris['feature_names']) + ['target'])

Dies wird gut funktionieren, obwohl ..

Es könnte einen besseren Weg geben, aber hier ist, was ich in der Vergangenheit getan habe und es funktioniert ganz gut:

items = data.items()                          #Gets all the data from this Bunch - a huge list
mydata = pd.DataFrame(items[1][1])            #Gets the Attributes
mydata[len(mydata.columns)] = items[2][1]     #Adds a column for the Target Variable
mydata.columns = items[-1][1] + [items[2][0]] #Gets the column names and updates the dataframe

Jetzt haben mydata alles, was Sie brauchen - Attribute, Zielvariablen und Spaltennamen

Dieses Snippet ist nur syntaktischer Zucker, der auf dem basiert , was TomDLT und Rolyat bereits beigetragen und erklärt haben. Die einzigen Unterschiede wären, dass load_irisein Tupel anstelle eines Wörterbuchs zurückgegeben wird und die Spaltennamen aufgelistet werden.

df = pd.DataFrame(np.c_[load_iris(return_X_y=True)])

import pandas as pd
from sklearn.datasets import load_iris
iris = load_iris()
X = iris['data']
y = iris['target']
iris_df = pd.DataFrame(X, columns = iris['feature_names'])
iris_df.head()

Eine der besten Möglichkeiten:

data = pd.DataFrame(digits.data)

Digits ist der sklearn-Datenrahmen und ich habe ihn in einen Pandas-Datenrahmen konvertiert

Ich habe ein paar Ideen aus Ihren Antworten genommen und weiß nicht, wie ich es kürzer machen soll :)

import pandas as pd
from sklearn.datasets import load_iris
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris['feature_names'])
df['target'] = iris['target']

Dies ergibt einen Pandas-Datenrahmen mit Funktionsnamen plus Ziel als Spalten und RangeIndex (Start = 0, Stopp = Länge (df), Schritt = 1). Ich hätte gerne einen kürzeren Code, bei dem ich 'Ziel' direkt hinzufügen kann.

Die API ist etwas sauberer als die vorgeschlagenen Antworten. Verwenden Sie hier as_frameauch eine Antwortspalte und stellen Sie sicher, dass diese enthalten ist.

import pandas as pd
from sklearn.datasets import load_wine

features, target = load_wine(as_frame=True).data, load_wine(as_frame=True).target
df = features
df['target'] = target

df.head(2)

Hier ist ein weiteres Beispiel für eine integrierte Methode, das möglicherweise hilfreich ist.

from sklearn.datasets import load_iris
iris_X, iris_y = load_iris(return_X_y=True, as_frame=True)
type(iris_X), type(iris_y)

Die Daten iris_X werden als Pandas DataFrame und die Ziel-iris_y als Pandas Series importiert.

from sklearn.datasets import load_iris
import pandas as pd

iris_dataset = load_iris()

datasets = pd.DataFrame(iris_dataset['data'], columns = 
           iris_dataset['feature_names'])
target_val = pd.Series(iris_dataset['target'], name = 
            'target_values')

species = []
for val in target_val:
    if val == 0:
        species.append('iris-setosa')
    if val == 1:
        species.append('iris-versicolor')
    if val == 2:
        species.append('iris-virginica')
species = pd.Series(species)

datasets['target'] = target_val
datasets['target_name'] = species
datasets.head()