msb-public
/
ML-For-Beginners
mirror of https://github.com/microsoft/ML-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity

Merge pull request #103 from iBlueDust/main

Browse Source 
Add Indonesian translation for 2-Regresion
pull/129/head
Jen Looper 3 years ago committed by GitHub
parent 1c70282cd8 dc46af12b9
commit 80190f3835
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 1079 additions and 0 deletions
Show Stats Download Patch File Download Diff File

208
2-Regression/1-Tools/translations/README.id.md
Unescape View File

@ -0,0 +1,208 @@
# Memulai dengan Python dan Scikit-learn untuk model regresi
![Ringkisan regresi dalam sebuah catatan sketsa](../../sketchnotes/ml-regression.png)
> Catatan sketsa oleh [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [Kuis Pra-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/9/)
## Pembukaan
Dalam keempat pelajaran ini, kamu akan belajar bagaimana membangun model regresi. Kita akan berdiskusi apa fungsi model tersebut dalam sejenak. Tetapi sebelum kamu melakukan apapun, pastikan bahwa kamu sudah mempunyai alat-alat yang diperlukan untuk memulai!
Dalam pelajaran ini, kamu akan belajar bagaimana untuk:
- Konfigurasi komputermu untuk tugas pembelajaran.
- Bekerja dengan Jupyter notebooks.
- Menggunakan Scikit-learn, termasuk instalasi.
- Menjelajahi regresi linear dengan latihan *hands-on*.
## Instalasi dan konfigurasi
[![Menggunakan Python dalam Visual Studio Code](https://img.youtube.com/vi/7EXd4_ttIuw/0.jpg)](https://youtu.be/7EXd4_ttIuw "Menggunakan Python dalam Visual Studio Code")
> 🎥 Klik foto di atas untuk sebuah video: menggunakan Python dalam VS Code
1. **Pasang Python**. Pastikan bahwa [Python](https://www.python.org/downloads/) telah dipasang di komputermu. Kamu akan menggunakan Python untuk banyak tugas *data science* dan *machine learning*. Python sudah dipasang di kebanyakan sistem komputer. Adapula *[Python Coding Packs](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-15963-cxa)* yang berguna untuk membantu proses pemasangan untuk beberapa pengguna.
Beberapa penggunaan Python memerlukan satu versi perangkat lunak tersebut, sedangkan beberapa penggunaan lainnya mungkin memerlukan versi Python yang beda lagi. Oleh sebab itulah akan sangat berguna untuk bekerja dalam sebuah *[virtual environment](https://docs.python.org/3/library/venv.html)* (lingkungan virtual).
2. **Pasang Visual Studio Code**. Pastikan kamu sudah memasangkan Visual Studio Code di komputermu. Ikuti instruksi-instruksi ini untuk [memasangkan Visual Studio Code](https://code.visualstudio.com/) untuk instalasi dasar. Kamu akan menggunakan Python dalam Visual Studio Code dalam kursus ini, jadi kamu mungkin akan ingin mencari tahu cara [mengkonfigurasi Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-15963-cxa) untuk menggunakan Python.
> Nyamankan diri dengan Python dengan mengerjakan [koleksi modul pembelajaran ini](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-15963-cxa)
3. **Pasang Scikit-learn**, dengan mengikuti [instruksi di sini](https://scikit-learn.org/stable/install.html). Karena harus dipastikan bahwa kamu sedang menggunakan Python 3, kami anjurkan kamu menggunakan sebuah *virtual environment*. Ingatlah juga bahwa jika kamu ingin memasangkan ini di sebuah M1 Mac, ada instruksi khusus dalam laman yang ditautkan di atas.
4. **Pasang Jupyter Notebook**. Kamu akan harus [memasang paket Jupyter](https://pypi.org/project/jupyter/).
## Lingkungan penulisan ML-mu
Kamu akan menggunakan ***notebooks*** untuk bekerja dengan kode Python-mu dan membuat model *machine learning*-mu. Jenis file ini adalah alat yang sering digunakan *data scientists* dan dapat diidentifikasikan dengan akhiran/ekstensi `.ipynb`.
*Notebook* adalah sebuah lingkungan interaktif yang memungkinkan seorang *developer* untuk menulis kode, catatan, dan dokumentasi mengenai kode tersebut sehingga menjadi sangat berguna untuk proyek eksperimental ataupun riset.
### Latihan - bekerja dengan sebuah *notebook*
Dalam folder ini, kamu akan menemukan file _notebook.ipynb_.
1. Buka _notebook.ipynb_ dalam Visual Studio Code.
Sebuah server Jupyter akan mulai dengan Python 3+. Kamu akan menemukan bagian-bagian *notebook* yang dapat di-`run` (dijalankan). Bagian-bagian tersebut adalah carikan-carikan kode. Kamu bisa menjalankan secarik kode dengan mengklik tombol ▶.
2. Pilih ikon `md` dan tambahlah sedikit *markdown*: **# Selamat datang di *notebook* saya!**
Lalu, tambahlah sedikit kode Python.
3. Ketik **print('hello notebook')** dalam blok kode.
4. Klik ▶ untuk menjalankan kode.
Hasilnya harusnya ini:
```output
hello notebook
```
![Sebuah *notebook* yang dibuka di VS Code](images/notebook.png)
Kamu bisa menyelipkan catatan-catatan antara kodemu untuk mendokumentasi *notebook*-nya.
✅ Pikirkanlah sejenak bagaimana lingkungan seorang *web developer* berbeda dengan lingkungan seorang *data scientist*.
## Berjalan dengan Scikit-learn
Sekarang, Python sudah siap dalam lingkungan lokalmu, dan kamu sudah nyaman bekerja dengan *Jupyter notebook*. Marilah membiasakan diri dengan Scikit-learn (dilafalkan `saikit lern`; huruf `e` dalam `lern` seperti `e` dalam kata `Perancis`). Scikit-learn menyediakan sebuah [API ekstensif](https://scikit-learn.org/stable/modules/classes.html#api-ref) untuk membantu kamu mengerjakan tugas ML.
Berdasarkan [situs mereka](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn" adalah sebuah *open-source library* untuk *machine-learning* yang dapat digunakan untuk *supervised* dan *unsupervised learning*. Scikit-learn juga menyediakan beragam alat untuk *model-fitting*, *data preprocessing*, seleksi dan evaluasi model, dll.
Dalam kursus ini, kamu akan menggunakan Scikit-learn dan beberapa alat lainnya untuk membangun model *machine-learning* untuk mengerjakan apa yang kami panggil tugas '*machine-learning* tradisional'. Kami sengaja menghindari *neural networks* dan *deep learning* sebab mereka akan dibahas dengan lebih lengkap dalam kurikulum 'AI untuk pemula' nanti.
Scikit-learn memudahkan pembangunan dan evaluasi model-model. Dia terutama fokus pada menggunakan data numerik dan mempunyai beberapa *dataset* yang siap sedia untuk digunakan sebagai alat belajar. Dia juga mempunyai model yang sudah dibangun untuk murid-murid untuk langsung coba. Mari menjelajahi proses memuat data yang sudah disiapkan dan menggunakan model ML pengestimasian pertama menggunakan Scikit-learn dengan data sederhana.
## Latihan - Scikit-learn *notebook* pertamamu
> Tutorial ini terinspirasi [contoh regresi linear ini](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) di situs Scikit-learn.
Dalam file _notebook.ipynb_ dari pelajaran ini, kosongkan semua sel dengan mengklik tombol berlambang 'tempat sampah'.
Dalam bagian ini, kamu akan bekerja dengan sebuah *dataset* kecil tentang diabetes yang datang bersama dengan Scikit-learn yang dimaksud sebagai bahan ajaran. Bayangkan bahwa kamu ingin mencoba sebuah cara pengobatan untuk pasien diabetes. Model *machine learning* mungkin dapat membantu kamu menentukan pasien mana merespon lebih baik pada pengobatan tersebut berdasarkan kombinasi-kombinasi variabel. Bahkan sebuah model regresi yang sederhana, saat divisualisasikan, dapat menunjukkanmu informasi tentang variabel-variabel yang dapat membantu kamu mengorganisasikan uji-uji klinis teoritismu.
✅ Ada banyak macam metode regresi, dan yang mana yang kamu pilih tergantung pada jawaban yang kamu sedang cari. Kalau kamu ingin memprediksi tinggi badan seseorang dari usianya, kamu bisa menggunakan regresi linear, karena kamu mencari sebuah **nilai numerik**. Kalau kamu tertarik pada apa sebuah jenis kuliner sebaiknya dianggap sebagai vegan atau tidak, kamu sedang mencari sebuah **kategorisasi/klasifikasi**; kamu bisa menggunakan regresi logistik. Kamu akan belajar lebih banyak tentang regresi logistik nanti. Pikirkan dahulu beberapa pertanyaan yang kamu bisa tanyakan dari data yang ada dan metode yang mana akan paling cocok.
Mari mulai mengerjakan tugas ini.
### Impor *library*
Untuk tugas ini, kita akan mengimpor beberapa *library*:
- **matplotlib**. Sebuah [alat untuk membuat grafik](https://matplotlib.org/) yang kita akan gunakan untuk membuat sebuah grafik garis.
- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) adalah sebuah *library* berguna untuk menangani data numerik di Python.
- **sklearn**. Ini adalah *library* Scikit-learn.
Imporlah *library-library* yang akan membantu dengan tugasmu.
1. Tambahlah impor dengan mengetik kode berikut:
```python
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, model_selection
```
Di atas, kamu sedang mengimpor `matplottlib`, `numpy`. Selain itu, kamu juga sedang mengimpor `datasets`, `linear_model` dan `model_selection` dari `sklearn`. `model_selection` digunakan untuk memisahkan data menjadi set latihan dan set ujian.
### *Dataset* diabetes
[*Dataset* diabetes](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) mencakupi 442 sampel data mengenai diabetes dengan 10 variabel utama, termasuk:
- age: usia dalam tahun
- bmi: *body mass index*
- bp: tekanan darah rata-rata
- s1 tc: Sel T (sejenis cel darah putih)
✅ *Dataset* ini juga mempunyai konsep 'jenis kelamin' sebagai sebuah variabel utama yang penting dalam riset diabetes. Banyak *dataset* medis mempunyai klasifikasi binari ini. Pikirkan sejenak bagaimana kategorisasi seperti yang ini dapat mengecualikan bagian tertentu dari sebuah populasi dari pengobatan.
Sekarang, muatkan data X dan y.
> 🎓 Ingatlah, ini adalah *supervised learning*, jadi kita perlu sebuah target (dinamakan 'y').
Dalam sebuah sel kode yang baru, muatkan *dataset* diabetes dengan memanggil `load_diabetes()`. Input `return_X_y=True` menunjukkan bahwa `X` adalah sebuah matriks data dan `y` adalah target regresi.
1. Tambah beberapa instruksi *print* untuk menunjukkan ukuran data matriks dan elemen pertama matriks tersebut.
```python
X, y = datasets.load_diabetes(return_X_y=True)
print(X.shape)
print(X[0])
```
Respon yang didapati adalah sebuah *tuple*. Kamu sedang menetapkan kedua nilai pertama dalam *tuple* itu ke dalam `X` dan `y` secara berturut. Pelajari lebih banyak [tentant *tuples*](https://wikipedia.org/wiki/Tuple).
Kamu bisa melihat bahwa data ini berupa 422 nilai yang disusun menjadi beberapa `array` dengan 10 elemen:
```text
(442, 10)
[ 0.03807591 0.05068012 0.06169621 0.02187235 -0.0442235 -0.03482076
-0.04340085 -0.00259226 0.01990842 -0.01764613]
```
✅ Pikirkan sejenak tentang hubungan antara data dan target regresi. Apa kamu bisa menemukan [targetnya](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) untuk *database* diabetes dalam dokumentasinya? Mengetahui targetnya, apa yang *dataset* ini sedang mendemonstrasikan?
2. Lalu, pilih sebuah porsi dataset ini untuk digambarkan dengan menyusuninya menjadi sebuah `array` baru dengan fungsi `newaxis` dari `numpy`. Kita akan menggunakan regresi linear untuk menggambar sebuah garis antara nilai-nilai dalam data ini sesuai dengan pola yang ditentukannya.
```python
X = X[:, np.newaxis, 2]
```
✅ Kapanpun, *print*-lah datanya untuk memeriksa bentuknya.
3. Sekarang datanya sudah siap untuk digambar. Kamu bisa melihat jikalau sebuah mesin dapat menentukan sebuah perpisahan logika dari nomor-nomor *dataset* ini. Untuk melakukan itu, kamu harus memisahkan data (X) dan target (y) menjadi set latihan dan set ujian. Scikit-learn juga memberi cara untuk melakukan itu; kamu bisa memisahkan data ujianmu pada titik tertentu.
```python
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
```
4. Sekarang, kamu sudah siap untuk melatihkan modelmu! Muatkan dahulu data regresi linear dan latihkan modelmu dengan set X dan y-mu dengan `model.fit()`:
```python
model = linear_model.LinearRegression()
model.fit(X_train, y_train)
```
✅ `model.fit()` adalah sebuah fungsi yang akan kamu temukan dalam banyak *library* ML seperti TensorFlow.
5. Lalu, buatlah sebuah prediksi dengan data ujianmu dengan fungsi `predict()`. Ini akan digunakan untuk menggambar sebuah garis antara grup-grup data.
```python
y_pred = model.predict(X_test)
```
6. Sekarang waktunya untuk menggambar data dalam sebuah grafik. Matplotlib adalah sebuah alat yang sangat berguna untuk melakukan itu. Buatlah sebuah petak sebar dari semua X dan y dari set ujian dan gunakan prediksi yang dihasilkan untuk menggambar sebuah garis di tempat yang paling cocok antara grup-grup data modelnya.
```python
plt.scatter(X_test, y_test, color='black')
plt.plot(X_test, y_pred, color='blue', linewidth=3)
plt.show()
```
![sebuah petak sebar yang menunjukkan titik-titik data sekitar diabetes](./images/scatterplot.png)
✅ Pikirkan sejenak tentang apa yang sedang terjadi di sini. Sebuah garis lurus membentang tengah-tengah titik-titik kecil data. Tetapi apa yang sedang garis itu lakukan? Apa kamu bisa melihat bagaimana kamu bisa menggunakan garis ini untuk memprediksi di mana sebuah titik data baru yang tidak pernah dilihat sebelumnya kemungkinan besar akan terletak berhubungan dengan sumbu y grafik ini? Coba jelaskan dalam kata-kata kegunaan praktis model ini.
Selamat, kamu telah membangun model regresi linear pertamamu, membuat sebuah prediksi darinya, dan menunjukkannya dalam sebuah grafik!
---
## Tantangan
Gambarkan sebuah variabel yang beda dari *dataset* ini. Petunjuk: edit baris ini: `X = X[:, np.newaxis, 2]`. Mengetahui target *dataset* ini, apa yang kamu bisa menemukan tentang kemajuan diabetes sebagai sebuah penyakit?
## [Kuis pasca-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/10/)
## Review & Pembelajaran Mandiri
Dalam tutorial ini, kamu bekerja dengan sebuah model regresi linear yang sederhana daripada regresi linear univariat atau berganda. Bacalah sedikit tentang perbedaan antara metode-metode ini atau tontonlah [video ini](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef).
Bacalah lebih banyak tentang konsep regresi dan pikirkanlah tentang jenis pertanyaan apa saja yang bisa dijawab teknik ini. Cobalah [tutorial ini](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-15963-cxa) untuk memperdalam pemahamanmu.
## Tugas
[*Dataset* yang beda](assignment.md)

202
2-Regression/2-Data/translations/README.id.md
Unescape View File

@ -0,0 +1,202 @@
# Membangun sebuah model regresi dengan Scikit-learn: siapkan dan visualisasikan data
> ![Infografik visualisasi data](./images/data-visualization.png)
> Infografik oleh [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [Kuis pra-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/11/)
## Pembukaan
Karena sekarang kamu sudah siap dengan alat-alat yang akan diperlukan untuk mulai melampiaskan pembangunan model *machine learning* dengan Scikit-learn, kamu juga siap untuk mulai membuat pertanyaan dari datamu. Selagi kamu bekerja dengan data dan mengaplikasikan solusi ML, sangatlah penting untuk mengerti bagaimana menanyakan cara yang benar dan tepat untuk mengemukakan potensial *dataset*-mu.
Dalam pelajaran ini, kamu akan belajar:
- Cara mempersiapkan datamu untuk pembangunan model.
- Cara menggunakan Matplotlib untuk memvisualisasikan data.
## Menanyakan pertanyaan yang tepat dari datamu
Pertanyaan yang perlu dijawab akan menentukan jenis algoritma ML yang kamu akan memanfaatkan. Lalu, kualitas jawaban yang kamu akan dapat sangat tergantung pada sifat datamu (*the nature of your data*).
Lihatlah [data](../data/US-pumpkins.csv) yang disiapkan untuk pelajaran ini. Kamu bisa membuka file .csv ini di VS Code. Membaca dengan cepat, *dataset* ini ada yang kosong dan ada yang campuran data *string* dan data numerik. Adapula sebuah kolom 'Package' yang aneh dan mengandung data antara 'sacks', 'bins', dll. Terus terang, data ini amburadul.
Faktanya adalah tidak sering kita dihadiahkan sebuah *dataset* yang langsung bisa digunakan untuk membuat sebuah model ML. Dalam pelajaran ini, kamu akan belajar bagaimana menyiapkan sebuah *dataset* 'mentah' menggunakan *library* standar Python. Kamu juga akan belajar aneka teknik untuk memvisualisasikan datanya.
## Studi kasus: 'pasar labu'
Dalam folder ini kamu akan menemukan sebuah file .csv dalam folder `data` bernama [US-pumpkins.csv](../data/US-pumpkins.csv) yang mempunyai 1757 baris data tentang pasar labu disortir dalam pengelompokkan berdasarkan kota. Ini adalah data mentah yang diambil dari [Specialty Crops Terminal Markets Standard Reports (Laporan Standar Pasar Terminal Tanaman Khusus)](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) yang didistribusi Departemen Agrikultur Amerika Serikat.
### Menyiapkan data
Data ini terbuka untuk umum (*publik domain*) dan bisa diunduh sebagai banyak file terpisah berdasarkan kota dari situs internet Departemen Agrikultur Amerika Serikat. Supaya tidak berurusan dengan terlalu banyak file, kami telah menggabungkan data dari semua kota menjadi satu *spreadsheet* (file Excel). Jadi kamu sudah _menyiapkan_ datanya sedikit. Selanjutnya, mari kita lihat datanya.
### Data labu - kesimpulan-kesimpulan awal
Apa yang kamu cermati tentang data ini? Kamu sudah melihat bahwa ada campuran *string*, nomor, kekosongan, dan nilai-nilai aneh yang harus diartikan.
Pertanyaan apa yang kamu bisa tanyakan dari data data ini menggunakan teknik regresi? Kalau "Prediksikan harga jual sebuah labu pada bulan tertentu" bagaimana? Melihat datanya sekali lagi, ada beberapa perubahan yang kamu harus terapkan untuk membuat struktur data yang diperlukan untuk tugas ini.
## Latihan - analisiskan data labu
Mari menggunakan [Pandas](https://pandas.pydata.org/) (singkatan dari `Python Data Analysis`), sebuah alat yang sangat beruna untuk membentuk, menganalisis, dan menyiapkan data labu ini.
### Pertama, carilah tanggal yang hilang
Kamu harus mengambil langkah untuk mencari tanggal-tanggal yang hilang terlebih dahulu:
1. Konversi tanggal-tanggalnya menjadi format bulan (tanggal-tanggal ini dalam format Amerika Serikat, yaitu `BULAN/TANGGAL/TAHUN`).
2. Jadikan data bulan menjadi kolom baru
Buka file _notebook.ipynb_ dalam Visual Studio Code dan impor *spreadsheet*-nya menjadi sebuah *dataframe* Pandas.
1. Gunakan fungsi `head()` untuk melihat lima baris pertama.
```python
import pandas as pd
pumpkins = pd.read_csv('../../data/US-pumpkins.csv')
pumpkins.head()
```
✅ Fungsi apa yang akan kamu gunakan untuk melihat lima baris **terakhir**?
2. Periksa apa ada data yang hilang dalam *dataframe* ini:
```python
pumpkins.isnull().sum()
```
Ada data yang hilang, namun mungkin tidak akan diperlukan untuk tugas ini.
3. Untuk menjadikan *dataframe* kamu lebih mudah untuk digunakan, buanglah beberapa kolom menggunakan `drop()` dan simpanlah kolom-kolom yang diperlukan saja:
```python
new_columns = ['Package', 'Month', 'Low Price', 'High Price', 'Date']
pumpkins = pumpkins.drop([c for c in pumpkins.columns if c not in new_columns], axis=1)
```
### Kedua, tentukan harga rata-rata labu
Pikirkan bagaimana caranya menentukan harga rata-rata sebuah labu pada bulan tertentu. Kamu akan pilih kolom apa saja untuk tugas ini? Petunjuk: kamu akan perlu 3 kolom.
Solusi: Ambil rata-rata kolom `Low Price` dan `High Price` untuk mengisi kolom `Price` yang baru. Terus, konversikan kolom `Date` untuk hanya menunjukkan bulan saja. Untungnya, berdasarkan pemeriksaan di atas, tidak ada data tanggal atau harga yang hilang.
1. Untuk mengkalkulasi rata-rata, tambahlah kode berikut:
```python
price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2
month = pd.DatetimeIndex(pumpkins['Date']).month
```
✅ Jangan ragu untuk mem-*print* data apapun yang kamu ingin periksa menggunakan `print(month)`.
2. Sekarang, salinlah data yang telah dikonversi ke sebuah *dataframe* Pandas yang baru:
```python
new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
```
Jika *dataframe* baru ini di-*print*, kamu akan lihat sebuah *dataset* yang rapih darimana kamu bisa membangun model regresi barumu.
### But wait! There's something odd here
### Tunggu! Ada yang aneh di sini
Kalau kamu lihat kolom `Package`, labu dijual dalam berbagai konfigurasi. Beberapa dijual dalam satuan '1 1/9 bushel', beberapa per labu, beberapa per pon, dan beberapa dalam dus-dus besar dengan kelebaran yang berbeda-beda.
> Kelihatannya susah untuk menimbang labu secara konsisten
Menggali data orisinal lebih dalam, sangatlah menarik untuk melihat apapun dengan `Unit of Sale` (satuan penjualan) yang sama dengan 'EACH' atau 'PER BIN' akan mempunyai jenis `Package` yang per inci, per bin, atau 'each'. Kelihatannya susah untuk menimbang labu secara konsisten, jadi mari memilah datanya dengan hanya memilih labu yang kolom `Package`-nya sama dengan *string* 'bushel'.
1. Tambah sebuah filter di atas file tetapi dibawah impor .csv yang di awal
```python
pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
```
Kalau kamu *print* datanya sekarang, kamu bisa lihat bahwa kamu hanya mendapatkan sekitar 415 baris data yang mengandung data labu per bushel.
### Tunggu! Masih ada satu lagi
Apa kamu sadar bahwa jumlah bushel berbeda-beda per baris? Kamu harus menormalisasi harganya supaya kamu menunjukkan harga per bushel. Gunakanlah sedikit matematika untuk menstandarisasinya.
1. Tambahlah beberapa baris ini setelah blok yang membuat *dataframe* new_pumpkins:
```python
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/(1 + 1/9)
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price/(1/2)
```
✅ Berdasarkan [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), berat satu bushel tergantung jenis hasil bumi sebab bushel adalah satuan volume. "Satu bushel tomat, sebagai contoh, seharusnya seberat 56 pon (25.4 kg)... Dedaunan mengambil lebih banyak ruang tetapi lebih ringan, jadi satu bushel bayam hanya seberat 20 pon (9.1 kg)" (diterjemah). Lumayan rumit ya! Kita tidak usah mengkonversi bushel ke pon saja bagaimana, jadi kita gunakan satuan harga per bushel? Namun, semua riset ini tentang bushel labu menunjukkan sebagaimana pentingnya untuk mengerti sifat datamu!
Sekarang, kamu bisa meneliti harga per satuan berdasarkan hitungan bushel mereka. Jika kamu *print* datanya sekali lagi, kamu bisa lihat bagaimana telah distandarisasi.
✅ Apa kamu sadar bahwa labu yang dijual per setengah bushel sangat mahal? Kira-kira mengapa ya? Petunjuk: labu kecil jauh lebih mahal daripada labu besar, mungkin karena ada lebih banyak per bushel, apalagi mengingat pula bahwa satu labu besar mempunyai rongga kosong yang besar di dalamnya.
## Strategi Visualisasi
Sebagian dari peran seorang *data scientist* adalah untuk mendemonstrasikan kualitas dan sifat data yang sedang digunakan. Untuk melakukan ini, mereka seringkali membuat visualisasi-visualisasi atau grafik menarik yang menunjukkan aspek-aspek berbeda tentang datanya. Dengan cara ini, mereka dapat menunjukkan hubungan-hubungan dan celah-celah secara visual. Kalau tidak secara visual, akan susah untuk menemukan pola-pola tersebut.
Visualisasi juga bisa membantu menentukan teknik *machine learning* yang palingn cocok untuk datanya. Sebagai contoh, sebuah petak sebar yang kelihatannya mengikuti sebuah garis mengindikasikan bahwa data ini adalah kandidat baik untuk latihan regresi linear.
Satu *library* visualisasi data yang bekerja dengan baik dalam sebuah *Jupyter notebook* adalah [Matplotlib](https://matplotlib.org/) (yang kamu juga lihat dalam pelajaran sebelumnya).
> Carilah pengalaman dalam memvisualisasi data dengan [tutorial-tutorial ini](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-15963-cxa).
## Latihan - sebuah experimen dengan Matplotlib
Coba membuat beberapa grafik sederhana untuk menunjukkan *dataframe* baru yang baru kamu buat. Kira-kira, sebuah plot garis akan menunjukkan apa ya?
1. Impor Matplotlib di atas file tetapi di bawah impor Pandas:
```python
import matplotlib.pyplot as plt
```
2. Jalankan ulang keseluruhan *notebook*-nya.
3. Di bagian bawah *notebook*-nya, tambahkan sebuah sel untuk menggambarkan datanya sebagai sebuah kotak.
```python
price = new_pumpkins.Price
month = new_pumpkins.Month
plt.scatter(price, month)
plt.show()
```
![Sebuah petak sebar yang menunjukkan hubungan antara harga dan bulan](./images/scatterplot.png)
Apakah grafik ini berguna? Apa ada yang mengejutkanmu?
Sebenarnya tidak terlalu berguna karena dia hanya menunjukkan datamu sebagai sebuah penyebaran poin pada bulan tertentu.
### Jadikan berguna
Untuk menjadikan sebuah grafik menjadi berguna, biasanya datanya harus dikelompokkan dengan suatu cara. Kita coba membuat suatu plot di mana sumbu y menunjukkan bulan dan datanya mendemonstrasikan distribusi data, yuk!
1. Tambah sebuah sel untuk membuat sebuah diagram batang berkelompok:
```python
new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
plt.ylabel("Pumpkin Price")
```
![Sebuah diagram batang yang menunjukkan hubungan antara harga dan bulan](./images/barchart.png)
Nah, ini lebih berguna! Kelihatannya visualisasi ini mengindikasi bahwa labu itu paling mahal pada bulan September dan Oktober. Apa itu sesuai ekspektasimu? Mengapa?
---
## 🚀Tantangan
Jelajahi jenis-jenis visualisasi yang beda dan yang disediakan Matplotlib. Jenis mana yang paling cocok untuk kasus regresi?
## [Kuis pasca-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/12/)
## Review & Pembelajaran Mandiri
Lihatlah beragam cara memvisualisasi data. Buatlah sebuah daftar dari aneka *library* yang tersedia dan catatlah yang mana yang paling baik untuk jenis-jenis tugas tertentu. Sebagai contoh, bagaimana dengan visualisasi 2D vs. 3D? Apa yang kamu temukan?
## Tugas
[Menjelajahi visualisasi](assignment.md)

335
2-Regression/3-Linear/translations/README.id.md
Unescape View File

@ -0,0 +1,335 @@
# Bangun sebuah model regresi dengan Scikit-learn: regresi dua arah
![Infografik regresi linear vs polinomial](./images/linear-polynomial.png)
> Infografik oleh [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [Kuis pra-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/13/)
### Pembukaan
Selama ini kamu telah menjelajahi apa regresi itu dengan data contoh yang dikumpulkan dari *dataset* harga labu yang kita akan gunakan terus sepanjang pelajaran ini. Kamu juga telah memvisualisasikannya dengan Matplotlib.
Sekarang kamu sudah siap terjun ke dalam regresi untuk ML. Dalam pelajaran ini, kamu akan belajar lebih tentang dua jenis regresi: _regresi linear sederhana_ dan _regresi polinomial_ serta sedikit matematika yang mendasari kedua teknik ini.
> Sepanjang kurikulum ini, kami mengasumsi kamu punya pengetahuan matematika yang minim dan ingin tetap membuat pelajaran ini terjangkau bagi murid-murid dari bidang-bidang lain. Jadi perhatikan catatan, 🧮 info, diagram, dan alat-alat belajar lainnya untuk membantu pemahaman.
### Prasyarat
Kamu harusnya sudah terbiasa sekarang dengan struktur data labu yang kita sedang teliti. Datanya harusnya sudah dimuat dan dibersihkan dalam file _notebook.ipynb_ pelajaran ini. Dalam file ini, harga labu ditampilkan per bushel dalam *dataframe* yang bari. Pastikan kamu bisa menjalankan *notebook-notebook* ini di *kernels* di Visual Studio Code.
### Persiapan
Ingat, kamu sedang memuat data ini untuk menanyakan pertanyaan darinya.
- Kapankah waktu terbaik untuk membeli labu?
- Saya kira-kira harus bayar berapa untuk satu kotak labu mini?
- Apa saya sebaiknya membelinya dalam keranjang-keranjang setengah bushel atau kardus-kardus 1 1/9 bushel?
Ayo terjun lebih lagi ke dalam data ini.
Dalam pelajaran sebelumnya, kamu membuat sebuah *dataframe* Pandas, mengisinya dengan sebagian *dataset* orisinal, dan menstandarisasi harganya per bushel. Tetapi, dengan begitu, kamu hanya dapat mengumpul sekitar 400 titik data dan itupun hanya untuk bulan-bulan musim gugur.
Lihatlah data yang kita sudah muat dalam *notebook* yang terlampir pelajaran ini. Data telah di muat dan sebuah petak sebar inisial telah digambar untuk menunjukkan data per bulan. Mungkin kita bisa dapat lebih banyak detail tentang sifat datanya dengan membersih-bersihkannya lebih lagi.
## Sebuah garis regresi linear
Seperti yang kamu telah belajar dalam Pelajaran 1, tujuan sebuah latihan regresi linear adalah untuk dapat menggambar sebuah garis untuk:
- **Menunjukkan hubungan antar-variabel**. Menunjukkan hubungan antara variabel-variabel.
- **Membuat prediksi**. Membuat prediksi akurat tentang di mana sebuah titik data baru akan terletak berhubungan dengan garis tersebut.
Dalam kasus **Regresi Kuadrat Terkecil (_Least-Squares Regression_)**, biasanya garis seperti ini digambar. Istilah 'kuadrat terkecil' berarti semua titik data yang mengitari garis regresi dikuadratkan dan dijumlahkan. Secara ideal, harusnya jumlah akhirnya sekecil mungkin, karena kita ingin kesalahan (error) terkecil, alias `kuadrat terkecil`.
Kita melakukan itu sebab kita ingin memodelkan sebuah garis yang jarak kumulatifnya dari semua titik data itu sekecil mungkin. Kita juga mengkuadratkan setiap suku sebelum dijumlahkan karena kita fokus pada besarannya daripada arahnya.
> **🧮 Tunjukkan matematikanya kepadaku**
>
> Garis ini, dipanggil _garis yang paling cocok_, dapat diekspresikan dalam [sebuah persamaan](https://en.wikipedia.org/wiki/Simple_linear_regression):
>
> ```
> Y = a + bX
> ```
>
> `X` adalah 'variabel penerang'. `Y` adalah 'variabel dependen'. Gradien garisnya adalah `b`, dan `a` adalah titik potong sumbu y yaitu nilai `Y` saat `X = 0`.
>
>![hitunglah gradiennya](images/slope.png)
>
> Pertama, hitunglah gradien `b`. Infografik oleh [Jen Looper](https://twitter.com/jenlooper)
>
> Dalam kata lain, dan berhubungan pula dengan pertanyaan awal data labu kita "prediksikan harga satu bushel labu setiap bulan", `X` merujuk pada harganya, sedangkan `Y` akan merujuk pada bulan penjualan.
>
>![lengkapilah persamaan ini](images/calculation.png)
>
> Hitunglah nilai Y. Kalau harganya $4, artinya pasti April! Infografik oleh [Jen Looper](https://twitter.com/jenlooper)
>
> Matematika yang mengkalkulasi garis ini harus mendemonstrasikan gradien garisnya yang juga tergantung pada titik potongnya pada sumbu y, alias apa `Y`-nya saat `X = 0`.
>
> Kamu bisa melihat metode menghitung nilai-nilai ini di situs internet [*Math is Fun* (Matematika Itu Menyenangkan)](https://www.mathsisfun.com/data/least-squares-regression.html). Kunjungi [kalkulator kuadrat terkecil ini](https://www.mathsisfun.com/data/least-squares-calculator.html) juga untuk melihat bagaimana nomor-nomor ini mengubah garisnya.
## Korelasi
Satu lagi yang harus dipahami adalah **Koefisien Korelasi** antara variabel X dan Y yang tersedia. Menggunakan sebuah petak sebar, kamu bisa memvisualisasi korelasi ini dengan cepat. Sebuah grafik dengan titik-titik data yang tersebar rapi seperti sebuah garis mempunyai korelasi yang tinggi. Namun, sebuah grafik dengan titik-titik data yang tersebar di mana-mana antara X dan Y mempunyai korelasi yang rendah.
Sebuah model regresi linear yang bagus akan mempunyai Koefisien Korelasi yang tinggi (lebih dekat ke 1 daripada ke 0) menggunakan metode Regresi Kuadrat Terkecil dengan sebuah garis regresi.
✅ Jalankan *notebook* yang terlampir dalam pelajaran ini dan lihatlah petak sebar City (Kota) ke Price (Harga). Apa data yang menghubungkan City ke Price untuk penjualan labu mempunyai korelasi yang tinggi atau rendah kelihatannya?
## Siapkan datamu untuk regresi
Sekarang dengan pemahamanmu mengenai matematika di balik latihan ini, buatlah sebuah model regresi untuk melihat apa kamu bisa memprediksi paket labu yang mana yang harganya paling baik. Seorang pembeli labu akan ingin mengetahui informasi ini untuk mengoptimasi pembelian labu mereka.
Karena kamu akan menggunakan Scikit-learn, tidak usah mengerjakan ini dengan tangan (walaupun bisa sih!). Dalam blok memrosesan data utama *notebook*-mu untuk pelajaran ini, tambahlah sebuah *library* dari Scikit-learn untuk mengkonversi semua data *string* menjadi nomor secara otomatis:
```python
from sklearn.preprocessing import LabelEncoder
new_pumpkins.iloc[:, 0:-1] = new_pumpkins.iloc[:, 0:-1].apply(LabelEncoder().fit_transform)
new_pumpkins.iloc[:, 0:-1] = new_pumpkins.iloc[:, 0:-1].apply(LabelEncoder().fit_transform)
```
Kalau kamu sekarang simak *dataframe* new_punkins, kamu akan lihat bahwa semua *string* sudah dijadikan nomor. Ini lebih susah untuk kita baca, tetapi jauh lebih mudah untuk Scikit-learn!
Sekarang kamu bisa membuat lebih banyak keputusan berakal (tidak hanya tebak-tebak dari petak sebarnya) tentang data yang paling cocok untuk regresi.
Coba cari sebuah korelasi bagus antara dua titik data yang berpotensi untuk membangun sebuah model prediksi yang baik. Ternyata, hanya ada korelasi yang lemah antara City dan Price:
```python
print(new_pumpkins['City'].corr(new_pumpkins['Price']))
0.32363971816089226
```
Meskipun begitu, ada korelasi yang sedikit lebih baik antara Package (Paket) dan Price (Harga). Masuk akal juga kan? Biasanya, lebih besar kardusnya, lebih mahal harganya.
```python
print(new_pumpkins['Package'].corr(new_pumpkins['Price']))
0.6061712937226021
```
Sebuah pertanyaan bagus untuk ditanyakan dari data ini adalah "Kira-kira harga sebuah paket labu berapa?"
Mari membangun sebuah model regresi
## Membangun sebuah model linear
Sebelum membangun modelmu, rapikanlah datamu sekali lagi. Buanglah sebuah data nil (null) dan periksalah sekali lagi datanya kelihatannya seperti apa.
```python
new_pumpkins.dropna(inplace=True)
new_pumpkins.info()
```
Lalu, buatlah sebuah *dataframe* baru dari set minimal ini dan *print*:
```python
new_columns = ['Package', 'Price']
lin_pumpkins = new_pumpkins.drop([c for c in new_pumpkins.columns if c not in new_columns], axis='columns')
lin_pumpkins
```
```output
Package Price
70 0 13.636364
71 0 16.363636
72 0 16.363636
73 0 15.454545
74 0 13.636364
... ... ...
1738 2 30.000000
1739 2 28.750000
1740 2 25.750000
1741 2 24.000000
1742 2 24.000000
415 rows × 2 columns
```
1. Sekarang kamu bisa menetapkan data koordinat X dan y-mu:
```python
X = lin_pumpkins.values[:, :1]
y = lin_pumpkins.values[:, 1:2]
```
✅ Apa yang sedang terjadi di sini? Kamu sedang menggunakan [notasi perpotongan Python (*Python slice notation*)](https://stackoverflow.com/questions/509211/understanding-slice-notation/509295#509295) untuk membuat dua *array* untuk mengisi `X` dan `y`.
1. Selanjutnya, mulailah rutin pembangunan model:
```python
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
pred = lin_reg.predict(X_test)
accuracy_score = lin_reg.score(X_train,y_train)
print('Model Accuracy: ', accuracy_score)
```
Karena korelasinya tidak begitu baik, model yang didapatkan tidak terlalu akurat.
```output
Model Accuracy: 0.3315342327998987
```
2. Kamu bisa memvisualisasi garis yang digambarkan dalam proses ini:
```python
plt.scatter(X_test, y_test, color='black')
plt.plot(X_test, pred, color='blue', linewidth=3)
plt.xlabel('Package')
plt.ylabel('Price')
plt.show()
```
![Sebuah petak sebar yang menunjukkan hubungan antara paket dan harga](./images/linear.png)
3. Ujilah modelnya dengan sebuah jenis labu hipotetis:
```python
lin_reg.predict( np.array([ [2.75] ]) )
```
Harga yang dihasilkan untuk jenis labu mitologis ini adalah:
```output
array([[33.15655975]])
```
Nomor itu masuk akal jikalau logika garis regresinya benar.
🎃 Selamat, kamu baru saja membuat sebuah model yang bisa membantu memprediksi harga beberapa jenis labu. Namun, kamu masih bisa membuatnya lebih baik!
## Regresi polinomial
Jenis lain regresi linear adalah regresi polinomial. Walaupun kadangkali ada hubungan linear antara variabel-variabel — lebih besar volume labunya, lebih tinggi harganya — kadangkali hubungan-hubungan ini tidak bisa digambarkan sebagai sebuah bidang atau garis lurus.
✅ Ini ada [beberapa contoh data lain](https://online.stat.psu.edu/stat501/lesson/9/9.8) yang bisa menggunakan regresi polinomial
Tengok kembali hubungan antara Variety (Jenis) dan Price (Harga) dalam grafik sebelumnya. Apa petak sebar ini terlihat seperti harus dianalisis dengan sebuah garis lurus? Mungkin tidak. Kali ini, kamu bisa mencoba regresi polinomial.
✅ Polinomial adalah sebuah pernyataan matematika yang mempunyai satu atau lebih variabel dan koefisien disusun menjadi suku-suku.
Regresi polinomial menghasilkan sebuah garis lengkung supaya lebih cocok dengan data non-linear.
1. Mari kita membuat sebuah *dataframe* yang diisi sebuah segmen dari data orisinal labu:
```python
new_columns = ['Variety', 'Package', 'City', 'Month', 'Price']
poly_pumpkins = new_pumpkins.drop([c for c in new_pumpkins.columns if c not in new_columns], axis='columns')
poly_pumpkins
```
Sebuah cara bagus untuk memvisualisasi korelasi-korelasi antara data dalam *dataframe-dataframe* adalah untuk menampilkannya dalam sebuah peta '*coolwarm*' (panas-dingin):
2. Gunakan fungsi `Background_gradient()` dengan `coolwarm` sebagai argumennya:
```python
corr = poly_pumpkins.corr()
corr.style.background_gradient(cmap='coolwarm')
```
This code creates a heatmap:
Kode ini membuat sebuah peta panas
![Sebuah peta panas yang menunjukkan korelasi data](./images/heatmap.png)
Melihat peta ini, kamu bisa memvisualisasikan korelasi yang baik antara Package dan Price. Jadi kamu seharusnya bisa membuat sebuah model yang lebih baik daripada yang sebelumnya.
### Buatlah sebuah *pipeline*
Scikit-learn mempunyai sebuah API yang berguna untuk membangun model regresi polinomial — [API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) `make_pipeline`. Sebuah '*pipeline*' adalah sebuah rantai penaksir. Dalam kasus ini, *pipeline* ini mempunyai fitur-fitur polinomial, atau prediksi-prediksi yang membuat garis non-linear.
1. Bangunlah kolom X dan y:
```python
X=poly_pumpkins.iloc[:,3:4].values
y=poly_pumpkins.iloc[:,4:5].values
```
2. Buatlah *pipeline*-nya dengan fungsi `make_pipeline()`:
```python
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
pipeline = make_pipeline(PolynomialFeatures(4), LinearRegression())
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
pipeline.fit(np.array(X_train), y_train)
y_pred=pipeline.predict(X_test)
```
### Buatlah sebuah barisan
Di sini, kamu harus membuat sebuah *dataframe* baru dengan data yang _berurutan_ supaya *pipeline*-nya bisa membuat sebuah barisan.
Tambahlah kode ini:
```python
df = pd.DataFrame({'x': X_test[:,0], 'y': y_pred[:,0]})
df.sort_values(by='x',inplace = True)
points = pd.DataFrame(df).to_numpy()
plt.plot(points[:, 0], points[:, 1],color="blue", linewidth=3)
plt.xlabel('Package')
plt.ylabel('Price')
plt.scatter(X,y, color="black")
plt.show()
```
Kamu membuat sebuah *dataframe* baru dengan fungsi `pd.DataFrame`. Lalu kamu mengurutkan isinya dengan fungsi `sort_values()`. Akhirnya kamu membuat sebuah bagan polinomial:
![Sebuah bagan polinomial yang menunjukkan hubungan antara paket dan harga](./images/polynomial.png)
Kamu bisa melihat garis lengkungnya yang lebih cocok terhadap datamu.
Ayo periksa akurasi modelnya:
```python
accuracy_score = pipeline.score(X_train,y_train)
print('Model Accuracy: ', accuracy_score)
```
Nah!
```output
Model Accuracy: 0.8537946517073784
```
Itu bagus! Coba memprediksi harga:
### Buatlah sebuah prediksi
Apa kita bisa memberi input dan dapat sebuah prediksi?
Pakai fungsi `predict()` untuk membuat prediksi:
```python
pipeline.predict( np.array([ [2.75] ]) )
```
Kamu diberi prediksi ini:
```output
array([[46.34509342]])
```
Itu sangat masuk akal dengan bagan sebelumnya! Selain itu, jika ini model lebih baik daripada yang sebelumnya dengan data ini, kamu bisa siap untuk labu-labu yang lebih mahal ini!
🏆 Mantap sekali! Kamu membuat dua model regresi dalam satu pelajaran. Dalam bagian terakhir mengenai regresi, kamu akan belajar tentang regresi logistik untuk pengkategorisasian.
---
## 🚀 Tantangan
Coba-cobalah variabel-variabel yang lain di *notebook* ini untuk melihat bagaimana korelasi berhubungan dengan akurasi model.
## [Kuis pasca-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/14/)
## Review & Pembelajaran Mandiri
Dalam pelajaran ini kita belajar tentang regresi linear. Ada banyak jenis regresi lain yang penting pula. Bacalah tentang teknik *Stepwise*, *Ridge*, *Lasso*, dan *Elasticnet*. [Kursus Pembelajaran Statistik Stanford](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning) juga baik untuk belajar lebih lanjut.
## Tugas
[Buatlah sebuah model](assignment.md)

301
2-Regression/4-Logistic/translations/README.id.md
Unescape View File

@ -0,0 +1,301 @@
# Regresi logistik untuk memprediksi kategori-kategori
![Infografik regresi logistik vs. linear](./images/logistic-linear.png)
> Infografik oleh [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [Kuis pra-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/15/)
## Pembukaan
Dalam pelajaran regresi terakhir, salah satu teknik ML _klasik_ dan sederhana adalah regresi logistik. Teknik ini digunakan untuk mengemukakan pola-pola untuk memprediksi kategori binari. Apa ini sebuah permen coklat atau tidak? Apa penyakit ini menular tidak? Apa pelanggan ini akan memilih produk ini tidak?
Dalam pelajaran ini, kamu akan belajar:
- Sebuah *library* baru untuk pemvisualisasian data
- Teknik-teknik untuk regresi logistik
✅ Perdalamkan pemahamanmu dalam bekerja dengan regresi jenis ini dalam [modul pembelajaran ini](https://docs.microsoft.com/learn/modules/train-evaluate-classification-models?WT.mc_id=academic-15963-cxa)
## Prasyarat
Setelah bekerja dengan data labu, kita sekarang sudah terbiasa dengannya untuk menyadari bahwa adapula sebuah kategori binari yang kita dapat menggunakan: `Color` (warna).
Mari membangun sebuah model regresi logistik untuk memprediksi _kemungkinannya labu ini warnanya apa_ berdasarkan beberapa variabel (oranye 🎃 atau putih 👻).
> Mengapa kita berbicara tentang klasifikasi binary dalam seri pelajaran tentang regresi? Hanya untuk kemudahan linguistik, regresi logistik juga [sebenarnya sebuah metode klasifikasi](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), namun satu yang berdasarkan garis linear. Pelajari lebih lanjut tentang cara-cara lain untuk mengklasifikasi data dalam seri pelajaran berikutnya.
## Tentukan pertanyaannya
Untuk keperluan kita, kita akan mengekspresikannya sebagai pilihan binari 'Orange' atau 'Not Orange' (oranye atau bukan oranye). Adapula kategori 'striped' (belang-belang) dalam dataset kita, tetapi tidak banyak titik datanya, jadi kita tidak akan menggunakannya. Lagipula, kategori itu hilang begitu kita buang nilai-nilai nil (null) dari datasetnya.
> 🎃 Tahukah tidak? Kita kadangkali memanggil labu putih labu 'hantu'. Mereka tidak mudah diukir, jadi mereka tidak sepopuler yang oranye pada Halloween. Tetapi mereka keren juga ya!
## Tentang regresi logistik
Regresi logistik berbeda dari regresi linear, jenis regresi yang kamu pelajari sebelumnya, dalam beberapa askpek penting.
### Klasifikasi binari
Regresi logistik tidak mempunyai beberapa fitur regresi linear. Regresi logistik menyediakan sebuah prediksi tentang sebuah kategori binari (seperti "oranye atau bukan oranye"), sedangkan yang lainnya dapat memprediksi nilai-nilai kontinu. Contohnya, dengan mengetahui dari mana labu ini dan kapan dipanennya, regresi linear dapat memprediksi _berapa harganya akan naik_, namun regresi logistik tidak bisa.
![Model klasifikasi labu](./images/pumpkin-classifier.png)
> Infografik oleh [Dasani Madipalli](https://twitter.com/dasani_decoded)
### Klasifikasi lain
Ditambah itu, ada banyak jenis regresi logistik, termasuk jenis multinomial dan ordinal:
- **Multinomial** memperlibatkan lebih dari satu kategori - "Oranye, Putih, dan Belang-belang".
- **Ordinal** memperlibatkan kategori-kategori berurut. Biasanya berguna jika kita inging mengurutkan hasil kita secara logikal, seperti labu-useful if we wanted to order our outcomes logically, like our pumpkins that are ordered by a finite number of sizes (mini,sm,med,lg,xl,xxl).
![Multinomial vs ordinal regression](./images/multinomial-ordinal.png)
> Infographic by [Dasani Madipalli](https://twitter.com/dasani_decoded)
### Eh, masih linear ya?
Walaupun jenis regresi ini semuanya tentang 'prediksi kategori', jenis ini masih paling efektif jika ada hubungan linear antara variabel dependen (warna) dan independen (sisa *dataset*-nya, seperti kota dan ukuran). Jadi baik juga untuk mencari tahu dahulu apa ada hubungan linear antara variabel-variabel ini.
### Variabel-variabel TIDAK HARUS berkorelasi
Ingat bagaimana regresi linear bekerja lebih baik dengan variabel berkorelasi? Regresi logistik itu kebalikannya: variabel-variabelnya tidak harus berjejer menjadi garis. Artinya, regresi ini bekerja untuk data ini yang korelasinya lumayan lemah.
### Perlu banyak data rapi
Regresi logistik akan memberi hasil lebih akurat jika kamu menggunakan data lebih banyak; *dataset* kecil kita tidak optimal untuk tugas ini, ingatlah itu.
✅ Pikirkan tentang jenis-jenis data yang akan bekerja baik dengan regresi logistik
## Latihan - rapikan data
Pertama, rapikanlah datanya sedikit. Buanglah nilai-nilai nil (null) dan pilihlah beberapa kolom:
1. Tambahlah kode di bawah ini:
```python
from sklearn.preprocessing import LabelEncoder
new_columns = ['Color','Origin','Item Size','Variety','City Name','Package']
new_pumpkins = pumpkins.drop([c for c in pumpkins.columns if c not in new_columns], axis=1)
new_pumpkins.dropna(inplace=True)
new_pumpkins = new_pumpkins.apply(LabelEncoder().fit_transform)
```
Kamu selalu bisa mengintip kedalam *dataframe*-mu:
```python
new_pumpkins.info
```
### Visualisasi - *grid* berdampingan (*side-by-side grid*)
Sekarang kamu sudah memuat [*notebook* starter](./notebook.ipynb) dengan data labunya sekali lagi dan merapikannya untuk mempertahankan sebuah *dataset* dengan beberapa variabel, termasuk `Color`. Mari memvisualisasi *dataframe*-nya dengan *library* yang beda: [Seaborn](https://seaborn.pydata.org/index.html) yang dibangun di atas Matplotlib yang kita gunakan sebelumnya.
Seaborn menyediakan beberapa cara keren untuk memvisualisasi datamu. Contohnya, kamu bisa membandungkan distribusi datanya untuk setiap titik data dalam sebuah *grid* berdampingan.
1. Buatlah sebuah *grid* dengan meng-*instantiate* sebuah `PairGrid` menggunakan data labu kita `new_pumpkins` diikuti memanggil fungsi `map()`:
```python
import seaborn as sns
g = sns.PairGrid(new_pumpkins)
g.map(sns.scatterplot)
```
![Sebuah visualisasi *grid* data](images/grid.png)
Dengan mengobservasi datanya secara berdampingan, kamu bisa lihat bagaimana data warnanya berhubungan dengan kolom-kolom lainnya.
✅ Dengan petak sebar ini, pendalaman menarik apa saja yang kamu bisa membayangkan?
### Gunakan sebuah bagan kawanan (*swarm plot*)
Karena warna adalah sebuah kategori binari (oranye atau bukan oranye), warna disebut 'data kategorikal' dan memerlukan 'sebuah [pendekatan khusus](https://seaborn.pydata.org/tutorial/categorical.html?highlight=bar) untuk memvisualisasi'. Ada beberapa cara lain untuk memvisualisasi hubungan antara kategori ini dengan variabel-variabel lainnya.
Kamu bisa memvisualisasikan variabel-variabel secara berdampingan dengan bagan-bagan Seaborn.
1. Cobalah sebuah bagan kawanan untuk menunjukkan distribusi nilai:
```python
sns.swarmplot(x="Color", y="Item Size", data=new_pumpkins)
```
![Sekawanan data yang divisualisasi](images/swarm.png)
### Bagan biola
Sebuah bagan 'biola' itu berguna sebab kamu bisa memvisualisasi bagaimana data dalam kedua kategori itu terdistribusi dengan mudah. Bagan viola tidak efektif dengan *dataset* yang lebih kecil sebab distribusinya ditampilkan sebagai lebih 'mulus'.
1. Gunakan fungsi `catplot()` dengan parameter `x=Color` dan `kind="violin"`:
```python
sns.catplot(x="Color", y="Item Size",
kind="violin", data=new_pumpkins)
```
![sebuah bagan biola](images/violin.png)
✅ Cobalah membuat bagan ini dan jenis-jenis bagan Seaborn lainnya dengan variabel-variabel lainnya.
Sekarang kita sudah dapat bayangan hubungan antara kedua kategori binary warna dan ukuran. Ayo menjelajahi regresi logistik untuk memprediksi warna sebuah labu tertentu.
> **🧮 Perlihatkanlah Matematikanya Kepada Saya**
>
> Ingat bagaiaman regresi linear seringkali menggunakan metode kuadrat terkecil untuk tiba pada sebuah nilai? Regresi logistik tergantung pada konsep 'kemungkinan terbesar' menggunakan [fungsi sigmoid](https://wikipedia.org/wiki/Sigmoid_function). Sebuah 'fungsi Sigmoid' terlihat seperti huruf 'S' dalam sistem koordinat Kartesius. Fungsi ini mengambil sebuah nilai dan 'mencorongkannya' menjadi sebuah nomor antara 0 dan 1. Kurva ini juga dipanggil sebuah 'kurva logistik'. Formulanya seperti ini:
>
> ![Fungsi logistic](images/sigmoid.png)
>
> Titik tengah sigmoidnya terletak di sumbu X. L adalah nilai maksimum kurvanya. k adalah terjalnya kurvanya. Jika hasil fungsinya lebih dari 0.5, nilai yang diberikan kepada fungsi tersebut akan diklasifikasikan sebagai '1'. Kalau tidak, nilai itu akan diklasifikasikan sebagai '0'.
## Bangunlah modelmu
Scikit-learn membuat membangun model klasifikasi binary sangat mudah.
1. Pilihlah variabel-variabel yang kamu ingin gunakan dalam model klasifikasimu dan bagilah datanya menjadi set latihan dan set ujian dengan fungsi `train_test_split()`:
```python
from sklearn.model_selection import train_test_split
Selected_features = ['Origin','Item Size','Variety','City Name','Package']
X = new_pumpkins[Selected_features]
y = new_pumpkins['Color']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
2. Sekarang kamu bisa melatihkan modelmu dengan fungsi `fit()` dengan data latihanmu. *Print* hasilnya:
```python
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(classification_report(y_test, predictions))
print('Predicted labels: ', predictions)
print('Accuracy: ', accuracy_score(y_test, predictions))
```
Lihatlah *scoreboard* modelmu. Tidak buruk, apalagi hanya dengan 1000 baris data:
```output
precision recall f1-score support
0 0.85 0.95 0.90 166
1 0.38 0.15 0.22 33
accuracy 0.82 199
macro avg 0.62 0.55 0.56 199
weighted avg 0.77 0.82 0.78 199
Predicted labels: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 1 0 0 1 0 0 0 1 0]
```
## Pemahaman lebih baik via sebuah 'matriks kebingungan'
Walaupun kamu bisa membuat sebuah *scoreboard* melaporkan [istilah-istilah](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html?highlight=classification_report#sklearn.metrics.classification_report) dengan mem-*print* yang di atas, kamu mungkin bisa memahami modelmu dengan lebih mudah dengan sebuah [matriks kebingungan](https://scikit-learn.org/stable/modules/model_evaluation.html#confusion-matrix) untuk membantu kita lebih paham akan performa modelnya.
> 🎓 Sebuah '[matriks kebingungan](https://wikipedia.org/wiki/Confusion_matrix)' (atau 'matriks kesalahan') adalah sebuah tabel yang mengekspresikan positif benar vs. positif palsu modelmu sehingga mengukur akurasi prediksi=prediksinya.
1. Untuk menggunakan sebuah matriks kebingungan, gunakan fungsi `confusin_matrix()`:
```python
from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, predictions)
```
Lihatlah matriks kebingungan modelmu:
```output
array([[162, 4],
[ 33, 0]])
```
Apa yang sedang terjadi di sini? Mari kita asumsi dulu bahwa model kita ditanyakan untuk mengklasifikasi antara dua kategori binari: 'labu' dan 'bukan labu'.
- Kalau modelmu memprediksi sesuatu sebagai sebuah labu dan memang benar sesuatu itu adalah sebuah labu, itu disebut positif benar yang diindikasi angka di pojok kiri atas.
- Kalau modelmu memprediksi sesuatu sebagai bukan sebuah labu tetapi sesuatu itu sebenarnya sebuah labu, itu disebut positif palsu yang diindikasi angka di pojok kanan atas.
- Kalau modelmu memprediksi sesuati sebagai sebuah labu tetapi sebenarnya bukan sebuah labu, itu disebut negatif palsu yang diindikasi angka di pojok kiri bawah.
- Kalau modelmu memprediksi sesuati sebagai bukan sebuah labu dan memang benar sesuatu itu bukan sebuah labu, itu disebut negatif benar yang diindikasi angka di pojok kanan bawah.
![Matriks Kebingungan](images/confusion-matrix.png)
> Infografik oleh [Jen Looper](https://twitter.com/jenlooper)
Sebagaimana kamu mungkin sudah pikirkan, lebih baik dapat banyak positif benar dan negatif benar dan sedikit positif palsu dan negatif palsu. Implikasinya adalah performa modelnya bagus.
✅ Pertanyaan: Berdasarkan matriks kebingungan, modelnya baik tidak? Jawaban: Tidak buruk; ada banyak positif benar dan sedikit negatif palsu.
Mari kita lihat kembali istilah-istilah yang kita lihat tadi dengan bantuan matriks kebingungan:
> PB: Positif benar
> PP: Positif palsu
> NB: Negatif benar
> NP: Negatif palsu
🎓 Presisi: PB/(PB + NP) Rasio titik data relevan antara semua titik data (seperti data mana yang benar dilabelkannya)
🎓 *Recall*: PB/(PB + PP) Rasio titk data relevan yang digunakan, maupun labelnya benar atau tidak.
🎓 *f1-score*: (2 * Presisi * *Recall*)/(Presisi + *Recall*) Sebuah rata-rata tertimbang antara presisi dan *recall*. 1 itu baik dan 0 itu buruk.
🎓 Dukungan: Jumlah kejadian per label
🎓 Akurasi: (PB + NB)/(PB + PS + NB + NS) Persentase label yang diprediksi dengan benar untuk sebuah sampel.
🎓 Rata-rata Makro: Hitungan rata-rata sederhana (non-tertimbang) metrik setiap label tanpa menghiraukan ketidakseimbangan label.
🎓 Rata-rata Tertimbang: Hitungan rata-rata metrik setiap label dengan mempertimbangkan ketidakseimbangan label. Rata-ratanya tertimbang nilai Dukungan (jumlah kejadian dalam realita) setiap label.
✅ Apa kamu bisa tebak metrik apa yang harus dipantau untuk mengurangi jumlah negatif palsu modelmu?
## Visualisasikan kurva ROC model ini
Ini bukanlah sebuah model buruk. Akurasinya sekitar 80%, jadi sebenarnya bisa digunakan untuk memprediksi warna sebuah labu berdasarkan beberapa variabel.
Mari kita memvisualisasikan datanya sekali lagi untuk melihat nilai ROC ini:
```python
from sklearn.metrics import roc_curve, roc_auc_score
y_scores = model.predict_proba(X_test)
# calculate ROC curve
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])
sns.lineplot([0, 1], [0, 1])
sns.lineplot(fpr, tpr)
```
Menggunakan Seaborn lagi, gambarlah [Receiving Operating Characteristic](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html?highlight=roc) (ROC) model ini. Kurva ROC seringkali digunakan untuk menunjukkan output sebuah pembuat klasifikasi berdasarkan jumlah positif benar dan positif palsunya. "Kurva ROC biasanya menetapkan persentase positif benar di sumbu Y dan positif palsunya di sumbu X" (diterjemahkan). Maka, terjalnya kurva ini dan ruang antara garis titik tengah dan kurvanya penting: kamu mau sebuah kurva yang naik ke atas garisnya secepat mungkin. Dalam kasus ini, ada positif palsu di awal, terus kurvanya naik di atas garisnya dengan benar:
![ROC](./images/ROC.png)
Akhirnya, gunakanlah [API `roc_auc_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html?highlight=roc_auc#sklearn.metrics.roc_auc_score) Scikit-learn untuk menghitung 'Area Di Bawah Kurva'-nya (ADBK) secara persis:
```python
auc = roc_auc_score(y_test,y_scores[:,1])
print(auc)
```
Hasilnya adalah `0.6976998904709748`. Mengingat bahwa ADBK itu antara 0 dan 1, lebih besar ADBK-nya lebih baik sebab ADBK model yang 100% benar terus adalah 1; dalam kasus ini, modelnya _lumayan bagus_.
Nanti dalam pelajaran lebih lanjut tentang klasifikasi, kamu akan belajar bagaimana mengulang untuk membuat nilai-nilai modelmu lebih baik. Tetapi sekian dulu. Selamat! Kamu selesai pelajaran-pelajaran regresi ini!
---
## 🚀 Tantangan
Masih ada banyak tentang regresi logistik! Tetapi cara paling baik adalah untuk bereksperimen. Carilah sebuah *dataset* yang bisa diteliti seperti ini dan bangunlah sebuah model darinya. Apa yang kamu pelajari? Petunjuk: Coba [Kaggle](https://kaggle.com) untuk *dataset-dataset* menarik.
## [Kuis pasca-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/16/)
## Review & Pembelajaran mandiri
Bacalah beberapa halaman pertama [makalah ini dari Stanford](https://web.stanford.edu/~jurafsky/slp3/5.pdf) tentang beberapa penggunaan praktis regresi logistik. Pikirkan tentang tugas-tugas yang lebih baik untuk suatu jenis regresi atau jenis-jenis lainnya yang kita telah pelajari sampai kini. Apa yang akan bekerja paling baik?
## Tugas
[Coba lagi regresi ini](assignment.md)

33
2-Regression/translations/README.id.md
Unescape View File

@ -0,0 +1,33 @@
# Model regresi untuk *machine learning*
## Topik regional: Model regresi untuk harga labu di Amerika Utara 🎃
Di Amerika Utara, labu seringkali diukir menjadi muka-muka seram untuk Halloween. Mari mencari tahu lebih banyak tentang sayur menarik ini!
![jack-o-lantern](./images/jack-o-lanterns.jpg)
> Foto oleh <a href="https://unsplash.com/@teutschmann?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Beth Teutschmann</a> di <a href="https://unsplash.com/s/photos/jack-o-lanterns?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
## Apa yang kamu akan pelajari
Pelajaran-pelajaran dalam seksi ini mencakupi jenis-jenis regresi dalam konteks *machine learning*. Model regresi dapat membantu menentukan _hubungan_ antara variabel-variabel. Model jenis ini dapat memprediksi nilai-nilai seperti panjang, temperatur, atau usia, sehingga mengemukakan hubungan-hubungan antara variabel dengan menganalisis titik-titik data.
Dalam seri pelajaran ini, kamu akan menemukan perbedaan antara regresi linear dan logistik, dan kapan untuk menggunakan satu atau yang lainnya.
Selain itu, kamu akan disiapkan untuk mulai mengerjakan tugas *machine learning*, termasuk mengkonfigurasi Visual Studio Code untuk mengelola *notebook*, lingkungan wajar untuk *data scientist*. Kamu akan menemukan Scikit-learn, sebuah *library* untuk *machine learning*, dan kamu akan membangun model pertamamu dengan memfokus pada model regresi dalam bab ini.
> Ada alat-alat *low-code* yang dapat membantumu belajar tentang bekerja dengan model regresi. Cobalah [Azure ML untuk tugas ini](https://docs.microsoft.com/learn/modules/create-regression-model-azure-machine-learning-designer/?WT.mc_id=academic-15963-cxa).
### Pelajaran
1. [Alat-alat seorang *data scientist*](1-Tools/README.md)
2. [Mengelola data](2-Data/README.md)
3. [Regresi linear dan polinomial](3-Linear/README.md)
4. [Regresi logistik](4-Logistic/README.md)
---
### Kredit
"ML with regression" (ML dengan regresi) ditulis dari ♥️ oleh [Jen Looper](https://twitter.com/jenlooper)
♥️ Kontributor kuis termasuk: [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan) dan [Ornella Altunyan](https://twitter.com/ornelladotcom)
*Dataset* labu disarankan [proyek ini di Kaggle](https://www.kaggle.com/usda/a-year-of-pumpkin-prices) dan datanya disumberkan dari [Specialty Crops Terminal Markets Standard Reports (Laporan Standar Pasar Terminal Tanaman Khusus)](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) yang didistribusikan Departemen Agrikultur Amerika Serikat. Kami telah menambahkan beberapa poin tentang warna berdasarkan jenis labu untuk menormalisasi distribusi data. Data ini terbuka untuk umum (*public domain*).
Write Preview
Loading…
Cancel
Save