पंडित डेटासेट के लिए स्किकिट-लर्निंग डेटासेट कैसे कन्वर्ट करें?

Question

मैं डेटा को Scikit-learn Bunch ऑब्जेक्ट से 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?

Answer 1

मैन्युअल रूप से, आप pd.DataFrameकंस्ट्रक्टर का उपयोग कर सकते हैं , एक सुन्न सरणी ( data) और कॉलम के नामों की सूची ( ) दे सकते हैं columns। एक DataFrame में सब कुछ करने के लिए, आप np.c_[...](नोट करें []) के साथ सुविधाओं और लक्ष्य को एक संख्यात्मक सारणी में बदल सकते हैं :

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'])

Comments

क्या आप इस कोड को समझाने के लिए थोड़ा पाठ जोड़ सकते हैं? यह हमारे मानकों द्वारा कुछ हद तक संक्षिप्त है।

— गंग -

कुछ गुच्छों में ndarray के रूप में feature_names होता है जो कॉलम पैरामीटर को तोड़ देगा।

गुम "प्रजाति" कुंजी और मान डेटाफ़्रेम के लिए।

— mastash3ff

यह कोड मेरे लिए काम नहीं कर रहा है। कॉलम पैरामीटर के लिए, मुझे कॉलम = np.append (iris ['feature_names'], 'target) में पास करना होगा। क्या मैंने कुछ गलत किया, या क्या इस उत्तर को संपादित करने की आवश्यकता है?

— जोश डेविस

यह सभी डेटासेट के लिए काम नहीं करता है, जैसे कि load_boston()। यह उत्तर आम तौर पर अधिक काम करता है: stackoverflow.com/a/46379878/1840471

— मैक्स गनीस

Answer 2

from sklearn.datasets import load_iris
import pandas as pd

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

इस ट्यूटोरियल की रुचि हो सकती है: http://www.neural.cz/dataset-exploration-boston-house-pricing.html

Comments

लक्ष्य के साथ डेटा को अलग करने की आवश्यकता है: df = pd.DataFrame (np.concatenate ((iris.data, np.array ([iris.target]))। T), अक्ष 1), कॉलम = iris.feature_names + [''। लक्ष्य '])

— टायलर 傲

Answer 3

TOMDLt का समाधान सभी डेटासेट के लिए पर्याप्त सामान्य नहीं है। उदाहरण के लिए, यह बुस्टॉन हाउसिंग डेटासेट के लिए काम नहीं करता है। मैं एक अलग समाधान का प्रस्ताव करता हूं जो अधिक सार्वभौमिक है। साथ ही सुन्न का उपयोग करने की आवश्यकता नहीं है।

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()

एक सामान्य कार्य के रूप में:

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())

Answer 4

एक विकल्प के रूप में मैं अपने सिर को बहुत आसानी से लपेट सकता था:

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

मूल रूप से गेट गो से समवर्ती करने के बजाय, बस सुविधाओं के मैट्रिक्स के साथ एक डेटा फ़्रेम बनाएं और फिर डेटा ['whatvername'] के साथ लक्ष्य कॉलम जोड़ें और डेटासेट से लक्ष्य मानों को पकड़ो

Answer 5

यह पता लगाने के लिए मुझे 2 घंटे लगे

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)

मेरे पंडों की प्रजातियों को वापस पाओ

Answer 6

अन्यथा समुद्री डेटा सेट का उपयोग करें जो वास्तविक पांडा डेटा फ़्रेम हैं:

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

डेटा सेट के साथ सीखें तुलना करें:

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

Answer 7

यह मेरे लिए काम करता है।

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

Answer 8

सुविधाओं और लक्ष्य चर को संयोजित करने का अन्य तरीका np.column_stack( विवरण ) का उपयोग किया जा सकता है

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())

परिणाम:

   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

आप के लिए स्ट्रिंग लेबल की जरूरत है target, तो आप उपयोग कर सकते हैं replaceपरिवर्तित करके target_namesकरने के लिए dictionaryऔर एक नया कॉलम जोड़ें:

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

परिणाम:

   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

Answer 9

मूल रूप से आपको जो "डेटा" की आवश्यकता होती है, और आप इसे स्किटिट गुच्छा में रखते हैं, अब आपको बस "लक्ष्य" (भविष्यवाणी) की आवश्यकता है जो कि गुच्छा में भी है।

इसलिए डेटा को पूरा करने के लिए बस इन दोनों को संक्षिप्त करने की आवश्यकता है

  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)

Answer 10

संस्करण 0.23 के रूप में, आप सीधे as_frameतर्क का उपयोग करके डेटाफ़्रेम को वापस कर सकते हैं । उदाहरण के लिए, आईरिस डेटा सेट लोड करना:

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

अनंतिम रूप से जारी किए गए नोटों का उपयोग करते हुए मेरी समझ में , यह ब्रेस्ट_कैंसर, डायबिटीज, डिजिट्स, आइरिस, लाइनरूड, वाइन और कैलिफ़ोर्निया_हाउस डेटा सेट के लिए काम करता है।

Answer 11

अपडेट: 2020

आप as_frame=Trueपांडा डेटाफ़्रेम प्राप्त करने के लिए पैरामीटर का उपयोग कर सकते हैं ।

यदि as_frame पैरामीटर उपलब्ध है (जैसे। 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

यदि as_frame पैरामीटर उपलब्ध नहीं है (जैसे। 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)

Answer 12

सबसे अच्छा जवाब देना और मेरी टिप्पणी को संबोधित करना, यहाँ रूपांतरण के लिए एक समारोह है

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)

Answer 13

जो भी TomDLT ने उत्तर दिया, वह आप में से कुछ के लिए काम नहीं कर सकता है

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

क्योंकि आईरिस ['feature_names'] आपको एक शानदार सरणी देता है। संख्यात्मक सारणी में आप एक सारणी और सूची ['लक्ष्य'] को सिर्फ + ऑपरेटर से नहीं जोड़ सकते। इसलिए आपको इसे पहले एक सूची में बदलने और फिर जोड़ने की आवश्यकता है।

तुम कर सकते हो

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

यह ठीक काम करेगा ..

Answer 14

एक बेहतर तरीका हो सकता है लेकिन यहां मैंने अतीत में किया है और यह काफी अच्छी तरह से काम करता है:

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

अब mydata में आपकी ज़रूरत की सभी चीज़ें होंगी - विशेषताएँ, लक्ष्य चर और स्तंभ नाम

Comments

TomDLT द्वारा समाधान मैं जो सुझाव दे रहा हूं, उससे बहुत बेहतर है। यह एक ही काम करता है लेकिन समझने में बहुत ही सुंदर और आसान है। उसका उपयोग करें!

— हकुनामाता

mydata = pd.DataFrame(items[1][1])फेंकता हैTypeError: 'dict_items' object does not support indexing

— SANBI का नमूना

Answer 15

यह स्निपेट केवल सिंथैटिक शुगर है जिसे टॉमडल्ट और रोलेट ने पहले ही योगदान दिया और समझाया। एकमात्र अंतर यह होगा कि load_irisएक शब्दकोश के बजाय एक टपल लौटेगा और कॉलम नाम संकलित किए जाएंगे।

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

Comments

इस कोड स्निपेट के लिए धन्यवाद, जो कुछ सीमित, तत्काल सहायता प्रदान कर सकता है। एक उचित व्याख्या यह दर्शाती है कि यह समस्या का एक अच्छा समाधान क्यों है, यह दिखा कर इसके दीर्घकालिक मूल्य में बहुत सुधार होगा , और यह भविष्य के पाठकों को अन्य, समान प्रश्नों के साथ और अधिक उपयोगी बना देगा। कृपया कुछ स्पष्टीकरण जोड़ने के लिए अपने उत्तर को संपादित करें, जिसमें आपके द्वारा की गई धारणाएँ शामिल हैं।

— गुडबाय StackExchange

Answer 16

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()

Answer 17

सबसे अच्छे तरीकों में से एक:

data = pd.DataFrame(digits.data)

अंक स्कील डेटाफ़्रेम है और मैंने इसे एक पांडा डेटाफ़्रेम में परिवर्तित कर दिया है

Answer 18

मैंने आपके उत्तरों में से कुछ विचारों को लिया और मुझे नहीं पता कि इसे छोटा कैसे बनाया जाए :)

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']

यह कॉलम और रेंजइंडेक्स (प्रारंभ = 0, स्टॉप = लेन (डीएफ), स्टेप = 1) के रूप में फीचर_नाम और लक्ष्य के साथ एक पंडास डेटाफ़्रेम देता है। मैं एक छोटा कोड रखना चाहूँगा जहाँ मैं 'लक्ष्य' को सीधे जोड़ सकता हूँ।

Answer 19

सुझाई गई प्रतिक्रियाओं की तुलना में एपीआई थोड़ा साफ है। यहां, as_frameएक प्रतिक्रिया कॉलम के साथ-साथ उपयोग करना और सुनिश्चित करना शामिल है।

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)

Answer 20

यहाँ एक और एकीकृत विधि उदाहरण शायद सहायक है।

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)

डेटा iris_X को पांडा डेटा के रूप में आयात किया जाता है और लक्ष्य iris_y को पांडा श्रृंखला के रूप में आयात किया जाता है।

Answer 21

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()