Cara membagi daftar secara acak dengan python

Question

Tugas Divide a Pandas Dataframe sangat berguna jika membagi dataset yang diberikan menjadi data latih dan uji untuk tujuan pelatihan dan pengujian di bidang Pembelajaran Mesin, Kecerdasan Buatan, dll. Mari kita lihat bagaimana membagi kerangka data panda secara acak ke dalam rasio tertentu. Untuk tugas ini, Kami akan menggunakan Dataframe. sampel() dan Dataframe. drop() metode kerangka data panda bersama-sama

Table of Contents Show

Pentingnya Pemisahan Data
Pelatihan, Validasi, dan Set Tes
Underfitting dan Overfitting
Prasyarat untuk Menggunakan $ conda install -c anaconda scikit-learn=0.23 7
Penerapan $ conda install -c anaconda scikit-learn=0.23 _7
Pembelajaran Mesin yang Diawasi Dengan $ conda install -c anaconda scikit-learn=0.23 7
Contoh Minimalis Regresi Linear
Contoh Regresi
Contoh Klasifikasi
Fungsi Validasi Lainnya
Bagaimana Anda membagi daftar dengan Python?
Bagaimana Anda membagi daftar menjadi beberapa bagian dengan Python?
Apa itu daftar 80 20 split dengan Python?
Bagaimana Anda membagi daftar menjadi melatih dan menguji?

Sintaks dari fungsi-fungsi ini adalah sebagai berikut –

Bingkai data. Sampel()

Sintaksis. Bingkai Data. sampel(n=Tidak ada, frac=Tidak ada, ganti=Salah, bobot=Tidak ada, status_acak=Tidak ada, sumbu=Tidak ada)
Jenis Pengembalian. Objek baru dengan tipe yang sama dengan pemanggil yang berisi n item yang diambil sampelnya secara acak dari objek pemanggil

Bingkai data. menjatuhkan()

Sintaksis. Bingkai Data. jatuhkan (label = Tidak ada, sumbu = 0, indeks = Tidak ada, kolom = Tidak ada, level = Tidak ada, inplace = Salah, kesalahan = 'naikkan')

Salah satu aspek kunci dari pembelajaran mesin yang diawasi adalah evaluasi dan validasi model. Saat Anda mengevaluasi kinerja prediktif model Anda, penting agar prosesnya tidak bias. Menggunakan
$ conda install -c anaconda scikit-learn=0.23
_7 dari perpustakaan ilmu data scikit-learn, Anda dapat membagi kumpulan data menjadi subkumpulan yang meminimalkan potensi bias dalam proses evaluasi dan validasi Anda
Dalam tutorial ini, Anda akan belajar
Mengapa Anda perlu membagi set data Anda dalam pembelajaran mesin yang diawasi
Subkumpulan data mana yang Anda perlukan untuk evaluasi model Anda yang tidak bias
Cara menggunakan
$ conda install -c anaconda scikit-learn=0.23
_7 untuk membagi data Anda
Cara menggabungkan
$ conda install -c anaconda scikit-learn=0.23
_7 dengan metode prediksi
Selain itu, Anda akan mendapatkan informasi tentang alat terkait dari
Bonus Gratis. yang mengarahkan Anda ke tutorial, video, dan buku terbaik untuk meningkatkan keterampilan NumPy Anda
Pentingnya Pemisahan Data
Pembelajaran mesin yang diawasi adalah tentang membuat model yang secara tepat memetakan input yang diberikan (variabel independen, atau prediktor) ke output yang diberikan (variabel dependen, atau respons)
Bagaimana Anda mengukur ketepatan model Anda bergantung pada jenis masalah yang Anda coba selesaikan. Dalam , Anda biasanya menggunakan koefisien determinasi, kesalahan kuadrat akar rata-rata, kesalahan absolut rata-rata, atau besaran serupa. Untuk masalah, Anda sering menerapkan akurasi, presisi, daya ingat, skor F1, dan indikator terkait
Nilai numerik yang dapat diterima yang mengukur presisi bervariasi dari bidang ke bidang. Anda dapat menemukan penjelasan mendetail dari Statistics By Jim, Quora, dan banyak sumber lainnya
Yang paling penting untuk dipahami adalah bahwa Anda biasanya memerlukan evaluasi yang tidak memihak untuk menggunakan langkah-langkah ini dengan benar, menilai kinerja prediksi model Anda, dan memvalidasi model tersebut.
Artinya, Anda tidak dapat mengevaluasi performa prediktif model dengan data yang sama dengan yang Anda gunakan untuk pelatihan. Anda perlu mengevaluasi model dengan data baru yang belum pernah dilihat oleh model sebelumnya. Anda dapat melakukannya dengan memisahkan dataset Anda sebelum Anda menggunakannya
Hilangkan iklan
Pelatihan, Validasi, dan Set Tes
Memisahkan kumpulan data Anda sangat penting untuk evaluasi kinerja prediksi yang tidak bias. Dalam kebanyakan kasus, membagi kumpulan data Anda secara acak menjadi tiga subkumpulan sudah cukup
Set pelatihan diterapkan untuk melatih, atau menyesuaikan, model Anda. Misalnya, Anda menggunakan set pelatihan untuk menemukan bobot optimal, atau koefisien, untuk regresi linier, regresi logistik, atau jaringan saraf.
Set validasi digunakan untuk evaluasi model yang tidak bias selama penyetelan hyperparameter. Misalnya, ketika Anda ingin menemukan jumlah neuron optimal dalam jaringan saraf atau kernel terbaik untuk mesin vektor pendukung, Anda bereksperimen dengan nilai yang berbeda. Untuk setiap pengaturan hyperparameter yang dipertimbangkan, Anda menyesuaikan model dengan set pelatihan dan menilai kinerjanya dengan set validasi
Set tes diperlukan untuk evaluasi model akhir yang tidak bias. Anda tidak boleh menggunakannya untuk pemasangan atau validasi
Dalam kasus yang tidak terlalu rumit, saat Anda tidak perlu menyetel hyperparameter, Anda boleh bekerja hanya dengan set pelatihan dan pengujian
Underfitting dan Overfitting
Memisahkan kumpulan data mungkin juga penting untuk mendeteksi jika model Anda mengalami salah satu dari dua masalah yang sangat umum, yang disebut underfitting dan overfitting
Underfitting biasanya merupakan konsekuensi dari model yang tidak dapat merangkum hubungan antar data. Misalnya, hal ini dapat terjadi saat mencoba merepresentasikan hubungan nonlinier dengan model linier. Model yang kurang pas kemungkinan akan memiliki kinerja yang buruk dengan set pelatihan dan pengujian
Overfitting biasanya terjadi ketika model memiliki struktur yang sangat kompleks dan mempelajari hubungan yang ada antara data dan noise. Model seperti itu seringkali memiliki kemampuan generalisasi yang buruk. Meskipun mereka bekerja dengan baik dengan data pelatihan, mereka biasanya menghasilkan kinerja yang buruk dengan data (tes) yang tidak terlihat
Anda dapat menemukan penjelasan yang lebih rinci tentang underfitting dan overfitting
Prasyarat untuk Menggunakan $ conda install -c anaconda scikit-learn=0.23 7
Sekarang setelah Anda memahami perlunya membagi set data untuk melakukan evaluasi model yang tidak bias dan mengidentifikasi underfitting atau overfitting, Anda siap mempelajari cara membagi set data Anda sendiri
Anda akan menggunakan versi 0. 23. 1 dari scikit-belajar, atau
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
2. Ini memiliki banyak paket untuk ilmu data dan pembelajaran mesin, tetapi untuk tutorial ini Anda akan fokus pada paket
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
3, khususnya pada fungsi
$ conda install -c anaconda scikit-learn=0.23
7
Anda dapat menginstal
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
_2 dengan
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
6
$ python -m pip install -U "scikit-learn==0.23.1"
_
Jika Anda menggunakan Anaconda, Anda mungkin sudah menginstalnya. Namun, jika Anda ingin menggunakan lingkungan baru, pastikan Anda memiliki versi yang ditentukan, atau menggunakan Miniconda, maka Anda dapat menginstal
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
2 dari Anaconda Cloud dengan
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
8
$ conda install -c anaconda scikit-learn=0.23
Anda juga memerlukan NumPy, tetapi Anda tidak perlu menginstalnya secara terpisah. Anda harus mendapatkannya bersama
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
_2 jika Anda belum menginstalnya. Jika Anda ingin menyegarkan kembali pengetahuan NumPy Anda, lihat dokumentasi resminya atau lihat Look Ma, No For-Loops. Pemrograman Array Dengan NumPy
Penerapan $ conda install -c anaconda scikit-learn=0.23 _7
Anda perlu mengimpor
$ conda install -c anaconda scikit-learn=0.23
7 dan NumPy sebelum Anda dapat menggunakannya, sehingga Anda dapat memulai dengan pernyataan
sklearn.model_selection.train_test_split(*arrays, **options) -> list
2
>>>
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
_
Sekarang setelah Anda mengimpor keduanya, Anda dapat menggunakannya untuk membagi data menjadi set pelatihan dan set pengujian. Anda akan membagi input dan output secara bersamaan, dengan satu panggilan fungsi

Dengan
$ conda install -c anaconda scikit-learn=0.23
_7, Anda perlu memberikan urutan yang ingin Anda pisahkan serta argumen opsional apa pun. Ini mengembalikan daftar array NumPy, urutan lain, atau matriks jarang SciPy jika sesuai
sklearn.model_selection.train_test_split(*arrays, **options) -> list
sklearn.model_selection.train_test_split(*arrays, **options) -> list
_4 adalah urutan daftar, larik NumPy, panda DataFrames, atau objek serupa larik yang menyimpan data yang ingin Anda pisahkan. Semua objek ini bersama-sama membentuk kumpulan data dan harus memiliki panjang yang sama
Dalam aplikasi pembelajaran mesin yang diawasi, Anda biasanya akan bekerja dengan dua urutan tersebut
Array dua dimensi dengan input (
sklearn.model_selection.train_test_split(*arrays, **options) -> list
5)
Array satu dimensi dengan output (
sklearn.model_selection.train_test_split(*arrays, **options) -> list
6)
sklearn.model_selection.train_test_split(*arrays, **options) -> list
7 adalah argumen kata kunci opsional yang dapat Anda gunakan untuk mendapatkan perilaku yang diinginkan
sklearn.model_selection.train_test_split(*arrays, **options) -> list
_8 adalah angka yang menentukan ukuran set pelatihan. Jika Anda memberikan
sklearn.model_selection.train_test_split(*arrays, **options) -> list
_9, maka itu harus antara
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
0 dan
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
1 dan akan menentukan bagian dari kumpulan data yang digunakan untuk pengujian. Jika Anda memberikan
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
_2, maka itu akan mewakili jumlah total sampel pelatihan. Nilai defaultnya adalah ________26______3
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
4 adalah angka yang menentukan ukuran set pengujian. Ini sangat mirip dengan
sklearn.model_selection.train_test_split(*arrays, **options) -> list
8. Anda harus memberikan
sklearn.model_selection.train_test_split(*arrays, **options) -> list
_8 atau
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
4. Jika tidak ada yang diberikan, maka bagian default dari kumpulan data yang akan digunakan untuk pengujian adalah
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
8, atau 25 persen
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
9 adalah objek yang mengontrol pengacakan selama pemisahan. Itu bisa berupa
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
_2 atau contoh dari. Nilai defaultnya adalah ________26______3
>>> x_train, x_test, y_train, y_test = train_test_split(x, y)
>>> x_train
array([[15, 16],
       [21, 22],
       [11, 12],
       [17, 18],
       [13, 14],
       [ 9, 10],
       [ 1,  2],
       [ 3,  4],
       [19, 20]])
>>> x_test
array([[ 5,  6],
       [ 7,  8],
       [23, 24]])
>>> y_train
array([1, 1, 0, 1, 0, 1, 0, 1, 0])
>>> y_test
array([1, 0, 0])
3 adalah objek Boolean (
>>> x_train, x_test, y_train, y_test = train_test_split(x, y)
>>> x_train
array([[15, 16],
       [21, 22],
       [11, 12],
       [17, 18],
       [13, 14],
       [ 9, 10],
       [ 1,  2],
       [ 3,  4],
       [19, 20]])
>>> x_test
array([[ 5,  6],
       [ 7,  8],
       [23, 24]])
>>> y_train
array([1, 1, 0, 1, 0, 1, 0, 1, 0])
>>> y_test
array([1, 0, 0])
4 secara default) yang menentukan apakah akan mengacak dataset sebelum menerapkan pemisahan
>>> x_train, x_test, y_train, y_test = train_test_split(x, y)
>>> x_train
array([[15, 16],
       [21, 22],
       [11, 12],
       [17, 18],
       [13, 14],
       [ 9, 10],
       [ 1,  2],
       [ 3,  4],
       [19, 20]])
>>> x_test
array([[ 5,  6],
       [ 7,  8],
       [23, 24]])
>>> y_train
array([1, 1, 0, 1, 0, 1, 0, 1, 0])
>>> y_test
array([1, 0, 0])
5 adalah objek seperti array yang, jika bukan
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
3, menentukan cara menggunakan pemisahan bertingkat
Sekarang saatnya mencoba pemisahan data. Anda akan mulai dengan membuat kumpulan data sederhana untuk digunakan. Dataset akan berisi input dalam array dua dimensi
sklearn.model_selection.train_test_split(*arrays, **options) -> list
5 dan output dalam array satu dimensi
sklearn.model_selection.train_test_split(*arrays, **options) -> list
6
>>>
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
_
Untuk mendapatkan data Anda, Anda menggunakan
>>> x_train, x_test, y_train, y_test = train_test_split(x, y)
>>> x_train
array([[15, 16],
       [21, 22],
       [11, 12],
       [17, 18],
       [13, 14],
       [ 9, 10],
       [ 1,  2],
       [ 3,  4],
       [19, 20]])
>>> x_test
array([[ 5,  6],
       [ 7,  8],
       [23, 24]])
>>> y_train
array([1, 1, 0, 1, 0, 1, 0, 1, 0])
>>> y_test
array([1, 0, 0])
_9, yang sangat nyaman untuk menghasilkan array berdasarkan rentang numerik. Anda juga menggunakan
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
_0 untuk memodifikasi bentuk array yang dikembalikan oleh
>>> x_train, x_test, y_train, y_test = train_test_split(x, y)
>>> x_train
array([[15, 16],
       [21, 22],
       [11, 12],
       [17, 18],
       [13, 14],
       [ 9, 10],
       [ 1,  2],
       [ 3,  4],
       [19, 20]])
>>> x_test
array([[ 5,  6],
       [ 7,  8],
       [23, 24]])
>>> y_train
array([1, 1, 0, 1, 0, 1, 0, 1, 0])
>>> y_test
array([1, 0, 0])
9 dan mendapatkan struktur data dua dimensi
Anda dapat membagi set data input dan output dengan satu panggilan fungsi
>>>_______ 38 ________
>>> x_train, x_test, y_train, y_test = train_test_split(x, y)
>>> x_train
array([[15, 16],
       [21, 22],
       [11, 12],
       [17, 18],
       [13, 14],
       [ 9, 10],
       [ 1,  2],
       [ 3,  4],
       [19, 20]])
>>> x_test
array([[ 5,  6],
       [ 7,  8],
       [23, 24]])
>>> y_train
array([1, 1, 0, 1, 0, 1, 0, 1, 0])
>>> y_test
array([1, 0, 0])
Diberikan dua urutan, seperti
sklearn.model_selection.train_test_split(*arrays, **options) -> list
_5 dan
sklearn.model_selection.train_test_split(*arrays, **options) -> list
6 di sini,
$ conda install -c anaconda scikit-learn=0.23
7 melakukan pemisahan dan mengembalikan empat urutan (dalam hal ini array NumPy) dalam urutan ini
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
_5. Bagian pelatihan dari urutan pertama (
sklearn.model_selection.train_test_split(*arrays, **options) -> list
5)
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
_7. Bagian uji dari urutan pertama (
sklearn.model_selection.train_test_split(*arrays, **options) -> list
5)
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
_9. Bagian pelatihan dari urutan kedua (
sklearn.model_selection.train_test_split(*arrays, **options) -> list
6)
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, random_state=4, stratify=y
.. )
>>> x_train
array([[21, 22],
       [ 1,  2],
       [15, 16],
       [13, 14],
       [17, 18],
       [19, 20],
       [23, 24],
       [ 3,  4]])
>>> x_test
array([[11, 12],
       [ 7,  8],
       [ 5,  6],
       [ 9, 10]])
>>> y_train
array([1, 0, 1, 0, 1, 0, 0, 1])
>>> y_test
array([0, 0, 1, 1])
1. Bagian tes dari urutan kedua (
sklearn.model_selection.train_test_split(*arrays, **options) -> list
6)
Anda mungkin mendapat hasil yang berbeda dari apa yang Anda lihat di sini. Ini karena pemisahan dataset dilakukan secara acak secara default. Hasilnya berbeda setiap kali Anda menjalankan fungsi. Namun, ini seringkali bukan yang Anda inginkan
Terkadang, agar pengujian Anda dapat direproduksi, Anda memerlukan pemisahan acak dengan keluaran yang sama untuk setiap pemanggilan fungsi. Anda dapat melakukannya dengan parameter ________26______9. Nilai
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
9 tidak penting—dapat berupa bilangan bulat bukan negatif. Anda bisa menggunakan instance
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, random_state=4, stratify=y
.. )
>>> x_train
array([[21, 22],
       [ 1,  2],
       [15, 16],
       [13, 14],
       [17, 18],
       [19, 20],
       [23, 24],
       [ 3,  4]])
>>> x_test
array([[11, 12],
       [ 7,  8],
       [ 5,  6],
       [ 9, 10]])
>>> y_train
array([1, 0, 1, 0, 1, 0, 0, 1])
>>> y_test
array([0, 0, 1, 1])
5 sebagai gantinya, tetapi itu adalah pendekatan yang lebih kompleks
Pada contoh sebelumnya, Anda menggunakan dataset dengan dua belas observasi (baris) dan mendapatkan sampel pelatihan dengan sembilan baris dan sampel uji dengan tiga baris. Itu karena Anda tidak menentukan ukuran set pelatihan dan pengujian yang diinginkan. Secara default, 25 persen sampel ditetapkan ke set pengujian. Rasio ini umumnya baik untuk banyak aplikasi, tetapi tidak selalu yang Anda butuhkan
Biasanya, Anda ingin menentukan ukuran set pengujian (atau pelatihan) secara eksplisit, dan terkadang Anda bahkan ingin bereksperimen dengan nilai yang berbeda. Anda dapat melakukannya dengan parameter
sklearn.model_selection.train_test_split(*arrays, **options) -> list
_8 atau
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
4
Ubah kode sehingga Anda dapat memilih ukuran set pengujian dan mendapatkan hasil yang dapat direproduksi
>>>_______ 46 ________
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
Dengan perubahan ini, Anda mendapatkan hasil yang berbeda dari sebelumnya. Sebelumnya, Anda memiliki set pelatihan dengan sembilan item dan set tes dengan tiga item. Sekarang, berkat argumen
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, random_state=4, stratify=y
.. )
>>> x_train
array([[21, 22],
       [ 1,  2],
       [15, 16],
       [13, 14],
       [17, 18],
       [19, 20],
       [23, 24],
       [ 3,  4]])
>>> x_test
array([[11, 12],
       [ 7,  8],
       [ 5,  6],
       [ 9, 10]])
>>> y_train
array([1, 0, 1, 0, 1, 0, 0, 1])
>>> y_test
array([0, 0, 1, 1])
8, set pelatihan memiliki delapan item dan set tes memiliki empat item. Anda akan mendapatkan hasil yang sama dengan
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, random_state=4, stratify=y
.. )
>>> x_train
array([[21, 22],
       [ 1,  2],
       [15, 16],
       [13, 14],
       [17, 18],
       [19, 20],
       [23, 24],
       [ 3,  4]])
>>> x_test
array([[11, 12],
       [ 7,  8],
       [ 5,  6],
       [ 9, 10]])
>>> y_train
array([1, 0, 1, 0, 1, 0, 0, 1])
>>> y_test
array([0, 0, 1, 1])
_9 karena 33 persen dari dua belas kira-kira empat
Ada satu lagi perbedaan yang sangat penting antara dua contoh terakhir. Anda sekarang mendapatkan hasil yang sama setiap kali Anda menjalankan fungsi. Ini karena Anda telah memperbaiki pembuat nomor acak dengan
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, shuffle=False
.. )
>>> x_train
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16]])
>>> x_test
array([[17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y_train
array([0, 1, 1, 0, 1, 0, 0, 1])
>>> y_test
array([1, 0, 1, 0])
0
Gambar di bawah menunjukkan apa yang terjadi saat Anda menelepon
$ conda install -c anaconda scikit-learn=0.23
7
Sampel dataset diacak secara acak dan kemudian dibagi menjadi set pelatihan dan pengujian sesuai dengan ukuran yang Anda tentukan
Anda dapat melihat bahwa
sklearn.model_selection.train_test_split(*arrays, **options) -> list
_6 memiliki enam angka nol dan enam angka satu. Namun, set tes memiliki tiga nol dari empat item. Jika Anda ingin (kira-kira) menjaga proporsi
sklearn.model_selection.train_test_split(*arrays, **options) -> list
6 nilai melalui set pelatihan dan tes, maka lulus
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, shuffle=False
.. )
>>> x_train
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16]])
>>> x_test
array([[17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y_train
array([0, 1, 1, 0, 1, 0, 0, 1])
>>> y_test
array([1, 0, 1, 0])
4. Ini akan memungkinkan pemisahan stratifikasi
>>>_______ 58 ________
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, random_state=4, stratify=y
.. )
>>> x_train
array([[21, 22],
       [ 1,  2],
       [15, 16],
       [13, 14],
       [17, 18],
       [19, 20],
       [23, 24],
       [ 3,  4]])
>>> x_test
array([[11, 12],
       [ 7,  8],
       [ 5,  6],
       [ 9, 10]])
>>> y_train
array([1, 0, 1, 0, 1, 0, 0, 1])
>>> y_test
array([0, 0, 1, 1])
Sekarang
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
_9 dan
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, random_state=4, stratify=y
.. )
>>> x_train
array([[21, 22],
       [ 1,  2],
       [15, 16],
       [13, 14],
       [17, 18],
       [19, 20],
       [23, 24],
       [ 3,  4]])
>>> x_test
array([[11, 12],
       [ 7,  8],
       [ 5,  6],
       [ 9, 10]])
>>> y_train
array([1, 0, 1, 0, 1, 0, 0, 1])
>>> y_test
array([0, 0, 1, 1])
1 memiliki rasio nol dan satu yang sama dengan larik
sklearn.model_selection.train_test_split(*arrays, **options) -> list
6 asli
Pemisahan bertingkat diinginkan dalam beberapa kasus, seperti saat Anda mengklasifikasikan kumpulan data yang tidak seimbang, kumpulan data dengan perbedaan yang signifikan dalam jumlah sampel yang termasuk dalam kelas yang berbeda
Terakhir, Anda dapat mematikan pengocokan data dan pembagian acak dengan
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, shuffle=False
.. )
>>> x_train
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16]])
>>> x_test
array([[17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y_train
array([0, 1, 1, 0, 1, 0, 0, 1])
>>> y_test
array([1, 0, 1, 0])
8
>>>
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, shuffle=False
.. )
>>> x_train
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16]])
>>> x_test
array([[17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y_train
array([0, 1, 1, 0, 1, 0, 0, 1])
>>> y_test
array([1, 0, 1, 0])
_
Sekarang Anda memiliki pemisahan di mana dua pertiga sampel pertama dalam array
sklearn.model_selection.train_test_split(*arrays, **options) -> list
5 asli dan
sklearn.model_selection.train_test_split(*arrays, **options) -> list
6 ditugaskan ke set pelatihan dan sepertiga terakhir ke set pengujian. Tidak ada pengacakan. Tidak ada keacakan
Hilangkan iklan
Pembelajaran Mesin yang Diawasi Dengan $ conda install -c anaconda scikit-learn=0.23 7
Sekarang saatnya untuk melihat
$ conda install -c anaconda scikit-learn=0.23
_7 beraksi saat memecahkan masalah pembelajaran yang diawasi. Anda akan mulai dengan masalah regresi kecil yang dapat diselesaikan dengan regresi linier sebelum melihat masalah yang lebih besar. Anda juga akan melihat bahwa Anda juga dapat menggunakan
$ conda install -c anaconda scikit-learn=0.23
7 untuk klasifikasi
Contoh Minimalis Regresi Linear
Dalam contoh ini, Anda akan menerapkan apa yang telah Anda pelajari sejauh ini untuk menyelesaikan masalah regresi kecil. Anda akan mempelajari cara membuat set data, membaginya menjadi subset pelatihan dan pengujian, dan menggunakannya untuk regresi linier
Seperti biasa, Anda akan mulai dengan mengimpor paket, fungsi, atau kelas yang diperlukan. Anda membutuhkan NumPy,
>>> import numpy as np
>>> from sklearn.linear_model import LinearRegression
>>> from sklearn.model_selection import train_test_split
4, dan
$ conda install -c anaconda scikit-learn=0.23
7
>>>
>>> import numpy as np
>>> from sklearn.linear_model import LinearRegression
>>> from sklearn.model_selection import train_test_split
_
Sekarang setelah Anda mengimpor semua yang Anda butuhkan, Anda dapat membuat dua array kecil,
sklearn.model_selection.train_test_split(*arrays, **options) -> list
5 dan
sklearn.model_selection.train_test_split(*arrays, **options) -> list
6, untuk mewakili pengamatan dan kemudian membaginya menjadi set pelatihan dan pengujian seperti yang Anda lakukan sebelumnya
>>>
$ conda install -c anaconda scikit-learn=0.23
0
Kumpulan data Anda memiliki dua puluh pengamatan, atau
sklearn.model_selection.train_test_split(*arrays, **options) -> list
5-
sklearn.model_selection.train_test_split(*arrays, **options) -> list
6 pasang. Anda menentukan argumen
$ conda install -c anaconda scikit-learn=0.23
00, sehingga dataset dibagi menjadi set pelatihan dengan dua belas pengamatan dan satu set tes dengan delapan pengamatan
Sekarang Anda dapat menggunakan set pelatihan agar sesuai dengan model
>>>
$ conda install -c anaconda scikit-learn=0.23
1
>>> import numpy as np
>>> from sklearn.linear_model import LinearRegression
>>> from sklearn.model_selection import train_test_split
_4 membuat objek yang mewakili model, saat melatih, atau menyesuaikan, model dan mengembalikannya. Dengan regresi linier, menyesuaikan model berarti menentukan nilai intersep (
$ conda install -c anaconda scikit-learn=0.23
03) dan kemiringan (
$ conda install -c anaconda scikit-learn=0.23
04) terbaik dari garis regresi
Meskipun Anda dapat menggunakan
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
5 dan
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
9 untuk memeriksa kesesuaiannya, ini bukan praktik terbaik. Estimasi yang tidak bias dari performa prediktif model Anda didasarkan pada data pengujian
>>>
$ conda install -c anaconda scikit-learn=0.23
2
mengembalikan koefisien determinasi, atau R², untuk data yang diteruskan. Maksimumnya adalah
$ conda install -c anaconda scikit-learn=0.23
_08. Semakin tinggi nilai R², semakin cocok. Dalam hal ini, data pelatihan menghasilkan koefisien yang sedikit lebih tinggi. Namun, R² yang dihitung dengan data pengujian merupakan ukuran yang tidak bias dari performa prediksi model Anda
Ini adalah tampilannya pada grafik
Titik hijau mewakili
sklearn.model_selection.train_test_split(*arrays, **options) -> list
_5-
sklearn.model_selection.train_test_split(*arrays, **options) -> list
6 pasangan yang digunakan untuk pelatihan. Garis hitam, yang disebut garis estimasi regresi, ditentukan oleh hasil model fitting. intersep dan kemiringan. Jadi, ini mencerminkan posisi titik-titik hijau saja
Titik putih mewakili set tes. Anda menggunakannya untuk memperkirakan performa model (garis regresi) dengan data yang tidak digunakan untuk pelatihan
Contoh Regresi
Sekarang Anda siap membagi kumpulan data yang lebih besar untuk menyelesaikan masalah regresi. Anda akan menggunakan yang terkenal, yang termasuk dalam
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
2. Dataset ini memiliki 506 sampel, 13 variabel input, dan nilai rumah sebagai outputnya. Anda dapat mengambilnya dengan
Pertama, impor
$ conda install -c anaconda scikit-learn=0.23
_7 dan
$ conda install -c anaconda scikit-learn=0.23
12
>>>
$ conda install -c anaconda scikit-learn=0.23
3
Sekarang setelah kedua fungsi diimpor, Anda bisa mendapatkan data untuk digunakan
>>>
$ conda install -c anaconda scikit-learn=0.23
4
Seperti yang Anda lihat,
$ conda install -c anaconda scikit-learn=0.23
12 dengan argumen
$ conda install -c anaconda scikit-learn=0.23
16 mengembalikan tuple dengan dua array NumPy
Array dua dimensi dengan input
Array satu dimensi dengan output
Langkah selanjutnya adalah membagi data dengan cara yang sama seperti sebelumnya
>>>
$ conda install -c anaconda scikit-learn=0.23
5
Sekarang Anda memiliki set pelatihan dan tes. Data pelatihan terdapat di
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
_5 dan
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
9, sedangkan data untuk pengujian ada di
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
7 dan
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, random_state=4, stratify=y
.. )
>>> x_train
array([[21, 22],
       [ 1,  2],
       [15, 16],
       [13, 14],
       [17, 18],
       [19, 20],
       [23, 24],
       [ 3,  4]])
>>> x_test
array([[11, 12],
       [ 7,  8],
       [ 5,  6],
       [ 9, 10]])
>>> y_train
array([1, 0, 1, 0, 1, 0, 0, 1])
>>> y_test
array([0, 0, 1, 1])
1
Saat Anda bekerja dengan kumpulan data yang lebih besar, biasanya lebih nyaman untuk lulus pelatihan atau ukuran pengujian sebagai rasio.
$ conda install -c anaconda scikit-learn=0.23
_21 berarti sekitar 40 persen sampel akan ditugaskan ke data uji, dan 60 persen sisanya akan ditugaskan ke data pelatihan
Terakhir, Anda dapat menggunakan set pelatihan (
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
5 dan
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
9) agar sesuai dengan model dan set pengujian (
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=4, random_state=4
.. )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])
7 dan
>>> x_train, x_test, y_train, y_test = train_test_split(
..     x, y, test_size=0.33, random_state=4, stratify=y
.. )
>>> x_train
array([[21, 22],
       [ 1,  2],
       [15, 16],
       [13, 14],
       [17, 18],
       [19, 20],
       [23, 24],
       [ 3,  4]])
>>> x_test
array([[11, 12],
       [ 7,  8],
       [ 5,  6],
       [ 9, 10]])
>>> y_train
array([1, 0, 1, 0, 1, 0, 0, 1])
>>> y_test
array([0, 0, 1, 1])
1) untuk evaluasi model yang tidak bias. Dalam contoh ini, Anda akan menerapkan tiga algoritme regresi terkenal untuk membuat model yang sesuai dengan data Anda
Regresi linier dengan
$ conda install -c anaconda scikit-learn=0.23
26
Peningkatan gradien dengan
$ conda install -c anaconda scikit-learn=0.23
_27
Hutan acak dengan
$ conda install -c anaconda scikit-learn=0.23
_28
Prosesnya hampir sama dengan contoh sebelumnya
Impor kelas yang Anda butuhkan
Buat instance model menggunakan kelas-kelas ini
Sesuaikan instance model dengan
$ conda install -c anaconda scikit-learn=0.23
_02 menggunakan set pelatihan
Evaluasi model dengan
$ conda install -c anaconda scikit-learn=0.23
_07 menggunakan set pengujian
Inilah kode yang mengikuti langkah-langkah yang dijelaskan di atas untuk ketiga algoritme regresi
>>>
$ conda install -c anaconda scikit-learn=0.23
6
Anda telah menggunakan kumpulan data pelatihan dan pengujian agar sesuai dengan tiga model dan mengevaluasi kinerjanya. Ukuran akurasi yang diperoleh dengan
$ conda install -c anaconda scikit-learn=0.23
07 adalah koefisien determinasi. Itu dapat dihitung dengan set pelatihan atau tes. Namun, seperti yang telah Anda pelajari, skor yang diperoleh dengan rangkaian tes mewakili estimasi kinerja yang tidak bias
Seperti yang disebutkan dalam dokumentasi, Anda dapat memberikan argumen opsional untuk
$ conda install -c anaconda scikit-learn=0.23
26,
$ conda install -c anaconda scikit-learn=0.23
27, dan
$ conda install -c anaconda scikit-learn=0.23
28.
$ conda install -c anaconda scikit-learn=0.23
27 dan
$ conda install -c anaconda scikit-learn=0.23
28 menggunakan parameter
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
9 untuk alasan yang sama dengan
$ conda install -c anaconda scikit-learn=0.23
7. untuk menangani keacakan dalam algoritme dan memastikan reproduktifitas
Untuk beberapa metode, Anda mungkin juga memerlukan penskalaan fitur. Dalam kasus seperti itu, Anda harus menyesuaikan penskala dengan data pelatihan dan menggunakannya untuk mengubah data pengujian
Hilangkan iklan
Contoh Klasifikasi
Anda dapat menggunakan
$ conda install -c anaconda scikit-learn=0.23
_7 untuk memecahkan masalah klasifikasi dengan cara yang sama seperti yang Anda lakukan untuk analisis regresi. Dalam pembelajaran mesin, masalah klasifikasi melibatkan pelatihan model untuk menerapkan label, atau mengklasifikasikan, nilai input dan mengurutkan kumpulan data Anda ke dalam kategori
Dalam tutorial Regresi Logistik dengan Python, Anda akan menemukan contoh tugas. Contoh tersebut memberikan demonstrasi lain tentang pemisahan data menjadi set pelatihan dan pengujian untuk menghindari bias dalam proses evaluasi
Fungsi Validasi Lainnya
Paket ini menawarkan banyak fungsi terkait pemilihan dan validasi model, termasuk yang berikut ini
Validasi silang
Kurva belajar
Penyetelan hiperparameter
Validasi silang adalah seperangkat teknik yang menggabungkan ukuran kinerja prediksi untuk mendapatkan estimasi model yang lebih akurat
Salah satu metode validasi silang yang banyak digunakan adalah. Di dalamnya, Anda membagi kumpulan data menjadi k (biasanya lima atau sepuluh) himpunan bagian, atau lipatan, dengan ukuran yang sama, lalu melakukan prosedur pelatihan dan pengujian sebanyak k kali. Setiap kali, Anda menggunakan lipatan yang berbeda sebagai set pengujian dan semua lipatan yang tersisa sebagai set pelatihan. Ini memberikan k ukuran kinerja prediktif, dan Anda kemudian dapat menganalisis rata-rata dan standar deviasinya
Anda dapat menerapkan validasi silang dengan
$ conda install -c anaconda scikit-learn=0.23
41,
$ conda install -c anaconda scikit-learn=0.23
42,
$ conda install -c anaconda scikit-learn=0.23
43, dan beberapa kelas dan fungsi lain dari
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
0
Kurva pembelajaran, terkadang disebut kurva pelatihan, menunjukkan bagaimana skor prediksi set pelatihan dan validasi bergantung pada jumlah sampel pelatihan. Anda dapat menggunakan
$ conda install -c anaconda scikit-learn=0.23
_45 untuk mendapatkan dependensi ini, yang dapat membantu Anda menemukan ukuran optimal dari set pelatihan, memilih hyperparameter, membandingkan model, dan seterusnya
Penyesuaian hyperparameter, juga disebut pengoptimalan hyperparameter, adalah proses menentukan kumpulan hyperparameter terbaik untuk menentukan model pembelajaran mesin Anda.
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
_0 memberi Anda beberapa opsi untuk tujuan ini, termasuk
$ conda install -c anaconda scikit-learn=0.23
47,
$ conda install -c anaconda scikit-learn=0.23
48,
$ conda install -c anaconda scikit-learn=0.23
49, dan lainnya. Memisahkan data Anda juga penting untuk penyetelan hyperparameter
Kesimpulan
Anda sekarang tahu mengapa dan bagaimana menggunakan
$ conda install -c anaconda scikit-learn=0.23
7 dari
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
2. Anda telah mempelajari bahwa, untuk estimasi kinerja prediksi model pembelajaran mesin yang tidak bias, Anda harus menggunakan data yang belum digunakan untuk pemasangan model. Itulah mengapa Anda perlu membagi set data menjadi pelatihan, pengujian, dan dalam beberapa kasus, subset validasi
Dalam tutorial ini, Anda telah mempelajari caranya
Gunakan
$ conda install -c anaconda scikit-learn=0.23
_7 untuk mendapatkan set pelatihan dan tes
Kontrol ukuran himpunan bagian dengan parameter
sklearn.model_selection.train_test_split(*arrays, **options) -> list
8 dan
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
4
Tentukan keacakan pemisahan Anda dengan parameter
>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
9
Dapatkan pemisahan bertingkat dengan parameter
>>> x_train, x_test, y_train, y_test = train_test_split(x, y)
>>> x_train
array([[15, 16],
       [21, 22],
       [11, 12],
       [17, 18],
       [13, 14],
       [ 9, 10],
       [ 1,  2],
       [ 3,  4],
       [19, 20]])
>>> x_test
array([[ 5,  6],
       [ 7,  8],
       [23, 24]])
>>> y_train
array([1, 1, 0, 1, 0, 1, 0, 1, 0])
>>> y_test
array([1, 0, 0])
5
Gunakan
$ conda install -c anaconda scikit-learn=0.23
_7 sebagai bagian dari prosedur pembelajaran mesin yang diawasi
Anda juga telah melihat bahwa modul
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
_0 menawarkan beberapa alat lain untuk validasi model, termasuk validasi silang, kurva pembelajaran, dan penyetelan hyperparameter
Jika Anda memiliki pertanyaan atau komentar, silakan taruh di bagian komentar di bawah ini
Tandai sebagai Selesai
Tonton Sekarang Tutorial ini memiliki kursus video terkait yang dibuat oleh tim Real Python. Tonton bersama dengan tutorial tertulis untuk memperdalam pemahaman Anda. Memisahkan Set Data Dengan scikit-learn dan train_test_split()
🐍 Trik Python 💌
Dapatkan Trik Python singkat & manis yang dikirim ke kotak masuk Anda setiap beberapa hari. Tidak pernah ada spam. Berhenti berlangganan kapan saja. Dikuratori oleh tim Real Python

Kirimi Saya Trik Python »
Tentang Mirko Stojiljkovic
Mirko memiliki Ph. D. di Teknik Mesin dan bekerja sebagai profesor universitas. Ia adalah seorang Pythonista yang menerapkan metode hybrid optimization dan machine learning untuk mendukung pengambilan keputusan di sektor energi
» Lebih lanjut tentang Mirko
Setiap tutorial di Real Python dibuat oleh tim pengembang sehingga memenuhi standar kualitas tinggi kami. Anggota tim yang mengerjakan tutorial ini adalah
Aldren
Geir Arne
Joanna
Yakub
Kyle
Master Keterampilan Python Dunia Nyata Dengan Akses Tanpa Batas ke Python Nyata
Bergabunglah dengan kami dan dapatkan akses ke ribuan tutorial, kursus video langsung, dan komunitas pakar Pythonista
Tingkatkan Keterampilan Python Anda »
Guru Keterampilan Python Dunia Nyata
Dengan Akses Tak Terbatas ke Real Python
Bergabunglah dengan kami dan dapatkan akses ke ribuan tutorial, kursus video langsung, dan komunitas ahli Pythonista
Tingkatkan Keterampilan Python Anda »
Bagaimana menurutmu?
Nilai artikel ini
Tweet Bagikan Bagikan Email
Apa takeaway # 1 Anda atau hal favorit yang Anda pelajari?
Kiat Berkomentar. Komentar yang paling berguna adalah yang ditulis dengan tujuan belajar dari atau membantu siswa lain. dan dapatkan jawaban atas pertanyaan umum di portal dukungan kami

Bagaimana Anda membagi daftar dengan Python?

Metode Python String split() . Anda dapat menentukan pemisah, pemisah default adalah spasi putih apa pun. Catatan. Ketika maxsplit ditentukan, daftar akan berisi jumlah elemen yang ditentukan ditambah satu. The split() method splits a string into a list. You can specify the separator, default separator is any whitespace. Note: When maxsplit is specified, the list will contain the specified number of elements plus one.

Bagaimana Anda membagi daftar menjadi beberapa bagian dengan Python?

Hal ini dapat dilakukan dengan menggunakan langkah-langkah berikut. .

Dapatkan panjang daftar menggunakan fungsi len()

Jika panjang bagian tidak diberikan, bagi panjang daftar dengan 2 menggunakan operator lantai untuk mendapatkan indeks tengah daftar

Iris daftar menjadi dua bagian menggunakan [. middle_index] dan [middle_index. ]

Apa itu daftar 80 20 split dengan Python?

Bagaimana cara membagi kumpulan data pelatihan dan pengujian dengan Python? . 20. Yaitu 80% dari set data masuk ke set pelatihan dan 20% dari set data masuk ke set pengujian . Sebelum membagi data, pastikan dataset cukup besar.

Bagaimana Anda membagi daftar menjadi melatih dan menguji?

Metode train_test_split() digunakan untuk membagi data kita menjadi set latihan dan pengujian . Pertama, kita perlu membagi data menjadi fitur (X) dan label (y). Kerangka data dibagi menjadi X_train,X_test , y_train dan y_test. Set X_train dan y_train digunakan untuk melatih dan menyesuaikan model.