উত্তর:
আমি কেবল নপীর ব্যবহার করব randn:
In [11]: df = pd.DataFrame(np.random.randn(100, 2))
In [12]: msk = np.random.rand(len(df)) < 0.8
In [13]: train = df[msk]
In [14]: test = df[~msk]এবং শুধু এটি কাজ করেছে তা দেখতে:
In [15]: len(test)
Out[15]: 21
In [16]: len(train)
Out[16]: 79randকরার < 0.8কারণ এটি অবিশেষে 0 এবং 1 এর মধ্যে র্যান্ডম সংখ্যা বিতরণ ফেরৎ জানার জন্য
in[12], কেউ অজগর শর্তে বিশুদ্ধভাবে ব্যাখ্যা করতে পারে in[13],, in[14]? আমি এখানে পাইথন কোডটি নিজেই বুঝতে চাই
np.random.rand(len(df))হ'ল আকারের একটি অ্যারে len(df)এবং এলোমেলোভাবে এবং অভিন্নভাবে বিতরণ করা ভাসমান মানগুলি পরিসীমা [0, 1] এর মধ্যে রয়েছে। < 0.8তুলনা উপাদান-অনুযায়ী ও সঞ্চয় জায়গায় ফলাফলের প্রযোজ্য। সুতরাং মানগুলি <0.8 হয়ে Trueও মান> = 0.8 হয়ে যায়False
সাইকিট লার্নিংtrain_test_split একটি ভাল।
from sklearn.model_selection import train_test_split
train, test = train_test_split(df, test_size=0.2)kf = KFold(n, n_folds=folds) for train_index, test_index in kf: X_train, X_test = X.ix[train_index], X.ix[test_index]এখানে পূর্ণ উদাহরণ দেখুন: quantstart.com/articles/…
from sklearn.model_selection import train_test_splitপরিবর্তে আমদানি করুন।
from sklearn.cross_validation import train_test_split
পান্ডসের এলোমেলো নমুনাও কাজ করবে
train=df.sample(frac=0.8,random_state=200) #random state is a seed value
test=df.drop(train.index)random_stateআরগ কি করছে?
testসেট হিসাবে এখানে উল্লেখ পছন্দসই stackoverflow.com/questions/29576430/shuffle-dataframe-rows । test=df.drop(train.index).sample(frac=1.0)
আমি সাইকিট-লার্নের নিজস্ব প্রশিক্ষণ_তিনিষ্ঠ_স্প্লিট ব্যবহার করব এবং এটি সূচক থেকে উত্পন্ন করব
from sklearn.model_selection import train_test_split
y = df.pop('output')
X = df
X_train,X_test,y_train,y_test = train_test_split(X.index,y,test_size=0.2)
X.iloc[X_train] # return dataframe traincross_validationমডিউল বর্তমানে অবচিত হয়েছে:DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
ট্রেন / পরীক্ষা এমনকি বৈধকরণের নমুনা তৈরির অনেকগুলি উপায় রয়েছে।
কেস 1: train_test_splitকোনও বিকল্প ছাড়াই ক্লাসিক উপায় :
from sklearn.model_selection import train_test_split
train, test = train_test_split(df, test_size=0.3)কেস 2: খুব ছোট ডেটাসেটের ক্ষেত্রে (<500 টি সারি): এই ক্রস-বৈধতা সহ আপনার সমস্ত লাইনের ফলাফল পাওয়ার জন্য। শেষে, আপনার উপলব্ধ প্রশিক্ষণের সেটটির প্রতিটি লাইনের জন্য একটি পূর্বাভাস থাকবে।
from sklearn.model_selection import KFold
kf = KFold(n_splits=10, random_state=0)
y_hat_all = []
for train_index, test_index in kf.split(X, y):
reg = RandomForestRegressor(n_estimators=50, random_state=0)
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
clf = reg.fit(X_train, y_train)
y_hat = clf.predict(X_test)
y_hat_all.append(y_hat)কেস 3 এ: শ্রেণিবিন্যাসের জন্য ভারসাম্যহীন ডেটাসেট। কেস 1 অনুসরণ করে, এখানে সমতুল্য সমাধান:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, test_size=0.3)কেস 3 বি: শ্রেণিবিন্যাসের জন্য ভারসাম্যহীন ডেটাসেট। কেস 2 অনুসরণ করে, এখানে সমতুল্য সমাধান:
from sklearn.model_selection import StratifiedKFold
kf = StratifiedKFold(n_splits=10, random_state=0)
y_hat_all = []
for train_index, test_index in kf.split(X, y):
reg = RandomForestRegressor(n_estimators=50, random_state=0)
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
clf = reg.fit(X_train, y_train)
y_hat = clf.predict(X_test)
y_hat_all.append(y_hat)কেস।: হাইপারপ্যারামিটারগুলি (60% ট্রেন, 20% পরীক্ষা এবং 20% ভাল) টিউন করতে আপনাকে বড় ডেটাতে একটি ট্রেন / পরীক্ষা / বৈধতা সেট তৈরি করতে হবে।
from sklearn.model_selection import train_test_split
X_train, X_test_val, y_train, y_test_val = train_test_split(X, y, test_size=0.6)
X_test, X_val, y_test, y_val = train_test_split(X_test_val, y_test_val, stratify=y, test_size=0.5)আপনি পরীক্ষা এবং ট্রেনের নমুনা তৈরি করতে নীচের কোডটি ব্যবহার করতে পারেন:
from sklearn.model_selection import train_test_split
trainingSet, testSet = train_test_split(df, test_size=0.2)পরীক্ষার আকার আপনি নিজের পরীক্ষা এবং ট্রেনের ডেটাসেটে যে পরিমাণ ডেটা রাখতে চান তার উপর নির্ভর করে পরিবর্তিত হতে পারে।
আপনি স্তরিত বিভাগকে প্রশিক্ষণ এবং পরীক্ষার সেট হিসাবে বিবেচনা করতে পারেন। স্টার্টিফায়েড বিভাগ এলোমেলোভাবে প্রশিক্ষণ ও পরীক্ষার সেট জেনারেট করে তবে এমনভাবে যাতে মূল শ্রেণীর অনুপাত সংরক্ষণ করা হয়। এটি প্রশিক্ষণ এবং পরীক্ষার সেটগুলি মূল ডেটাসেটের বৈশিষ্ট্যগুলিকে আরও ভালভাবে প্রতিবিম্বিত করে।
import numpy as np
def get_train_test_inds(y,train_proportion=0.7):
'''Generates indices, making random stratified split into training set and testing sets
with proportions train_proportion and (1-train_proportion) of initial sample.
y is any iterable indicating classes of each observation in the sample.
Initial proportions of classes inside training and
testing sets are preserved (stratified sampling).
'''
y=np.array(y)
train_inds = np.zeros(len(y),dtype=bool)
test_inds = np.zeros(len(y),dtype=bool)
values = np.unique(y)
for value in values:
value_inds = np.nonzero(y==value)[0]
np.random.shuffle(value_inds)
n = int(train_proportion*len(value_inds))
train_inds[value_inds[:n]]=True
test_inds[value_inds[n:]]=True
return train_inds,test_indsdf [train_inds] এবং df [test_inds] আপনাকে আপনার আসল ডেটা ফ্রেম df এর প্রশিক্ষণ এবং পরীক্ষার সেট দেয়।
আপনার ডেটা সেটে লেবেল কলামের ক্ষেত্রে আপনার ডেটা বিভক্ত করার প্রয়োজন হলে আপনি এটি ব্যবহার করতে পারেন:
def split_to_train_test(df, label_column, train_frac=0.8):
train_df, test_df = pd.DataFrame(), pd.DataFrame()
labels = df[label_column].unique()
for lbl in labels:
lbl_df = df[df[label_column] == lbl]
lbl_train_df = lbl_df.sample(frac=train_frac)
lbl_test_df = lbl_df.drop(lbl_train_df.index)
print '\n%s:\n---------\ntotal:%d\ntrain_df:%d\ntest_df:%d' % (lbl, len(lbl_df), len(lbl_train_df), len(lbl_test_df))
train_df = train_df.append(lbl_train_df)
test_df = test_df.append(lbl_test_df)
return train_df, test_dfএবং এটি ব্যবহার করুন:
train, test = split_to_train_test(data, 'class', 0.7)আপনি বিভক্ত র্যান্ডমকে নিয়ন্ত্রণ করতে বা কিছু বিশ্বব্যাপী এলোমেলো বীজ ব্যবহার করতে চাইলে আপনি এলোমেলো_স্টেটও পাস করতে পারেন।
import pandas as pd
from sklearn.model_selection import train_test_split
datafile_name = 'path_to_data_file'
data = pd.read_csv(datafile_name)
target_attribute = data['column_name']
X_train, X_test, y_train, y_test = train_test_split(data, target_attribute, test_size=0.8)আপনি df.sample () ব্যবহার করে নমুনাযুক্ত সারিগুলি বাদ দেওয়ার জন্য ~ (টিল্ড অপারেটর) ব্যবহার করতে পারেন, দুটি সেট পাওয়ার জন্য পান্ডাকে একা নমুনা স্যাম্পলিং এবং ফিল্টারিং পরিচালনা করতে দেয়।
train_df = df.sample(frac=0.8, random_state=100)
test_df = df[~df.index.isin(train_df.index)]যখন আমি ডেটা ফ্রেম বিভক্ত করার প্রয়োজন ছিল তখন এটি আমি লিখেছিলাম। আমি উপরে অ্যান্ডির পদ্ধতির ব্যবহার বিবেচনা করেছি, তবে আমি পছন্দ করি না যে আমি ডেটা সেটগুলির আকারটি ঠিকঠাকভাবে নিয়ন্ত্রণ করতে পারি না (অর্থাত এটি কখনও কখনও 79৯, কখনও কখনও ৮১ ইত্যাদি)।
def make_sets(data_df, test_portion):
import random as rnd
tot_ix = range(len(data_df))
test_ix = sort(rnd.sample(tot_ix, int(test_portion * len(data_df))))
train_ix = list(set(tot_ix) ^ set(test_ix))
test_df = data_df.ix[test_ix]
train_df = data_df.ix[train_ix]
return train_df, test_df
train_df, test_df = make_sets(data_df, 0.2)
test_df.head()এই জাতীয় df থেকে সীমা সারিটি নির্বাচন করুন
row_count = df.shape[0]
split_point = int(row_count*1/5)
test_data, train_data = df[:split_point], df[split_point:]dfকোডটিতে স্নিপেট যুক্ত করেন (বা হওয়া উচিত) তবে এটি উত্তরটির উন্নতি করবে।
উপরে অনেক দুর্দান্ত উত্তর রয়েছে তাই আমি কেবলমাত্র সেই ক্ষেত্রে আরও একটি উদাহরণ যুক্ত করতে চাই যে আপনি কেবল numpyলাইব্রেরি ব্যবহার করে ট্রেন এবং পরীক্ষার সেটগুলির জন্য সঠিক নমুনার সংখ্যা নির্দিষ্ট করতে চান ।
# set the random seed for the reproducibility
np.random.seed(17)
# e.g. number of samples for the training set is 1000
n_train = 1000
# shuffle the indexes
shuffled_indexes = np.arange(len(data_df))
np.random.shuffle(shuffled_indexes)
# use 'n_train' samples for training and the rest for testing
train_ids = shuffled_indexes[:n_train]
test_ids = shuffled_indexes[n_train:]
train_data = data_df.iloc[train_ids]
train_labels = labels_df.iloc[train_ids]
test_data = data_df.iloc[test_ids]
test_labels = data_df.iloc[test_ids]ট্রেন, পরীক্ষা এবং বৈধকরণের মতো দুটিরও বেশি শ্রেণিতে বিভক্ত হওয়ার জন্য, কেউ এটি করতে পারেন:
probs = np.random.rand(len(df))
training_mask = probs < 0.7
test_mask = (probs>=0.7) & (probs < 0.85)
validatoin_mask = probs >= 0.85
df_training = df[training_mask]
df_test = df[test_mask]
df_validation = df[validatoin_mask]এটি প্রশিক্ষণে প্রায় 70% ডেটা, পরীক্ষায় 15% এবং বৈধতার 15% রাখবে।
আপনাকে পান্ডাস ডেটাফ্রেমকে নম্পি অ্যারে রূপান্তর করতে হবে এবং তারপরে নম্পি অ্যারেটিকে ডেটাফ্রেমে রূপান্তর করতে হবে
import pandas as pd
df=pd.read_csv('/content/drive/My Drive/snippet.csv', sep='\t')
from sklearn.model_selection import train_test_split
train, test = train_test_split(df, test_size=0.2)
train1=pd.DataFrame(train)
test1=pd.DataFrame(test)
train1.to_csv('/content/drive/My Drive/train.csv',sep="\t",header=None, encoding='utf-8', index = False)
test1.to_csv('/content/drive/My Drive/test.csv',sep="\t",header=None, encoding='utf-8', index = False)যদি আপনার ইচ্ছাটি একটি ডেটাফ্র্যাম ইন এবং দুটি ডেটাফ্রেম বেরিয়ে আসে (ন্যাপি অ্যারে নয়) তবে এই কৌশলটি করা উচিত:
def split_data(df, train_perc = 0.8):
df['train'] = np.random.rand(len(df)) < train_perc
train = df[df.train == 1]
test = df[df.train == 0]
split_data ={'train': train, 'test': test}
return split_dataআমার স্বাদে আরও খানিকটা মার্জিত হ'ল একটি এলোমেলো কলাম তৈরি করা এবং তারপরে এর দ্বারা বিভক্ত হওয়া, এইভাবে আমরা একটি বিভাজন পেতে পারি যা আমাদের প্রয়োজনের সাথে খাপ খায় এবং এলোমেলো হয়ে যায়।
def split_df(df, p=[0.8, 0.2]):
import numpy as np
df["rand"]=np.random.choice(len(p), len(df), p=p)
r = [df[df["rand"]==val] for val in df["rand"].unique()]
return rshuffle = np.random.permutation(len(df))
test_size = int(len(df) * 0.2)
test_aux = shuffle[:test_size]
train_aux = shuffle[test_size:]
TRAIN_DF =df.iloc[train_aux]
TEST_DF = df.iloc[test_aux]
mskdtype হয়bool,df[msk],df.iloc[msk]এবংdf.loc[msk]সবসময় একই ফলাফল ফিরে যান।