Python membagi array berdasarkan persentase

Halo semuanya. Setelah posting terakhir saya tentang regresi linier dengan Python, saya pikir wajar saja untuk menulis posting tentang Train/Test Split dan Cross Validation. Seperti biasa, saya akan memberikan ikhtisar singkat tentang topik ini dan kemudian memberikan contoh penerapannya di Python. Ini adalah dua konsep yang agak penting dalam ilmu data dan analisis data dan digunakan sebagai alat untuk mencegah (atau setidaknya meminimalkan) overfitting. Saya akan menjelaskan apa itu - ketika kita menggunakan model statistik (seperti regresi linier, misalnya), kita biasanya menyesuaikan model pada rangkaian pelatihan untuk membuat prediksi pada data yang tidak dilatih (data umum . Overfitting berarti apa yang kita sesuaikan model terlalu banyak dengan data pelatihan. Semuanya akan segera masuk akal, aku janji

Seperti yang disebutkan, dalam statistik dan pembelajaran mesin, kami biasanya membagi data kami menjadi dua himpunan bagian. data pelatihan dan data pengujian (dan terkadang hingga tiga. latih, validasi, dan uji), dan paskan model kami pada data latih, untuk membuat prediksi pada data uji. Ketika kita melakukan itu, satu dari dua hal mungkin terjadi. kami mengenakan model kami atau kami mengenakan model kami. Kami tidak ingin hal-hal ini terjadi, karena memengaruhi prediktabilitas model kami — kami mungkin menggunakan model yang memiliki akurasi lebih rendah dan/atau tidak digeneralisasikan (artinya Anda tidak dapat menggeneralisasi prediksi Anda pada data lain). Mari kita lihat apa sebenarnya arti under dan overfitting

Overfitting

Overfitting berarti bahwa model yang kami latih telah melatih "terlalu baik" dan sekarang, terlalu pas dengan dataset pelatihan. Ini biasanya terjadi ketika modelnya terlalu kompleks (mis. e. terlalu banyak fitur/variabel dibandingkan dengan jumlah observasi). Model ini akan sangat akurat pada data pelatihan tetapi mungkin akan sangat tidak akurat pada data yang tidak terlatih atau baru. Itu karena model ini tidak digeneralisasikan (atau tidak digeneralisasi AS), yang berarti Anda dapat menggeneralisasi hasil dan tidak dapat membuat kesimpulan apa pun pada data lain, yang pada akhirnya adalah apa yang Anda coba lakukan. Pada dasarnya, ketika ini terjadi, model mempelajari atau menggambarkan "noise" dalam data pelatihan alih-alih hubungan sebenarnya antara variabel dalam data. Kebisingan ini, jelas, bukan bagian dari kumpulan data baru mana pun, dan tidak dapat diterapkan padanya

Meremehkan

Berbeda dengan overfitting, ketika model underfitted, itu berarti model tidak sesuai dengan data pelatihan dan oleh karena itu ketinggalan tren dalam data. Ini juga berarti model tidak dapat digeneralisasikan ke data baru. Seperti yang mungkin Anda duga (atau temukan. ), ini biasanya merupakan hasil dari model yang sangat sederhana (tidak cukup prediktor/variabel independen). Itu juga bisa terjadi ketika, misalnya, kami menyesuaikan model linier (seperti regresi linier) dengan data yang tidak linier. Hampir tidak perlu dikatakan lagi bahwa model ini akan memiliki kemampuan prediksi yang buruk (pada data pelatihan dan tidak dapat digeneralisasikan ke data lain)

Perlu dicatat bahwa underfitting tidak lazim seperti overfitting. Namun demikian, kami ingin menghindari kedua masalah tersebut dalam analisis data. Anda mungkin mengatakan kami mencoba menemukan jalan tengah antara under dan overfitting model kami. Seperti yang akan Anda lihat, latih/uji split dan validasi silang membantu menghindari overfitting lebih dari underfitting. Mari selami keduanya

Seperti yang saya katakan sebelumnya, data yang kita gunakan biasanya dibagi menjadi data pelatihan dan data uji. Set pelatihan berisi keluaran yang diketahui dan model mempelajari data ini untuk digeneralisasikan ke data lain di kemudian hari. Kami memiliki dataset uji (atau subset) untuk menguji prediksi model kami pada subset ini

Mari kita lihat bagaimana melakukan ini dengan Python. Kami akan melakukan ini menggunakan perpustakaan Scikit-Learn dan khususnya metode train_test_split. Kami akan mulai dengan mengimpor perpustakaan yang diperlukan

import pandas as pd
from sklearn import datasets, linear_model
from sklearn.model_selection import train_test_split
from matplotlib import pyplot as plt

Mari kita cepat melihat perpustakaan yang telah saya impor

• Pandas — untuk memuat file data sebagai bingkai data Pandas dan menganalisis data. Jika Anda ingin membaca lebih lanjut tentang Panda, silakan lihat posting saya
• Dari Sklearn, saya telah mengimpor modul kumpulan data, sehingga saya dapat memuat kumpulan data sampel, dan model_linier, sehingga saya dapat menjalankan regresi linier
• Dari Sklearn, sub-library model_selection, saya telah mengimpor train_test_split sehingga saya dapat membaginya menjadi set pelatihan dan pengujian
• Dari Matplotlib saya telah mengimpor pyplot untuk memplot grafik data

Oke, siap. Mari memuat dataset diabetes, mengubahnya menjadi bingkai data dan menentukan nama kolom

# Load the Diabetes dataset
columns = “age sex bmi map tc ldl hdl tch ltg glu”.split() # Declare the columns names
diabetes = datasets.load_diabetes() # Call the diabetes dataset from sklearn
df = pd.DataFrame(diabetes.data, columns=columns) # load the dataset as a pandas data frame
y = diabetes.target # define the target variable (dependent variable) as y

Sekarang kita dapat menggunakan fungsi train_test_split untuk melakukan pemisahan. test_size=0. 2 di dalam fungsi menunjukkan persentase data yang harus disimpan untuk pengujian. Biasanya sekitar 80/20 atau 70/30

# create training and testing vars
X_train, X_test, y_train, y_test = train_test_split(df, y, test_size=0.2)
print X_train.shape, y_train.shape
print X_test.shape, y_test.shape(353, 10) (353,)
(89, 10) (89,)

Sekarang kita akan menyesuaikan model pada data pelatihan

# fit a model
lm = linear_model.LinearRegression()model = lm.fit(X_train, y_train)
predictions = lm.predict(X_test)

Seperti yang Anda lihat, kami menyesuaikan model pada data pelatihan dan mencoba memprediksi data pengujian. Mari kita lihat apa (beberapa) prediksinya

predictions[0:5]
array([ 205.68012533,   64.58785513,  175.12880278,  169.95993301,
        128.92035866])

Catatan. karena saya menggunakan [0. 5] setelah prediksi, itu hanya menunjukkan lima nilai prediksi pertama. Menghapus [0. 5] akan membuatnya mencetak semua nilai prediksi yang dibuat oleh model kita

Mari plot modelnya

## The line / model
plt.scatter(y_test, predictions)
plt.xlabel(“True Values”)
plt.ylabel(“Predictions”)

Dan mencetak skor akurasi

print “Score:”, model.score(X_test, y_test)Score: 0.485829586737

Ini dia. Berikut adalah ringkasan dari apa yang saya lakukan. Saya telah memuat data, membaginya menjadi set pelatihan dan pengujian, memasang model regresi ke data pelatihan, membuat prediksi berdasarkan data ini dan menguji prediksi pada data pengujian. Sepertinya bagus, bukan? . Ini akan mengakibatkan overfitting, meskipun kami berusaha menghindarinya. Di sinilah validasi silang masuk

Di paragraf sebelumnya, saya menyebutkan peringatan dalam metode train/test split. Untuk menghindari hal ini, kita dapat melakukan sesuatu yang disebut validasi silang. Ini sangat mirip dengan pemisahan latih/uji, tetapi diterapkan ke lebih banyak subset. Artinya, kami membagi data kami menjadi k subset, dan melatih k-1 salah satu subset tersebut. Apa yang kami lakukan adalah menahan subset terakhir untuk pengujian. Kami dapat melakukannya untuk setiap himpunan bagian

Ada banyak metode validasi silang, saya akan membahas dua di antaranya. yang pertama adalah K-Folds Cross Validation dan yang kedua adalah Leave One Out Cross Validation (LOOCV)

Validasi Silang K-Folds

Dalam K-Folds Cross Validation kami membagi data kami menjadi k subset (atau lipatan) yang berbeda. Kami menggunakan subset k-1 untuk melatih data kami dan meninggalkan subset terakhir (atau lipatan terakhir) sebagai data uji. Kami kemudian rata-rata model terhadap setiap lipatan dan kemudian menyelesaikan model kami. Setelah itu kami mengujinya terhadap set pengujian

Ini adalah contoh yang sangat sederhana dari untuk K-Folds

from sklearn.model_selection import KFold # import KFold
X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) # create an array
y = np.array([1, 2, 3, 4]) # Create another array
kf = KFold(n_splits=2) # Define the split - into 2 folds 
kf.get_n_splits(X) # returns the number of splitting iterations in the cross-validatorprint(kf) KFold(n_splits=2, random_state=None, shuffle=False)

Dan mari kita lihat hasilnya — lipatannya

for train_index, test_index in kf.split(X):
 print(“TRAIN:”, train_index, “TEST:”, test_index)
 X_train, X_test = X[train_index], X[test_index]
 y_train, y_test = y[train_index], y[test_index]('TRAIN:', array([2, 3]), 'TEST:', array([0, 1]))
('TRAIN:', array([0, 1]), 'TEST:', array([2, 3]))

Seperti yang Anda lihat, fungsi membagi data asli menjadi subset data yang berbeda. Sekali lagi, contoh yang sangat sederhana tapi menurut saya ini menjelaskan konsepnya dengan cukup baik

Tinggalkan Satu Validasi Silang (LOOCV)

Ini adalah metode lain untuk validasi silang, (omong-omong, metode ini bukan hanya dua, ada banyak metode lain untuk validasi silang. Periksa mereka di). Dalam validasi silang jenis ini, jumlah lipatan (subset) sama dengan jumlah pengamatan yang kita miliki dalam kumpulan data. Kami kemudian rata-rata SEMUA lipatan ini dan membangun model kami dengan rata-rata. Kami kemudian menguji model terhadap lipatan terakhir. Karena kita akan mendapatkan set pelatihan dalam jumlah besar (sama dengan jumlah sampel), metode ini sangat mahal secara komputasi dan sebaiknya digunakan pada dataset kecil. Jika datasetnya besar, kemungkinan besar akan lebih baik menggunakan metode lain, seperti kfold

Mari kita lihat contoh lain dari Sklearn

from sklearn.model_selection import LeaveOneOut 
X = np.array([[1, 2], [3, 4]])
y = np.array([1, 2])
loo = LeaveOneOut()
loo.get_n_splits(X)


for train_index, test_index in loo.split(X):
   print("TRAIN:", train_index, "TEST:", test_index)
   X_train, X_test = X[train_index], X[test_index]
   y_train, y_test = y[train_index], y[test_index]
   print(X_train, X_test, y_train, y_test)

Dan ini adalah outputnya

# Load the Diabetes dataset
columns = “age sex bmi map tc ldl hdl tch ltg glu”.split() # Declare the columns names
diabetes = datasets.load_diabetes() # Call the diabetes dataset from sklearn
df = pd.DataFrame(diabetes.data, columns=columns) # load the dataset as a pandas data frame
y = diabetes.target # define the target variable (dependent variable) as y

Sekali lagi, contoh sederhana, tapi menurut saya ini sangat membantu dalam memahami konsep dasar metode ini

Jadi, metode apa yang harus kita gunakan? . Dengan jumlah lipatan yang lebih sedikit, kami mengurangi kesalahan karena varians, tetapi kesalahan karena bias akan lebih besar. Ini juga akan lebih murah secara komputasi. Oleh karena itu, dalam kumpulan data besar, k=3 biasanya disarankan. Dalam kumpulan data yang lebih kecil, seperti yang telah saya sebutkan sebelumnya, sebaiknya gunakan LOOCV

Mari kita lihat contoh yang saya gunakan sebelumnya, kali ini dengan menggunakan validasi silang. Saya akan menggunakan fungsi cross_val_predict untuk mengembalikan nilai prediksi untuk setiap titik data saat berada di bagian pengujian

# Load the Diabetes dataset
columns = “age sex bmi map tc ldl hdl tch ltg glu”.split() # Declare the columns names
diabetes = datasets.load_diabetes() # Call the diabetes dataset from sklearn
df = pd.DataFrame(diabetes.data, columns=columns) # load the dataset as a pandas data frame
y = diabetes.target # define the target variable (dependent variable) as y

Seperti yang Anda ingat, sebelumnya saya telah membuat pemisahan kereta/tes untuk kumpulan data diabetes dan memasang model. Mari kita lihat berapa skor setelah validasi silang

# Load the Diabetes dataset
columns = “age sex bmi map tc ldl hdl tch ltg glu”.split() # Declare the columns names
diabetes = datasets.load_diabetes() # Call the diabetes dataset from sklearn
df = pd.DataFrame(diabetes.data, columns=columns) # load the dataset as a pandas data frame
y = diabetes.target # define the target variable (dependent variable) as y

Seperti yang Anda lihat, lipatan terakhir meningkatkan skor model asli — dari 0. 485 ke 0. 569. Bukan hasil yang luar biasa, tapi hei, kami akan mengambil apa yang bisa kami dapatkan. )

Sekarang, mari buat prediksi baru, setelah melakukan validasi silang

# Load the Diabetes dataset
columns = “age sex bmi map tc ldl hdl tch ltg glu”.split() # Declare the columns names
diabetes = datasets.load_diabetes() # Call the diabetes dataset from sklearn
df = pd.DataFrame(diabetes.data, columns=columns) # load the dataset as a pandas data frame
y = diabetes.target # define the target variable (dependent variable) as y

Anda dapat melihatnya sangat berbeda dari plot aslinya sebelumnya. Poinnya enam kali lebih banyak dari plot aslinya karena saya menggunakan cv=6

Terakhir, mari kita periksa skor R² model (R² adalah "angka yang menunjukkan proporsi varian dalam variabel dependen yang dapat diprediksi dari variabel independen". Pada dasarnya, seberapa akurat model kita)

# Load the Diabetes dataset
columns = “age sex bmi map tc ldl hdl tch ltg glu”.split() # Declare the columns names
diabetes = datasets.load_diabetes() # Call the diabetes dataset from sklearn
df = pd.DataFrame(diabetes.data, columns=columns) # load the dataset as a pandas data frame
y = diabetes.target # define the target variable (dependent variable) as y

Itu saja untuk kali ini. Saya harap anda menikmati postingan ini. Seperti biasa, saya menerima pertanyaan, catatan, komentar, dan permintaan posting tentang topik yang ingin Anda baca. Sampai jumpa lain waktu

Bagaimana Anda membagi array dengan Python?

Bagaimana Anda membagi array menjadi dua dengan Python?

Bagaimana Anda membagi array menjadi beberapa array dengan Python?