Lee Stott
3 weeks ago
committed by
GitHub
parent
fdf8e37752
commit
f6488401b6
@ -1,300 +0,0 @@
|
||||
# Pengenalan kepada klasifikasi
|
||||
|
||||
Dalam empat pelajaran ini, anda akan meneroka fokus asas pembelajaran mesin klasik - _klasifikasi_. Kami akan melalui penggunaan pelbagai algoritma klasifikasi dengan set data tentang semua masakan hebat di Asia dan India. Harap anda lapar!
|
||||
|
||||
|
||||
|
||||
> Raikan masakan pan-Asia dalam pelajaran ini! Imej oleh [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
Klasifikasi adalah satu bentuk [pembelajaran berarah](https://wikipedia.org/wiki/Supervised_learning) yang banyak persamaannya dengan teknik regresi. Jika pembelajaran mesin adalah tentang meramal nilai atau nama kepada sesuatu dengan menggunakan set data, maka klasifikasi umumnya terbahagi kepada dua kumpulan: _klasifikasi binari_ dan _klasifikasi berbilang kelas_.
|
||||
|
||||
[](https://youtu.be/eg8DJYwdMyg "Pengenalan kepada klasifikasi")
|
||||
|
||||
Ingat:
|
||||
|
||||
- **Regresi linear** membantu anda meramal hubungan antara pembolehubah dan membuat ramalan tepat di mana titik data baru akan jatuh dalam hubungan dengan garis tersebut. Jadi, anda boleh meramal _berapa harga labu pada bulan September vs. Disember_, sebagai contoh.
|
||||
- **Regresi logistik** membantu anda menemui "kategori binari": pada titik harga ini, _adakah labu ini oren atau tidak-oren_?
|
||||
|
||||
Klasifikasi menggunakan pelbagai algoritma untuk menentukan cara lain dalam menentukan label atau kelas sesuatu titik data. Mari kita bekerja dengan data masakan ini untuk melihat sama ada, dengan memerhatikan sekumpulan bahan, kita boleh menentukan asal usul masakannya.
|
||||
|
||||
## [Kuiz pra-ceramah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/19/)
|
||||
|
||||
> ### [Pelajaran ini tersedia dalam R!](../../../../4-Classification/1-Introduction/solution/R/lesson_10.html)
|
||||
|
||||
### Pengenalan
|
||||
|
||||
Klasifikasi adalah salah satu aktiviti asas penyelidik pembelajaran mesin dan saintis data. Dari klasifikasi asas nilai binari ("adakah emel ini spam atau tidak?"), kepada klasifikasi dan segmentasi imej yang kompleks menggunakan visi komputer, adalah selalu berguna untuk dapat menyusun data ke dalam kelas dan bertanya soalan mengenainya.
|
||||
|
||||
Untuk menyatakan proses ini dengan cara yang lebih saintifik, kaedah klasifikasi anda mencipta model ramalan yang membolehkan anda memetakan hubungan antara pembolehubah input kepada pembolehubah output.
|
||||
|
||||
|
||||
|
||||
> Masalah binari vs. berbilang kelas untuk algoritma klasifikasi untuk diatasi. Infografik oleh [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
Sebelum memulakan proses membersihkan data, memvisualisasikannya, dan menyiapkannya untuk tugas ML kita, mari kita belajar sedikit tentang pelbagai cara pembelajaran mesin boleh digunakan untuk mengklasifikasikan data.
|
||||
|
||||
Diperoleh daripada [statistik](https://wikipedia.org/wiki/Statistical_classification), klasifikasi menggunakan pembelajaran mesin klasik menggunakan ciri-ciri, seperti `smoker`, `weight`, dan `age` untuk menentukan _kemungkinan mengembangkan penyakit X_. Sebagai teknik pembelajaran berarah yang serupa dengan latihan regresi yang anda lakukan sebelum ini, data anda dilabelkan dan algoritma ML menggunakan label tersebut untuk mengklasifikasikan dan meramal kelas (atau 'ciri-ciri') satu set data dan menetapkannya kepada satu kumpulan atau hasil.
|
||||
|
||||
✅ Luangkan masa sejenak untuk membayangkan set data tentang masakan. Apakah yang boleh dijawab oleh model berbilang kelas? Apakah yang boleh dijawab oleh model binari? Bagaimana jika anda ingin menentukan sama ada sesuatu masakan mungkin menggunakan fenugreek? Bagaimana jika anda ingin melihat jika, dengan pemberian beg runcit penuh dengan bunga lawang, artichoke, kembang kol, dan lobak pedas, anda boleh mencipta hidangan India yang tipikal?
|
||||
|
||||
[](https://youtu.be/GuTeDbaNoEU "Bakul misteri gila")
|
||||
|
||||
> 🎥 Klik imej di atas untuk video. Premis keseluruhan rancangan 'Chopped' adalah 'bakul misteri' di mana chef perlu membuat hidangan daripada pilihan bahan yang rawak. Pasti model ML akan membantu!
|
||||
|
||||
## Hello 'classifier'
|
||||
|
||||
Soalan yang ingin kita tanya tentang set data masakan ini sebenarnya adalah soalan **berbilang kelas**, kerana kita mempunyai beberapa masakan kebangsaan yang berpotensi untuk bekerja dengannya. Diberikan sekumpulan bahan, kelas manakah yang akan data ini sesuai?
|
||||
|
||||
Scikit-learn menawarkan beberapa algoritma yang berbeza untuk digunakan untuk mengklasifikasikan data, bergantung kepada jenis masalah yang anda ingin selesaikan. Dalam dua pelajaran seterusnya, anda akan belajar tentang beberapa algoritma ini.
|
||||
|
||||
## Latihan - bersihkan dan seimbangkan data anda
|
||||
|
||||
Tugas pertama yang perlu dilakukan, sebelum memulakan projek ini, adalah membersihkan dan **mengimbangkan** data anda untuk mendapatkan hasil yang lebih baik. Mulakan dengan fail _notebook.ipynb_ kosong di akar folder ini.
|
||||
|
||||
Perkara pertama yang perlu dipasang adalah [imblearn](https://imbalanced-learn.org/stable/). Ini adalah pakej Scikit-learn yang akan membolehkan anda mengimbangkan data dengan lebih baik (anda akan belajar lebih lanjut tentang tugas ini sebentar lagi).
|
||||
|
||||
1. Untuk memasang `imblearn`, jalankan `pip install`, seperti ini:
|
||||
|
||||
```python
|
||||
pip install imblearn
|
||||
```
|
||||
|
||||
1. Import pakej yang anda perlukan untuk mengimport data anda dan memvisualisasikannya, juga import `SMOTE` dari `imblearn`.
|
||||
|
||||
```python
|
||||
import pandas as pd
|
||||
import matplotlib.pyplot as plt
|
||||
import matplotlib as mpl
|
||||
import numpy as np
|
||||
from imblearn.over_sampling import SMOTE
|
||||
```
|
||||
|
||||
Sekarang anda telah bersedia untuk membaca import data seterusnya.
|
||||
|
||||
1. Tugas seterusnya adalah untuk mengimport data:
|
||||
|
||||
```python
|
||||
df = pd.read_csv('../data/cuisines.csv')
|
||||
```
|
||||
|
||||
Menggunakan `read_csv()` will read the content of the csv file _cusines.csv_ and place it in the variable `df`.
|
||||
|
||||
1. Semak bentuk data:
|
||||
|
||||
```python
|
||||
df.head()
|
||||
```
|
||||
|
||||
Lima baris pertama kelihatan seperti ini:
|
||||
|
||||
```output
|
||||
| | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
|
||||
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
|
||||
| 0 | 65 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 1 | 66 | indian | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 2 | 67 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 3 | 68 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 4 | 69 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
|
||||
```
|
||||
|
||||
1. Dapatkan maklumat tentang data ini dengan memanggil `info()`:
|
||||
|
||||
```python
|
||||
df.info()
|
||||
```
|
||||
|
||||
Output anda kelihatan seperti ini:
|
||||
|
||||
```output
|
||||
<class 'pandas.core.frame.DataFrame'>
|
||||
RangeIndex: 2448 entries, 0 to 2447
|
||||
Columns: 385 entries, Unnamed: 0 to zucchini
|
||||
dtypes: int64(384), object(1)
|
||||
memory usage: 7.2+ MB
|
||||
```
|
||||
|
||||
## Latihan - belajar tentang masakan
|
||||
|
||||
Sekarang kerja mula menjadi lebih menarik. Mari kita temui pengedaran data, per masakan
|
||||
|
||||
1. Plot data sebagai bar dengan memanggil `barh()`:
|
||||
|
||||
```python
|
||||
df.cuisine.value_counts().plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Terdapat bilangan masakan yang terhad, tetapi pengedaran data tidak sekata. Anda boleh membetulkannya! Sebelum berbuat demikian, teroka sedikit lagi.
|
||||
|
||||
1. Ketahui berapa banyak data yang tersedia per masakan dan cetak:
|
||||
|
||||
```python
|
||||
thai_df = df[(df.cuisine == "thai")]
|
||||
japanese_df = df[(df.cuisine == "japanese")]
|
||||
chinese_df = df[(df.cuisine == "chinese")]
|
||||
indian_df = df[(df.cuisine == "indian")]
|
||||
korean_df = df[(df.cuisine == "korean")]
|
||||
|
||||
print(f'thai df: {thai_df.shape}')
|
||||
print(f'japanese df: {japanese_df.shape}')
|
||||
print(f'chinese df: {chinese_df.shape}')
|
||||
print(f'indian df: {indian_df.shape}')
|
||||
print(f'korean df: {korean_df.shape}')
|
||||
```
|
||||
|
||||
output kelihatan seperti ini:
|
||||
|
||||
```output
|
||||
thai df: (289, 385)
|
||||
japanese df: (320, 385)
|
||||
chinese df: (442, 385)
|
||||
indian df: (598, 385)
|
||||
korean df: (799, 385)
|
||||
```
|
||||
|
||||
## Menemui bahan-bahan
|
||||
|
||||
Sekarang anda boleh menggali lebih mendalam ke dalam data dan belajar apakah bahan-bahan tipikal per masakan. Anda harus membersihkan data berulang yang mencipta kekeliruan antara masakan, jadi mari kita belajar tentang masalah ini.
|
||||
|
||||
1. Cipta fungsi `create_ingredient()` dalam Python untuk mencipta dataframe bahan. Fungsi ini akan bermula dengan menjatuhkan lajur yang tidak berguna dan menyusun bahan mengikut kiraannya:
|
||||
|
||||
```python
|
||||
def create_ingredient_df(df):
|
||||
ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
|
||||
ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
|
||||
ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
|
||||
inplace=False)
|
||||
return ingredient_df
|
||||
```
|
||||
|
||||
Sekarang anda boleh menggunakan fungsi itu untuk mendapatkan idea tentang sepuluh bahan paling popular mengikut masakan.
|
||||
|
||||
1. Panggil `create_ingredient()` and plot it calling `barh()`:
|
||||
|
||||
```python
|
||||
thai_ingredient_df = create_ingredient_df(thai_df)
|
||||
thai_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Lakukan perkara yang sama untuk data Jepun:
|
||||
|
||||
```python
|
||||
japanese_ingredient_df = create_ingredient_df(japanese_df)
|
||||
japanese_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Sekarang untuk bahan-bahan Cina:
|
||||
|
||||
```python
|
||||
chinese_ingredient_df = create_ingredient_df(chinese_df)
|
||||
chinese_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Plot bahan-bahan India:
|
||||
|
||||
```python
|
||||
indian_ingredient_df = create_ingredient_df(indian_df)
|
||||
indian_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Akhir sekali, plot bahan-bahan Korea:
|
||||
|
||||
```python
|
||||
korean_ingredient_df = create_ingredient_df(korean_df)
|
||||
korean_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Sekarang, jatuhkan bahan-bahan yang paling biasa yang mencipta kekeliruan antara masakan yang berbeza, dengan memanggil `drop()`:
|
||||
|
||||
Semua orang suka nasi, bawang putih dan halia!
|
||||
|
||||
```python
|
||||
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
|
||||
labels_df = df.cuisine #.unique()
|
||||
feature_df.head()
|
||||
```
|
||||
|
||||
## Imbangkan set data
|
||||
|
||||
Sekarang anda telah membersihkan data, gunakan [SMOTE](https://imbalanced-learn.org/dev/references/generated/imblearn.over_sampling.SMOTE.html) - "Teknik Over-sampling Minoriti Sintetik" - untuk mengimbangkannya.
|
||||
|
||||
1. Panggil `fit_resample()`, strategi ini menjana sampel baru dengan interpolasi.
|
||||
|
||||
```python
|
||||
oversample = SMOTE()
|
||||
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
|
||||
```
|
||||
|
||||
Dengan mengimbangkan data anda, anda akan mendapat hasil yang lebih baik apabila mengklasifikasikannya. Fikirkan tentang klasifikasi binari. Jika kebanyakan data anda adalah satu kelas, model ML akan meramalkan kelas itu dengan lebih kerap, hanya kerana terdapat lebih banyak data untuknya. Mengimbangkan data mengambil sebarang data yang tidak seimbang dan membantu menghilangkan ketidakseimbangan ini.
|
||||
|
||||
1. Sekarang anda boleh menyemak bilangan label per bahan:
|
||||
|
||||
```python
|
||||
print(f'new label count: {transformed_label_df.value_counts()}')
|
||||
print(f'old label count: {df.cuisine.value_counts()}')
|
||||
```
|
||||
|
||||
Output anda kelihatan seperti ini:
|
||||
|
||||
```output
|
||||
new label count: korean 799
|
||||
chinese 799
|
||||
indian 799
|
||||
japanese 799
|
||||
thai 799
|
||||
Name: cuisine, dtype: int64
|
||||
old label count: korean 799
|
||||
indian 598
|
||||
chinese 442
|
||||
japanese 320
|
||||
thai 289
|
||||
Name: cuisine, dtype: int64
|
||||
```
|
||||
|
||||
Data ini kemas dan bersih, seimbang, dan sangat lazat!
|
||||
|
||||
1. Langkah terakhir adalah menyimpan data yang seimbang, termasuk label dan ciri-ciri, ke dalam dataframe baru yang boleh dieksport ke dalam fail:
|
||||
|
||||
```python
|
||||
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
|
||||
```
|
||||
|
||||
1. Anda boleh melihat data sekali lagi menggunakan `transformed_df.head()` and `transformed_df.info()`. Simpan salinan data ini untuk digunakan dalam pelajaran masa depan:
|
||||
|
||||
```python
|
||||
transformed_df.head()
|
||||
transformed_df.info()
|
||||
transformed_df.to_csv("../data/cleaned_cuisines.csv")
|
||||
```
|
||||
|
||||
CSV baru ini kini boleh didapati di folder data akar.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Cabaran
|
||||
|
||||
Kurikulum ini mengandungi beberapa set data yang menarik. Gali melalui folder `data` dan lihat jika ada yang mengandungi set data yang sesuai untuk klasifikasi binari atau berbilang kelas? Apakah soalan yang akan anda tanya tentang set data ini?
|
||||
|
||||
## [Kuiz selepas ceramah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/20/)
|
||||
|
||||
## Ulasan & Kajian Sendiri
|
||||
|
||||
Teroka API SMOTE. Apakah kes penggunaan yang terbaik digunakan? Apakah masalah yang diselesaikannya?
|
||||
|
||||
## Tugasan
|
||||
|
||||
[Teroka kaedah klasifikasi](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,14 +0,0 @@
|
||||
# Terokai kaedah pengelasan
|
||||
|
||||
## Arahan
|
||||
|
||||
Dalam [dokumentasi Scikit-learn](https://scikit-learn.org/stable/supervised_learning.html) anda akan menemui senarai panjang cara untuk mengelas data. Lakukan sedikit pencarian dalam dokumen ini: matlamat anda adalah untuk mencari kaedah pengelasan dan padankan dengan dataset dalam kurikulum ini, soalan yang boleh anda tanyakan mengenainya, dan teknik pengelasan. Buat spreadsheet atau jadual dalam fail .doc dan terangkan bagaimana dataset tersebut akan berfungsi dengan algoritma pengelasan.
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | ----------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| | dokumen disampaikan yang mengandungi 5 algoritma bersama teknik pengelasan. Gambaran keseluruhan dijelaskan dengan baik dan terperinci. | dokumen disampaikan yang mengandungi 3 algoritma bersama teknik pengelasan. Gambaran keseluruhan dijelaskan dengan baik dan terperinci. | dokumen disampaikan yang mengandungi kurang daripada tiga algoritma bersama teknik pengelasan dan gambaran keseluruhan tidak dijelaskan dengan baik atau terperinci. |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,77 +0,0 @@
|
||||
# Pengelasan Masakan 1
|
||||
|
||||
Dalam pelajaran ini, anda akan menggunakan dataset yang anda simpan dari pelajaran terakhir yang penuh dengan data seimbang dan bersih tentang masakan.
|
||||
|
||||
Anda akan menggunakan dataset ini dengan pelbagai pengelas untuk _meramal jenis masakan kebangsaan berdasarkan sekumpulan bahan_. Semasa melakukannya, anda akan mempelajari lebih lanjut tentang beberapa cara algoritma boleh digunakan untuk tugas pengelasan.
|
||||
|
||||
## [Kuiz pra-kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/21/)
|
||||
# Persiapan
|
||||
|
||||
Dengan anggapan anda telah menyelesaikan [Pelajaran 1](../1-Introduction/README.md), pastikan fail _cleaned_cuisines.csv_ wujud di folder root `/data` untuk empat pelajaran ini.
|
||||
|
||||
## Latihan - ramalkan masakan kebangsaan
|
||||
|
||||
1. Bekerja dalam folder _notebook.ipynb_ pelajaran ini, import fail tersebut bersama dengan perpustakaan Pandas:
|
||||
|
||||
```python
|
||||
import pandas as pd
|
||||
cuisines_df = pd.read_csv("../data/cleaned_cuisines.csv")
|
||||
cuisines_df.head()
|
||||
```
|
||||
|
||||
Data kelihatan seperti ini:
|
||||
|
||||
| | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
|
||||
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
|
||||
| 0 | 0 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 1 | 1 | indian | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 2 | 2 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 3 | 3 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 4 | 4 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
|
||||
|
||||
|
||||
1. Sekarang, import beberapa lagi perpustakaan:
|
||||
|
||||
```python
|
||||
from sklearn.linear_model import LogisticRegression
|
||||
from sklearn.model_selection import train_test_split, cross_val_score
|
||||
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
|
||||
from sklearn.svm import SVC
|
||||
import numpy as np
|
||||
```
|
||||
|
||||
1. Bahagikan koordinat X dan y kepada dua dataframe untuk latihan. `cuisine` boleh menjadi dataframe label:
|
||||
|
||||
```python
|
||||
cuisines_label_df = cuisines_df['cuisine']
|
||||
cuisines_label_df.head()
|
||||
```
|
||||
|
||||
Ia akan kelihatan seperti ini:
|
||||
|
||||
```output
|
||||
0 indian
|
||||
1 indian
|
||||
2 indian
|
||||
3 indian
|
||||
4 indian
|
||||
Name: cuisine, dtype: object
|
||||
```
|
||||
|
||||
1. Hapuskan `Unnamed: 0` column and the `cuisine` column, calling `drop()`. Simpan baki data sebagai ciri-ciri yang boleh dilatih:
|
||||
|
||||
```python
|
||||
cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)
|
||||
cuisines_feature_df.head()
|
||||
```
|
||||
|
||||
Ciri-ciri anda kelihatan seperti ini:
|
||||
|
||||
| | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | artemisia | artichoke | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
|
||||
| ---: | -----: | -------: | ----: | ---------: | ----: | -----------: | ------: | -------: | --------: | --------: | ---: | ------: | ----------: | ---------: | ----------------------: | ---: | ---: | ---: | ----: | -----: | -------: |
|
||||
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,12 +0,0 @@
|
||||
# Mengkaji Penyelesai
|
||||
## Arahan
|
||||
|
||||
Dalam pelajaran ini, anda telah mempelajari tentang pelbagai penyelesai yang memadankan algoritma dengan proses pembelajaran mesin untuk mencipta model yang tepat. Telusuri penyelesai yang disenaraikan dalam pelajaran dan pilih dua. Dengan kata-kata anda sendiri, bandingkan dan bezakan dua penyelesai ini. Jenis masalah apa yang mereka selesaikan? Bagaimana mereka bekerja dengan pelbagai struktur data? Mengapa anda akan memilih satu berbanding yang lain?
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Peningkatan |
|
||||
| -------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------ | ---------------------------- |
|
||||
| | Fail .doc disampaikan dengan dua perenggan, satu untuk setiap penyelesai, membandingkan mereka dengan teliti. | Fail .doc disampaikan dengan hanya satu perenggan | Tugasan tidak lengkap |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,238 +0,0 @@
|
||||
# Pengelasan Masakan 2
|
||||
|
||||
Dalam pelajaran pengelasan kedua ini, anda akan meneroka lebih banyak cara untuk mengelaskan data numerik. Anda juga akan belajar tentang kesan memilih satu pengelas berbanding yang lain.
|
||||
|
||||
## [Kuiz Pra-Kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/23/)
|
||||
|
||||
### Prasyarat
|
||||
|
||||
Kami menganggap bahawa anda telah menyelesaikan pelajaran sebelumnya dan mempunyai dataset yang dibersihkan dalam folder `data` anda yang dinamakan _cleaned_cuisines.csv_ di akar folder 4-pelajaran ini.
|
||||
|
||||
### Persiapan
|
||||
|
||||
Kami telah memuatkan fail _notebook.ipynb_ anda dengan dataset yang dibersihkan dan telah membahagikannya kepada dataframe X dan y, siap untuk proses pembinaan model.
|
||||
|
||||
## Peta pengelasan
|
||||
|
||||
Sebelumnya, anda telah belajar tentang pelbagai pilihan yang anda miliki ketika mengelaskan data menggunakan helaian cheat Microsoft. Scikit-learn menawarkan helaian cheat yang serupa tetapi lebih terperinci yang dapat membantu mempersempit pemilihan penganggar anda (istilah lain untuk pengelas):
|
||||
|
||||
|
||||
> Tip: [kunjungi peta ini secara online](https://scikit-learn.org/stable/tutorial/machine_learning_map/) dan klik sepanjang jalan untuk membaca dokumentasi.
|
||||
|
||||
### Pelan
|
||||
|
||||
Peta ini sangat membantu apabila anda mempunyai pemahaman yang jelas tentang data anda, kerana anda boleh 'berjalan' sepanjang jalannya untuk membuat keputusan:
|
||||
|
||||
- Kami mempunyai >50 sampel
|
||||
- Kami ingin meramalkan kategori
|
||||
- Kami mempunyai data yang berlabel
|
||||
- Kami mempunyai kurang dari 100K sampel
|
||||
- ✨ Kami boleh memilih Linear SVC
|
||||
- Jika itu tidak berfungsi, kerana kami mempunyai data numerik
|
||||
- Kami boleh mencuba ✨ KNeighbors Classifier
|
||||
- Jika itu tidak berfungsi, cuba ✨ SVC dan ✨ Ensemble Classifiers
|
||||
|
||||
Ini adalah jalan yang sangat membantu untuk diikuti.
|
||||
|
||||
## Latihan - bahagikan data
|
||||
|
||||
Mengikuti jalan ini, kita harus memulakan dengan mengimport beberapa perpustakaan untuk digunakan.
|
||||
|
||||
1. Import perpustakaan yang diperlukan:
|
||||
|
||||
```python
|
||||
from sklearn.neighbors import KNeighborsClassifier
|
||||
from sklearn.linear_model import LogisticRegression
|
||||
from sklearn.svm import SVC
|
||||
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
|
||||
from sklearn.model_selection import train_test_split, cross_val_score
|
||||
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
|
||||
import numpy as np
|
||||
```
|
||||
|
||||
1. Bahagikan data latihan dan ujian anda:
|
||||
|
||||
```python
|
||||
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
|
||||
```
|
||||
|
||||
## Pengelas Linear SVC
|
||||
|
||||
Support-Vector clustering (SVC) adalah sebahagian daripada keluarga teknik ML Support-Vector machines (pelajari lebih lanjut mengenai ini di bawah). Dalam kaedah ini, anda boleh memilih 'kernel' untuk menentukan bagaimana mengelompokkan label. Parameter 'C' merujuk kepada 'regularization' yang mengatur pengaruh parameter. Kernel boleh menjadi salah satu dari [beberapa](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); di sini kita menetapkannya kepada 'linear' untuk memastikan kita memanfaatkan linear SVC. Kebarangkalian secara default adalah 'false'; di sini kita menetapkannya kepada 'true' untuk mengumpulkan anggaran kebarangkalian. Kami menetapkan keadaan rawak kepada '0' untuk mengocok data untuk mendapatkan kebarangkalian.
|
||||
|
||||
### Latihan - gunakan linear SVC
|
||||
|
||||
Mulakan dengan mencipta array pengelas. Anda akan menambah secara progresif ke dalam array ini semasa kita menguji.
|
||||
|
||||
1. Mulakan dengan Linear SVC:
|
||||
|
||||
```python
|
||||
C = 10
|
||||
# Create different classifiers.
|
||||
classifiers = {
|
||||
'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
|
||||
}
|
||||
```
|
||||
|
||||
2. Latih model anda menggunakan Linear SVC dan cetak laporan:
|
||||
|
||||
```python
|
||||
n_classifiers = len(classifiers)
|
||||
|
||||
for index, (name, classifier) in enumerate(classifiers.items()):
|
||||
classifier.fit(X_train, np.ravel(y_train))
|
||||
|
||||
y_pred = classifier.predict(X_test)
|
||||
accuracy = accuracy_score(y_test, y_pred)
|
||||
print("Accuracy (train) for %s: %0.1f%% " % (name, accuracy * 100))
|
||||
print(classification_report(y_test,y_pred))
|
||||
```
|
||||
|
||||
Hasilnya agak baik:
|
||||
|
||||
```output
|
||||
Accuracy (train) for Linear SVC: 78.6%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.71 0.67 0.69 242
|
||||
indian 0.88 0.86 0.87 234
|
||||
japanese 0.79 0.74 0.76 254
|
||||
korean 0.85 0.81 0.83 242
|
||||
thai 0.71 0.86 0.78 227
|
||||
|
||||
accuracy 0.79 1199
|
||||
macro avg 0.79 0.79 0.79 1199
|
||||
weighted avg 0.79 0.79 0.79 1199
|
||||
```
|
||||
|
||||
## Pengelas K-Neighbors
|
||||
|
||||
K-Neighbors adalah sebahagian daripada keluarga kaedah ML "neighbors", yang boleh digunakan untuk pembelajaran yang diselia dan tidak diselia. Dalam kaedah ini, sejumlah titik yang telah ditetapkan dibuat dan data dikumpulkan di sekitar titik-titik ini supaya label yang digeneralisasi dapat diramalkan untuk data tersebut.
|
||||
|
||||
### Latihan - gunakan pengelas K-Neighbors
|
||||
|
||||
Pengelas sebelumnya bagus, dan berfungsi dengan baik dengan data, tetapi mungkin kita boleh mendapatkan ketepatan yang lebih baik. Cuba pengelas K-Neighbors.
|
||||
|
||||
1. Tambahkan satu baris ke array pengelas anda (tambahkan koma selepas item Linear SVC):
|
||||
|
||||
```python
|
||||
'KNN classifier': KNeighborsClassifier(C),
|
||||
```
|
||||
|
||||
Hasilnya sedikit lebih buruk:
|
||||
|
||||
```output
|
||||
Accuracy (train) for KNN classifier: 73.8%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.64 0.67 0.66 242
|
||||
indian 0.86 0.78 0.82 234
|
||||
japanese 0.66 0.83 0.74 254
|
||||
korean 0.94 0.58 0.72 242
|
||||
thai 0.71 0.82 0.76 227
|
||||
|
||||
accuracy 0.74 1199
|
||||
macro avg 0.76 0.74 0.74 1199
|
||||
weighted avg 0.76 0.74 0.74 1199
|
||||
```
|
||||
|
||||
✅ Pelajari tentang [K-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors)
|
||||
|
||||
## Pengelas Support Vector
|
||||
|
||||
Pengelas Support-Vector adalah sebahagian daripada keluarga [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine) kaedah ML yang digunakan untuk tugas pengelasan dan regresi. SVMs "memetakan contoh latihan kepada titik di ruang" untuk memaksimumkan jarak antara dua kategori. Data seterusnya dipetakan ke dalam ruang ini supaya kategori mereka dapat diramalkan.
|
||||
|
||||
### Latihan - gunakan pengelas Support Vector
|
||||
|
||||
Mari cuba mendapatkan ketepatan yang sedikit lebih baik dengan pengelas Support Vector.
|
||||
|
||||
1. Tambahkan koma selepas item K-Neighbors, dan kemudian tambahkan baris ini:
|
||||
|
||||
```python
|
||||
'SVC': SVC(),
|
||||
```
|
||||
|
||||
Hasilnya sangat baik!
|
||||
|
||||
```output
|
||||
Accuracy (train) for SVC: 83.2%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.79 0.74 0.76 242
|
||||
indian 0.88 0.90 0.89 234
|
||||
japanese 0.87 0.81 0.84 254
|
||||
korean 0.91 0.82 0.86 242
|
||||
thai 0.74 0.90 0.81 227
|
||||
|
||||
accuracy 0.83 1199
|
||||
macro avg 0.84 0.83 0.83 1199
|
||||
weighted avg 0.84 0.83 0.83 1199
|
||||
```
|
||||
|
||||
✅ Pelajari tentang [Support-Vectors](https://scikit-learn.org/stable/modules/svm.html#svm)
|
||||
|
||||
## Pengelas Ensemble
|
||||
|
||||
Mari ikuti jalan ini hingga ke akhir, walaupun ujian sebelumnya cukup baik. Mari cuba beberapa 'Pengelas Ensemble', khususnya Random Forest dan AdaBoost:
|
||||
|
||||
```python
|
||||
'RFST': RandomForestClassifier(n_estimators=100),
|
||||
'ADA': AdaBoostClassifier(n_estimators=100)
|
||||
```
|
||||
|
||||
Hasilnya sangat baik, terutama untuk Random Forest:
|
||||
|
||||
```output
|
||||
Accuracy (train) for RFST: 84.5%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.80 0.77 0.78 242
|
||||
indian 0.89 0.92 0.90 234
|
||||
japanese 0.86 0.84 0.85 254
|
||||
korean 0.88 0.83 0.85 242
|
||||
thai 0.80 0.87 0.83 227
|
||||
|
||||
accuracy 0.84 1199
|
||||
macro avg 0.85 0.85 0.84 1199
|
||||
weighted avg 0.85 0.84 0.84 1199
|
||||
|
||||
Accuracy (train) for ADA: 72.4%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.64 0.49 0.56 242
|
||||
indian 0.91 0.83 0.87 234
|
||||
japanese 0.68 0.69 0.69 254
|
||||
korean 0.73 0.79 0.76 242
|
||||
thai 0.67 0.83 0.74 227
|
||||
|
||||
accuracy 0.72 1199
|
||||
macro avg 0.73 0.73 0.72 1199
|
||||
weighted avg 0.73 0.72 0.72 1199
|
||||
```
|
||||
|
||||
✅ Pelajari tentang [Pengelas Ensemble](https://scikit-learn.org/stable/modules/ensemble.html)
|
||||
|
||||
Kaedah Pembelajaran Mesin ini "menggabungkan ramalan beberapa penganggar asas" untuk meningkatkan kualiti model. Dalam contoh kita, kita menggunakan Random Trees dan AdaBoost.
|
||||
|
||||
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), kaedah purata, membina 'hutan' 'pokok keputusan' yang disuntik dengan kebetulan untuk mengelakkan overfitting. Parameter n_estimators ditetapkan kepada jumlah pokok.
|
||||
|
||||
- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) memadankan pengelas ke dataset dan kemudian memadankan salinan pengelas tersebut ke dataset yang sama. Ia memberi tumpuan kepada berat item yang salah dikelaskan dan menyesuaikan padanan untuk pengelas seterusnya untuk membetulkan.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Cabaran
|
||||
|
||||
Setiap teknik ini mempunyai sejumlah besar parameter yang boleh anda ubah. Kajilah parameter default masing-masing dan fikirkan apa yang akan berlaku jika parameter ini diubah untuk kualiti model.
|
||||
|
||||
## [Kuiz Pasca-Kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/24/)
|
||||
|
||||
## Ulasan & Kajian Sendiri
|
||||
|
||||
Terdapat banyak jargon dalam pelajaran ini, jadi luangkan masa sebentar untuk menyemak [senarai ini](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) istilah yang berguna!
|
||||
|
||||
## Tugasan
|
||||
|
||||
[Parameter play](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,14 +0,0 @@
|
||||
# Parameter Play
|
||||
|
||||
## Arahan
|
||||
|
||||
Terdapat banyak parameter yang ditetapkan secara default apabila bekerja dengan pengklasifikasi ini. Intellisense dalam VS Code boleh membantu anda menggali ke dalamnya. Gunakan salah satu Teknik Pengelasan ML dalam pelajaran ini dan latih semula model dengan menyesuaikan pelbagai nilai parameter. Bina sebuah notebook yang menerangkan mengapa beberapa perubahan membantu kualiti model sementara yang lain merosakkannya. Berikan jawapan anda dengan terperinci.
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- | ----------------------------- |
|
||||
| | Sebuah notebook dipersembahkan dengan pengklasifikasi yang dibina sepenuhnya dan parameternya disesuaikan serta perubahan dijelaskan dalam kotak teks | Sebuah notebook dipersembahkan sebahagian atau dijelaskan dengan lemah | Sebuah notebook yang bermasalah atau cacat |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesalahan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,317 +0,0 @@
|
||||
# Bina Aplikasi Web Pencadang Masakan
|
||||
|
||||
Dalam pelajaran ini, anda akan membina model klasifikasi menggunakan beberapa teknik yang telah anda pelajari dalam pelajaran sebelumnya dan dengan dataset masakan yang lazat yang digunakan sepanjang siri ini. Selain itu, anda akan membina aplikasi web kecil untuk menggunakan model yang disimpan, memanfaatkan runtime web Onnx.
|
||||
|
||||
Salah satu kegunaan praktikal pembelajaran mesin yang paling berguna adalah membina sistem cadangan, dan anda boleh mengambil langkah pertama ke arah itu hari ini!
|
||||
|
||||
[](https://youtu.be/17wdM9AHMfg "Applied ML")
|
||||
|
||||
> 🎥 Klik gambar di atas untuk video: Jen Looper membina aplikasi web menggunakan data masakan yang diklasifikasikan
|
||||
|
||||
## [Kuiz pra-kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/25/)
|
||||
|
||||
Dalam pelajaran ini, anda akan belajar:
|
||||
|
||||
- Cara membina model dan menyimpannya sebagai model Onnx
|
||||
- Cara menggunakan Netron untuk memeriksa model
|
||||
- Cara menggunakan model anda dalam aplikasi web untuk inferens
|
||||
|
||||
## Bina model anda
|
||||
|
||||
Membina sistem ML yang diterapkan adalah bahagian penting dalam memanfaatkan teknologi ini untuk sistem perniagaan anda. Anda boleh menggunakan model dalam aplikasi web anda (dan dengan itu menggunakannya dalam konteks luar talian jika diperlukan) dengan menggunakan Onnx.
|
||||
|
||||
Dalam [pelajaran sebelumnya](../../3-Web-App/1-Web-App/README.md), anda telah membina model Regresi tentang penampakan UFO, "dipickle" dan menggunakannya dalam aplikasi Flask. Walaupun seni bina ini sangat berguna untuk diketahui, ia adalah aplikasi Python full-stack, dan keperluan anda mungkin termasuk penggunaan aplikasi JavaScript.
|
||||
|
||||
Dalam pelajaran ini, anda boleh membina sistem asas berasaskan JavaScript untuk inferens. Pertama, bagaimanapun, anda perlu melatih model dan menukarnya untuk digunakan dengan Onnx.
|
||||
|
||||
## Latihan - latih model klasifikasi
|
||||
|
||||
Pertama, latih model klasifikasi menggunakan dataset masakan yang telah dibersihkan yang kita gunakan.
|
||||
|
||||
1. Mulakan dengan mengimport perpustakaan yang berguna:
|
||||
|
||||
```python
|
||||
!pip install skl2onnx
|
||||
import pandas as pd
|
||||
```
|
||||
|
||||
Anda memerlukan '[skl2onnx](https://onnx.ai/sklearn-onnx/)' untuk membantu menukar model Scikit-learn anda kepada format Onnx.
|
||||
|
||||
1. Kemudian, bekerja dengan data anda dengan cara yang sama seperti yang anda lakukan dalam pelajaran sebelumnya, dengan membaca fail CSV menggunakan `read_csv()`:
|
||||
|
||||
```python
|
||||
data = pd.read_csv('../data/cleaned_cuisines.csv')
|
||||
data.head()
|
||||
```
|
||||
|
||||
1. Keluarkan dua lajur pertama yang tidak diperlukan dan simpan data yang tinggal sebagai 'X':
|
||||
|
||||
```python
|
||||
X = data.iloc[:,2:]
|
||||
X.head()
|
||||
```
|
||||
|
||||
1. Simpan label sebagai 'y':
|
||||
|
||||
```python
|
||||
y = data[['cuisine']]
|
||||
y.head()
|
||||
|
||||
```
|
||||
|
||||
### Mulakan rutin latihan
|
||||
|
||||
Kami akan menggunakan perpustakaan 'SVC' yang mempunyai ketepatan yang baik.
|
||||
|
||||
1. Import perpustakaan yang sesuai dari Scikit-learn:
|
||||
|
||||
```python
|
||||
from sklearn.model_selection import train_test_split
|
||||
from sklearn.svm import SVC
|
||||
from sklearn.model_selection import cross_val_score
|
||||
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report
|
||||
```
|
||||
|
||||
1. Pisahkan set latihan dan ujian:
|
||||
|
||||
```python
|
||||
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3)
|
||||
```
|
||||
|
||||
1. Bina model Klasifikasi SVC seperti yang anda lakukan dalam pelajaran sebelumnya:
|
||||
|
||||
```python
|
||||
model = SVC(kernel='linear', C=10, probability=True,random_state=0)
|
||||
model.fit(X_train,y_train.values.ravel())
|
||||
```
|
||||
|
||||
1. Sekarang, uji model anda, memanggil `predict()`:
|
||||
|
||||
```python
|
||||
y_pred = model.predict(X_test)
|
||||
```
|
||||
|
||||
1. Cetak laporan klasifikasi untuk memeriksa kualiti model:
|
||||
|
||||
```python
|
||||
print(classification_report(y_test,y_pred))
|
||||
```
|
||||
|
||||
Seperti yang kita lihat sebelum ini, ketepatan adalah baik:
|
||||
|
||||
```output
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.72 0.69 0.70 257
|
||||
indian 0.91 0.87 0.89 243
|
||||
japanese 0.79 0.77 0.78 239
|
||||
korean 0.83 0.79 0.81 236
|
||||
thai 0.72 0.84 0.78 224
|
||||
|
||||
accuracy 0.79 1199
|
||||
macro avg 0.79 0.79 0.79 1199
|
||||
weighted avg 0.79 0.79 0.79 1199
|
||||
```
|
||||
|
||||
### Tukar model anda kepada Onnx
|
||||
|
||||
Pastikan untuk melakukan penukaran dengan nombor Tensor yang betul. Dataset ini mempunyai 380 bahan yang disenaraikan, jadi anda perlu mencatatkan nombor itu dalam `FloatTensorType`:
|
||||
|
||||
1. Tukar menggunakan nombor tensor 380.
|
||||
|
||||
```python
|
||||
from skl2onnx import convert_sklearn
|
||||
from skl2onnx.common.data_types import FloatTensorType
|
||||
|
||||
initial_type = [('float_input', FloatTensorType([None, 380]))]
|
||||
options = {id(model): {'nocl': True, 'zipmap': False}}
|
||||
```
|
||||
|
||||
1. Buat onx dan simpan sebagai fail **model.onnx**:
|
||||
|
||||
```python
|
||||
onx = convert_sklearn(model, initial_types=initial_type, options=options)
|
||||
with open("./model.onnx", "wb") as f:
|
||||
f.write(onx.SerializeToString())
|
||||
```
|
||||
|
||||
> Perhatikan, anda boleh memasukkan [pilihan](https://onnx.ai/sklearn-onnx/parameterized.html) dalam skrip penukaran anda. Dalam kes ini, kami memasukkan 'nocl' untuk menjadi Benar dan 'zipmap' untuk menjadi Palsu. Oleh kerana ini adalah model klasifikasi, anda mempunyai pilihan untuk mengeluarkan ZipMap yang menghasilkan senarai kamus (tidak diperlukan). `nocl` refers to class information being included in the model. Reduce your model's size by setting `nocl` to 'True'.
|
||||
|
||||
Running the entire notebook will now build an Onnx model and save it to this folder.
|
||||
|
||||
## View your model
|
||||
|
||||
Onnx models are not very visible in Visual Studio code, but there's a very good free software that many researchers use to visualize the model to ensure that it is properly built. Download [Netron](https://github.com/lutzroeder/Netron) and open your model.onnx file. You can see your simple model visualized, with its 380 inputs and classifier listed:
|
||||
|
||||
|
||||
|
||||
Netron is a helpful tool to view your models.
|
||||
|
||||
Now you are ready to use this neat model in a web app. Let's build an app that will come in handy when you look in your refrigerator and try to figure out which combination of your leftover ingredients you can use to cook a given cuisine, as determined by your model.
|
||||
|
||||
## Build a recommender web application
|
||||
|
||||
You can use your model directly in a web app. This architecture also allows you to run it locally and even offline if needed. Start by creating an `index.html` file in the same folder where you stored your `model.onnx` fail.
|
||||
|
||||
1. Dalam fail ini _index.html_, tambahkan markup berikut:
|
||||
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<header>
|
||||
<title>Cuisine Matcher</title>
|
||||
</header>
|
||||
<body>
|
||||
...
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
|
||||
1. Sekarang, bekerja dalam tag `body`, tambahkan sedikit markup untuk menunjukkan senarai kotak semak yang mencerminkan beberapa bahan:
|
||||
|
||||
```html
|
||||
<h1>Check your refrigerator. What can you create?</h1>
|
||||
<div id="wrapper">
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="4" class="checkbox">
|
||||
<label>apple</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="247" class="checkbox">
|
||||
<label>pear</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="77" class="checkbox">
|
||||
<label>cherry</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="126" class="checkbox">
|
||||
<label>fenugreek</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="302" class="checkbox">
|
||||
<label>sake</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="327" class="checkbox">
|
||||
<label>soy sauce</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="112" class="checkbox">
|
||||
<label>cumin</label>
|
||||
</div>
|
||||
</div>
|
||||
<div style="padding-top:10px">
|
||||
<button onClick="startInference()">What kind of cuisine can you make?</button>
|
||||
</div>
|
||||
```
|
||||
|
||||
Perhatikan bahawa setiap kotak semak diberi nilai. Ini mencerminkan indeks di mana bahan itu ditemui mengikut dataset. Epal, sebagai contoh, dalam senarai abjad ini, menduduki lajur kelima, jadi nilainya adalah '4' kerana kita mula mengira pada 0. Anda boleh merujuk kepada [lembaran ramuan](../../../../4-Classification/data/ingredient_indexes.csv) untuk mengetahui indeks bahan tertentu.
|
||||
|
||||
Meneruskan kerja anda dalam fail index.html, tambahkan blok skrip di mana model dipanggil selepas penutupan akhir `</div>`.
|
||||
|
||||
1. Pertama, import [Onnx Runtime](https://www.onnxruntime.ai/):
|
||||
|
||||
```html
|
||||
<script src="https://cdn.jsdelivr.net/npm/onnxruntime-web@1.9.0/dist/ort.min.js"></script>
|
||||
```
|
||||
|
||||
> Onnx Runtime digunakan untuk membolehkan menjalankan model Onnx anda di pelbagai platform perkakasan, termasuk pengoptimuman dan API untuk digunakan.
|
||||
|
||||
1. Setelah Runtime ada, anda boleh memanggilnya:
|
||||
|
||||
```html
|
||||
<script>
|
||||
const ingredients = Array(380).fill(0);
|
||||
|
||||
const checks = [...document.querySelectorAll('.checkbox')];
|
||||
|
||||
checks.forEach(check => {
|
||||
check.addEventListener('change', function() {
|
||||
// toggle the state of the ingredient
|
||||
// based on the checkbox's value (1 or 0)
|
||||
ingredients[check.value] = check.checked ? 1 : 0;
|
||||
});
|
||||
});
|
||||
|
||||
function testCheckboxes() {
|
||||
// validate if at least one checkbox is checked
|
||||
return checks.some(check => check.checked);
|
||||
}
|
||||
|
||||
async function startInference() {
|
||||
|
||||
let atLeastOneChecked = testCheckboxes()
|
||||
|
||||
if (!atLeastOneChecked) {
|
||||
alert('Please select at least one ingredient.');
|
||||
return;
|
||||
}
|
||||
try {
|
||||
// create a new session and load the model.
|
||||
|
||||
const session = await ort.InferenceSession.create('./model.onnx');
|
||||
|
||||
const input = new ort.Tensor(new Float32Array(ingredients), [1, 380]);
|
||||
const feeds = { float_input: input };
|
||||
|
||||
// feed inputs and run
|
||||
const results = await session.run(feeds);
|
||||
|
||||
// read from results
|
||||
alert('You can enjoy ' + results.label.data[0] + ' cuisine today!')
|
||||
|
||||
} catch (e) {
|
||||
console.log(`failed to inference ONNX model`);
|
||||
console.error(e);
|
||||
}
|
||||
}
|
||||
|
||||
</script>
|
||||
```
|
||||
|
||||
Dalam kod ini, terdapat beberapa perkara yang berlaku:
|
||||
|
||||
1. Anda mencipta array 380 nilai yang mungkin (1 atau 0) untuk ditetapkan dan dihantar ke model untuk inferens, bergantung pada sama ada kotak semak bahan dicentang.
|
||||
2. Anda mencipta array kotak semak dan cara untuk menentukan sama ada mereka dicentang dalam `init` function that is called when the application starts. When a checkbox is checked, the `ingredients` array is altered to reflect the chosen ingredient.
|
||||
3. You created a `testCheckboxes` function that checks whether any checkbox was checked.
|
||||
4. You use `startInference` function when the button is pressed and, if any checkbox is checked, you start inference.
|
||||
5. The inference routine includes:
|
||||
1. Setting up an asynchronous load of the model
|
||||
2. Creating a Tensor structure to send to the model
|
||||
3. Creating 'feeds' that reflects the `float_input` input that you created when training your model (you can use Netron to verify that name)
|
||||
4. Sending these 'feeds' to the model and waiting for a response
|
||||
|
||||
## Test your application
|
||||
|
||||
Open a terminal session in Visual Studio Code in the folder where your index.html file resides. Ensure that you have [http-server](https://www.npmjs.com/package/http-server) installed globally, and type `http-server` pada arahan. Sebuah localhost harus dibuka dan anda boleh melihat aplikasi web anda. Periksa apa masakan yang disarankan berdasarkan pelbagai bahan:
|
||||
|
||||
|
||||
|
||||
Tahniah, anda telah mencipta aplikasi web 'cadangan' dengan beberapa medan. Luangkan sedikit masa untuk membina sistem ini!
|
||||
## 🚀Cabaran
|
||||
|
||||
Aplikasi web anda sangat minimal, jadi teruskan membina dengan menggunakan bahan dan indeks mereka dari data [ingredient_indexes](../../../../4-Classification/data/ingredient_indexes.csv). Kombinasi rasa apa yang berfungsi untuk mencipta hidangan kebangsaan tertentu?
|
||||
|
||||
## [Kuiz pasca-kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/26/)
|
||||
|
||||
## Ulasan & Kajian Kendiri
|
||||
|
||||
Walaupun pelajaran ini hanya menyentuh tentang kegunaan mencipta sistem cadangan untuk bahan makanan, kawasan aplikasi ML ini sangat kaya dengan contoh. Baca lebih lanjut tentang bagaimana sistem ini dibina:
|
||||
|
||||
- https://www.sciencedirect.com/topics/computer-science/recommendation-engine
|
||||
- https://www.technologyreview.com/2014/08/25/171547/the-ultimate-challenge-for-recommendation-engines/
|
||||
- https://www.technologyreview.com/2015/03/23/168831/everything-is-a-recommendation/
|
||||
|
||||
## Tugasan
|
||||
|
||||
[Bina cadangan baru](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber berwibawa. Untuk maklumat penting, terjemahan manusia profesional disarankan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,14 +0,0 @@
|
||||
# Bina Pencadang
|
||||
|
||||
## Arahan
|
||||
|
||||
Berdasarkan latihan dalam pelajaran ini, anda kini tahu cara membina aplikasi web berasaskan JavaScript menggunakan Onnx Runtime dan model Onnx yang ditukar. Cuba bina pencadang baru menggunakan data dari pelajaran ini atau sumber lain (sila berikan kredit). Anda mungkin mencipta pencadang haiwan peliharaan berdasarkan pelbagai atribut personaliti, atau pencadang genre muzik berdasarkan mood seseorang. Jadilah kreatif!
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | --------------------------------------------------------------------- | ------------------------------------- | --------------------------------- |
|
||||
| | Aplikasi web dan buku nota disediakan, kedua-duanya didokumentasikan dengan baik dan berfungsi | Salah satu daripadanya hilang atau mempunyai kelemahan | Kedua-duanya sama ada hilang atau mempunyai kelemahan |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab ke atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,30 +0,0 @@
|
||||
# Memulakan dengan klasifikasi
|
||||
|
||||
## Topik serantau: Masakan Asia dan India yang Lazat 🍜
|
||||
|
||||
Di Asia dan India, tradisi makanan sangat pelbagai dan sangat lazat! Mari kita lihat data tentang masakan serantau untuk cuba memahami bahan-bahan mereka.
|
||||
|
||||
|
||||
> Foto oleh <a href="https://unsplash.com/@changlisheng?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Lisheng Chang</a> di <a href="https://unsplash.com/s/photos/asian-food?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## Apa yang anda akan pelajari
|
||||
|
||||
Dalam bahagian ini, anda akan membina dari kajian awal anda tentang Regresi dan belajar tentang pengklasifikasi lain yang boleh anda gunakan untuk memahami data dengan lebih baik.
|
||||
|
||||
> Terdapat alat low-code yang berguna yang boleh membantu anda belajar tentang bekerja dengan model klasifikasi. Cuba [Azure ML untuk tugas ini](https://docs.microsoft.com/learn/modules/create-classification-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
|
||||
|
||||
## Pelajaran
|
||||
|
||||
1. [Pengenalan kepada klasifikasi](1-Introduction/README.md)
|
||||
2. [Lebih banyak pengklasifikasi](2-Classifiers-1/README.md)
|
||||
3. [Pengklasifikasi lain](3-Classifiers-2/README.md)
|
||||
4. [ML Terapan: bina aplikasi web](4-Applied/README.md)
|
||||
|
||||
## Kredit
|
||||
|
||||
"Memulakan dengan klasifikasi" ditulis dengan ♥️ oleh [Cassie Breviu](https://www.twitter.com/cassiebreviu) dan [Jen Looper](https://www.twitter.com/jenlooper)
|
||||
|
||||
Dataset masakan lazat diperoleh dari [Kaggle](https://www.kaggle.com/hoandan/asian-and-indian-cuisines).
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab ke atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,218 +0,0 @@
|
||||
# Pengenalan kepada pengelompokan
|
||||
|
||||
Pegelompokan adalah sejenis [Pembelajaran Tanpa Pengawasan](https://wikipedia.org/wiki/Unsupervised_learning) yang menganggap bahawa satu set data tidak dilabel atau inputnya tidak dipadankan dengan output yang telah ditetapkan. Ia menggunakan pelbagai algoritma untuk menyusun data yang tidak dilabel dan menyediakan pengelompokan mengikut corak yang ditemui dalam data tersebut.
|
||||
|
||||
[](https://youtu.be/ty2advRiWJM "No One Like You oleh PSquare")
|
||||
|
||||
> 🎥 Klik gambar di atas untuk video. Semasa anda mempelajari pembelajaran mesin dengan pengelompokan, nikmati beberapa lagu Dance Hall Nigeria - ini adalah lagu yang sangat dihargai dari tahun 2014 oleh PSquare.
|
||||
## [Kuiz sebelum kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/27/)
|
||||
### Pengenalan
|
||||
|
||||
[Pegelompokan](https://link.springer.com/referenceworkentry/10.1007%2F978-0-387-30164-8_124) sangat berguna untuk penerokaan data. Mari kita lihat jika ia dapat membantu menemui tren dan corak dalam cara penonton Nigeria menikmati muzik.
|
||||
|
||||
✅ Luangkan masa sebentar untuk memikirkan kegunaan pengelompokan. Dalam kehidupan sebenar, pengelompokan berlaku setiap kali anda mempunyai timbunan pakaian dan perlu menyusun pakaian ahli keluarga anda 🧦👕👖🩲. Dalam sains data, pengelompokan berlaku apabila cuba menganalisis pilihan pengguna, atau menentukan ciri-ciri mana-mana set data yang tidak dilabel. Pengelompokan, dalam cara tertentu, membantu memahami kekacauan, seperti laci stokin.
|
||||
|
||||
[](https://youtu.be/esmzYhuFnds "Pengenalan kepada Pengelompokan")
|
||||
|
||||
> 🎥 Klik gambar di atas untuk video: John Guttag dari MIT memperkenalkan pengelompokan
|
||||
|
||||
Dalam suasana profesional, pengelompokan boleh digunakan untuk menentukan perkara seperti segmentasi pasaran, menentukan kumpulan umur yang membeli barangan tertentu, sebagai contoh. Kegunaan lain mungkin adalah pengesanan anomali, mungkin untuk mengesan penipuan daripada set data transaksi kad kredit. Atau anda mungkin menggunakan pengelompokan untuk menentukan tumor dalam sekumpulan imbasan perubatan.
|
||||
|
||||
✅ Fikir sebentar tentang bagaimana anda mungkin pernah menemui pengelompokan 'di alam liar', dalam perbankan, e-dagang, atau perniagaan.
|
||||
|
||||
> 🎓 Menariknya, analisis pengelompokan berasal dari bidang Antropologi dan Psikologi pada tahun 1930-an. Bolehkah anda bayangkan bagaimana ia mungkin digunakan?
|
||||
|
||||
Sebagai alternatif, anda boleh menggunakannya untuk mengelompokkan hasil carian - melalui pautan membeli-belah, imej, atau ulasan, sebagai contoh. Pengelompokan berguna apabila anda mempunyai set data yang besar yang anda ingin kurangkan dan di mana anda ingin melakukan analisis yang lebih terperinci, jadi teknik ini boleh digunakan untuk mempelajari tentang data sebelum model lain dibina.
|
||||
|
||||
✅ Setelah data anda disusun dalam kelompok, anda memberikan Id kelompok kepadanya, dan teknik ini boleh berguna apabila mengekalkan privasi set data; anda boleh merujuk kepada titik data dengan id kelompoknya, dan bukannya dengan data yang lebih mendedahkan. Bolehkah anda memikirkan sebab-sebab lain mengapa anda akan merujuk kepada Id kelompok dan bukannya elemen lain dalam kelompok untuk mengenalpastinya?
|
||||
|
||||
Mendalami pemahaman anda tentang teknik pengelompokan dalam [modul Pembelajaran](https://docs.microsoft.com/learn/modules/train-evaluate-cluster-models?WT.mc_id=academic-77952-leestott) ini.
|
||||
## Bermula dengan pengelompokan
|
||||
|
||||
[Scikit-learn menawarkan pelbagai kaedah](https://scikit-learn.org/stable/modules/clustering.html) untuk melaksanakan pengelompokan. Jenis yang anda pilih akan bergantung pada kes penggunaan anda. Menurut dokumentasi, setiap kaedah mempunyai pelbagai manfaat. Berikut adalah jadual ringkas kaedah yang disokong oleh Scikit-learn dan kes penggunaan yang sesuai:
|
||||
|
||||
| Nama kaedah | Kes penggunaan |
|
||||
| :--------------------------- | :--------------------------------------------------------------------- |
|
||||
| K-Means | tujuan umum, induktif |
|
||||
| Penyebaran afiniti | banyak, kelompok tidak sekata, induktif |
|
||||
| Mean-shift | banyak, kelompok tidak sekata, induktif |
|
||||
| Pengelompokan spektral | beberapa, kelompok sekata, transduktif |
|
||||
| Pengelompokan hierarki Ward | banyak, kelompok terhad, transduktif |
|
||||
| Pengelompokan aglomeratif | banyak, terhad, jarak bukan Euclidean, transduktif |
|
||||
| DBSCAN | geometri bukan rata, kelompok tidak sekata, transduktif |
|
||||
| OPTICS | geometri bukan rata, kelompok tidak sekata dengan ketumpatan berubah, transduktif |
|
||||
| Campuran Gaussian | geometri rata, induktif |
|
||||
| BIRCH | set data besar dengan outlier, induktif |
|
||||
|
||||
> 🎓 Bagaimana kita mencipta kelompok banyak bergantung pada bagaimana kita mengumpulkan titik data ke dalam kumpulan. Mari kita huraikan beberapa istilah:
|
||||
>
|
||||
> 🎓 ['Transduktif' vs. 'induktif'](https://wikipedia.org/wiki/Transduction_(machine_learning))
|
||||
>
|
||||
> Inferens transduktif diperoleh daripada kes latihan yang diperhatikan yang memetakan kepada kes ujian tertentu. Inferens induktif diperoleh daripada kes latihan yang memetakan kepada peraturan umum yang hanya kemudian digunakan pada kes ujian.
|
||||
>
|
||||
> Contoh: Bayangkan anda mempunyai set data yang hanya dilabel sebahagiannya. Beberapa perkara adalah 'rekod', beberapa 'cd', dan beberapa kosong. Tugas anda adalah menyediakan label untuk yang kosong. Jika anda memilih pendekatan induktif, anda akan melatih model yang mencari 'rekod' dan 'cd', dan menggunakan label tersebut pada data yang tidak dilabel. Pendekatan ini akan menghadapi kesukaran untuk mengklasifikasikan perkara yang sebenarnya 'kaset'. Pendekatan transduktif, sebaliknya, menangani data yang tidak diketahui ini dengan lebih berkesan kerana ia berusaha untuk mengelompokkan item yang serupa bersama-sama dan kemudian memberikan label kepada kumpulan. Dalam kes ini, kelompok mungkin mencerminkan 'perkara muzik bulat' dan 'perkara muzik segi empat'.
|
||||
>
|
||||
> 🎓 ['Geometri bukan rata' vs. 'rata'](https://datascience.stackexchange.com/questions/52260/terminology-flat-geometry-in-the-context-of-clustering)
|
||||
>
|
||||
> Berasal daripada istilah matematik, geometri bukan rata vs. rata merujuk kepada ukuran jarak antara titik dengan kaedah geometri 'rata' ([Euclidean](https://wikipedia.org/wiki/Euclidean_geometry)) atau 'bukan rata' (bukan Euclidean).
|
||||
>
|
||||
>'Rata' dalam konteks ini merujuk kepada geometri Euclidean (sebahagian daripadanya diajar sebagai geometri 'pesawat'), dan bukan rata merujuk kepada geometri bukan Euclidean. Apa kaitannya geometri dengan pembelajaran mesin? Nah, sebagai dua bidang yang berakar pada matematik, mesti ada cara umum untuk mengukur jarak antara titik dalam kelompok, dan itu boleh dilakukan dengan cara 'rata' atau 'bukan rata', bergantung pada sifat data. [Jarak Euclidean](https://wikipedia.org/wiki/Euclidean_distance) diukur sebagai panjang segmen garis antara dua titik. [Jarak bukan Euclidean](https://wikipedia.org/wiki/Non-Euclidean_geometry) diukur sepanjang lengkung. Jika data anda, divisualisasikan, kelihatan tidak wujud pada satah, anda mungkin perlu menggunakan algoritma khusus untuk menanganinya.
|
||||
>
|
||||
|
||||
> Infografik oleh [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
||||
>
|
||||
> 🎓 ['Jarak'](https://web.stanford.edu/class/cs345a/slides/12-clustering.pdf)
|
||||
>
|
||||
> Kelompok ditakrifkan oleh matriks jaraknya, contohnya jarak antara titik. Jarak ini boleh diukur dalam beberapa cara. Kelompok Euclidean ditakrifkan oleh purata nilai titik, dan mengandungi 'centroid' atau titik pusat. Jarak diukur dengan jarak ke centroid tersebut. Jarak bukan Euclidean merujuk kepada 'clustroids', titik terdekat dengan titik lain. Clustroids seterusnya boleh ditakrifkan dalam pelbagai cara.
|
||||
>
|
||||
> 🎓 ['Terhad'](https://wikipedia.org/wiki/Constrained_clustering)
|
||||
>
|
||||
> [Pengelompokan Terhad](https://web.cs.ucdavis.edu/~davidson/Publications/ICDMTutorial.pdf) memperkenalkan pembelajaran 'semi-supervised' ke dalam kaedah tanpa pengawasan ini. Hubungan antara titik ditandakan sebagai 'tidak boleh paut' atau 'mesti paut' jadi beberapa peraturan dipaksa ke atas set data.
|
||||
>
|
||||
>Contoh: Jika algoritma dilepaskan pada sekumpulan data yang tidak dilabel atau separa dilabel, kelompok yang dihasilkan mungkin berkualiti rendah. Dalam contoh di atas, kelompok mungkin mengelompokkan 'perkara muzik bulat' dan 'perkara muzik segi empat' dan 'perkara segi tiga' dan 'biskut'. Jika diberikan beberapa kekangan, atau peraturan untuk diikuti ("item mesti diperbuat daripada plastik", "item perlu dapat menghasilkan muzik") ini boleh membantu 'mengekang' algoritma untuk membuat pilihan yang lebih baik.
|
||||
>
|
||||
> 🎓 'Ketumpatan'
|
||||
>
|
||||
> Data yang 'berisik' dianggap 'padat'. Jarak antara titik dalam setiap kelompoknya mungkin terbukti, apabila diperiksa, lebih atau kurang padat, atau 'sesak' dan oleh itu data ini perlu dianalisis dengan kaedah pengelompokan yang sesuai. [Artikel ini](https://www.kdnuggets.com/2020/02/understanding-density-based-clustering.html) menunjukkan perbezaan antara menggunakan pengelompokan K-Means vs. algoritma HDBSCAN untuk meneroka set data yang berisik dengan ketumpatan kelompok yang tidak sekata.
|
||||
|
||||
## Algoritma pengelompokan
|
||||
|
||||
Terdapat lebih 100 algoritma pengelompokan, dan penggunaannya bergantung pada sifat data yang ada. Mari kita bincangkan beberapa yang utama:
|
||||
|
||||
- **Pengelompokan hierarki**. Jika objek diklasifikasikan mengikut jaraknya dengan objek berdekatan, dan bukan dengan yang lebih jauh, kelompok dibentuk berdasarkan jarak anggotanya dengan objek lain. Pengelompokan aglomeratif Scikit-learn adalah hierarki.
|
||||
|
||||
|
||||
> Infografik oleh [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
||||
|
||||
- **Pengelompokan centroid**. Algoritma popular ini memerlukan pilihan 'k', atau bilangan kelompok untuk dibentuk, selepas itu algoritma menentukan titik pusat kelompok dan mengumpulkan data di sekitar titik tersebut. [Pengelompokan K-means](https://wikipedia.org/wiki/K-means_clustering) adalah versi pengelompokan centroid yang popular. Pusatnya ditentukan oleh min terdekat, oleh itu namanya. Jarak kuasa dua dari kelompok diminimumkan.
|
||||
|
||||
|
||||
> Infografik oleh [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
||||
|
||||
- **Pengelompokan berasaskan pengedaran**. Berdasarkan pemodelan statistik, pengelompokan berasaskan pengedaran berpusat pada menentukan kebarangkalian bahawa titik data tergolong dalam kelompok, dan menugaskannya dengan sewajarnya. Kaedah campuran Gaussian tergolong dalam jenis ini.
|
||||
|
||||
- **Pengelompokan berasaskan ketumpatan**. Titik data ditugaskan kepada kelompok berdasarkan ketumpatannya, atau pengelompokan di sekitar satu sama lain. Titik data yang jauh dari kumpulan dianggap sebagai outlier atau bunyi. DBSCAN, Mean-shift dan OPTICS tergolong dalam jenis pengelompokan ini.
|
||||
|
||||
- **Pengelompokan berasaskan grid**. Untuk set data berbilang dimensi, grid dicipta dan data dibahagikan di antara sel grid, dengan itu mencipta kelompok.
|
||||
|
||||
## Latihan - mengelompokkan data anda
|
||||
|
||||
Pengelompokan sebagai teknik sangat dibantu oleh visualisasi yang betul, jadi mari kita mulakan dengan memvisualisasikan data muzik kita. Latihan ini akan membantu kita memutuskan kaedah pengelompokan yang paling berkesan untuk digunakan berdasarkan sifat data ini.
|
||||
|
||||
1. Buka fail [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/1-Visualize/notebook.ipynb) dalam folder ini.
|
||||
|
||||
1. Import pakej `Seaborn` untuk visualisasi data yang baik.
|
||||
|
||||
```python
|
||||
!pip install seaborn
|
||||
```
|
||||
|
||||
1. Lampirkan data lagu dari [_nigerian-songs.csv_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/data/nigerian-songs.csv). Muatkan dataframe dengan beberapa data tentang lagu-lagu tersebut. Bersedia untuk meneroka data ini dengan mengimport perpustakaan dan mengeluarkan data:
|
||||
|
||||
```python
|
||||
import matplotlib.pyplot as plt
|
||||
import pandas as pd
|
||||
|
||||
df = pd.read_csv("../data/nigerian-songs.csv")
|
||||
df.head()
|
||||
```
|
||||
|
||||
Semak beberapa baris pertama data:
|
||||
|
||||
| | nama | album | artis | genre_teratas_artis | tarikh_keluar | panjang | populariti | kebolehdansaan | keakustikan | tenaga | keinstrumentalan | kesegaran | kelantangan | keceritaan | tempo | tanda_waktu |
|
||||
| --- | ------------------------ | ---------------------------- | ------------------- | ---------------- | ------------ | ------ | ---------- | ------------ | ------------ | ------ | ---------------- | -------- | -------- | ----------- | ------- | -------------- |
|
||||
| 0 | Sparky | Mandy & The Jungle | Cruel Santino | r&b alternatif | 2019 | 144000 | 48 | 0.666 | 0.851 | 0.42 | 0.534 | 0.11 | -6.699 | 0.0829 | 133.015 | 5 |
|
||||
| 1 | shuga rush | EVERYTHING YOU HEARD IS TRUE | Odunsi (The Engine) | afropop | 2020 | 89488 | 30 | 0.71 | 0.0822 | 0.683 | 0.000169 | 0.101 | -5.64 | 0.36 | 129.993 | 3 |
|
||||
| 2 | LITT! | LITT! | AYLØ | indie r&b | 2018 | 207758 | 40 | 0.836 | 0.272 | 0.564 | 0.000537 | 0.11 | -7.127 | 0.0424 | 130.005 | 4 |
|
||||
| 3 | Confident / Feeling Cool | Enjoy Your Life | Lady Donli | pop Nigeria | 2019 | 175135 | 14 | 0.894 | 0.798 | 0.611 | 0.000187 | 0.0964 | -4.961 | 0.113 | 111.087 | 4 |
|
||||
| 4 | wanted you | rare. | Odunsi (The Engine) | afropop | 2018 | 152049 | 25 | 0.702 | 0.116 | 0.833 | 0.91 | 0.348 | -6.044 | 0.0447 | 105.115 | 4 |
|
||||
|
||||
1. Dapatkan beberapa maklumat tentang dataframe, dengan memanggil `info()`:
|
||||
|
||||
```python
|
||||
df.info()
|
||||
```
|
||||
|
||||
Outputnya kelihatan seperti ini:
|
||||
|
||||
```output
|
||||
<class 'pandas.core.frame.DataFrame'>
|
||||
RangeIndex: 530 entries, 0 to 529
|
||||
Data columns (total 16 columns):
|
||||
# Column Non-Null Count Dtype
|
||||
--- ------ -------------- -----
|
||||
0 name 530 non-null object
|
||||
1 album 530 non-null object
|
||||
2 artist 530 non-null object
|
||||
3 artist_top_genre 530 non-null object
|
||||
4 release_date 530 non-null int64
|
||||
5 length 530 non-null int64
|
||||
6 popularity 530 non-null int64
|
||||
7 danceability 530 non-null float64
|
||||
8 acousticness 530 non-null float64
|
||||
9 energy 530 non-null float64
|
||||
10 instrumentalness 530 non-null float64
|
||||
11 liveness 530 non-null float64
|
||||
12 loudness 530 non-null float64
|
||||
13 speechiness 530 non-null float64
|
||||
14 tempo 530 non-null float64
|
||||
15 time_signature 530 non-null int64
|
||||
dtypes: float64(8), int64(4), object(4)
|
||||
memory usage: 66.4+ KB
|
||||
```
|
||||
|
||||
1. Periksa semula untuk nilai null, dengan memanggil `isnull()` dan mengesahkan jumlahnya adalah 0:
|
||||
|
||||
```python
|
||||
df.isnull().sum()
|
||||
```
|
||||
|
||||
Kelihatan baik:
|
||||
|
||||
```output
|
||||
name 0
|
||||
album 0
|
||||
artist 0
|
||||
artist_top_genre 0
|
||||
release_date 0
|
||||
length 0
|
||||
popularity 0
|
||||
danceability 0
|
||||
acousticness 0
|
||||
energy 0
|
||||
instrumentalness 0
|
||||
liveness 0
|
||||
loudness 0
|
||||
speechiness 0
|
||||
tempo 0
|
||||
time_signature 0
|
||||
dtype: int64
|
||||
```
|
||||
|
||||
1. Huraikan data:
|
||||
|
||||
```python
|
||||
df.describe()
|
||||
```
|
||||
|
||||
| | tarikh_keluar | panjang | populariti | kebolehdansaan | keakustikan | tenaga | keinstrumentalan | kesegaran | kelantangan | keceritaan | tempo | tanda_waktu |
|
||||
| ----- | ------------ | ----------- | ---------- | ------------ | ------------ | -------- | ---------------- | -------- | --------- | ----------- | ---------- | -------------- |
|
||||
| count | 530 | 530 | 530 | 530 | 530 | 530 | 530 | 530 | 530 | 530 | 530 | 530 |
|
||||
| mean | 2015.390566 | 222298.1698 | 17.507547 | 0.741619 | 0.265412 | 0.760623 | 0.016305 | 0.147308 | -4.953011 | 0.130748 | 116.487864 | 3.986792 |
|
||||
| std | 3.131688 | 39696.82226 | 18.992212 | 0.117522 | 0.208342 | 0.148533 | 0.090321 | 0.123588 | 2.464186 | 0.092939 | 23.518601 | 0.333701 |
|
||||
| min | 1998 | 89488 | 0 | 0.255 | 0.000665 | 0.111 | 0 | 0.0283 | -19.362 | 0.0278 | 61.695 | 3 |
|
||||
| 25%
|
||||
## [Kuiz selepas kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/28/)
|
||||
|
||||
## Kajian & Pembelajaran Sendiri
|
||||
|
||||
Sebelum anda menggunakan algoritma pengelompokan, seperti yang telah kita pelajari, adalah idea yang baik untuk memahami sifat dataset anda. Baca lebih lanjut mengenai topik ini [di sini](https://www.kdnuggets.com/2019/10/right-clustering-algorithm.html)
|
||||
|
||||
[Artikel yang berguna ini](https://www.freecodecamp.org/news/8-clustering-algorithms-in-machine-learning-that-all-data-scientists-should-know/) membimbing anda melalui pelbagai cara yang berbeza bagaimana algoritma pengelompokan berkelakuan, diberikan bentuk data yang berbeza.
|
||||
|
||||
## Tugasan
|
||||
|
||||
[Selidiki visualisasi lain untuk pengelompokan](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab ke atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,14 +0,0 @@
|
||||
# Menyiasat visualisasi lain untuk pengelompokan
|
||||
|
||||
## Arahan
|
||||
|
||||
Dalam pelajaran ini, anda telah bekerja dengan beberapa teknik visualisasi untuk memahami cara memplot data anda sebagai persiapan untuk pengelompokan. Scatterplot, khususnya, berguna untuk mencari kumpulan objek. Siasat pelbagai cara dan pelbagai perpustakaan untuk mencipta scatterplot dan dokumentasikan kerja anda dalam sebuah notebook. Anda boleh menggunakan data dari pelajaran ini, pelajaran lain, atau data yang anda cari sendiri (sila kreditkan sumbernya, bagaimanapun, dalam notebook anda). Plotkan beberapa data menggunakan scatterplot dan jelaskan apa yang anda temui.
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Contoh Terbaik | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | -------------------------------------------------------------- | ---------------------------------------------------------------------------------------- | ----------------------------------- |
|
||||
| | Sebuah notebook dipersembahkan dengan lima scatterplot yang didokumentasikan dengan baik | Sebuah notebook dipersembahkan dengan kurang dari lima scatterplot dan kurang didokumentasikan dengan baik | Sebuah notebook yang tidak lengkap dipersembahkan |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,250 +0,0 @@
|
||||
# Pengelompokan K-Means
|
||||
|
||||
## [Kuiz Pra-kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/29/)
|
||||
|
||||
Dalam pelajaran ini, anda akan belajar cara membuat kluster menggunakan Scikit-learn dan dataset musik Nigeria yang anda impor sebelumnya. Kita akan membahas dasar-dasar K-Means untuk Pengelompokan. Ingatlah bahwa, seperti yang telah anda pelajari dalam pelajaran sebelumnya, ada banyak cara untuk bekerja dengan kluster dan metode yang anda gunakan tergantung pada data anda. Kita akan mencoba K-Means karena ini adalah teknik pengelompokan yang paling umum. Mari kita mulai!
|
||||
|
||||
Istilah-istilah yang akan anda pelajari:
|
||||
|
||||
- Skor Silhouette
|
||||
- Metode Elbow
|
||||
- Inertia
|
||||
- Variansi
|
||||
|
||||
## Pengenalan
|
||||
|
||||
[Pemgumpulan K-Means](https://wikipedia.org/wiki/K-means_clustering) adalah metode yang berasal dari domain pemrosesan sinyal. Metode ini digunakan untuk membagi dan mengelompokkan data menjadi 'k' kluster menggunakan serangkaian observasi. Setiap observasi berfungsi untuk mengelompokkan titik data yang diberikan ke 'mean' terdekatnya, atau titik tengah dari sebuah kluster.
|
||||
|
||||
Kluster-kluster tersebut dapat divisualisasikan sebagai [diagram Voronoi](https://wikipedia.org/wiki/Voronoi_diagram), yang mencakup sebuah titik (atau 'benih') dan wilayah yang sesuai.
|
||||
|
||||
|
||||
|
||||
> infografis oleh [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
Proses pengelompokan K-Means [dijalankan dalam tiga langkah](https://scikit-learn.org/stable/modules/clustering.html#k-means):
|
||||
|
||||
1. Algoritma memilih sejumlah k-titik tengah dengan mengambil sampel dari dataset. Setelah itu, algoritma melakukan iterasi:
|
||||
1. Menugaskan setiap sampel ke centroid terdekat.
|
||||
2. Membuat centroid baru dengan mengambil nilai rata-rata dari semua sampel yang ditugaskan ke centroid sebelumnya.
|
||||
3. Kemudian, menghitung perbedaan antara centroid baru dan lama dan mengulangi hingga centroid stabil.
|
||||
|
||||
Salah satu kelemahan menggunakan K-Means adalah anda perlu menetapkan 'k', yaitu jumlah centroid. Untungnya, 'metode elbow' membantu memperkirakan nilai awal yang baik untuk 'k'. Anda akan mencobanya sebentar lagi.
|
||||
|
||||
## Prasyarat
|
||||
|
||||
Anda akan bekerja dalam file [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/2-K-Means/notebook.ipynb) dari pelajaran ini yang mencakup impor data dan pembersihan awal yang anda lakukan pada pelajaran sebelumnya.
|
||||
|
||||
## Latihan - persiapan
|
||||
|
||||
Mulailah dengan melihat kembali data lagu.
|
||||
|
||||
1. Buat boxplot, panggil `boxplot()` untuk setiap kolom:
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(20,20), dpi=200)
|
||||
|
||||
plt.subplot(4,3,1)
|
||||
sns.boxplot(x = 'popularity', data = df)
|
||||
|
||||
plt.subplot(4,3,2)
|
||||
sns.boxplot(x = 'acousticness', data = df)
|
||||
|
||||
plt.subplot(4,3,3)
|
||||
sns.boxplot(x = 'energy', data = df)
|
||||
|
||||
plt.subplot(4,3,4)
|
||||
sns.boxplot(x = 'instrumentalness', data = df)
|
||||
|
||||
plt.subplot(4,3,5)
|
||||
sns.boxplot(x = 'liveness', data = df)
|
||||
|
||||
plt.subplot(4,3,6)
|
||||
sns.boxplot(x = 'loudness', data = df)
|
||||
|
||||
plt.subplot(4,3,7)
|
||||
sns.boxplot(x = 'speechiness', data = df)
|
||||
|
||||
plt.subplot(4,3,8)
|
||||
sns.boxplot(x = 'tempo', data = df)
|
||||
|
||||
plt.subplot(4,3,9)
|
||||
sns.boxplot(x = 'time_signature', data = df)
|
||||
|
||||
plt.subplot(4,3,10)
|
||||
sns.boxplot(x = 'danceability', data = df)
|
||||
|
||||
plt.subplot(4,3,11)
|
||||
sns.boxplot(x = 'length', data = df)
|
||||
|
||||
plt.subplot(4,3,12)
|
||||
sns.boxplot(x = 'release_date', data = df)
|
||||
```
|
||||
|
||||
Data ini agak bising: dengan mengamati setiap kolom sebagai boxplot, anda dapat melihat outlier.
|
||||
|
||||
|
||||
|
||||
Anda bisa melalui dataset dan menghapus outlier ini, tetapi itu akan membuat data cukup minimal.
|
||||
|
||||
1. Untuk saat ini, pilih kolom mana yang akan anda gunakan untuk latihan pengelompokan. Pilih yang memiliki rentang yang serupa dan kodekan kolom `artist_top_genre` sebagai data numerik:
|
||||
|
||||
```python
|
||||
from sklearn.preprocessing import LabelEncoder
|
||||
le = LabelEncoder()
|
||||
|
||||
X = df.loc[:, ('artist_top_genre','popularity','danceability','acousticness','loudness','energy')]
|
||||
|
||||
y = df['artist_top_genre']
|
||||
|
||||
X['artist_top_genre'] = le.fit_transform(X['artist_top_genre'])
|
||||
|
||||
y = le.transform(y)
|
||||
```
|
||||
|
||||
1. Sekarang anda perlu memilih berapa banyak kluster yang akan ditargetkan. Anda tahu ada 3 genre lagu yang kami ambil dari dataset, jadi mari coba 3:
|
||||
|
||||
```python
|
||||
from sklearn.cluster import KMeans
|
||||
|
||||
nclusters = 3
|
||||
seed = 0
|
||||
|
||||
km = KMeans(n_clusters=nclusters, random_state=seed)
|
||||
km.fit(X)
|
||||
|
||||
# Predict the cluster for each data point
|
||||
|
||||
y_cluster_kmeans = km.predict(X)
|
||||
y_cluster_kmeans
|
||||
```
|
||||
|
||||
Anda melihat array yang dicetak dengan kluster yang diprediksi (0, 1, atau 2) untuk setiap baris dataframe.
|
||||
|
||||
1. Gunakan array ini untuk menghitung 'skor silhouette':
|
||||
|
||||
```python
|
||||
from sklearn import metrics
|
||||
score = metrics.silhouette_score(X, y_cluster_kmeans)
|
||||
score
|
||||
```
|
||||
|
||||
## Skor Silhouette
|
||||
|
||||
Carilah skor silhouette yang mendekati 1. Skor ini bervariasi dari -1 hingga 1, dan jika skornya 1, kluster tersebut padat dan terpisah dengan baik dari kluster lain. Nilai mendekati 0 mewakili kluster yang tumpang tindih dengan sampel yang sangat dekat dengan batas keputusan kluster tetangga. [(Sumber)](https://dzone.com/articles/kmeans-silhouette-score-explained-with-python-exam)
|
||||
|
||||
Skor kita adalah **.53**, jadi tepat di tengah. Ini menunjukkan bahwa data kita tidak terlalu cocok untuk jenis pengelompokan ini, tetapi mari kita lanjutkan.
|
||||
|
||||
### Latihan - membangun model
|
||||
|
||||
1. Impor `KMeans` dan mulai proses pengelompokan.
|
||||
|
||||
```python
|
||||
from sklearn.cluster import KMeans
|
||||
wcss = []
|
||||
|
||||
for i in range(1, 11):
|
||||
kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
|
||||
kmeans.fit(X)
|
||||
wcss.append(kmeans.inertia_)
|
||||
|
||||
```
|
||||
|
||||
Ada beberapa bagian di sini yang perlu dijelaskan.
|
||||
|
||||
> 🎓 range: Ini adalah iterasi dari proses pengelompokan
|
||||
|
||||
> 🎓 random_state: "Menentukan penghasil angka acak untuk inisialisasi centroid." [Sumber](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html#sklearn.cluster.KMeans)
|
||||
|
||||
> 🎓 WCSS: "within-cluster sums of squares" mengukur jarak rata-rata kuadrat dari semua titik dalam sebuah kluster ke centroid kluster. [Sumber](https://medium.com/@ODSC/unsupervised-learning-evaluating-clusters-bd47eed175ce).
|
||||
|
||||
> 🎓 Inertia: Algoritma K-Means berusaha memilih centroid untuk meminimalkan 'inertia', "ukuran seberapa koheren kluster secara internal." [Sumber](https://scikit-learn.org/stable/modules/clustering.html). Nilainya ditambahkan ke variabel wcss pada setiap iterasi.
|
||||
|
||||
> 🎓 k-means++: Dalam [Scikit-learn](https://scikit-learn.org/stable/modules/clustering.html#k-means) anda dapat menggunakan optimasi 'k-means++', yang "menginisialisasi centroid agar (secara umum) jauh dari satu sama lain, menghasilkan kemungkinan hasil yang lebih baik daripada inisialisasi acak.
|
||||
|
||||
### Metode Elbow
|
||||
|
||||
Sebelumnya, anda menduga bahwa, karena anda menargetkan 3 genre lagu, anda harus memilih 3 kluster. Tetapi apakah itu benar?
|
||||
|
||||
1. Gunakan 'metode elbow' untuk memastikannya.
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(10,5))
|
||||
sns.lineplot(x=range(1, 11), y=wcss, marker='o', color='red')
|
||||
plt.title('Elbow')
|
||||
plt.xlabel('Number of clusters')
|
||||
plt.ylabel('WCSS')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
Gunakan variabel `wcss` yang anda buat pada langkah sebelumnya untuk membuat grafik yang menunjukkan di mana 'tikungan' pada elbow, yang menunjukkan jumlah kluster yang optimal. Mungkin memang **3**!
|
||||
|
||||
|
||||
|
||||
## Latihan - menampilkan kluster
|
||||
|
||||
1. Cobalah prosesnya lagi, kali ini menetapkan tiga kluster, dan tampilkan kluster sebagai scatterplot:
|
||||
|
||||
```python
|
||||
from sklearn.cluster import KMeans
|
||||
kmeans = KMeans(n_clusters = 3)
|
||||
kmeans.fit(X)
|
||||
labels = kmeans.predict(X)
|
||||
plt.scatter(df['popularity'],df['danceability'],c = labels)
|
||||
plt.xlabel('popularity')
|
||||
plt.ylabel('danceability')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
1. Periksa akurasi model:
|
||||
|
||||
```python
|
||||
labels = kmeans.labels_
|
||||
|
||||
correct_labels = sum(y == labels)
|
||||
|
||||
print("Result: %d out of %d samples were correctly labeled." % (correct_labels, y.size))
|
||||
|
||||
print('Accuracy score: {0:0.2f}'. format(correct_labels/float(y.size)))
|
||||
```
|
||||
|
||||
Akurasi model ini tidak terlalu bagus, dan bentuk kluster memberi anda petunjuk mengapa.
|
||||
|
||||
|
||||
|
||||
Data ini terlalu tidak seimbang, terlalu sedikit berkorelasi dan ada terlalu banyak varians antara nilai kolom untuk dikelompokkan dengan baik. Faktanya, kluster yang terbentuk mungkin sangat dipengaruhi atau bias oleh tiga kategori genre yang kita definisikan di atas. Itu adalah proses pembelajaran!
|
||||
|
||||
Dalam dokumentasi Scikit-learn, anda dapat melihat bahwa model seperti ini, dengan kluster yang tidak terlalu jelas, memiliki masalah 'varians':
|
||||
|
||||
|
||||
> Infografis dari Scikit-learn
|
||||
|
||||
## Variansi
|
||||
|
||||
Variansi didefinisikan sebagai "rata-rata dari perbedaan kuadrat dari Mean" [(Sumber)](https://www.mathsisfun.com/data/standard-deviation.html). Dalam konteks masalah pengelompokan ini, ini mengacu pada data yang angka-angka dalam dataset kita cenderung menyimpang terlalu jauh dari mean.
|
||||
|
||||
✅ Ini adalah saat yang tepat untuk memikirkan semua cara anda dapat memperbaiki masalah ini. Mengubah data sedikit lebih banyak? Menggunakan kolom yang berbeda? Menggunakan algoritma yang berbeda? Petunjuk: Cobalah [menyelaraskan data anda](https://www.mygreatlearning.com/blog/learning-data-science-with-k-means-clustering/) untuk menormalkannya dan menguji kolom lain.
|
||||
|
||||
> Cobalah '[kalkulator varians](https://www.calculatorsoup.com/calculators/statistics/variance-calculator.php)' ini untuk memahami konsep ini lebih lanjut.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Tantangan
|
||||
|
||||
Habiskan waktu dengan notebook ini, mengubah parameter. Bisakah anda meningkatkan akurasi model dengan membersihkan data lebih banyak (menghapus outlier, misalnya)? Anda dapat menggunakan bobot untuk memberikan bobot lebih pada sampel data tertentu. Apa lagi yang bisa anda lakukan untuk membuat kluster yang lebih baik?
|
||||
|
||||
Petunjuk: Cobalah untuk menyelaraskan data anda. Ada kode yang dikomentari dalam notebook yang menambahkan penskalaan standar untuk membuat kolom data lebih mirip satu sama lain dalam hal rentang. Anda akan menemukan bahwa meskipun skor silhouette turun, 'tikungan' dalam grafik elbow menjadi lebih halus. Ini karena membiarkan data tidak diskalakan memungkinkan data dengan varians lebih sedikit untuk membawa lebih banyak bobot. Baca lebih lanjut tentang masalah ini [di sini](https://stats.stackexchange.com/questions/21222/are-mean-normalization-and-feature-scaling-needed-for-k-means-clustering/21226#21226).
|
||||
|
||||
## [Kuiz Pasca-kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/30/)
|
||||
|
||||
## Tinjauan & Studi Mandiri
|
||||
|
||||
Lihatlah Simulator K-Means [seperti yang ini](https://user.ceng.metu.edu.tr/~akifakkus/courses/ceng574/k-means/). Anda dapat menggunakan alat ini untuk memvisualisasikan titik data sampel dan menentukan centroidnya. Anda dapat mengedit keacakan data, jumlah kluster, dan jumlah centroid. Apakah ini membantu anda mendapatkan gambaran tentang bagaimana data dapat dikelompokkan?
|
||||
|
||||
Juga, lihat [handout ini tentang K-Means](https://stanford.edu/~cpiech/cs221/handouts/kmeans.html) dari Stanford.
|
||||
|
||||
## Tugas
|
||||
|
||||
[Cobalah metode pengelompokan yang berbeda](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,13 +0,0 @@
|
||||
# Cuba kaedah pengelompokan yang berbeza
|
||||
|
||||
## Arahan
|
||||
|
||||
Dalam pelajaran ini, anda telah mempelajari tentang pengelompokan K-Means. Kadang-kadang K-Means tidak sesuai untuk data anda. Buatlah sebuah notebook menggunakan data sama ada dari pelajaran ini atau dari sumber lain (nyatakan sumber anda) dan tunjukkan kaedah pengelompokan yang berbeza TANPA menggunakan K-Means. Apa yang anda pelajari?
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | --------------------------------------------------------------- | -------------------------------------------------------------------- | ---------------------------- |
|
||||
| | Sebuah notebook disediakan dengan model pengelompokan yang didokumentasikan dengan baik | Sebuah notebook disediakan tanpa dokumentasi yang baik dan/atau tidak lengkap | Kerja yang tidak lengkap diserahkan |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab ke atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,31 +0,0 @@
|
||||
# Model Pengelompokan untuk Pembelajaran Mesin
|
||||
|
||||
Pengelompokan adalah tugas pembelajaran mesin di mana ia mencari objek yang menyerupai satu sama lain dan mengelompokkannya ke dalam kelompok yang disebut kelompok. Apa yang membedakan pengelompokan dari pendekatan lain dalam pembelajaran mesin adalah bahwa semuanya terjadi secara otomatis, sebenarnya, bisa dikatakan ini adalah kebalikan dari pembelajaran terawasi.
|
||||
|
||||
## Topik Regional: model pengelompokan untuk selera musik audiens Nigeria 🎧
|
||||
|
||||
Audiens Nigeria yang beragam memiliki selera musik yang beragam. Menggunakan data yang diambil dari Spotify (terinspirasi oleh [artikel ini](https://towardsdatascience.com/country-wise-visual-analysis-of-music-taste-using-spotify-api-seaborn-in-python-77f5b749b421)), mari kita lihat beberapa musik yang populer di Nigeria. Dataset ini mencakup data tentang skor 'danceability', 'acousticness', kerasnya, 'speechiness', popularitas, dan energi dari berbagai lagu. Akan sangat menarik untuk menemukan pola dalam data ini!
|
||||
|
||||
|
||||
|
||||
> Foto oleh <a href="https://unsplash.com/@marcelalaskoski?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Marcela Laskoski</a> di <a href="https://unsplash.com/s/photos/nigerian-music?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
Dalam rangkaian pelajaran ini, Anda akan menemukan cara baru untuk menganalisis data menggunakan teknik pengelompokan. Pengelompokan sangat berguna ketika dataset Anda tidak memiliki label. Jika memiliki label, maka teknik klasifikasi seperti yang Anda pelajari di pelajaran sebelumnya mungkin lebih berguna. Tetapi dalam kasus di mana Anda mencari untuk mengelompokkan data tanpa label, pengelompokan adalah cara yang bagus untuk menemukan pola.
|
||||
|
||||
> Ada alat low-code yang berguna yang dapat membantu Anda mempelajari tentang bekerja dengan model pengelompokan. Coba [Azure ML untuk tugas ini](https://docs.microsoft.com/learn/modules/create-clustering-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
|
||||
|
||||
## Pelajaran
|
||||
|
||||
1. [Pengantar pengelompokan](1-Visualize/README.md)
|
||||
2. [Pengelompokan K-Means](2-K-Means/README.md)
|
||||
|
||||
## Kredit
|
||||
|
||||
Pelajaran ini ditulis dengan 🎶 oleh [Jen Looper](https://www.twitter.com/jenlooper) dengan ulasan yang bermanfaat oleh [Rishit Dagli](https://rishit_dagli) dan [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan).
|
||||
|
||||
Dataset [Nigerian Songs](https://www.kaggle.com/sootersaalu/nigerian-songs-spotify) bersumber dari Kaggle sebagai hasil scraping dari Spotify.
|
||||
|
||||
Contoh K-Means yang berguna yang membantu dalam membuat pelajaran ini termasuk [eksplorasi iris](https://www.kaggle.com/bburns/iris-exploration-pca-k-means-and-gmm-clustering) ini, [notebook pengantar](https://www.kaggle.com/prashant111/k-means-clustering-with-python) ini, dan [contoh hipotetis NGO](https://www.kaggle.com/ankandash/pca-k-means-clustering-hierarchical-clustering) ini.
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,168 +0,0 @@
|
||||
# Pengenalan kepada pemprosesan bahasa semulajadi
|
||||
|
||||
Pelajaran ini merangkumi sejarah ringkas dan konsep penting dalam *pemprosesan bahasa semulajadi*, satu cabang daripada *linguistik komputasi*.
|
||||
|
||||
## [Kuiz pra-ceramah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/31/)
|
||||
|
||||
## Pengenalan
|
||||
|
||||
NLP, seperti yang biasa dikenali, adalah salah satu bidang yang paling terkenal di mana pembelajaran mesin telah digunakan dan diterapkan dalam perisian pengeluaran.
|
||||
|
||||
✅ Bolehkah anda memikirkan perisian yang anda gunakan setiap hari yang mungkin mempunyai beberapa NLP di dalamnya? Bagaimana dengan program pemprosesan kata atau aplikasi mudah alih yang anda gunakan secara kerap?
|
||||
|
||||
Anda akan belajar tentang:
|
||||
|
||||
- **Idea tentang bahasa**. Bagaimana bahasa berkembang dan apakah bidang kajian utama.
|
||||
- **Definisi dan konsep**. Anda juga akan belajar definisi dan konsep tentang bagaimana komputer memproses teks, termasuk penguraian, tatabahasa, dan mengenal pasti kata nama dan kata kerja. Terdapat beberapa tugas pengekodan dalam pelajaran ini, dan beberapa konsep penting diperkenalkan yang anda akan belajar untuk kod kemudian dalam pelajaran seterusnya.
|
||||
|
||||
## Linguistik komputasi
|
||||
|
||||
Linguistik komputasi adalah bidang penyelidikan dan pembangunan selama beberapa dekad yang mengkaji bagaimana komputer boleh bekerja dengan, dan bahkan memahami, menterjemah, dan berkomunikasi dengan bahasa. Pemprosesan bahasa semulajadi (NLP) adalah bidang berkaitan yang memberi tumpuan kepada bagaimana komputer boleh memproses bahasa 'semulajadi', atau bahasa manusia.
|
||||
|
||||
### Contoh - pendiktean telefon
|
||||
|
||||
Jika anda pernah mendikte kepada telefon anda daripada menaip atau bertanya kepada pembantu maya soalan, ucapan anda telah ditukar kepada bentuk teks dan kemudian diproses atau *diuraikan* dari bahasa yang anda gunakan. Kata kunci yang dikesan kemudian diproses ke dalam format yang telefon atau pembantu boleh faham dan bertindak balas.
|
||||
|
||||
|
||||
> Pemahaman linguistik sebenar adalah sukar! Imej oleh [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
### Bagaimana teknologi ini dibuat mungkin?
|
||||
|
||||
Ini mungkin kerana seseorang menulis program komputer untuk melakukannya. Beberapa dekad yang lalu, beberapa penulis fiksyen sains meramalkan bahawa orang akan kebanyakannya bercakap dengan komputer mereka, dan komputer akan sentiasa memahami dengan tepat apa yang mereka maksudkan. Malangnya, ia ternyata menjadi masalah yang lebih sukar daripada yang dibayangkan oleh ramai, dan walaupun ia adalah masalah yang lebih difahami hari ini, terdapat cabaran yang ketara dalam mencapai pemprosesan bahasa semulajadi yang 'sempurna' apabila ia berkaitan dengan memahami makna ayat. Ini adalah masalah yang sangat sukar apabila ia berkaitan dengan memahami humor atau mengesan emosi seperti sindiran dalam ayat.
|
||||
|
||||
Pada ketika ini, anda mungkin mengingati kelas sekolah di mana guru meliputi bahagian tatabahasa dalam ayat. Di sesetengah negara, pelajar diajar tatabahasa dan linguistik sebagai subjek khusus, tetapi di banyak negara, topik-topik ini dimasukkan sebagai sebahagian daripada pembelajaran bahasa: sama ada bahasa pertama anda di sekolah rendah (belajar membaca dan menulis) dan mungkin bahasa kedua di sekolah menengah. Jangan risau jika anda bukan pakar dalam membezakan kata nama daripada kata kerja atau kata keterangan daripada kata sifat!
|
||||
|
||||
Jika anda bergelut dengan perbezaan antara *masa kini mudah* dan *masa kini progresif*, anda tidak bersendirian. Ini adalah perkara yang mencabar bagi ramai orang, bahkan penutur asli bahasa. Berita baiknya adalah bahawa komputer sangat baik dalam menerapkan peraturan formal, dan anda akan belajar untuk menulis kod yang boleh *menguraikan* ayat serta manusia. Cabaran yang lebih besar yang anda akan kaji kemudian ialah memahami *makna*, dan *sentimen*, sesuatu ayat.
|
||||
|
||||
## Prasyarat
|
||||
|
||||
Untuk pelajaran ini, prasyarat utama adalah dapat membaca dan memahami bahasa pelajaran ini. Tiada masalah matematik atau persamaan untuk diselesaikan. Walaupun pengarang asal menulis pelajaran ini dalam bahasa Inggeris, ia juga diterjemahkan ke dalam bahasa lain, jadi anda mungkin sedang membaca terjemahan. Terdapat contoh di mana beberapa bahasa yang berbeza digunakan (untuk membandingkan peraturan tatabahasa yang berbeza dari bahasa yang berbeza). Ini *tidak* diterjemahkan, tetapi teks penjelasan diterjemahkan, jadi maknanya harus jelas.
|
||||
|
||||
Untuk tugas pengekodan, anda akan menggunakan Python dan contoh-contohnya menggunakan Python 3.8.
|
||||
|
||||
Dalam bahagian ini, anda akan memerlukan, dan menggunakan:
|
||||
|
||||
- **Pemahaman Python 3**. Pemahaman bahasa pengaturcaraan dalam Python 3, pelajaran ini menggunakan input, gelung, pembacaan fail, array.
|
||||
- **Visual Studio Code + sambungan**. Kami akan menggunakan Visual Studio Code dan sambungan Python. Anda juga boleh menggunakan IDE Python pilihan anda.
|
||||
- **TextBlob**. [TextBlob](https://github.com/sloria/TextBlob) adalah perpustakaan pemprosesan teks yang dipermudahkan untuk Python. Ikuti arahan di laman TextBlob untuk memasangnya pada sistem anda (pasang juga korpora, seperti yang ditunjukkan di bawah):
|
||||
|
||||
```bash
|
||||
pip install -U textblob
|
||||
python -m textblob.download_corpora
|
||||
```
|
||||
|
||||
> 💡 Tip: Anda boleh menjalankan Python secara langsung dalam persekitaran VS Code. Semak [dokumentasi](https://code.visualstudio.com/docs/languages/python?WT.mc_id=academic-77952-leestott) untuk maklumat lanjut.
|
||||
|
||||
## Bercakap dengan mesin
|
||||
|
||||
Sejarah mencuba untuk membuat komputer memahami bahasa manusia kembali beberapa dekad, dan salah seorang saintis terawal yang mempertimbangkan pemprosesan bahasa semulajadi adalah *Alan Turing*.
|
||||
|
||||
### Ujian 'Turing'
|
||||
|
||||
Ketika Turing sedang meneliti *kecerdasan buatan* pada tahun 1950-an, dia mempertimbangkan jika ujian perbualan boleh diberikan kepada seorang manusia dan komputer (melalui surat-menyurat yang ditaip) di mana manusia dalam perbualan itu tidak pasti sama ada mereka sedang berbual dengan manusia lain atau komputer.
|
||||
|
||||
Jika, selepas tempoh perbualan tertentu, manusia tidak dapat menentukan bahawa jawapan itu dari komputer atau tidak, maka bolehkah komputer dikatakan *berfikir*?
|
||||
|
||||
### Inspirasi - 'permainan tiruan'
|
||||
|
||||
Idea untuk ini datang dari permainan pesta yang dipanggil *The Imitation Game* di mana seorang penyiasat berada sendirian dalam bilik dan ditugaskan untuk menentukan siapa daripada dua orang (di bilik lain) adalah lelaki dan wanita masing-masing. Penyiasat boleh menghantar nota, dan mesti cuba memikirkan soalan di mana jawapan bertulis mendedahkan jantina orang misteri itu. Sudah tentu, pemain di bilik lain cuba menipu penyiasat dengan menjawab soalan dengan cara yang mengelirukan atau mengelirukan penyiasat, sambil memberikan penampilan menjawab dengan jujur.
|
||||
|
||||
### Membangunkan Eliza
|
||||
|
||||
Pada tahun 1960-an, seorang saintis MIT bernama *Joseph Weizenbaum* membangunkan [*Eliza*](https://wikipedia.org/wiki/ELIZA), seorang 'terapis' komputer yang akan menanyakan soalan kepada manusia dan memberikan penampilan memahami jawapan mereka. Walau bagaimanapun, walaupun Eliza boleh menguraikan ayat dan mengenal pasti beberapa struktur tatabahasa dan kata kunci untuk memberikan jawapan yang munasabah, ia tidak boleh dikatakan *memahami* ayat itu. Jika Eliza diberi ayat yang mengikuti format "**I am** <u>sedih</u>" ia mungkin menyusun semula dan menggantikan kata-kata dalam ayat untuk membentuk jawapan "Berapa lama **anda telah** <u>sedih</u>".
|
||||
|
||||
Ini memberikan kesan bahawa Eliza memahami kenyataan itu dan menanyakan soalan susulan, sedangkan sebenarnya, ia hanya mengubah masa dan menambah beberapa kata. Jika Eliza tidak dapat mengenal pasti kata kunci yang ia mempunyai jawapan untuk, ia akan memberikan jawapan rawak yang boleh digunakan untuk banyak kenyataan yang berbeza. Eliza boleh dengan mudah ditipu, contohnya jika pengguna menulis "**Anda adalah** sebuah <u>basikal</u>" ia mungkin menjawab dengan "Berapa lama **saya telah** sebuah <u>basikal</u>?", bukannya jawapan yang lebih beralasan.
|
||||
|
||||
[](https://youtu.be/RMK9AphfLco "Berbual dengan Eliza")
|
||||
|
||||
> 🎥 Klik imej di atas untuk video tentang program ELIZA asal
|
||||
|
||||
> Nota: Anda boleh membaca keterangan asal [Eliza](https://cacm.acm.org/magazines/1966/1/13317-elizaa-computer-program-for-the-study-of-natural-language-communication-between-man-and-machine/abstract) yang diterbitkan pada tahun 1966 jika anda mempunyai akaun ACM. Sebagai alternatif, baca tentang Eliza di [wikipedia](https://wikipedia.org/wiki/ELIZA)
|
||||
|
||||
## Latihan - mengekod bot perbualan asas
|
||||
|
||||
Bot perbualan, seperti Eliza, adalah program yang meminta input pengguna dan kelihatan memahami dan memberi respons dengan bijak. Tidak seperti Eliza, bot kita tidak akan mempunyai beberapa peraturan yang memberikan penampilan mempunyai perbualan pintar. Sebaliknya, bot kita hanya akan mempunyai satu kebolehan, iaitu untuk meneruskan perbualan dengan respons rawak yang mungkin berfungsi dalam hampir mana-mana perbualan remeh.
|
||||
|
||||
### Rancangan
|
||||
|
||||
Langkah-langkah anda semasa membina bot perbualan:
|
||||
|
||||
1. Cetak arahan yang menasihati pengguna cara berinteraksi dengan bot
|
||||
2. Mulakan gelung
|
||||
1. Terima input pengguna
|
||||
2. Jika pengguna meminta untuk keluar, maka keluar
|
||||
3. Proses input pengguna dan tentukan respons (dalam kes ini, respons adalah pilihan rawak daripada senarai kemungkinan respons generik)
|
||||
4. Cetak respons
|
||||
3. kembali ke langkah 2
|
||||
|
||||
### Membina bot
|
||||
|
||||
Mari kita buat bot seterusnya. Kita akan mulakan dengan mendefinisikan beberapa frasa.
|
||||
|
||||
1. Buat bot ini sendiri dalam Python dengan respons rawak berikut:
|
||||
|
||||
```python
|
||||
random_responses = ["That is quite interesting, please tell me more.",
|
||||
"I see. Do go on.",
|
||||
"Why do you say that?",
|
||||
"Funny weather we've been having, isn't it?",
|
||||
"Let's change the subject.",
|
||||
"Did you catch the game last night?"]
|
||||
```
|
||||
|
||||
Berikut adalah beberapa output contoh untuk panduan anda (input pengguna pada baris yang bermula dengan `>`):
|
||||
|
||||
```output
|
||||
Hello, I am Marvin, the simple robot.
|
||||
You can end this conversation at any time by typing 'bye'
|
||||
After typing each answer, press 'enter'
|
||||
How are you today?
|
||||
> I am good thanks
|
||||
That is quite interesting, please tell me more.
|
||||
> today I went for a walk
|
||||
Did you catch the game last night?
|
||||
> I did, but my team lost
|
||||
Funny weather we've been having, isn't it?
|
||||
> yes but I hope next week is better
|
||||
Let's change the subject.
|
||||
> ok, lets talk about music
|
||||
Why do you say that?
|
||||
> because I like music!
|
||||
Why do you say that?
|
||||
> bye
|
||||
It was nice talking to you, goodbye!
|
||||
```
|
||||
|
||||
Satu penyelesaian yang mungkin untuk tugas ini adalah [di sini](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/1-Introduction-to-NLP/solution/bot.py)
|
||||
|
||||
✅ Berhenti dan pertimbangkan
|
||||
|
||||
1. Adakah anda fikir respons rawak akan 'menipu' seseorang untuk berfikir bahawa bot sebenarnya memahami mereka?
|
||||
2. Apakah ciri-ciri yang perlu ada pada bot untuk menjadi lebih berkesan?
|
||||
3. Jika bot benar-benar boleh 'memahami' makna ayat, adakah ia perlu 'mengingati' makna ayat-ayat sebelumnya dalam perbualan juga?
|
||||
|
||||
---
|
||||
|
||||
## 🚀Cabaran
|
||||
|
||||
Pilih salah satu elemen "berhenti dan pertimbangkan" di atas dan sama ada cuba melaksanakannya dalam kod atau tulis penyelesaian di atas kertas menggunakan pseudokod.
|
||||
|
||||
Dalam pelajaran seterusnya, anda akan belajar tentang beberapa pendekatan lain untuk menguraikan bahasa semulajadi dan pembelajaran mesin.
|
||||
|
||||
## [Kuiz pasca-ceramah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/32/)
|
||||
|
||||
## Kajian Semula & Kajian Sendiri
|
||||
|
||||
Lihat rujukan di bawah sebagai peluang bacaan lanjut.
|
||||
|
||||
### Rujukan
|
||||
|
||||
1. Schubert, Lenhart, "Linguistik Komputasi", *The Stanford Encyclopedia of Philosophy* (Edisi Musim Bunga 2020), Edward N. Zalta (ed.), URL = <https://plato.stanford.edu/archives/spr2020/entries/computational-linguistics/>.
|
||||
2. Princeton University "About WordNet." [WordNet](https://wordnet.princeton.edu/). Princeton University. 2010.
|
||||
|
||||
## Tugasan
|
||||
|
||||
[Cari bot](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,14 +0,0 @@
|
||||
# Cari Bot
|
||||
|
||||
## Arahan
|
||||
|
||||
Bot ada di mana-mana. Tugas anda: cari satu dan ambil ia sebagai milik anda! Anda boleh menemui mereka di laman web, dalam aplikasi perbankan, dan di telefon, contohnya apabila anda menghubungi syarikat perkhidmatan kewangan untuk nasihat atau maklumat akaun. Analisis bot tersebut dan lihat jika anda boleh mengelirukannya. Jika anda boleh mengelirukan bot tersebut, mengapa anda fikir itu berlaku? Tulis satu kertas pendek tentang pengalaman anda.
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Contoh | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | ----------------------------------------------------------------------------------------------------------- | ------------------------------------------- | --------------------- |
|
||||
| | Satu kertas penuh ditulis, menerangkan andaian seni bina bot dan menggariskan pengalaman anda dengannya | Kertas tidak lengkap atau tidak cukup diselidik | Tiada kertas diserahkan |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,217 +0,0 @@
|
||||
# Tugas dan Teknik Pemprosesan Bahasa Semulajadi yang Biasa
|
||||
|
||||
Untuk kebanyakan tugas *pemprosesan bahasa semulajadi*, teks yang hendak diproses mesti dipecahkan, diperiksa, dan hasilnya disimpan atau dirujuk silang dengan peraturan dan set data. Tugas-tugas ini membolehkan pengaturcara untuk mendapatkan _makna_ atau _niat_ atau hanya _kekerapan_ istilah dan kata dalam teks.
|
||||
|
||||
## [Kuiz pra-kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/33/)
|
||||
|
||||
Mari kita terokai teknik-teknik biasa yang digunakan dalam memproses teks. Digabungkan dengan pembelajaran mesin, teknik-teknik ini membantu anda menganalisis sejumlah besar teks dengan efisien. Sebelum menerapkan ML kepada tugas-tugas ini, mari kita fahami masalah yang dihadapi oleh pakar NLP.
|
||||
|
||||
## Tugas biasa dalam NLP
|
||||
|
||||
Terdapat pelbagai cara untuk menganalisis teks yang anda sedang kerjakan. Terdapat tugas-tugas yang boleh anda lakukan dan melalui tugas-tugas ini anda dapat memahami teks dan membuat kesimpulan. Biasanya anda menjalankan tugas-tugas ini secara berurutan.
|
||||
|
||||
### Tokenisasi
|
||||
|
||||
Mungkin perkara pertama yang perlu dilakukan oleh kebanyakan algoritma NLP adalah memecahkan teks kepada token, atau kata-kata. Walaupun ini kedengaran mudah, perlu mengambil kira tanda baca dan pembatas kata dan ayat dari pelbagai bahasa boleh membuatnya rumit. Anda mungkin perlu menggunakan pelbagai kaedah untuk menentukan sempadan.
|
||||
|
||||
|
||||
> Tokenisasi ayat dari **Pride and Prejudice**. Infografik oleh [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
### Embeddings
|
||||
|
||||
[Word embeddings](https://wikipedia.org/wiki/Word_embedding) adalah cara untuk menukar data teks anda secara numerik. Embeddings dilakukan dengan cara supaya kata-kata yang mempunyai makna serupa atau kata-kata yang digunakan bersama berkumpul bersama.
|
||||
|
||||
|
||||
> "I have the highest respect for your nerves, they are my old friends." - Word embeddings untuk ayat dalam **Pride and Prejudice**. Infografik oleh [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
✅ Cuba [alat menarik ini](https://projector.tensorflow.org/) untuk bereksperimen dengan word embeddings. Mengklik pada satu kata menunjukkan kumpulan kata-kata yang serupa: 'toy' berkumpul dengan 'disney', 'lego', 'playstation', dan 'console'.
|
||||
|
||||
### Parsing & Tagging Bahagian Ucapan
|
||||
|
||||
Setiap kata yang telah ditokenkan boleh ditandakan sebagai bahagian ucapan - kata nama, kata kerja, atau kata sifat. Ayat `the quick red fox jumped over the lazy brown dog` mungkin ditandakan POS sebagai fox = kata nama, jumped = kata kerja.
|
||||
|
||||
|
||||
|
||||
> Parsing ayat dari **Pride and Prejudice**. Infografik oleh [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
Parsing adalah mengenali kata-kata yang berkaitan antara satu sama lain dalam satu ayat - sebagai contoh `the quick red fox jumped` adalah urutan kata sifat-kata nama-kata kerja yang berasingan dari urutan `lazy brown dog`.
|
||||
|
||||
### Kekerapan Kata dan Frasa
|
||||
|
||||
Prosedur yang berguna apabila menganalisis sejumlah besar teks adalah membina kamus setiap kata atau frasa yang menarik dan seberapa kerap ia muncul. Frasa `the quick red fox jumped over the lazy brown dog` mempunyai kekerapan kata 2 untuk the.
|
||||
|
||||
Mari kita lihat contoh teks di mana kita mengira kekerapan kata. Puisi Rudyard Kipling The Winners mengandungi ayat berikut:
|
||||
|
||||
```output
|
||||
What the moral? Who rides may read.
|
||||
When the night is thick and the tracks are blind
|
||||
A friend at a pinch is a friend, indeed,
|
||||
But a fool to wait for the laggard behind.
|
||||
Down to Gehenna or up to the Throne,
|
||||
He travels the fastest who travels alone.
|
||||
```
|
||||
|
||||
Oleh kerana kekerapan frasa boleh tidak sensitif huruf besar atau sensitif huruf besar seperti yang diperlukan, frasa `a friend` has a frequency of 2 and `the` has a frequency of 6, and `travels` adalah 2.
|
||||
|
||||
### N-grams
|
||||
|
||||
Teks boleh dipecahkan kepada urutan kata dengan panjang yang ditetapkan, satu kata (unigram), dua kata (bigrams), tiga kata (trigrams) atau sebarang bilangan kata (n-grams).
|
||||
|
||||
Sebagai contoh `the quick red fox jumped over the lazy brown dog` dengan skor n-gram 2 menghasilkan n-grams berikut:
|
||||
|
||||
1. the quick
|
||||
2. quick red
|
||||
3. red fox
|
||||
4. fox jumped
|
||||
5. jumped over
|
||||
6. over the
|
||||
7. the lazy
|
||||
8. lazy brown
|
||||
9. brown dog
|
||||
|
||||
Ia mungkin lebih mudah untuk membayangkannya sebagai kotak gelongsor di atas ayat. Ini adalah untuk n-grams 3 kata, n-gram adalah tebal dalam setiap ayat:
|
||||
|
||||
1. <u>**the quick red**</u> fox jumped over the lazy brown dog
|
||||
2. the **<u>quick red fox</u>** jumped over the lazy brown dog
|
||||
3. the quick **<u>red fox jumped</u>** over the lazy brown dog
|
||||
4. the quick red **<u>fox jumped over</u>** the lazy brown dog
|
||||
5. the quick red fox **<u>jumped over the</u>** lazy brown dog
|
||||
6. the quick red fox jumped **<u>over the lazy</u>** brown dog
|
||||
7. the quick red fox jumped over <u>**the lazy brown**</u> dog
|
||||
8. the quick red fox jumped over the **<u>lazy brown dog</u>**
|
||||
|
||||
|
||||
|
||||
> Nilai N-gram 3: Infografik oleh [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
### Ekstraksi Frasa Kata Nama
|
||||
|
||||
Dalam kebanyakan ayat, terdapat kata nama yang menjadi subjek, atau objek ayat. Dalam bahasa Inggeris, ia sering boleh dikenal pasti sebagai mempunyai 'a' atau 'an' atau 'the' sebelum ia. Mengenal pasti subjek atau objek ayat dengan 'mengekstrak frasa kata nama' adalah tugas biasa dalam NLP apabila cuba memahami makna ayat.
|
||||
|
||||
✅ Dalam ayat "I cannot fix on the hour, or the spot, or the look or the words, which laid the foundation. It is too long ago. I was in the middle before I knew that I had begun.", bolehkah anda mengenal pasti frasa kata nama?
|
||||
|
||||
Dalam ayat `the quick red fox jumped over the lazy brown dog` terdapat 2 frasa kata nama: **quick red fox** dan **lazy brown dog**.
|
||||
|
||||
### Analisis Sentimen
|
||||
|
||||
Satu ayat atau teks boleh dianalisis untuk sentimen, atau betapa *positif* atau *negatif* ia. Sentimen diukur dalam *polariti* dan *objektiviti/subjektiviti*. Polariti diukur dari -1.0 hingga 1.0 (negatif ke positif) dan 0.0 hingga 1.0 (paling objektif ke paling subjektif).
|
||||
|
||||
✅ Kemudian anda akan belajar bahawa terdapat pelbagai cara untuk menentukan sentimen menggunakan pembelajaran mesin, tetapi satu cara adalah mempunyai senarai kata dan frasa yang dikategorikan sebagai positif atau negatif oleh pakar manusia dan menerapkan model itu kepada teks untuk mengira skor polariti. Bolehkah anda melihat bagaimana ini berfungsi dalam beberapa keadaan dan kurang baik dalam keadaan lain?
|
||||
|
||||
### Infleksi
|
||||
|
||||
Infleksi membolehkan anda mengambil satu kata dan mendapatkan bentuk tunggal atau jamak kata tersebut.
|
||||
|
||||
### Lematisasi
|
||||
|
||||
*Lema* adalah akar atau kata kepala untuk satu set kata, contohnya *flew*, *flies*, *flying* mempunyai lema kata kerja *fly*.
|
||||
|
||||
Terdapat juga pangkalan data yang berguna untuk penyelidik NLP, terutamanya:
|
||||
|
||||
### WordNet
|
||||
|
||||
[WordNet](https://wordnet.princeton.edu/) adalah pangkalan data kata, sinonim, antonim dan banyak butiran lain untuk setiap kata dalam pelbagai bahasa. Ia sangat berguna apabila cuba membina terjemahan, pemeriksa ejaan, atau alat bahasa dari sebarang jenis.
|
||||
|
||||
## Perpustakaan NLP
|
||||
|
||||
Nasib baik, anda tidak perlu membina semua teknik ini sendiri, kerana terdapat perpustakaan Python yang sangat baik yang menjadikannya lebih mudah diakses oleh pembangun yang tidak pakar dalam pemprosesan bahasa semulajadi atau pembelajaran mesin. Pelajaran seterusnya termasuk lebih banyak contoh ini, tetapi di sini anda akan belajar beberapa contoh berguna untuk membantu anda dengan tugas seterusnya.
|
||||
|
||||
### Latihan - menggunakan `TextBlob` library
|
||||
|
||||
Let's use a library called TextBlob as it contains helpful APIs for tackling these types of tasks. TextBlob "stands on the giant shoulders of [NLTK](https://nltk.org) and [pattern](https://github.com/clips/pattern), and plays nicely with both." It has a considerable amount of ML embedded in its API.
|
||||
|
||||
> Note: A useful [Quick Start](https://textblob.readthedocs.io/en/dev/quickstart.html#quickstart) guide is available for TextBlob that is recommended for experienced Python developers
|
||||
|
||||
When attempting to identify *noun phrases*, TextBlob offers several options of extractors to find noun phrases.
|
||||
|
||||
1. Take a look at `ConllExtractor`.
|
||||
|
||||
```python
|
||||
from textblob import TextBlob
|
||||
from textblob.np_extractors import ConllExtractor
|
||||
# import and create a Conll extractor to use later
|
||||
extractor = ConllExtractor()
|
||||
|
||||
# later when you need a noun phrase extractor:
|
||||
user_input = input("> ")
|
||||
user_input_blob = TextBlob(user_input, np_extractor=extractor) # note non-default extractor specified
|
||||
np = user_input_blob.noun_phrases
|
||||
```
|
||||
|
||||
> Apa yang berlaku di sini? [ConllExtractor](https://textblob.readthedocs.io/en/dev/api_reference.html?highlight=Conll#textblob.en.np_extractors.ConllExtractor) adalah "Pengestrak frasa kata nama yang menggunakan parsing chunk yang dilatih dengan korpus latihan ConLL-2000." ConLL-2000 merujuk kepada Persidangan Pembelajaran Bahasa Semulajadi Komputasi tahun 2000. Setiap tahun persidangan tersebut mengadakan bengkel untuk menangani masalah NLP yang sukar, dan pada tahun 2000 ia adalah chunking kata nama. Model ini dilatih pada Wall Street Journal, dengan "bahagian 15-18 sebagai data latihan (211727 token) dan bahagian 20 sebagai data ujian (47377 token)". Anda boleh melihat prosedur yang digunakan [di sini](https://www.clips.uantwerpen.be/conll2000/chunking/) dan [hasilnya](https://ifarm.nl/erikt/research/np-chunking.html).
|
||||
|
||||
### Cabaran - meningkatkan bot anda dengan NLP
|
||||
|
||||
Dalam pelajaran sebelumnya anda membina bot Q&A yang sangat mudah. Sekarang, anda akan membuat Marvin lebih simpatik dengan menganalisis input anda untuk sentimen dan mencetak respons yang sesuai dengan sentimen tersebut. Anda juga perlu mengenal pasti `noun_phrase` dan bertanya mengenainya.
|
||||
|
||||
Langkah-langkah anda semasa membina bot perbualan yang lebih baik:
|
||||
|
||||
1. Cetak arahan yang memberi nasihat kepada pengguna cara berinteraksi dengan bot
|
||||
2. Mulakan gelung
|
||||
1. Terima input pengguna
|
||||
2. Jika pengguna meminta untuk keluar, maka keluar
|
||||
3. Proses input pengguna dan tentukan respons sentimen yang sesuai
|
||||
4. Jika frasa kata nama dikesan dalam sentimen, jamakkan ia dan minta input lanjut mengenai topik tersebut
|
||||
5. Cetak respons
|
||||
3. kembali ke langkah 2
|
||||
|
||||
Berikut adalah snippet kod untuk menentukan sentimen menggunakan TextBlob. Perhatikan hanya terdapat empat *gradien* respons sentimen (anda boleh mempunyai lebih banyak jika anda suka):
|
||||
|
||||
```python
|
||||
if user_input_blob.polarity <= -0.5:
|
||||
response = "Oh dear, that sounds bad. "
|
||||
elif user_input_blob.polarity <= 0:
|
||||
response = "Hmm, that's not great. "
|
||||
elif user_input_blob.polarity <= 0.5:
|
||||
response = "Well, that sounds positive. "
|
||||
elif user_input_blob.polarity <= 1:
|
||||
response = "Wow, that sounds great. "
|
||||
```
|
||||
|
||||
Berikut adalah beberapa output contoh untuk membimbing anda (input pengguna adalah pada baris yang bermula dengan >):
|
||||
|
||||
```output
|
||||
Hello, I am Marvin, the friendly robot.
|
||||
You can end this conversation at any time by typing 'bye'
|
||||
After typing each answer, press 'enter'
|
||||
How are you today?
|
||||
> I am ok
|
||||
Well, that sounds positive. Can you tell me more?
|
||||
> I went for a walk and saw a lovely cat
|
||||
Well, that sounds positive. Can you tell me more about lovely cats?
|
||||
> cats are the best. But I also have a cool dog
|
||||
Wow, that sounds great. Can you tell me more about cool dogs?
|
||||
> I have an old hounddog but he is sick
|
||||
Hmm, that's not great. Can you tell me more about old hounddogs?
|
||||
> bye
|
||||
It was nice talking to you, goodbye!
|
||||
```
|
||||
|
||||
Satu penyelesaian yang mungkin untuk tugas ini adalah [di sini](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/2-Tasks/solution/bot.py)
|
||||
|
||||
✅ Semak Pengetahuan
|
||||
|
||||
1. Adakah anda fikir respons yang simpatik akan 'menipu' seseorang untuk berfikir bahawa bot sebenarnya memahami mereka?
|
||||
2. Adakah mengenal pasti frasa kata nama menjadikan bot lebih 'boleh dipercayai'?
|
||||
3. Mengapa mengekstrak 'frasa kata nama' dari ayat merupakan perkara yang berguna untuk dilakukan?
|
||||
|
||||
---
|
||||
|
||||
Laksanakan bot dalam semak pengetahuan sebelumnya dan uji pada seorang rakan. Bolehkah ia menipu mereka? Bolehkah anda menjadikan bot anda lebih 'boleh dipercayai'?
|
||||
|
||||
## 🚀Cabaran
|
||||
|
||||
Ambil satu tugas dalam semak pengetahuan sebelumnya dan cuba melaksanakannya. Uji bot pada seorang rakan. Bolehkah ia menipu mereka? Bolehkah anda menjadikan bot anda lebih 'boleh dipercayai'?
|
||||
|
||||
## [Kuiz pasca-kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/34/)
|
||||
|
||||
## Kajian & Kajian Kendiri
|
||||
|
||||
Dalam beberapa pelajaran berikutnya, anda akan belajar lebih lanjut mengenai analisis sentimen. Selidiki teknik menarik ini dalam artikel seperti ini di [KDNuggets](https://www.kdnuggets.com/tag/nlp)
|
||||
|
||||
## Tugasan
|
||||
|
||||
[Buat bot bercakap balik](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,14 +0,0 @@
|
||||
# Buat Bot Berbicara Balik
|
||||
|
||||
## Arahan
|
||||
|
||||
Dalam beberapa pelajaran sebelumnya, anda telah memprogram sebuah bot dasar untuk berbicara. Bot ini memberikan jawapan rawak sehingga anda mengatakan 'bye'. Bolehkah anda membuat jawapan tersebut menjadi kurang rawak, dan mencetuskan jawapan jika anda mengatakan perkara tertentu, seperti 'why' atau 'how'? Fikirkan sedikit bagaimana pembelajaran mesin mungkin membuat jenis kerja ini kurang manual semasa anda memperluas bot anda. Anda boleh menggunakan perpustakaan NLTK atau TextBlob untuk memudahkan tugas anda.
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | ---------------------------------------------- | ------------------------------------------------- | ----------------------- |
|
||||
| | Fail bot.py baru disediakan dan didokumentasikan | Fail bot baru disediakan tetapi mengandungi bug | Fail tidak disediakan |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,14 +0,0 @@
|
||||
# Lesen Puitis
|
||||
|
||||
## Arahan
|
||||
|
||||
Dalam [notebook ini](https://www.kaggle.com/jenlooper/emily-dickinson-word-frequency) anda boleh menemui lebih daripada 500 puisi Emily Dickinson yang telah dianalisis untuk sentimen menggunakan Azure text analytics. Menggunakan dataset ini, analisislah ia menggunakan teknik yang diterangkan dalam pelajaran. Adakah sentimen yang dicadangkan dalam sebuah puisi sepadan dengan keputusan perkhidmatan Azure yang lebih canggih? Mengapa atau mengapa tidak, pada pendapat anda? Adakah sesuatu yang mengejutkan anda?
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | ------------------------------------------------------------------------- | ------------------------------------------------------- | ------------------------ |
|
||||
| | Notebook yang dipersembahkan dengan analisis yang kukuh terhadap output sampel penulis | Notebook tidak lengkap atau tidak melakukan analisis | Tiada notebook dipersembahkan |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional disyorkan. Kami tidak bertanggungjawab ke atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,303 +0,0 @@
|
||||
# Analisis Sentimen dengan Ulasan Hotel - Memproses Data
|
||||
|
||||
Dalam bagian ini, Anda akan menggunakan teknik yang telah dipelajari dalam pelajaran sebelumnya untuk melakukan analisis data eksplorasi pada dataset besar. Setelah Anda memiliki pemahaman yang baik tentang kegunaan berbagai kolom, Anda akan belajar:
|
||||
|
||||
- bagaimana menghapus kolom yang tidak diperlukan
|
||||
- bagaimana menghitung beberapa data baru berdasarkan kolom yang ada
|
||||
- bagaimana menyimpan dataset yang dihasilkan untuk digunakan dalam tantangan akhir
|
||||
|
||||
## [Kuis Pra-Kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/37/)
|
||||
|
||||
### Pengenalan
|
||||
|
||||
Sejauh ini Anda telah belajar tentang bagaimana data teks sangat berbeda dengan jenis data numerik. Jika itu adalah teks yang ditulis atau diucapkan oleh manusia, dapat dianalisis untuk menemukan pola dan frekuensi, sentimen, dan makna. Pelajaran ini membawa Anda ke dalam dataset nyata dengan tantangan nyata: **[515K Hotel Reviews Data in Europe](https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe)** dan termasuk [lisensi CC0: Domain Publik](https://creativecommons.org/publicdomain/zero/1.0/). Dataset ini diambil dari Booking.com dari sumber publik. Pembuat dataset ini adalah Jiashen Liu.
|
||||
|
||||
### Persiapan
|
||||
|
||||
Anda akan membutuhkan:
|
||||
|
||||
* Kemampuan untuk menjalankan notebook .ipynb menggunakan Python 3
|
||||
* pandas
|
||||
* NLTK, [yang harus Anda instal secara lokal](https://www.nltk.org/install.html)
|
||||
* Dataset yang tersedia di Kaggle [515K Hotel Reviews Data in Europe](https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe). Ukurannya sekitar 230 MB setelah diekstrak. Unduh ke folder root `/data` yang terkait dengan pelajaran NLP ini.
|
||||
|
||||
## Analisis data eksplorasi
|
||||
|
||||
Tantangan ini mengasumsikan bahwa Anda sedang membangun bot rekomendasi hotel menggunakan analisis sentimen dan skor ulasan tamu. Dataset yang akan Anda gunakan mencakup ulasan dari 1493 hotel berbeda di 6 kota.
|
||||
|
||||
Menggunakan Python, dataset ulasan hotel, dan analisis sentimen NLTK Anda bisa mengetahui:
|
||||
|
||||
* Apa kata dan frasa yang paling sering digunakan dalam ulasan?
|
||||
* Apakah *tag* resmi yang menggambarkan hotel berkorelasi dengan skor ulasan (misalnya apakah ulasan lebih negatif untuk hotel tertentu untuk *Keluarga dengan anak kecil* dibandingkan dengan *Pelancong Solo*, mungkin menunjukkan bahwa hotel tersebut lebih baik untuk *Pelancong Solo*?)
|
||||
* Apakah skor sentimen NLTK 'setuju' dengan skor numerik ulasan hotel?
|
||||
|
||||
#### Dataset
|
||||
|
||||
Mari kita jelajahi dataset yang telah Anda unduh dan simpan secara lokal. Buka file dalam editor seperti VS Code atau bahkan Excel.
|
||||
|
||||
Header dalam dataset adalah sebagai berikut:
|
||||
|
||||
*Hotel_Address, Additional_Number_of_Scoring, Review_Date, Average_Score, Hotel_Name, Reviewer_Nationality, Negative_Review, Review_Total_Negative_Word_Counts, Total_Number_of_Reviews, Positive_Review, Review_Total_Positive_Word_Counts, Total_Number_of_Reviews_Reviewer_Has_Given, Reviewer_Score, Tags, days_since_review, lat, lng*
|
||||
|
||||
Berikut ini mereka dikelompokkan dengan cara yang mungkin lebih mudah untuk diperiksa:
|
||||
##### Kolom Hotel
|
||||
|
||||
* `Hotel_Name`, `Hotel_Address`, `lat` (latitude), `lng` (longitude)
|
||||
* Menggunakan *lat* dan *lng* Anda bisa memetakan lokasi hotel dengan Python (mungkin diberi kode warna untuk ulasan negatif dan positif)
|
||||
* Hotel_Address tidak jelas bermanfaat bagi kita, dan kita mungkin akan menggantinya dengan negara untuk memudahkan pengurutan & pencarian
|
||||
|
||||
**Kolom Meta-ulasan Hotel**
|
||||
|
||||
* `Average_Score`
|
||||
* Menurut pembuat dataset, kolom ini adalah *Skor Rata-rata hotel, dihitung berdasarkan komentar terbaru dalam setahun terakhir*. Ini tampaknya cara yang tidak biasa untuk menghitung skor, tetapi ini adalah data yang diambil sehingga kita mungkin menerimanya apa adanya untuk saat ini.
|
||||
|
||||
✅ Berdasarkan kolom lain dalam data ini, dapatkah Anda memikirkan cara lain untuk menghitung skor rata-rata?
|
||||
|
||||
* `Total_Number_of_Reviews`
|
||||
* Jumlah total ulasan yang diterima hotel ini - tidak jelas (tanpa menulis beberapa kode) apakah ini mengacu pada ulasan dalam dataset.
|
||||
* `Additional_Number_of_Scoring`
|
||||
* Ini berarti skor ulasan diberikan tetapi tidak ada ulasan positif atau negatif yang ditulis oleh pengulas
|
||||
|
||||
**Kolom Ulasan**
|
||||
|
||||
- `Reviewer_Score`
|
||||
- Ini adalah nilai numerik dengan paling banyak 1 tempat desimal antara nilai minimum dan maksimum 2.5 dan 10
|
||||
- Tidak dijelaskan mengapa 2.5 adalah skor terendah yang mungkin
|
||||
- `Negative_Review`
|
||||
- Jika seorang pengulas tidak menulis apa-apa, kolom ini akan berisi "**No Negative**"
|
||||
- Perhatikan bahwa seorang pengulas mungkin menulis ulasan positif di kolom Ulasan Negatif (misalnya "tidak ada yang buruk tentang hotel ini")
|
||||
- `Review_Total_Negative_Word_Counts`
|
||||
- Jumlah kata negatif yang lebih tinggi menunjukkan skor yang lebih rendah (tanpa memeriksa sentimen)
|
||||
- `Positive_Review`
|
||||
- Jika seorang pengulas tidak menulis apa-apa, kolom ini akan berisi "**No Positive**"
|
||||
- Perhatikan bahwa seorang pengulas mungkin menulis ulasan negatif di kolom Ulasan Positif (misalnya "tidak ada yang baik tentang hotel ini sama sekali")
|
||||
- `Review_Total_Positive_Word_Counts`
|
||||
- Jumlah kata positif yang lebih tinggi menunjukkan skor yang lebih tinggi (tanpa memeriksa sentimen)
|
||||
- `Review_Date` dan `days_since_review`
|
||||
- Sebuah ukuran kesegaran atau ketidakaktualan dapat diterapkan pada ulasan (ulasan yang lebih lama mungkin tidak seakurat yang lebih baru karena manajemen hotel berubah, atau renovasi telah dilakukan, atau kolam renang ditambahkan, dll.)
|
||||
- `Tags`
|
||||
- Ini adalah deskriptor pendek yang mungkin dipilih pengulas untuk menggambarkan jenis tamu mereka (misalnya solo atau keluarga), jenis kamar yang mereka miliki, lama menginap dan bagaimana ulasan diajukan.
|
||||
- Sayangnya, menggunakan tag ini bermasalah, lihat bagian di bawah yang membahas kegunaannya
|
||||
|
||||
**Kolom Pengulas**
|
||||
|
||||
- `Total_Number_of_Reviews_Reviewer_Has_Given`
|
||||
- Ini mungkin menjadi faktor dalam model rekomendasi, misalnya, jika Anda dapat menentukan bahwa pengulas yang lebih produktif dengan ratusan ulasan lebih cenderung negatif daripada positif. Namun, pengulas dari ulasan tertentu tidak diidentifikasi dengan kode unik, dan oleh karena itu tidak dapat dikaitkan dengan satu set ulasan. Ada 30 pengulas dengan 100 atau lebih ulasan, tetapi sulit untuk melihat bagaimana ini dapat membantu model rekomendasi.
|
||||
- `Reviewer_Nationality`
|
||||
- Beberapa orang mungkin berpikir bahwa kebangsaan tertentu lebih cenderung memberikan ulasan positif atau negatif karena kecenderungan nasional. Berhati-hatilah membangun pandangan anekdotal seperti itu ke dalam model Anda. Ini adalah stereotip nasional (dan terkadang rasial), dan setiap pengulas adalah individu yang menulis ulasan berdasarkan pengalaman mereka. Mungkin telah disaring melalui banyak lensa seperti pengalaman hotel sebelumnya, jarak yang ditempuh, dan temperamen pribadi mereka. Berpikir bahwa kebangsaan mereka adalah alasan untuk skor ulasan sulit untuk dibenarkan.
|
||||
|
||||
##### Contoh
|
||||
|
||||
| Skor Rata-rata | Total Jumlah Ulasan | Skor Pengulas | Ulasan <br />Negatif | Ulasan Positif | Tag |
|
||||
| -------------- | ------------------- | ------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ----------------------------------------------------------------------------------------- |
|
||||
| 7.8 | 1945 | 2.5 | Saat ini ini bukan hotel tetapi situs konstruksi Saya diteror dari pagi hari dan sepanjang hari dengan kebisingan bangunan yang tidak dapat diterima saat beristirahat setelah perjalanan panjang dan bekerja di kamar Orang-orang bekerja sepanjang hari dengan palu di kamar yang bersebelahan Saya meminta untuk pindah kamar tetapi tidak ada kamar yang tenang tersedia Untuk memperburuk keadaan saya dikenakan biaya lebih Saya check out di malam hari karena saya harus berangkat sangat pagi penerbangan dan menerima tagihan yang sesuai Sehari kemudian hotel membuat biaya lain tanpa persetujuan saya melebihi harga yang dipesan Ini tempat yang mengerikan Jangan menghukum diri Anda dengan memesan di sini | Tidak ada tempat yang mengerikan | Perjalanan bisnis Pasangan Kamar Double Standar Menginap 2 malam |
|
||||
|
||||
Seperti yang Anda lihat, tamu ini tidak memiliki pengalaman menginap yang menyenangkan di hotel ini. Hotel ini memiliki skor rata-rata yang baik yaitu 7.8 dan 1945 ulasan, tetapi pengulas ini memberikan skor 2.5 dan menulis 115 kata tentang betapa negatifnya pengalaman mereka. Jika mereka tidak menulis apa pun di kolom Ulasan_Positive, Anda mungkin menyimpulkan bahwa tidak ada yang positif, tetapi sayangnya mereka menulis 7 kata peringatan. Jika kita hanya menghitung kata-kata alih-alih makna, atau sentimen dari kata-kata tersebut, kita mungkin memiliki pandangan yang miring tentang niat pengulas. Anehnya, skor mereka yang 2.5 membingungkan, karena jika pengalaman menginap di hotel itu sangat buruk, mengapa memberikan poin sama sekali? Menyelidiki dataset dengan cermat, Anda akan melihat bahwa skor terendah yang mungkin adalah 2.5, bukan 0. Skor tertinggi yang mungkin adalah 10.
|
||||
|
||||
##### Tag
|
||||
|
||||
Seperti disebutkan di atas, pada pandangan pertama, ide untuk menggunakan `Tags` untuk mengkategorikan data masuk akal. Sayangnya, tag ini tidak distandarisasi, yang berarti bahwa di hotel tertentu, opsinya mungkin *Kamar Single*, *Kamar Twin*, dan *Kamar Double*, tetapi di hotel berikutnya, mereka adalah *Kamar Single Deluxe*, *Kamar Queen Klasik*, dan *Kamar King Eksekutif*. Ini mungkin hal yang sama, tetapi ada begitu banyak variasi sehingga pilihannya menjadi:
|
||||
|
||||
1. Mencoba mengubah semua istilah menjadi satu standar, yang sangat sulit, karena tidak jelas apa jalur konversinya dalam setiap kasus (misalnya *Kamar single klasik* dipetakan ke *Kamar single* tetapi *Kamar Queen Superior dengan Pemandangan Taman atau Kota* jauh lebih sulit untuk dipetakan)
|
||||
|
||||
1. Kita dapat mengambil pendekatan NLP dan mengukur frekuensi istilah tertentu seperti *Solo*, *Pelancong Bisnis*, atau *Keluarga dengan anak kecil* karena berlaku untuk setiap hotel, dan memasukkan itu ke dalam rekomendasi
|
||||
|
||||
Tag biasanya (tetapi tidak selalu) merupakan satu bidang yang berisi daftar 5 hingga 6 nilai yang dipisahkan dengan koma yang sesuai dengan *Jenis perjalanan*, *Jenis tamu*, *Jenis kamar*, *Jumlah malam*, dan *Jenis perangkat yang digunakan untuk mengirimkan ulasan*. Namun, karena beberapa pengulas tidak mengisi setiap bidang (mereka mungkin meninggalkan satu kosong), nilainya tidak selalu dalam urutan yang sama.
|
||||
|
||||
Sebagai contoh, ambil *Jenis grup*. Ada 1025 kemungkinan unik dalam bidang ini di kolom `Tags`, dan sayangnya hanya beberapa dari mereka yang merujuk pada grup (beberapa adalah jenis kamar, dll.). Jika Anda memfilter hanya yang menyebutkan keluarga, hasilnya mengandung banyak hasil tipe *Kamar keluarga*. Jika Anda memasukkan istilah *dengan*, yaitu menghitung nilai *Keluarga dengan*, hasilnya lebih baik, dengan lebih dari 80.000 dari 515.000 hasil yang mengandung frasa "Keluarga dengan anak kecil" atau "Keluarga dengan anak yang lebih tua".
|
||||
|
||||
Ini berarti kolom tag tidak sepenuhnya tidak berguna bagi kita, tetapi akan membutuhkan beberapa pekerjaan untuk membuatnya berguna.
|
||||
|
||||
##### Skor rata-rata hotel
|
||||
|
||||
Ada sejumlah keanehan atau ketidaksesuaian dengan dataset yang tidak bisa saya pahami, tetapi diilustrasikan di sini sehingga Anda menyadarinya saat membangun model Anda. Jika Anda mengetahuinya, beri tahu kami di bagian diskusi!
|
||||
|
||||
Dataset ini memiliki kolom berikut yang berkaitan dengan skor rata-rata dan jumlah ulasan:
|
||||
|
||||
1. Hotel_Name
|
||||
2. Additional_Number_of_Scoring
|
||||
3. Average_Score
|
||||
4. Total_Number_of_Reviews
|
||||
5. Reviewer_Score
|
||||
|
||||
Hotel tunggal dengan ulasan terbanyak dalam dataset ini adalah *Britannia International Hotel Canary Wharf* dengan 4789 ulasan dari 515.000. Tetapi jika kita melihat nilai `Total_Number_of_Reviews` untuk hotel ini, nilainya adalah 9086. Anda mungkin menyimpulkan bahwa ada banyak skor tanpa ulasan, jadi mungkin kita harus menambahkan nilai kolom `Additional_Number_of_Scoring`. Nilai itu adalah 2682, dan menambahkannya ke 4789 memberi kita 7.471 yang masih 1615 kurang dari `Total_Number_of_Reviews`.
|
||||
|
||||
Jika Anda mengambil kolom `Average_Score`, Anda mungkin menyimpulkan bahwa itu adalah rata-rata dari ulasan dalam dataset, tetapi deskripsi dari Kaggle adalah "*Skor Rata-rata hotel, dihitung berdasarkan komentar terbaru dalam setahun terakhir*". Itu tampaknya tidak terlalu berguna, tetapi kita dapat menghitung rata-rata kita sendiri berdasarkan skor ulasan dalam dataset. Menggunakan hotel yang sama sebagai contoh, skor rata-rata hotel yang diberikan adalah 7.1 tetapi skor yang dihitung (rata-rata skor pengulas *dalam* dataset) adalah 6.8. Ini dekat, tetapi bukan nilai yang sama, dan kita hanya bisa menebak bahwa skor yang diberikan dalam ulasan `Additional_Number_of_Scoring` meningkatkan rata-rata menjadi 7.1. Sayangnya, tanpa cara untuk menguji atau membuktikan pernyataan tersebut, sulit untuk menggunakan atau mempercayai `Average_Score`, `Additional_Number_of_Scoring` dan `Total_Number_of_Reviews` ketika mereka didasarkan pada, atau merujuk pada, data yang tidak kita miliki.
|
||||
|
||||
Untuk memperumit masalah lebih lanjut, hotel dengan jumlah ulasan tertinggi kedua memiliki skor rata-rata yang dihitung sebesar 8.12 dan dataset `Average_Score` adalah 8.1. Apakah skor yang benar ini kebetulan atau apakah hotel pertama adalah ketidaksesuaian?
|
||||
|
||||
Dengan kemungkinan bahwa hotel ini mungkin merupakan outlier, dan mungkin sebagian besar nilai cocok (tetapi beberapa tidak karena alasan tertentu) kita akan menulis program singkat berikutnya untuk mengeksplorasi nilai-nilai dalam dataset dan menentukan penggunaan yang benar (atau tidak- penggunaan) dari nilai-nilai tersebut.
|
||||
|
||||
> 🚨 Sebuah catatan peringatan
|
||||
>
|
||||
> Saat bekerja dengan dataset ini, Anda akan menulis kode yang menghitung sesuatu dari teks tanpa harus membaca atau menganalisis teks sendiri. Ini adalah esensi dari NLP, menafsirkan makna atau sentimen tanpa harus ada manusia yang melakukannya. Namun, ada kemungkinan Anda akan membaca beberapa ulasan negatif. Saya akan menyarankan Anda untuk tidak melakukannya, karena Anda tidak perlu. Beberapa dari mereka konyol, atau ulasan hotel negatif yang tidak relevan, seperti "Cuacanya tidak bagus", sesuatu yang di luar kendali hotel, atau siapa pun. Tetapi ada sisi gelap dari beberapa ulasan juga. Terkadang ulasan negatif bersifat rasis, seksis, atau ageis. Ini tidak menyenangkan tetapi diharapkan dalam dataset yang diambil dari situs web publik. Beberapa pengulas meninggalkan ulasan yang Anda anggap tidak menyenangkan, tidak nyaman, atau mengganggu. Lebih baik biarkan kode yang mengukur sentimen daripada membaca sendiri dan merasa tidak nyaman. Yang mengatakan, itu adalah minoritas yang menulis hal-hal seperti itu, tetapi mereka tetap ada.
|
||||
|
||||
## Latihan - Eksplorasi Data
|
||||
### Memuat data
|
||||
|
||||
Itu cukup memeriksa data secara visual, sekarang Anda akan menulis beberapa kode dan mendapatkan beberapa jawaban! Bagian ini menggunakan perpustakaan pandas. Tugas pertama Anda adalah memastikan Anda dapat memuat dan membaca data CSV. Perpustakaan pandas memiliki pemuat CSV yang cepat, dan hasilnya ditempatkan dalam dataframe, seperti pada pelajaran sebelumnya. CSV yang kita muat memiliki lebih dari setengah juta baris, tetapi hanya 17 kolom. Pandas memberi Anda banyak cara yang kuat untuk berinteraksi dengan dataframe, termasuk kemampuan untuk melakukan operasi pada setiap baris.
|
||||
|
||||
Dari sini di pelajaran ini, akan ada cuplikan kode dan beberapa penjelasan tentang kode dan beberapa diskusi tentang apa arti hasilnya. Gunakan _notebook.ipynb_ yang disertakan untuk kode Anda.
|
||||
|
||||
Mari kita mulai dengan memuat file data yang akan Anda gunakan:
|
||||
|
||||
```python
|
||||
# Load the hotel reviews from CSV
|
||||
import pandas as pd
|
||||
import time
|
||||
# importing time so the start and end time can be used to calculate file loading time
|
||||
print("Loading data file now, this could take a while depending on file size")
|
||||
start = time.time()
|
||||
# df is 'DataFrame' - make sure you downloaded the file to the data folder
|
||||
df = pd.read_csv('../../data/Hotel_Reviews.csv')
|
||||
end = time.time()
|
||||
print("Loading took " + str(round(end - start, 2)) + " seconds")
|
||||
```
|
||||
|
||||
Sekarang data sudah dimuat, kita bisa melakukan beberapa operasi pada data tersebut. Simpan kode ini di bagian atas program Anda untuk bagian selanjutnya.
|
||||
|
||||
## Jelajahi data
|
||||
|
||||
Dalam hal ini, datanya sudah *bersih*, artinya siap untuk digunakan, dan tidak memiliki karakter dalam bahasa lain yang mungkin mengganggu algoritma yang hanya mengharapkan karakter bahasa Inggris.
|
||||
|
||||
✅ Anda mungkin harus bekerja dengan data yang memerlukan beberapa pemrosesan awal untuk memformatnya sebelum menerapkan teknik NLP, tetapi tidak kali ini. Jika Anda harus melakukannya, bagaimana Anda akan menangani karakter non-Inggris?
|
||||
|
||||
Luangkan waktu sejenak untuk memastikan bahwa setelah data dimuat, Anda dapat menjelajahinya dengan kode. Sangat mudah untuk ingin fokus pada kolom `Negative_Review` dan `Positive_Review`. Mereka penuh dengan teks alami untuk diproses oleh algoritma NLP Anda. Tapi tunggu! Sebelum Anda terjun ke NLP dan sentimen, Anda harus mengikuti kode di bawah ini untuk memastikan bahwa nilai yang diberikan dalam dataset sesuai dengan nilai yang Anda hitung dengan pandas.
|
||||
|
||||
## Operasi Dataframe
|
||||
|
||||
Tugas pertama dalam pelajaran ini adalah memeriksa apakah pernyataan berikut benar dengan menulis beberapa kode yang memeriksa data frame (tanpa mengubahnya).
|
||||
|
||||
> Seperti banyak tugas pemrograman, ada beberapa cara untuk menyelesaikannya, tetapi saran yang baik adalah melakukannya dengan cara yang paling sederhana dan termudah yang Anda bisa, terutama jika akan lebih mudah untuk dipahami saat Anda kembali ke kode ini di masa mendatang. Dengan dataframes, ada API yang komprehensif yang sering kali memiliki cara untuk melakukan apa yang Anda inginkan secara efisien.
|
||||
Perlakukan pertanyaan-pertanyaan berikut sebagai tugas pemrograman dan cobalah menjawabnya tanpa melihat solusinya. 1. Cetak *shape* dari data frame yang baru saja Anda muat (shape adalah jumlah baris dan kolom) 2. Hitung frekuensi untuk kebangsaan pengulas: 1. Berapa banyak nilai berbeda yang ada untuk
|
||||
baris mempunyai nilai lajur `Positive_Review` "No Positive" 9. Kira dan cetak berapa banyak baris yang mempunyai nilai lajur `Positive_Review` "No Positive" **dan** nilai lajur `Negative_Review` "No Negative" ### Jawapan Kod 1. Cetak *bentuk* data frame yang baru sahaja dimuatkan (bentuk adalah bilangan baris dan lajur) ```python
|
||||
print("The shape of the data (rows, cols) is " + str(df.shape))
|
||||
> The shape of the data (rows, cols) is (515738, 17)
|
||||
``` 2. Kira jumlah kekerapan untuk kewarganegaraan pengulas: 1. Berapa banyak nilai yang berbeza ada untuk lajur `Reviewer_Nationality` dan apakah ia? 2. Apakah kewarganegaraan pengulas yang paling umum dalam dataset (cetak negara dan bilangan ulasan)? ```python
|
||||
# value_counts() creates a Series object that has index and values in this case, the country and the frequency they occur in reviewer nationality
|
||||
nationality_freq = df["Reviewer_Nationality"].value_counts()
|
||||
print("There are " + str(nationality_freq.size) + " different nationalities")
|
||||
# print first and last rows of the Series. Change to nationality_freq.to_string() to print all of the data
|
||||
print(nationality_freq)
|
||||
|
||||
There are 227 different nationalities
|
||||
United Kingdom 245246
|
||||
United States of America 35437
|
||||
Australia 21686
|
||||
Ireland 14827
|
||||
United Arab Emirates 10235
|
||||
...
|
||||
Comoros 1
|
||||
Palau 1
|
||||
Northern Mariana Islands 1
|
||||
Cape Verde 1
|
||||
Guinea 1
|
||||
Name: Reviewer_Nationality, Length: 227, dtype: int64
|
||||
``` 3. Apakah 10 kewarganegaraan yang paling kerap ditemui seterusnya, dan jumlah kekerapan mereka? ```python
|
||||
print("The highest frequency reviewer nationality is " + str(nationality_freq.index[0]).strip() + " with " + str(nationality_freq[0]) + " reviews.")
|
||||
# Notice there is a leading space on the values, strip() removes that for printing
|
||||
# What is the top 10 most common nationalities and their frequencies?
|
||||
print("The next 10 highest frequency reviewer nationalities are:")
|
||||
print(nationality_freq[1:11].to_string())
|
||||
|
||||
The highest frequency reviewer nationality is United Kingdom with 245246 reviews.
|
||||
The next 10 highest frequency reviewer nationalities are:
|
||||
United States of America 35437
|
||||
Australia 21686
|
||||
Ireland 14827
|
||||
United Arab Emirates 10235
|
||||
Saudi Arabia 8951
|
||||
Netherlands 8772
|
||||
Switzerland 8678
|
||||
Germany 7941
|
||||
Canada 7894
|
||||
France 7296
|
||||
``` 3. Apakah hotel yang paling kerap diulas untuk setiap 10 kewarganegaraan pengulas teratas? ```python
|
||||
# What was the most frequently reviewed hotel for the top 10 nationalities
|
||||
# Normally with pandas you will avoid an explicit loop, but wanted to show creating a new dataframe using criteria (don't do this with large amounts of data because it could be very slow)
|
||||
for nat in nationality_freq[:10].index:
|
||||
# First, extract all the rows that match the criteria into a new dataframe
|
||||
nat_df = df[df["Reviewer_Nationality"] == nat]
|
||||
# Now get the hotel freq
|
||||
freq = nat_df["Hotel_Name"].value_counts()
|
||||
print("The most reviewed hotel for " + str(nat).strip() + " was " + str(freq.index[0]) + " with " + str(freq[0]) + " reviews.")
|
||||
|
||||
The most reviewed hotel for United Kingdom was Britannia International Hotel Canary Wharf with 3833 reviews.
|
||||
The most reviewed hotel for United States of America was Hotel Esther a with 423 reviews.
|
||||
The most reviewed hotel for Australia was Park Plaza Westminster Bridge London with 167 reviews.
|
||||
The most reviewed hotel for Ireland was Copthorne Tara Hotel London Kensington with 239 reviews.
|
||||
The most reviewed hotel for United Arab Emirates was Millennium Hotel London Knightsbridge with 129 reviews.
|
||||
The most reviewed hotel for Saudi Arabia was The Cumberland A Guoman Hotel with 142 reviews.
|
||||
The most reviewed hotel for Netherlands was Jaz Amsterdam with 97 reviews.
|
||||
The most reviewed hotel for Switzerland was Hotel Da Vinci with 97 reviews.
|
||||
The most reviewed hotel for Germany was Hotel Da Vinci with 86 reviews.
|
||||
The most reviewed hotel for Canada was St James Court A Taj Hotel London with 61 reviews.
|
||||
``` 4. Berapa banyak ulasan terdapat bagi setiap hotel (jumlah kekerapan hotel) dalam dataset? ```python
|
||||
# First create a new dataframe based on the old one, removing the uneeded columns
|
||||
hotel_freq_df = df.drop(["Hotel_Address", "Additional_Number_of_Scoring", "Review_Date", "Average_Score", "Reviewer_Nationality", "Negative_Review", "Review_Total_Negative_Word_Counts", "Positive_Review", "Review_Total_Positive_Word_Counts", "Total_Number_of_Reviews_Reviewer_Has_Given", "Reviewer_Score", "Tags", "days_since_review", "lat", "lng"], axis = 1)
|
||||
|
||||
# Group the rows by Hotel_Name, count them and put the result in a new column Total_Reviews_Found
|
||||
hotel_freq_df['Total_Reviews_Found'] = hotel_freq_df.groupby('Hotel_Name').transform('count')
|
||||
|
||||
# Get rid of all the duplicated rows
|
||||
hotel_freq_df = hotel_freq_df.drop_duplicates(subset = ["Hotel_Name"])
|
||||
display(hotel_freq_df)
|
||||
``` | Hotel_Name | Total_Number_of_Reviews | Total_Reviews_Found | | :----------------------------------------: | :---------------------: | :-----------------: | | Britannia International Hotel Canary Wharf | 9086 | 4789 | | Park Plaza Westminster Bridge London | 12158 | 4169 | | Copthorne Tara Hotel London Kensington | 7105 | 3578 | | ... | ... | ... | | Mercure Paris Porte d Orleans | 110 | 10 | | Hotel Wagner | 135 | 10 | | Hotel Gallitzinberg | 173 | 8 | Anda mungkin perasan bahawa hasil *yang dikira dalam dataset* tidak sepadan dengan nilai dalam `Total_Number_of_Reviews`. Tidak jelas jika nilai dalam dataset ini mewakili jumlah ulasan yang hotel ada, tetapi tidak semua dikikis, atau beberapa pengiraan lain. `Total_Number_of_Reviews` tidak digunakan dalam model kerana ketidakjelasan ini. 5. Walaupun terdapat lajur `Average_Score` untuk setiap hotel dalam dataset, anda juga boleh mengira skor purata (mendapatkan purata semua skor pengulas dalam dataset untuk setiap hotel). Tambah lajur baru kepada dataframe anda dengan tajuk lajur `Calc_Average_Score` yang mengandungi purata yang dikira itu. Cetak lajur `Hotel_Name`, `Average_Score`, dan `Calc_Average_Score`. ```python
|
||||
# define a function that takes a row and performs some calculation with it
|
||||
def get_difference_review_avg(row):
|
||||
return row["Average_Score"] - row["Calc_Average_Score"]
|
||||
|
||||
# 'mean' is mathematical word for 'average'
|
||||
df['Calc_Average_Score'] = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1)
|
||||
|
||||
# Add a new column with the difference between the two average scores
|
||||
df["Average_Score_Difference"] = df.apply(get_difference_review_avg, axis = 1)
|
||||
|
||||
# Create a df without all the duplicates of Hotel_Name (so only 1 row per hotel)
|
||||
review_scores_df = df.drop_duplicates(subset = ["Hotel_Name"])
|
||||
|
||||
# Sort the dataframe to find the lowest and highest average score difference
|
||||
review_scores_df = review_scores_df.sort_values(by=["Average_Score_Difference"])
|
||||
|
||||
display(review_scores_df[["Average_Score_Difference", "Average_Score", "Calc_Average_Score", "Hotel_Name"]])
|
||||
``` Anda mungkin juga tertanya-tanya tentang nilai `Average_Score` dan mengapa ia kadang-kadang berbeza daripada skor purata yang dikira. Oleh kerana kita tidak tahu mengapa beberapa nilai sepadan, tetapi yang lain mempunyai perbezaan, adalah lebih selamat dalam kes ini untuk menggunakan skor ulasan yang kita ada untuk mengira purata sendiri. Walau bagaimanapun, perbezaan biasanya sangat kecil, berikut adalah hotel dengan perbezaan terbesar dari purata dataset dan purata yang dikira: | Average_Score_Difference | Average_Score | Calc_Average_Score | Hotel_Name | | :----------------------: | :-----------: | :----------------: | ------------------------------------------: | | -0.8 | 7.7 | 8.5 | Best Western Hotel Astoria | | -0.7 | 8.8 | 9.5 | Hotel Stendhal Place Vend me Paris MGallery | | -0.7 | 7.5 | 8.2 | Mercure Paris Porte d Orleans | | -0.7 | 7.9 | 8.6 | Renaissance Paris Vendome Hotel | | -0.5 | 7.0 | 7.5 | Hotel Royal Elys es | | ... | ... | ... | ... | | 0.7 | 7.5 | 6.8 | Mercure Paris Op ra Faubourg Montmartre | | 0.8 | 7.1 | 6.3 | Holiday Inn Paris Montparnasse Pasteur | | 0.9 | 6.8 | 5.9 | Villa Eugenie | | 0.9 | 8.6 | 7.7 | MARQUIS Faubourg St Honor Relais Ch teaux | | 1.3 | 7.2 | 5.9 | Kube Hotel Ice Bar | Dengan hanya 1 hotel yang mempunyai perbezaan skor lebih daripada 1, ini bermakna kita mungkin boleh mengabaikan perbezaan tersebut dan menggunakan skor purata yang dikira. 6. Kira dan cetak berapa banyak baris yang mempunyai nilai lajur `Negative_Review` "No Negative" 7. Kira dan cetak berapa banyak baris yang mempunyai nilai lajur `Positive_Review` "No Positive" 8. Kira dan cetak berapa banyak baris yang mempunyai nilai lajur `Positive_Review` "No Positive" **dan** nilai lajur `Negative_Review` "No Negative" ```python
|
||||
# with lambdas:
|
||||
start = time.time()
|
||||
no_negative_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" else False , axis=1)
|
||||
print("Number of No Negative reviews: " + str(len(no_negative_reviews[no_negative_reviews == True].index)))
|
||||
|
||||
no_positive_reviews = df.apply(lambda x: True if x['Positive_Review'] == "No Positive" else False , axis=1)
|
||||
print("Number of No Positive reviews: " + str(len(no_positive_reviews[no_positive_reviews == True].index)))
|
||||
|
||||
both_no_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" and x['Positive_Review'] == "No Positive" else False , axis=1)
|
||||
print("Number of both No Negative and No Positive reviews: " + str(len(both_no_reviews[both_no_reviews == True].index)))
|
||||
end = time.time()
|
||||
print("Lambdas took " + str(round(end - start, 2)) + " seconds")
|
||||
|
||||
Number of No Negative reviews: 127890
|
||||
Number of No Positive reviews: 35946
|
||||
Number of both No Negative and No Positive reviews: 127
|
||||
Lambdas took 9.64 seconds
|
||||
``` ## Cara lain Cara lain untuk mengira item tanpa Lambdas, dan menggunakan sum untuk mengira baris: ```python
|
||||
# without lambdas (using a mixture of notations to show you can use both)
|
||||
start = time.time()
|
||||
no_negative_reviews = sum(df.Negative_Review == "No Negative")
|
||||
print("Number of No Negative reviews: " + str(no_negative_reviews))
|
||||
|
||||
no_positive_reviews = sum(df["Positive_Review"] == "No Positive")
|
||||
print("Number of No Positive reviews: " + str(no_positive_reviews))
|
||||
|
||||
both_no_reviews = sum((df.Negative_Review == "No Negative") & (df.Positive_Review == "No Positive"))
|
||||
print("Number of both No Negative and No Positive reviews: " + str(both_no_reviews))
|
||||
|
||||
end = time.time()
|
||||
print("Sum took " + str(round(end - start, 2)) + " seconds")
|
||||
|
||||
Number of No Negative reviews: 127890
|
||||
Number of No Positive reviews: 35946
|
||||
Number of both No Negative and No Positive reviews: 127
|
||||
Sum took 0.19 seconds
|
||||
``` Anda mungkin perasan bahawa terdapat 127 baris yang mempunyai kedua-dua nilai "No Negative" dan "No Positive" untuk lajur `Negative_Review` dan `Positive_Review` masing-masing. Ini bermakna pengulas memberikan skor numerik kepada hotel, tetapi enggan menulis ulasan positif atau negatif. Nasib baik ini adalah jumlah baris yang kecil (127 daripada 515738, atau 0.02%), jadi mungkin tidak akan menjejaskan model atau keputusan kita dalam mana-mana arah tertentu, tetapi anda mungkin tidak menjangkakan dataset ulasan mempunyai baris tanpa ulasan, jadi ia patut meneroka data untuk menemui baris seperti ini. Sekarang setelah anda meneroka dataset, dalam pelajaran seterusnya anda akan menapis data dan menambah beberapa analisis sentimen. --- ## 🚀Cabaran Pelajaran ini menunjukkan, seperti yang kita lihat dalam pelajaran sebelumnya, betapa pentingnya untuk memahami data anda dan kekurangannya sebelum melakukan operasi ke atasnya. Data berasaskan teks, khususnya, memerlukan pemeriksaan yang teliti. Selidiki pelbagai set data yang berat dengan teks dan lihat jika anda dapat menemui kawasan yang boleh memperkenalkan bias atau sentimen yang menyimpang ke dalam model. ## [Kuiz selepas kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/38/) ## Kajian & Pembelajaran Kendiri Ambil [Laluan Pembelajaran ini mengenai NLP](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77952-leestott) untuk menemui alat yang boleh dicuba semasa membina model yang berat dengan ucapan dan teks. ## Tugasan [NLTK](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,8 +0,0 @@
|
||||
# NLTK
|
||||
|
||||
## Arahan
|
||||
|
||||
NLTK adalah perpustakaan terkenal untuk digunakan dalam linguistik komputasi dan NLP. Ambil peluang ini untuk membaca melalui '[buku NLTK](https://www.nltk.org/book/)' dan cuba latihan-latihannya. Dalam tugasan yang tidak dinilai ini, anda akan mengenali perpustakaan ini dengan lebih mendalam.
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesalahan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,377 +0,0 @@
|
||||
# Analisis Sentimen dengan Ulasan Hotel
|
||||
|
||||
Sekarang setelah anda menjelajahi dataset secara detail, saatnya untuk menyaring kolom-kolom dan kemudian menggunakan teknik NLP pada dataset untuk mendapatkan wawasan baru tentang hotel-hotel tersebut.
|
||||
## [Kuis Pra-Kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/39/)
|
||||
|
||||
### Operasi Penyaringan & Analisis Sentimen
|
||||
|
||||
Seperti yang mungkin sudah anda perhatikan, dataset ini memiliki beberapa masalah. Beberapa kolom diisi dengan informasi yang tidak berguna, yang lain tampaknya tidak benar. Jika mereka benar, tidak jelas bagaimana mereka dihitung, dan jawabannya tidak dapat diverifikasi secara independen oleh perhitungan anda sendiri.
|
||||
|
||||
## Latihan: sedikit lagi pemrosesan data
|
||||
|
||||
Bersihkan data sedikit lagi. Tambahkan kolom yang akan berguna nanti, ubah nilai di kolom lain, dan hapus beberapa kolom sepenuhnya.
|
||||
|
||||
1. Pemrosesan kolom awal
|
||||
|
||||
1. Hapus `lat` dan `lng`
|
||||
|
||||
2. Ganti nilai `Hotel_Address` dengan nilai berikut (jika alamat berisi nama kota dan negara, ubah menjadi hanya kota dan negara).
|
||||
|
||||
Ini adalah satu-satunya kota dan negara dalam dataset:
|
||||
|
||||
Amsterdam, Netherlands
|
||||
|
||||
Barcelona, Spain
|
||||
|
||||
London, United Kingdom
|
||||
|
||||
Milan, Italy
|
||||
|
||||
Paris, France
|
||||
|
||||
Vienna, Austria
|
||||
|
||||
```python
|
||||
def replace_address(row):
|
||||
if "Netherlands" in row["Hotel_Address"]:
|
||||
return "Amsterdam, Netherlands"
|
||||
elif "Barcelona" in row["Hotel_Address"]:
|
||||
return "Barcelona, Spain"
|
||||
elif "United Kingdom" in row["Hotel_Address"]:
|
||||
return "London, United Kingdom"
|
||||
elif "Milan" in row["Hotel_Address"]:
|
||||
return "Milan, Italy"
|
||||
elif "France" in row["Hotel_Address"]:
|
||||
return "Paris, France"
|
||||
elif "Vienna" in row["Hotel_Address"]:
|
||||
return "Vienna, Austria"
|
||||
|
||||
# Replace all the addresses with a shortened, more useful form
|
||||
df["Hotel_Address"] = df.apply(replace_address, axis = 1)
|
||||
# The sum of the value_counts() should add up to the total number of reviews
|
||||
print(df["Hotel_Address"].value_counts())
|
||||
```
|
||||
|
||||
Sekarang anda bisa meng-query data tingkat negara:
|
||||
|
||||
```python
|
||||
display(df.groupby("Hotel_Address").agg({"Hotel_Name": "nunique"}))
|
||||
```
|
||||
|
||||
| Hotel_Address | Hotel_Name |
|
||||
| :--------------------- | :--------: |
|
||||
| Amsterdam, Netherlands | 105 |
|
||||
| Barcelona, Spain | 211 |
|
||||
| London, United Kingdom | 400 |
|
||||
| Milan, Italy | 162 |
|
||||
| Paris, France | 458 |
|
||||
| Vienna, Austria | 158 |
|
||||
|
||||
2. Proses kolom Meta-review Hotel
|
||||
|
||||
1. Hapus `Additional_Number_of_Scoring`
|
||||
|
||||
1. Replace `Total_Number_of_Reviews` with the total number of reviews for that hotel that are actually in the dataset
|
||||
|
||||
1. Replace `Average_Score` dengan skor yang dihitung sendiri
|
||||
|
||||
```python
|
||||
# Drop `Additional_Number_of_Scoring`
|
||||
df.drop(["Additional_Number_of_Scoring"], axis = 1, inplace=True)
|
||||
# Replace `Total_Number_of_Reviews` and `Average_Score` with our own calculated values
|
||||
df.Total_Number_of_Reviews = df.groupby('Hotel_Name').transform('count')
|
||||
df.Average_Score = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1)
|
||||
```
|
||||
|
||||
3. Proses kolom ulasan
|
||||
|
||||
1. Hapus `Review_Total_Negative_Word_Counts`, `Review_Total_Positive_Word_Counts`, `Review_Date` and `days_since_review`
|
||||
|
||||
2. Keep `Reviewer_Score`, `Negative_Review`, and `Positive_Review` as they are,
|
||||
|
||||
3. Keep `Tags` for now
|
||||
|
||||
- We'll be doing some additional filtering operations on the tags in the next section and then tags will be dropped
|
||||
|
||||
4. Process reviewer columns
|
||||
|
||||
1. Drop `Total_Number_of_Reviews_Reviewer_Has_Given`
|
||||
|
||||
2. Keep `Reviewer_Nationality`
|
||||
|
||||
### Tag columns
|
||||
|
||||
The `Tag` column is problematic as it is a list (in text form) stored in the column. Unfortunately the order and number of sub sections in this column are not always the same. It's hard for a human to identify the correct phrases to be interested in, because there are 515,000 rows, and 1427 hotels, and each has slightly different options a reviewer could choose. This is where NLP shines. You can scan the text and find the most common phrases, and count them.
|
||||
|
||||
Unfortunately, we are not interested in single words, but multi-word phrases (e.g. *Business trip*). Running a multi-word frequency distribution algorithm on that much data (6762646 words) could take an extraordinary amount of time, but without looking at the data, it would seem that is a necessary expense. This is where exploratory data analysis comes in useful, because you've seen a sample of the tags such as `[' Business trip ', ' Solo traveler ', ' Single Room ', ' Stayed 5 nights ', ' Submitted from a mobile device ']`, anda bisa mulai bertanya apakah mungkin untuk mengurangi pemrosesan yang harus dilakukan. Untungnya, itu mungkin - tetapi pertama-tama anda perlu mengikuti beberapa langkah untuk memastikan tag yang diminati.
|
||||
|
||||
### Penyaringan tag
|
||||
|
||||
Ingat bahwa tujuan dataset ini adalah untuk menambahkan sentimen dan kolom yang akan membantu anda memilih hotel terbaik (untuk diri sendiri atau mungkin untuk tugas klien yang meminta anda membuat bot rekomendasi hotel). Anda perlu bertanya pada diri sendiri apakah tag tersebut berguna atau tidak dalam dataset akhir. Berikut adalah satu interpretasi (jika anda membutuhkan dataset untuk alasan lain, tag yang berbeda mungkin tetap masuk/keluar dari seleksi):
|
||||
|
||||
1. Jenis perjalanan itu relevan, dan itu harus tetap
|
||||
2. Jenis kelompok tamu itu penting, dan itu harus tetap
|
||||
3. Jenis kamar, suite, atau studio tempat tamu menginap tidak relevan (semua hotel pada dasarnya memiliki kamar yang sama)
|
||||
4. Perangkat yang digunakan untuk mengirim ulasan tidak relevan
|
||||
5. Jumlah malam yang dihabiskan pengulas *mungkin* relevan jika anda mengaitkan masa tinggal yang lebih lama dengan mereka yang lebih menyukai hotel tersebut, tetapi itu sedikit berlebihan, dan mungkin tidak relevan
|
||||
|
||||
Singkatnya, **pertahankan 2 jenis tag dan hapus yang lain**.
|
||||
|
||||
Pertama, anda tidak ingin menghitung tag sampai mereka dalam format yang lebih baik, jadi itu berarti menghapus tanda kurung siku dan kutipan. Anda bisa melakukannya dengan beberapa cara, tetapi anda ingin yang tercepat karena bisa memakan waktu lama untuk memproses banyak data. Untungnya, pandas memiliki cara mudah untuk melakukan masing-masing langkah ini.
|
||||
|
||||
```Python
|
||||
# Remove opening and closing brackets
|
||||
df.Tags = df.Tags.str.strip("[']")
|
||||
# remove all quotes too
|
||||
df.Tags = df.Tags.str.replace(" ', '", ",", regex = False)
|
||||
```
|
||||
|
||||
Setiap tag menjadi sesuatu seperti: `Business trip, Solo traveler, Single Room, Stayed 5 nights, Submitted from a mobile device`.
|
||||
|
||||
Next we find a problem. Some reviews, or rows, have 5 columns, some 3, some 6. This is a result of how the dataset was created, and hard to fix. You want to get a frequency count of each phrase, but they are in different order in each review, so the count might be off, and a hotel might not get a tag assigned to it that it deserved.
|
||||
|
||||
Instead you will use the different order to our advantage, because each tag is multi-word but also separated by a comma! The simplest way to do this is to create 6 temporary columns with each tag inserted in to the column corresponding to its order in the tag. You can then merge the 6 columns into one big column and run the `value_counts()` method on the resulting column. Printing that out, you'll see there was 2428 unique tags. Here is a small sample:
|
||||
|
||||
| Tag | Count |
|
||||
| ------------------------------ | ------ |
|
||||
| Leisure trip | 417778 |
|
||||
| Submitted from a mobile device | 307640 |
|
||||
| Couple | 252294 |
|
||||
| Stayed 1 night | 193645 |
|
||||
| Stayed 2 nights | 133937 |
|
||||
| Solo traveler | 108545 |
|
||||
| Stayed 3 nights | 95821 |
|
||||
| Business trip | 82939 |
|
||||
| Group | 65392 |
|
||||
| Family with young children | 61015 |
|
||||
| Stayed 4 nights | 47817 |
|
||||
| Double Room | 35207 |
|
||||
| Standard Double Room | 32248 |
|
||||
| Superior Double Room | 31393 |
|
||||
| Family with older children | 26349 |
|
||||
| Deluxe Double Room | 24823 |
|
||||
| Double or Twin Room | 22393 |
|
||||
| Stayed 5 nights | 20845 |
|
||||
| Standard Double or Twin Room | 17483 |
|
||||
| Classic Double Room | 16989 |
|
||||
| Superior Double or Twin Room | 13570 |
|
||||
| 2 rooms | 12393 |
|
||||
|
||||
Some of the common tags like `Submitted from a mobile device` are of no use to us, so it might be a smart thing to remove them before counting phrase occurrence, but it is such a fast operation you can leave them in and ignore them.
|
||||
|
||||
### Removing the length of stay tags
|
||||
|
||||
Removing these tags is step 1, it reduces the total number of tags to be considered slightly. Note you do not remove them from the dataset, just choose to remove them from consideration as values to count/keep in the reviews dataset.
|
||||
|
||||
| Length of stay | Count |
|
||||
| ---------------- | ------ |
|
||||
| Stayed 1 night | 193645 |
|
||||
| Stayed 2 nights | 133937 |
|
||||
| Stayed 3 nights | 95821 |
|
||||
| Stayed 4 nights | 47817 |
|
||||
| Stayed 5 nights | 20845 |
|
||||
| Stayed 6 nights | 9776 |
|
||||
| Stayed 7 nights | 7399 |
|
||||
| Stayed 8 nights | 2502 |
|
||||
| Stayed 9 nights | 1293 |
|
||||
| ... | ... |
|
||||
|
||||
There are a huge variety of rooms, suites, studios, apartments and so on. They all mean roughly the same thing and not relevant to you, so remove them from consideration.
|
||||
|
||||
| Type of room | Count |
|
||||
| ----------------------------- | ----- |
|
||||
| Double Room | 35207 |
|
||||
| Standard Double Room | 32248 |
|
||||
| Superior Double Room | 31393 |
|
||||
| Deluxe Double Room | 24823 |
|
||||
| Double or Twin Room | 22393 |
|
||||
| Standard Double or Twin Room | 17483 |
|
||||
| Classic Double Room | 16989 |
|
||||
| Superior Double or Twin Room | 13570 |
|
||||
|
||||
Finally, and this is delightful (because it didn't take much processing at all), you will be left with the following *useful* tags:
|
||||
|
||||
| Tag | Count |
|
||||
| --------------------------------------------- | ------ |
|
||||
| Leisure trip | 417778 |
|
||||
| Couple | 252294 |
|
||||
| Solo traveler | 108545 |
|
||||
| Business trip | 82939 |
|
||||
| Group (combined with Travellers with friends) | 67535 |
|
||||
| Family with young children | 61015 |
|
||||
| Family with older children | 26349 |
|
||||
| With a pet | 1405 |
|
||||
|
||||
You could argue that `Travellers with friends` is the same as `Group` more or less, and that would be fair to combine the two as above. The code for identifying the correct tags is [the Tags notebook](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb).
|
||||
|
||||
The final step is to create new columns for each of these tags. Then, for every review row, if the `Tag` kolom cocok dengan salah satu kolom baru, tambahkan 1, jika tidak, tambahkan 0. Hasil akhirnya adalah hitungan berapa banyak pengulas yang memilih hotel ini (secara agregat) untuk, misalnya, bisnis vs liburan, atau untuk membawa hewan peliharaan, dan ini adalah informasi yang berguna saat merekomendasikan hotel.
|
||||
|
||||
```python
|
||||
# Process the Tags into new columns
|
||||
# The file Hotel_Reviews_Tags.py, identifies the most important tags
|
||||
# Leisure trip, Couple, Solo traveler, Business trip, Group combined with Travelers with friends,
|
||||
# Family with young children, Family with older children, With a pet
|
||||
df["Leisure_trip"] = df.Tags.apply(lambda tag: 1 if "Leisure trip" in tag else 0)
|
||||
df["Couple"] = df.Tags.apply(lambda tag: 1 if "Couple" in tag else 0)
|
||||
df["Solo_traveler"] = df.Tags.apply(lambda tag: 1 if "Solo traveler" in tag else 0)
|
||||
df["Business_trip"] = df.Tags.apply(lambda tag: 1 if "Business trip" in tag else 0)
|
||||
df["Group"] = df.Tags.apply(lambda tag: 1 if "Group" in tag or "Travelers with friends" in tag else 0)
|
||||
df["Family_with_young_children"] = df.Tags.apply(lambda tag: 1 if "Family with young children" in tag else 0)
|
||||
df["Family_with_older_children"] = df.Tags.apply(lambda tag: 1 if "Family with older children" in tag else 0)
|
||||
df["With_a_pet"] = df.Tags.apply(lambda tag: 1 if "With a pet" in tag else 0)
|
||||
|
||||
```
|
||||
|
||||
### Simpan file anda
|
||||
|
||||
Akhirnya, simpan dataset sebagaimana adanya sekarang dengan nama baru.
|
||||
|
||||
```python
|
||||
df.drop(["Review_Total_Negative_Word_Counts", "Review_Total_Positive_Word_Counts", "days_since_review", "Total_Number_of_Reviews_Reviewer_Has_Given"], axis = 1, inplace=True)
|
||||
|
||||
# Saving new data file with calculated columns
|
||||
print("Saving results to Hotel_Reviews_Filtered.csv")
|
||||
df.to_csv(r'../data/Hotel_Reviews_Filtered.csv', index = False)
|
||||
```
|
||||
|
||||
## Operasi Analisis Sentimen
|
||||
|
||||
Di bagian akhir ini, anda akan menerapkan analisis sentimen pada kolom ulasan dan menyimpan hasilnya dalam dataset.
|
||||
|
||||
## Latihan: memuat dan menyimpan data yang sudah disaring
|
||||
|
||||
Perhatikan bahwa sekarang anda memuat dataset yang sudah disaring yang disimpan di bagian sebelumnya, **bukan** dataset asli.
|
||||
|
||||
```python
|
||||
import time
|
||||
import pandas as pd
|
||||
import nltk as nltk
|
||||
from nltk.corpus import stopwords
|
||||
from nltk.sentiment.vader import SentimentIntensityAnalyzer
|
||||
nltk.download('vader_lexicon')
|
||||
|
||||
# Load the filtered hotel reviews from CSV
|
||||
df = pd.read_csv('../../data/Hotel_Reviews_Filtered.csv')
|
||||
|
||||
# You code will be added here
|
||||
|
||||
|
||||
# Finally remember to save the hotel reviews with new NLP data added
|
||||
print("Saving results to Hotel_Reviews_NLP.csv")
|
||||
df.to_csv(r'../data/Hotel_Reviews_NLP.csv', index = False)
|
||||
```
|
||||
|
||||
### Menghapus kata-kata stop
|
||||
|
||||
Jika anda menjalankan Analisis Sentimen pada kolom Ulasan Negatif dan Positif, itu bisa memakan waktu lama. Diuji pada laptop uji yang kuat dengan CPU cepat, itu memakan waktu 12 - 14 menit tergantung pada perpustakaan sentimen yang digunakan. Itu adalah waktu yang (relatif) lama, jadi patut diselidiki apakah itu bisa dipercepat.
|
||||
|
||||
Menghapus kata-kata stop, atau kata-kata umum dalam bahasa Inggris yang tidak mengubah sentimen suatu kalimat, adalah langkah pertama. Dengan menghapusnya, analisis sentimen harus berjalan lebih cepat, tetapi tidak kurang akurat (karena kata-kata stop tidak mempengaruhi sentimen, tetapi mereka memperlambat analisis).
|
||||
|
||||
Ulasan negatif terpanjang adalah 395 kata, tetapi setelah menghapus kata-kata stop, itu menjadi 195 kata.
|
||||
|
||||
Menghapus kata-kata stop juga merupakan operasi yang cepat, menghapus kata-kata stop dari 2 kolom ulasan lebih dari 515.000 baris memakan waktu 3,3 detik pada perangkat uji. Itu bisa memakan waktu sedikit lebih atau kurang untuk anda tergantung pada kecepatan CPU perangkat anda, RAM, apakah anda memiliki SSD atau tidak, dan beberapa faktor lainnya. Relatif singkatnya operasi ini berarti bahwa jika itu meningkatkan waktu analisis sentimen, maka itu layak dilakukan.
|
||||
|
||||
```python
|
||||
from nltk.corpus import stopwords
|
||||
|
||||
# Load the hotel reviews from CSV
|
||||
df = pd.read_csv("../../data/Hotel_Reviews_Filtered.csv")
|
||||
|
||||
# Remove stop words - can be slow for a lot of text!
|
||||
# Ryan Han (ryanxjhan on Kaggle) has a great post measuring performance of different stop words removal approaches
|
||||
# https://www.kaggle.com/ryanxjhan/fast-stop-words-removal # using the approach that Ryan recommends
|
||||
start = time.time()
|
||||
cache = set(stopwords.words("english"))
|
||||
def remove_stopwords(review):
|
||||
text = " ".join([word for word in review.split() if word not in cache])
|
||||
return text
|
||||
|
||||
# Remove the stop words from both columns
|
||||
df.Negative_Review = df.Negative_Review.apply(remove_stopwords)
|
||||
df.Positive_Review = df.Positive_Review.apply(remove_stopwords)
|
||||
```
|
||||
|
||||
### Melakukan analisis sentimen
|
||||
|
||||
Sekarang anda harus menghitung analisis sentimen untuk kolom ulasan negatif dan positif, dan menyimpan hasilnya dalam 2 kolom baru. Uji sentimen akan membandingkannya dengan skor pengulas untuk ulasan yang sama. Misalnya, jika sentimen berpikir ulasan negatif memiliki sentimen 1 (sentimen sangat positif) dan sentimen ulasan positif 1, tetapi pengulas memberi hotel skor terendah yang mungkin, maka teks ulasan tidak cocok dengan skor, atau analisis sentimen tidak dapat mengenali sentimen dengan benar. Anda harus mengharapkan beberapa skor sentimen sepenuhnya salah, dan sering kali itu bisa dijelaskan, misalnya ulasan bisa sangat sarkastis "Tentu saja saya SANGAT MENYUKAI tidur di kamar tanpa pemanas" dan analisis sentimen berpikir itu adalah sentimen positif, meskipun manusia yang membacanya akan tahu itu adalah sarkasme.
|
||||
|
||||
NLTK menyediakan berbagai analis sentimen untuk dipelajari, dan anda bisa menggantinya dan melihat apakah sentimen lebih atau kurang akurat. Analisis sentimen VADER digunakan di sini.
|
||||
|
||||
> Hutto, C.J. & Gilbert, E.E. (2014). VADER: Model Berbasis Aturan yang Parsimonious untuk Analisis Sentimen Teks Media Sosial. Konferensi Internasional Kedelapan tentang Weblogs dan Media Sosial (ICWSM-14). Ann Arbor, MI, Juni 2014.
|
||||
|
||||
```python
|
||||
from nltk.sentiment.vader import SentimentIntensityAnalyzer
|
||||
|
||||
# Create the vader sentiment analyser (there are others in NLTK you can try too)
|
||||
vader_sentiment = SentimentIntensityAnalyzer()
|
||||
# Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. Eighth International Conference on Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, June 2014.
|
||||
|
||||
# There are 3 possibilities of input for a review:
|
||||
# It could be "No Negative", in which case, return 0
|
||||
# It could be "No Positive", in which case, return 0
|
||||
# It could be a review, in which case calculate the sentiment
|
||||
def calc_sentiment(review):
|
||||
if review == "No Negative" or review == "No Positive":
|
||||
return 0
|
||||
return vader_sentiment.polarity_scores(review)["compound"]
|
||||
```
|
||||
|
||||
Nantinya dalam program anda ketika anda siap menghitung sentimen, anda bisa menerapkannya pada setiap ulasan sebagai berikut:
|
||||
|
||||
```python
|
||||
# Add a negative sentiment and positive sentiment column
|
||||
print("Calculating sentiment columns for both positive and negative reviews")
|
||||
start = time.time()
|
||||
df["Negative_Sentiment"] = df.Negative_Review.apply(calc_sentiment)
|
||||
df["Positive_Sentiment"] = df.Positive_Review.apply(calc_sentiment)
|
||||
end = time.time()
|
||||
print("Calculating sentiment took " + str(round(end - start, 2)) + " seconds")
|
||||
```
|
||||
|
||||
Ini memakan waktu sekitar 120 detik di komputer saya, tetapi akan bervariasi di setiap komputer. Jika anda ingin mencetak hasilnya dan melihat apakah sentimen sesuai dengan ulasan:
|
||||
|
||||
```python
|
||||
df = df.sort_values(by=["Negative_Sentiment"], ascending=True)
|
||||
print(df[["Negative_Review", "Negative_Sentiment"]])
|
||||
df = df.sort_values(by=["Positive_Sentiment"], ascending=True)
|
||||
print(df[["Positive_Review", "Positive_Sentiment"]])
|
||||
```
|
||||
|
||||
Hal terakhir yang harus dilakukan dengan file sebelum menggunakannya dalam tantangan adalah menyimpannya! Anda juga harus mempertimbangkan untuk mengatur ulang semua kolom baru anda agar mudah digunakan (untuk manusia, ini adalah perubahan kosmetik).
|
||||
|
||||
```python
|
||||
# Reorder the columns (This is cosmetic, but to make it easier to explore the data later)
|
||||
df = df.reindex(["Hotel_Name", "Hotel_Address", "Total_Number_of_Reviews", "Average_Score", "Reviewer_Score", "Negative_Sentiment", "Positive_Sentiment", "Reviewer_Nationality", "Leisure_trip", "Couple", "Solo_traveler", "Business_trip", "Group", "Family_with_young_children", "Family_with_older_children", "With_a_pet", "Negative_Review", "Positive_Review"], axis=1)
|
||||
|
||||
print("Saving results to Hotel_Reviews_NLP.csv")
|
||||
df.to_csv(r"../data/Hotel_Reviews_NLP.csv", index = False)
|
||||
```
|
||||
|
||||
Anda harus menjalankan seluruh kode untuk [notebook analisis](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb) (setelah anda menjalankan [notebook penyaringan](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb) untuk menghasilkan file Hotel_Reviews_Filtered.csv).
|
||||
|
||||
Untuk meninjau, langkah-langkahnya adalah:
|
||||
|
||||
1. File dataset asli **Hotel_Reviews.csv** dieksplorasi dalam pelajaran sebelumnya dengan [notebook penjelajah](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/4-Hotel-Reviews-1/solution/notebook.ipynb)
|
||||
2. Hotel_Reviews.csv disaring oleh [notebook penyaringan](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb) menghasilkan **Hotel_Reviews_Filtered.csv**
|
||||
3. Hotel_Reviews_Filtered.csv diproses oleh [notebook analisis sentimen](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb) menghasilkan **Hotel_Reviews_NLP.csv**
|
||||
4. Gunakan Hotel_Reviews_NLP.csv dalam Tantangan NLP di bawah ini
|
||||
|
||||
### Kesimpulan
|
||||
|
||||
Ketika anda mulai, anda memiliki dataset dengan kolom dan data tetapi tidak semuanya dapat diverifikasi atau digunakan. Anda telah menjelajahi data, menyaring apa yang tidak anda butuhkan, mengubah tag menjadi sesuatu yang berguna, menghitung rata-rata anda sendiri, menambahkan beberapa kolom sentimen dan semoga, mempelajari beberapa hal menarik tentang pemrosesan teks alami.
|
||||
|
||||
## [Kuis Pasca-Kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/40/)
|
||||
|
||||
## Tantangan
|
||||
|
||||
Sekarang setelah anda menganalisis dataset untuk sentimen, lihat apakah anda bisa menggunakan strategi yang telah anda pelajari dalam kurikulum ini (klastering, mungkin?) untuk menentukan pola di sekitar sentimen.
|
||||
|
||||
## Tinjauan & Studi Mandiri
|
||||
|
||||
Ikuti [modul Learn ini](https://docs.microsoft.com/en-us/learn/modules/classify-user-feedback-with-the-text-analytics-api/?WT.mc_id=academic-77952-leestott) untuk mempelajari lebih lanjut dan menggunakan alat yang berbeda untuk menjelajahi sentimen dalam teks.
|
||||
## Tugas
|
||||
|
||||
[Coba dataset yang berbeda](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,14 +0,0 @@
|
||||
# Cuba dataset yang berbeza
|
||||
|
||||
## Arahan
|
||||
|
||||
Sekarang setelah anda belajar tentang menggunakan NLTK untuk menetapkan sentimen kepada teks, cuba dataset yang berbeza. Anda mungkin perlu melakukan beberapa pemprosesan data, jadi buat notebook dan dokumentasikan proses pemikiran anda. Apa yang anda temui?
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | ----------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ---------------------- |
|
||||
| | Notebook lengkap dan dataset disertakan dengan sel-sel yang didokumentasikan dengan baik menerangkan bagaimana sentimen ditetapkan | Notebook kekurangan penjelasan yang baik | Notebook mempunyai kecacatan |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab ke atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,27 +0,0 @@
|
||||
# Memulakan dengan pemprosesan bahasa semula jadi
|
||||
|
||||
Pemprosesan bahasa semula jadi (NLP) adalah keupayaan program komputer untuk memahami bahasa manusia seperti yang dituturkan dan ditulis -- dirujuk sebagai bahasa semula jadi. Ia adalah komponen kecerdasan buatan (AI). NLP telah wujud lebih daripada 50 tahun dan mempunyai akar dalam bidang linguistik. Keseluruhan bidang ini ditujukan untuk membantu mesin memahami dan memproses bahasa manusia. Ini kemudian boleh digunakan untuk melaksanakan tugas seperti pemeriksaan ejaan atau terjemahan mesin. Ia mempunyai pelbagai aplikasi dunia sebenar dalam beberapa bidang, termasuk penyelidikan perubatan, enjin carian dan kecerdasan perniagaan.
|
||||
|
||||
## Topik serantau: Bahasa dan sastera Eropah dan hotel romantik di Eropah ❤️
|
||||
|
||||
Dalam bahagian kurikulum ini, anda akan diperkenalkan kepada salah satu penggunaan pembelajaran mesin yang paling meluas: pemprosesan bahasa semula jadi (NLP). Diperoleh daripada linguistik komputasi, kategori kecerdasan buatan ini adalah jambatan antara manusia dan mesin melalui komunikasi suara atau teks.
|
||||
|
||||
Dalam pelajaran ini kita akan belajar asas-asas NLP dengan membina bot perbualan kecil untuk mempelajari bagaimana pembelajaran mesin membantu menjadikan perbualan ini semakin 'pintar'. Anda akan mengembara ke masa lalu, berbual dengan Elizabeth Bennett dan Mr. Darcy dari novel klasik Jane Austen, **Pride and Prejudice**, yang diterbitkan pada tahun 1813. Kemudian, anda akan menambah pengetahuan anda dengan mempelajari tentang analisis sentimen melalui ulasan hotel di Eropah.
|
||||
|
||||
|
||||
> Foto oleh <a href="https://unsplash.com/@elaineh?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Elaine Howlin</a> di <a href="https://unsplash.com/s/photos/pride-and-prejudice?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## Pelajaran
|
||||
|
||||
1. [Pengenalan kepada pemprosesan bahasa semula jadi](1-Introduction-to-NLP/README.md)
|
||||
2. [Tugas dan teknik NLP yang biasa](2-Tasks/README.md)
|
||||
3. [Terjemahan dan analisis sentimen dengan pembelajaran mesin](3-Translation-Sentiment/README.md)
|
||||
4. [Menyiapkan data anda](4-Hotel-Reviews-1/README.md)
|
||||
5. [NLTK untuk Analisis Sentimen](5-Hotel-Reviews-2/README.md)
|
||||
|
||||
## Kredit
|
||||
|
||||
Pelajaran pemprosesan bahasa semula jadi ini ditulis dengan ☕ oleh [Stephen Howell](https://twitter.com/Howell_MSFT)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab ke atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,188 +0,0 @@
|
||||
# Pengenalan kepada ramalan siri masa
|
||||
|
||||
|
||||
|
||||
> Sketchnote oleh [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
Dalam pelajaran ini dan pelajaran berikutnya, anda akan mempelajari sedikit tentang ramalan siri masa, satu bahagian yang menarik dan berharga dalam repertoir seorang saintis ML yang kurang dikenali berbanding topik lain. Ramalan siri masa adalah sejenis 'bola kristal': berdasarkan prestasi lalu sesuatu pembolehubah seperti harga, anda boleh meramalkan nilai potensinya pada masa depan.
|
||||
|
||||
[](https://youtu.be/cBojo1hsHiI "Pengenalan kepada ramalan siri masa")
|
||||
|
||||
> 🎥 Klik imej di atas untuk video tentang ramalan siri masa
|
||||
|
||||
## [Kuiz pra-kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/41/)
|
||||
|
||||
Ia adalah bidang yang berguna dan menarik dengan nilai sebenar kepada perniagaan, memandangkan aplikasinya yang langsung kepada masalah penentuan harga, inventori, dan isu rantaian bekalan. Walaupun teknik pembelajaran mendalam telah mula digunakan untuk mendapatkan lebih banyak wawasan bagi meramalkan prestasi masa depan dengan lebih baik, ramalan siri masa tetap menjadi bidang yang banyak dimaklumkan oleh teknik ML klasik.
|
||||
|
||||
> Kurikulum siri masa yang berguna dari Penn State boleh didapati [di sini](https://online.stat.psu.edu/stat510/lesson/1)
|
||||
|
||||
## Pengenalan
|
||||
|
||||
Bayangkan anda menyelenggara satu rangkaian meter parkir pintar yang menyediakan data tentang seberapa kerap ia digunakan dan untuk berapa lama dari semasa ke semasa.
|
||||
|
||||
> Bagaimana jika anda boleh meramalkan, berdasarkan prestasi lalu meter tersebut, nilai masa depannya mengikut undang-undang penawaran dan permintaan?
|
||||
|
||||
Meramalkan dengan tepat bila untuk bertindak bagi mencapai matlamat anda adalah cabaran yang boleh ditangani oleh ramalan siri masa. Ia mungkin tidak menyenangkan orang ramai apabila dikenakan bayaran lebih tinggi pada masa sibuk ketika mereka mencari tempat parkir, tetapi ia adalah cara yang pasti untuk menjana pendapatan untuk membersihkan jalan!
|
||||
|
||||
Mari kita terokai beberapa jenis algoritma siri masa dan mulakan sebuah buku nota untuk membersihkan dan menyediakan beberapa data. Data yang akan anda analisis diambil dari pertandingan ramalan GEFCom2014. Ia terdiri daripada 3 tahun nilai beban elektrik dan suhu setiap jam antara 2012 dan 2014. Berdasarkan corak sejarah beban elektrik dan suhu, anda boleh meramalkan nilai masa depan beban elektrik.
|
||||
|
||||
Dalam contoh ini, anda akan belajar bagaimana untuk meramalkan satu langkah masa ke hadapan, hanya menggunakan data beban sejarah. Sebelum memulakan, bagaimanapun, adalah berguna untuk memahami apa yang berlaku di sebalik tabir.
|
||||
|
||||
## Beberapa definisi
|
||||
|
||||
Apabila menghadapi istilah 'siri masa' anda perlu memahami penggunaannya dalam beberapa konteks yang berbeza.
|
||||
|
||||
🎓 **Siri masa**
|
||||
|
||||
Dalam matematik, "siri masa adalah satu siri titik data yang diindeks (atau disenaraikan atau diplot) mengikut urutan masa. Selalunya, siri masa adalah urutan yang diambil pada titik masa yang sama jarak." Contoh siri masa adalah nilai penutupan harian [Dow Jones Industrial Average](https://wikipedia.org/wiki/Time_series). Penggunaan plot siri masa dan pemodelan statistik sering ditemui dalam pemprosesan isyarat, ramalan cuaca, ramalan gempa bumi, dan bidang lain di mana peristiwa berlaku dan titik data boleh diplot mengikut masa.
|
||||
|
||||
🎓 **Analisis siri masa**
|
||||
|
||||
Analisis siri masa adalah analisis data siri masa yang disebutkan di atas. Data siri masa boleh mengambil bentuk yang berbeza, termasuk 'siri masa terganggu' yang mengesan corak dalam evolusi siri masa sebelum dan selepas peristiwa yang mengganggu. Jenis analisis yang diperlukan untuk siri masa bergantung pada sifat data. Data siri masa itu sendiri boleh berbentuk siri nombor atau aksara.
|
||||
|
||||
Analisis yang akan dijalankan menggunakan pelbagai kaedah, termasuk domain frekuensi dan domain masa, linear dan tidak linear, dan banyak lagi. [Ketahui lebih lanjut](https://www.itl.nist.gov/div898/handbook/pmc/section4/pmc4.htm) tentang pelbagai cara untuk menganalisis jenis data ini.
|
||||
|
||||
🎓 **Ramalan siri masa**
|
||||
|
||||
Ramalan siri masa adalah penggunaan model untuk meramalkan nilai masa depan berdasarkan corak yang dipamerkan oleh data yang dikumpulkan sebelum ini seperti yang berlaku pada masa lalu. Walaupun mungkin untuk menggunakan model regresi untuk meneroka data siri masa, dengan indeks masa sebagai pembolehubah x pada plot, data sedemikian paling baik dianalisis menggunakan jenis model khas.
|
||||
|
||||
Data siri masa adalah senarai pemerhatian yang dipesan, tidak seperti data yang boleh dianalisis dengan regresi linear. Yang paling biasa adalah ARIMA, akronim yang bermaksud "Autoregressive Integrated Moving Average".
|
||||
|
||||
[Model ARIMA](https://online.stat.psu.edu/stat510/lesson/1/1.1) "mengaitkan nilai semasa siri kepada nilai masa lalu dan ralat ramalan masa lalu." Ia paling sesuai untuk menganalisis data domain masa, di mana data diatur mengikut masa.
|
||||
|
||||
> Terdapat beberapa jenis model ARIMA, yang boleh anda pelajari [di sini](https://people.duke.edu/~rnau/411arim.htm) dan yang akan anda sentuh dalam pelajaran seterusnya.
|
||||
|
||||
Dalam pelajaran seterusnya, anda akan membina model ARIMA menggunakan [Univariate Time Series](https://itl.nist.gov/div898/handbook/pmc/section4/pmc44.htm), yang menumpukan pada satu pembolehubah yang mengubah nilainya dari semasa ke semasa. Contoh jenis data ini adalah [set data ini](https://itl.nist.gov/div898/handbook/pmc/section4/pmc4411.htm) yang merekodkan kepekatan C02 bulanan di Observatori Mauna Loa:
|
||||
|
||||
| CO2 | YearMonth | Year | Month |
|
||||
| :----: | :-------: | :---: | :---: |
|
||||
| 330.62 | 1975.04 | 1975 | 1 |
|
||||
| 331.40 | 1975.13 | 1975 | 2 |
|
||||
| 331.87 | 1975.21 | 1975 | 3 |
|
||||
| 333.18 | 1975.29 | 1975 | 4 |
|
||||
| 333.92 | 1975.38 | 1975 | 5 |
|
||||
| 333.43 | 1975.46 | 1975 | 6 |
|
||||
| 331.85 | 1975.54 | 1975 | 7 |
|
||||
| 330.01 | 1975.63 | 1975 | 8 |
|
||||
| 328.51 | 1975.71 | 1975 | 9 |
|
||||
| 328.41 | 1975.79 | 1975 | 10 |
|
||||
| 329.25 | 1975.88 | 1975 | 11 |
|
||||
| 330.97 | 1975.96 | 1975 | 12 |
|
||||
|
||||
✅ Kenal pasti pembolehubah yang berubah dari semasa ke semasa dalam set data ini
|
||||
|
||||
## Ciri-ciri data siri masa untuk dipertimbangkan
|
||||
|
||||
Apabila melihat data siri masa, anda mungkin perasan bahawa ia mempunyai [ciri-ciri tertentu](https://online.stat.psu.edu/stat510/lesson/1/1.1) yang perlu anda ambil kira dan kurangkan untuk lebih memahami coraknya. Jika anda menganggap data siri masa berpotensi memberikan 'isyarat' yang anda ingin analisis, ciri-ciri ini boleh dianggap sebagai 'bunyi'. Anda sering perlu mengurangkan 'bunyi' ini dengan mengimbangi beberapa ciri ini menggunakan beberapa teknik statistik.
|
||||
|
||||
Berikut adalah beberapa konsep yang anda perlu tahu untuk bekerja dengan siri masa:
|
||||
|
||||
🎓 **Tren**
|
||||
|
||||
Tren ditakrifkan sebagai peningkatan dan penurunan yang boleh diukur dari semasa ke semasa. [Baca lebih lanjut](https://machinelearningmastery.com/time-series-trends-in-python). Dalam konteks siri masa, ia adalah tentang cara menggunakan dan, jika perlu, menghapuskan tren dari siri masa anda.
|
||||
|
||||
🎓 **[Musim](https://machinelearningmastery.com/time-series-seasonality-with-python/)**
|
||||
|
||||
Musim ditakrifkan sebagai turun naik berkala, seperti lonjakan cuti yang mungkin mempengaruhi jualan, sebagai contoh. [Lihat](https://itl.nist.gov/div898/handbook/pmc/section4/pmc443.htm) bagaimana jenis plot yang berbeza memaparkan musim dalam data.
|
||||
|
||||
🎓 **Pelepasan**
|
||||
|
||||
Pelepasan adalah jauh dari varians data standard.
|
||||
|
||||
🎓 **Kitaran jangka panjang**
|
||||
|
||||
Bebas daripada musim, data mungkin memaparkan kitaran jangka panjang seperti kemerosotan ekonomi yang berlangsung lebih lama daripada setahun.
|
||||
|
||||
🎓 **Varians tetap**
|
||||
|
||||
Dari semasa ke semasa, sesetengah data memaparkan turun naik yang tetap, seperti penggunaan tenaga setiap hari dan malam.
|
||||
|
||||
🎓 **Perubahan mendadak**
|
||||
|
||||
Data mungkin memaparkan perubahan mendadak yang mungkin memerlukan analisis lanjut. Penutupan perniagaan secara mendadak akibat COVID, sebagai contoh, menyebabkan perubahan dalam data.
|
||||
|
||||
✅ Berikut adalah [contoh plot siri masa](https://www.kaggle.com/kashnitsky/topic-9-part-1-time-series-analysis-in-python) yang menunjukkan perbelanjaan mata wang dalam permainan harian selama beberapa tahun. Bolehkah anda mengenal pasti mana-mana ciri yang disenaraikan di atas dalam data ini?
|
||||
|
||||
|
||||
|
||||
## Latihan - bermula dengan data penggunaan kuasa
|
||||
|
||||
Mari kita mula mencipta model siri masa untuk meramalkan penggunaan kuasa masa depan berdasarkan penggunaan masa lalu.
|
||||
|
||||
> Data dalam contoh ini diambil dari pertandingan ramalan GEFCom2014. Ia terdiri daripada 3 tahun nilai beban elektrik dan suhu setiap jam antara 2012 dan 2014.
|
||||
>
|
||||
> Tao Hong, Pierre Pinson, Shu Fan, Hamidreza Zareipour, Alberto Troccoli dan Rob J. Hyndman, "Ramalan tenaga probabilistik: Pertandingan Ramalan Tenaga Global 2014 dan seterusnya", International Journal of Forecasting, vol.32, no.3, pp 896-913, Julai-September, 2016.
|
||||
|
||||
1. Dalam folder `working` pelajaran ini, buka fail _notebook.ipynb_. Mulakan dengan menambah perpustakaan yang akan membantu anda memuat dan memvisualisasikan data
|
||||
|
||||
```python
|
||||
import os
|
||||
import matplotlib.pyplot as plt
|
||||
from common.utils import load_data
|
||||
%matplotlib inline
|
||||
```
|
||||
|
||||
Perhatikan, anda menggunakan fail daripada `common` folder which set up your environment and handle downloading the data.
|
||||
|
||||
2. Next, examine the data as a dataframe calling `load_data()` and `head()` yang disertakan:
|
||||
|
||||
```python
|
||||
data_dir = './data'
|
||||
energy = load_data(data_dir)[['load']]
|
||||
energy.head()
|
||||
```
|
||||
|
||||
Anda dapat melihat bahawa terdapat dua lajur yang mewakili tarikh dan beban:
|
||||
|
||||
| | load |
|
||||
| :-----------------: | :----: |
|
||||
| 2012-01-01 00:00:00 | 2698.0 |
|
||||
| 2012-01-01 01:00:00 | 2558.0 |
|
||||
| 2012-01-01 02:00:00 | 2444.0 |
|
||||
| 2012-01-01 03:00:00 | 2402.0 |
|
||||
| 2012-01-01 04:00:00 | 2403.0 |
|
||||
|
||||
3. Sekarang, plot data dengan memanggil `plot()`:
|
||||
|
||||
```python
|
||||
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
4. Sekarang, plot minggu pertama bulan Julai 2014, dengan memberikannya sebagai input kepada corak `energy` in `[from date]: [to date]`:
|
||||
|
||||
```python
|
||||
energy['2014-07-01':'2014-07-07'].plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Plot yang cantik! Lihatlah plot-plot ini dan lihat jika anda boleh menentukan mana-mana ciri yang disenaraikan di atas. Apa yang boleh kita simpulkan dengan memvisualisasikan data?
|
||||
|
||||
Dalam pelajaran seterusnya, anda akan mencipta model ARIMA untuk membuat beberapa ramalan.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Cabaran
|
||||
|
||||
Buat senarai semua industri dan bidang kajian yang anda boleh fikirkan yang akan mendapat manfaat daripada ramalan siri masa. Bolehkah anda memikirkan aplikasi teknik-teknik ini dalam seni? Dalam Ekonometrik? Ekologi? Runcit? Industri? Kewangan? Di mana lagi?
|
||||
|
||||
## [Kuiz pasca-kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/42/)
|
||||
|
||||
## Tinjauan & Kajian Sendiri
|
||||
|
||||
Walaupun kita tidak akan membincangkannya di sini, rangkaian neural kadangkala digunakan untuk meningkatkan kaedah klasik ramalan siri masa. Baca lebih lanjut tentang mereka [dalam artikel ini](https://medium.com/microsoftazure/neural-networks-for-forecasting-financial-and-economic-time-series-6aca370ff412)
|
||||
|
||||
## Tugasan
|
||||
|
||||
[Visualisasikan lebih banyak siri masa](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,14 +0,0 @@
|
||||
# Visualisasikan Beberapa Lagi Siri Masa
|
||||
|
||||
## Arahan
|
||||
|
||||
Anda telah mula mempelajari tentang Ramalan Siri Masa dengan melihat jenis data yang memerlukan pemodelan khas ini. Anda telah memvisualisasikan beberapa data berkaitan tenaga. Sekarang, carilah beberapa data lain yang akan mendapat manfaat daripada Ramalan Siri Masa. Cari tiga contoh (cuba [Kaggle](https://kaggle.com) dan [Azure Open Datasets](https://azure.microsoft.com/en-us/services/open-datasets/catalog/?WT.mc_id=academic-77952-leestott)) dan buat satu notebook untuk memvisualisasikannya. Catatkan sebarang ciri khas yang mereka ada (musim, perubahan mendadak, atau trend lain) dalam notebook tersebut.
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Contoh Terbaik | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | ---------------------------------------------------------- | --------------------------------------------------- | -------------------------------------------------------------------------------------------- |
|
||||
| | Tiga set data diplot dan dijelaskan dalam notebook | Dua set data diplot dan dijelaskan dalam notebook | Beberapa set data diplot atau dijelaskan dalam notebook atau data yang disampaikan tidak mencukupi |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab ke atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,396 +0,0 @@
|
||||
# Ramalan siri masa dengan ARIMA
|
||||
|
||||
Dalam pelajaran sebelumnya, anda telah mempelajari sedikit tentang ramalan siri masa dan memuat dataset yang menunjukkan turun naik beban elektrik dalam satu tempoh masa.
|
||||
|
||||
[](https://youtu.be/IUSk-YDau10 "Pengenalan kepada ARIMA")
|
||||
|
||||
> 🎥 Klik pada imej di atas untuk video: Pengenalan ringkas kepada model ARIMA. Contoh dilakukan dalam R, tetapi konsepnya adalah universal.
|
||||
|
||||
## [Kuiz pra-kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/43/)
|
||||
|
||||
## Pengenalan
|
||||
|
||||
Dalam pelajaran ini, anda akan menemui cara khusus untuk membina model dengan [ARIMA: *A*uto*R*egressive *I*ntegrated *M*oving *A*verage](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average). Model ARIMA sangat sesuai untuk data yang menunjukkan [ketidakstasioner](https://wikipedia.org/wiki/Stationary_process).
|
||||
|
||||
## Konsep umum
|
||||
|
||||
Untuk dapat bekerja dengan ARIMA, terdapat beberapa konsep yang perlu anda ketahui:
|
||||
|
||||
- 🎓 **Stasioneriti**. Dari konteks statistik, stasioneriti merujuk kepada data yang taburannya tidak berubah apabila digeser dalam masa. Data yang tidak stasioner, kemudian, menunjukkan turun naik akibat tren yang mesti ditransformasikan untuk dianalisis. Musim, sebagai contoh, boleh memperkenalkan turun naik dalam data dan boleh dihapuskan melalui proses 'perbezaan bermusim'.
|
||||
|
||||
- 🎓 **[Perbezaan](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average#Differencing)**. Membezakan data, sekali lagi dari konteks statistik, merujuk kepada proses mengubah data yang tidak stasioner untuk menjadikannya stasioner dengan menghapuskan tren yang tidak tetap. "Perbezaan menghapuskan perubahan dalam tahap siri masa, menghapuskan tren dan musim dan seterusnya menstabilkan purata siri masa." [Kertas oleh Shixiong et al](https://arxiv.org/abs/1904.07632)
|
||||
|
||||
## ARIMA dalam konteks siri masa
|
||||
|
||||
Mari kita huraikan bahagian-bahagian ARIMA untuk lebih memahami bagaimana ia membantu kita memodelkan siri masa dan membantu kita membuat ramalan terhadapnya.
|
||||
|
||||
- **AR - untuk AutoRegressive**. Model autoregressive, seperti namanya, melihat 'ke belakang' dalam masa untuk menganalisis nilai-nilai terdahulu dalam data anda dan membuat anggapan mengenainya. Nilai-nilai terdahulu ini dipanggil 'lags'. Contohnya ialah data yang menunjukkan jualan bulanan pensel. Jumlah jualan setiap bulan akan dianggap sebagai 'pembolehubah yang berkembang' dalam dataset. Model ini dibina kerana "pembolehubah yang berkembang menarik minat diregresi pada nilai terdahulunya sendiri (iaitu, nilai sebelumnya)." [wikipedia](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average)
|
||||
|
||||
- **I - untuk Integrated**. Berbeza dengan model 'ARMA' yang serupa, 'I' dalam ARIMA merujuk kepada aspek *[terintegrasi](https://wikipedia.org/wiki/Order_of_integration)*. Data 'terintegrasi' apabila langkah-langkah perbezaan diterapkan untuk menghapuskan ketidakstasioner.
|
||||
|
||||
- **MA - untuk Moving Average**. Aspek [moving-average](https://wikipedia.org/wiki/Moving-average_model) model ini merujuk kepada pembolehubah output yang ditentukan dengan memerhati nilai semasa dan masa lalu lag.
|
||||
|
||||
Kesimpulan: ARIMA digunakan untuk membuat model sesuai dengan bentuk khas data siri masa seakrab mungkin.
|
||||
|
||||
## Latihan - bina model ARIMA
|
||||
|
||||
Buka folder [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/working) dalam pelajaran ini dan cari fail [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/2-ARIMA/working/notebook.ipynb).
|
||||
|
||||
1. Jalankan notebook untuk memuat perpustakaan `statsmodels` Python; anda akan memerlukannya untuk model ARIMA.
|
||||
|
||||
1. Muatkan perpustakaan yang diperlukan
|
||||
|
||||
1. Sekarang, muatkan beberapa perpustakaan lagi yang berguna untuk melukis data:
|
||||
|
||||
```python
|
||||
import os
|
||||
import warnings
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import datetime as dt
|
||||
import math
|
||||
|
||||
from pandas.plotting import autocorrelation_plot
|
||||
from statsmodels.tsa.statespace.sarimax import SARIMAX
|
||||
from sklearn.preprocessing import MinMaxScaler
|
||||
from common.utils import load_data, mape
|
||||
from IPython.display import Image
|
||||
|
||||
%matplotlib inline
|
||||
pd.options.display.float_format = '{:,.2f}'.format
|
||||
np.set_printoptions(precision=2)
|
||||
warnings.filterwarnings("ignore") # specify to ignore warning messages
|
||||
```
|
||||
|
||||
1. Muat data dari fail `/data/energy.csv` ke dalam dataframe Pandas dan lihat:
|
||||
|
||||
```python
|
||||
energy = load_data('./data')[['load']]
|
||||
energy.head(10)
|
||||
```
|
||||
|
||||
1. Lukis semua data tenaga yang tersedia dari Januari 2012 hingga Disember 2014. Tidak sepatutnya ada kejutan kerana kita telah melihat data ini dalam pelajaran lepas:
|
||||
|
||||
```python
|
||||
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
Sekarang, mari kita bina model!
|
||||
|
||||
### Buat dataset latihan dan ujian
|
||||
|
||||
Sekarang data anda telah dimuatkan, jadi anda boleh memisahkannya ke dalam set latihan dan ujian. Anda akan melatih model anda pada set latihan. Seperti biasa, selepas model selesai dilatih, anda akan menilai ketepatannya menggunakan set ujian. Anda perlu memastikan bahawa set ujian meliputi tempoh masa yang lebih lewat daripada set latihan untuk memastikan bahawa model tidak memperoleh maklumat daripada tempoh masa hadapan.
|
||||
|
||||
1. Peruntukkan tempoh dua bulan dari 1 September hingga 31 Oktober 2014 kepada set latihan. Set ujian akan merangkumi tempoh dua bulan dari 1 November hingga 31 Disember 2014:
|
||||
|
||||
```python
|
||||
train_start_dt = '2014-11-01 00:00:00'
|
||||
test_start_dt = '2014-12-30 00:00:00'
|
||||
```
|
||||
|
||||
Oleh kerana data ini mencerminkan penggunaan tenaga harian, terdapat corak bermusim yang kuat, tetapi penggunaan adalah paling serupa dengan penggunaan pada hari-hari yang lebih baru.
|
||||
|
||||
1. Visualisasikan perbezaannya:
|
||||
|
||||
```python
|
||||
energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
|
||||
.join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
|
||||
.plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Oleh itu, menggunakan jangka masa yang agak kecil untuk melatih data sepatutnya mencukupi.
|
||||
|
||||
> Nota: Oleh kerana fungsi yang kita gunakan untuk menyesuaikan model ARIMA menggunakan pengesahan dalam-sampel semasa pemasangan, kita akan mengabaikan data pengesahan.
|
||||
|
||||
### Sediakan data untuk latihan
|
||||
|
||||
Sekarang, anda perlu menyediakan data untuk latihan dengan melakukan penapisan dan penskalaan data anda. Tapis dataset anda untuk hanya merangkumi tempoh masa dan lajur yang anda perlukan, dan penskalaan untuk memastikan data diproyeksikan dalam selang 0,1.
|
||||
|
||||
1. Tapis dataset asal untuk hanya merangkumi tempoh masa yang disebutkan di atas setiap set dan hanya termasuk lajur 'load' yang diperlukan serta tarikh:
|
||||
|
||||
```python
|
||||
train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
|
||||
test = energy.copy()[energy.index >= test_start_dt][['load']]
|
||||
|
||||
print('Training data shape: ', train.shape)
|
||||
print('Test data shape: ', test.shape)
|
||||
```
|
||||
|
||||
Anda boleh melihat bentuk data:
|
||||
|
||||
```output
|
||||
Training data shape: (1416, 1)
|
||||
Test data shape: (48, 1)
|
||||
```
|
||||
|
||||
1. Skala data untuk berada dalam julat (0, 1).
|
||||
|
||||
```python
|
||||
scaler = MinMaxScaler()
|
||||
train['load'] = scaler.fit_transform(train)
|
||||
train.head(10)
|
||||
```
|
||||
|
||||
1. Visualisasikan data asal vs. data berskala:
|
||||
|
||||
```python
|
||||
energy[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']].rename(columns={'load':'original load'}).plot.hist(bins=100, fontsize=12)
|
||||
train.rename(columns={'load':'scaled load'}).plot.hist(bins=100, fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
> Data asal
|
||||
|
||||
|
||||
|
||||
> Data berskala
|
||||
|
||||
1. Sekarang bahawa anda telah menentukur data berskala, anda boleh menskala data ujian:
|
||||
|
||||
```python
|
||||
test['load'] = scaler.transform(test)
|
||||
test.head()
|
||||
```
|
||||
|
||||
### Laksanakan ARIMA
|
||||
|
||||
Sudah tiba masanya untuk melaksanakan ARIMA! Anda kini akan menggunakan perpustakaan `statsmodels` yang anda pasang sebelum ini.
|
||||
|
||||
Sekarang anda perlu mengikuti beberapa langkah
|
||||
|
||||
1. Tentukan model dengan memanggil `SARIMAX()` and passing in the model parameters: p, d, and q parameters, and P, D, and Q parameters.
|
||||
2. Prepare the model for the training data by calling the fit() function.
|
||||
3. Make predictions calling the `forecast()` function and specifying the number of steps (the `horizon`) to forecast.
|
||||
|
||||
> 🎓 What are all these parameters for? In an ARIMA model there are 3 parameters that are used to help model the major aspects of a time series: seasonality, trend, and noise. These parameters are:
|
||||
|
||||
`p`: the parameter associated with the auto-regressive aspect of the model, which incorporates *past* values.
|
||||
`d`: the parameter associated with the integrated part of the model, which affects the amount of *differencing* (🎓 remember differencing 👆?) to apply to a time series.
|
||||
`q`: the parameter associated with the moving-average part of the model.
|
||||
|
||||
> Note: If your data has a seasonal aspect - which this one does - , we use a seasonal ARIMA model (SARIMA). In that case you need to use another set of parameters: `P`, `D`, and `Q` which describe the same associations as `p`, `d`, and `q`, tetapi sepadan dengan komponen bermusim model.
|
||||
|
||||
1. Mulakan dengan menetapkan nilai horizon pilihan anda. Mari cuba 3 jam:
|
||||
|
||||
```python
|
||||
# Specify the number of steps to forecast ahead
|
||||
HORIZON = 3
|
||||
print('Forecasting horizon:', HORIZON, 'hours')
|
||||
```
|
||||
|
||||
Memilih nilai terbaik untuk parameter model ARIMA boleh menjadi mencabar kerana ia agak subjektif dan memerlukan masa. Anda mungkin mempertimbangkan untuk menggunakan `auto_arima()` function from the [`pyramid` library](https://alkaline-ml.com/pmdarima/0.9.0/modules/generated/pyramid.arima.auto_arima.html),
|
||||
|
||||
1. Buat masa ini cuba beberapa pilihan manual untuk mencari model yang baik.
|
||||
|
||||
```python
|
||||
order = (4, 1, 0)
|
||||
seasonal_order = (1, 1, 0, 24)
|
||||
|
||||
model = SARIMAX(endog=train, order=order, seasonal_order=seasonal_order)
|
||||
results = model.fit()
|
||||
|
||||
print(results.summary())
|
||||
```
|
||||
|
||||
Jadual keputusan dicetak.
|
||||
|
||||
Anda telah membina model pertama anda! Sekarang kita perlu mencari cara untuk menilainya.
|
||||
|
||||
### Menilai model anda
|
||||
|
||||
Untuk menilai model anda, anda boleh melakukan pengesahan `walk forward`. Dalam amalan, model siri masa dilatih semula setiap kali data baru tersedia. Ini membolehkan model membuat ramalan terbaik pada setiap langkah masa.
|
||||
|
||||
Bermula dari awal siri masa menggunakan teknik ini, latih model pada set data latihan. Kemudian buat ramalan pada langkah masa seterusnya. Ramalan dinilai terhadap nilai yang diketahui. Set latihan kemudian diperluas untuk merangkumi nilai yang diketahui dan proses diulang.
|
||||
|
||||
> Nota: Anda harus memastikan tetingkap set latihan tetap untuk latihan yang lebih cekap supaya setiap kali anda menambah pemerhatian baru pada set latihan, anda menghapuskan pemerhatian dari permulaan set.
|
||||
|
||||
Proses ini menyediakan anggaran yang lebih kukuh tentang bagaimana model akan berfungsi dalam amalan. Walau bagaimanapun, ia datang pada kos pengiraan untuk mencipta begitu banyak model. Ini boleh diterima jika data kecil atau model mudah, tetapi boleh menjadi isu pada skala besar.
|
||||
|
||||
Pengesahan 'walk-forward' adalah standard emas penilaian model siri masa dan disyorkan untuk projek anda sendiri.
|
||||
|
||||
1. Pertama, buat titik data ujian untuk setiap langkah HORIZON.
|
||||
|
||||
```python
|
||||
test_shifted = test.copy()
|
||||
|
||||
for t in range(1, HORIZON+1):
|
||||
test_shifted['load+'+str(t)] = test_shifted['load'].shift(-t, freq='H')
|
||||
|
||||
test_shifted = test_shifted.dropna(how='any')
|
||||
test_shifted.head(5)
|
||||
```
|
||||
|
||||
| | | load | load+1 | load+2 |
|
||||
| ---------- | -------- | ---- | ------ | ------ |
|
||||
| 2014-12-30 | 00:00:00 | 0.33 | 0.29 | 0.27 |
|
||||
| 2014-12-30 | 01:00:00 | 0.29 | 0.27 | 0.27 |
|
||||
| 2014-12-30 | 02:00:00 | 0.27 | 0.27 | 0.30 |
|
||||
| 2014-12-30 | 03:00:00 | 0.27 | 0.30 | 0.41 |
|
||||
| 2014-12-30 | 04:00:00 | 0.30 | 0.41 | 0.57 |
|
||||
|
||||
Data digeser secara mendatar mengikut titik horizon.
|
||||
|
||||
1. Buat ramalan pada data ujian anda menggunakan pendekatan tetingkap gelongsor ini dalam gelung sepanjang panjang data ujian:
|
||||
|
||||
```python
|
||||
%%time
|
||||
training_window = 720 # dedicate 30 days (720 hours) for training
|
||||
|
||||
train_ts = train['load']
|
||||
test_ts = test_shifted
|
||||
|
||||
history = [x for x in train_ts]
|
||||
history = history[(-training_window):]
|
||||
|
||||
predictions = list()
|
||||
|
||||
order = (2, 1, 0)
|
||||
seasonal_order = (1, 1, 0, 24)
|
||||
|
||||
for t in range(test_ts.shape[0]):
|
||||
model = SARIMAX(endog=history, order=order, seasonal_order=seasonal_order)
|
||||
model_fit = model.fit()
|
||||
yhat = model_fit.forecast(steps = HORIZON)
|
||||
predictions.append(yhat)
|
||||
obs = list(test_ts.iloc[t])
|
||||
# move the training window
|
||||
history.append(obs[0])
|
||||
history.pop(0)
|
||||
print(test_ts.index[t])
|
||||
print(t+1, ': predicted =', yhat, 'expected =', obs)
|
||||
```
|
||||
|
||||
Anda boleh melihat latihan berlaku:
|
||||
|
||||
```output
|
||||
2014-12-30 00:00:00
|
||||
1 : predicted = [0.32 0.29 0.28] expected = [0.32945389435989236, 0.2900626678603402, 0.2739480752014323]
|
||||
|
||||
2014-12-30 01:00:00
|
||||
2 : predicted = [0.3 0.29 0.3 ] expected = [0.2900626678603402, 0.2739480752014323, 0.26812891674127126]
|
||||
|
||||
2014-12-30 02:00:00
|
||||
3 : predicted = [0.27 0.28 0.32] expected = [0.2739480752014323, 0.26812891674127126, 0.3025962399283795]
|
||||
```
|
||||
|
||||
1. Bandingkan ramalan dengan beban sebenar:
|
||||
|
||||
```python
|
||||
eval_df = pd.DataFrame(predictions, columns=['t+'+str(t) for t in range(1, HORIZON+1)])
|
||||
eval_df['timestamp'] = test.index[0:len(test.index)-HORIZON+1]
|
||||
eval_df = pd.melt(eval_df, id_vars='timestamp', value_name='prediction', var_name='h')
|
||||
eval_df['actual'] = np.array(np.transpose(test_ts)).ravel()
|
||||
eval_df[['prediction', 'actual']] = scaler.inverse_transform(eval_df[['prediction', 'actual']])
|
||||
eval_df.head()
|
||||
```
|
||||
|
||||
Output
|
||||
| | | timestamp | h | prediction | actual |
|
||||
| --- | ---------- | --------- | --- | ---------- | -------- |
|
||||
| 0 | 2014-12-30 | 00:00:00 | t+1 | 3,008.74 | 3,023.00 |
|
||||
| 1 | 2014-12-30 | 01:00:00 | t+1 | 2,955.53 | 2,935.00 |
|
||||
| 2 | 2014-12-30 | 02:00:00 | t+1 | 2,900.17 | 2,899.00 |
|
||||
| 3 | 2014-12-30 | 03:00:00 | t+1 | 2,917.69 | 2,886.00 |
|
||||
| 4 | 2014-12-30 | 04:00:00 | t+1 | 2,946.99 | 2,963.00 |
|
||||
|
||||
Perhatikan ramalan data setiap jam, berbanding beban sebenar. Sejauh mana ketepatannya?
|
||||
|
||||
### Semak ketepatan model
|
||||
|
||||
Periksa ketepatan model anda dengan menguji ralat peratusan mutlak purata (MAPE) ke atas semua ramalan.
|
||||
|
||||
> **🧮 Tunjukkan saya matematik**
|
||||
>
|
||||
> 
|
||||
>
|
||||
> [MAPE](https://www.linkedin.com/pulse/what-mape-mad-msd-time-series-allameh-statistics/) digunakan untuk menunjukkan ketepatan ramalan sebagai nisbah yang ditakrifkan oleh formula di atas. Perbezaan antara actual<sub>t</sub> dan predicted<sub>t</sub> dibahagikan dengan actual<sub>t</sub>. "Nilai mutlak dalam pengiraan ini dijumlahkan untuk setiap titik ramalan dalam masa dan dibahagikan dengan bilangan titik yang dipasangkan n." [wikipedia](https://wikipedia.org/wiki/Mean_absolute_percentage_error)
|
||||
|
||||
1. Nyatakan persamaan dalam kod:
|
||||
|
||||
```python
|
||||
if(HORIZON > 1):
|
||||
eval_df['APE'] = (eval_df['prediction'] - eval_df['actual']).abs() / eval_df['actual']
|
||||
print(eval_df.groupby('h')['APE'].mean())
|
||||
```
|
||||
|
||||
1. Kira MAPE satu langkah:
|
||||
|
||||
```python
|
||||
print('One step forecast MAPE: ', (mape(eval_df[eval_df['h'] == 't+1']['prediction'], eval_df[eval_df['h'] == 't+1']['actual']))*100, '%')
|
||||
```
|
||||
|
||||
MAPE ramalan satu langkah: 0.5570581332313952 %
|
||||
|
||||
1. Cetak MAPE ramalan pelbagai langkah:
|
||||
|
||||
```python
|
||||
print('Multi-step forecast MAPE: ', mape(eval_df['prediction'], eval_df['actual'])*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
Multi-step forecast MAPE: 1.1460048657704118 %
|
||||
```
|
||||
|
||||
Nombor yang rendah adalah yang terbaik: pertimbangkan bahawa ramalan yang mempunyai MAPE 10 adalah meleset sebanyak 10%.
|
||||
|
||||
1. Tetapi seperti biasa, lebih mudah untuk melihat jenis ukuran ketepatan ini secara visual, jadi mari kita plotkannya:
|
||||
|
||||
```python
|
||||
if(HORIZON == 1):
|
||||
## Plotting single step forecast
|
||||
eval_df.plot(x='timestamp', y=['actual', 'prediction'], style=['r', 'b'], figsize=(15, 8))
|
||||
|
||||
else:
|
||||
## Plotting multi step forecast
|
||||
plot_df = eval_df[(eval_df.h=='t+1')][['timestamp', 'actual']]
|
||||
for t in range(1, HORIZON+1):
|
||||
plot_df['t+'+str(t)] = eval_df[(eval_df.h=='t+'+str(t))]['prediction'].values
|
||||
|
||||
fig = plt.figure(figsize=(15, 8))
|
||||
ax = plt.plot(plot_df['timestamp'], plot_df['actual'], color='red', linewidth=4.0)
|
||||
ax = fig.add_subplot(111)
|
||||
for t in range(1, HORIZON+1):
|
||||
x = plot_df['timestamp'][(t-1):]
|
||||
y = plot_df['t+'+str(t)][0:len(x)]
|
||||
ax.plot(x, y, color='blue', linewidth=4*math.pow(.9,t), alpha=math.pow(0.8,t))
|
||||
|
||||
ax.legend(loc='best')
|
||||
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
🏆 Plot yang sangat bagus, menunjukkan model dengan ketepatan yang baik. Syabas!
|
||||
|
||||
---
|
||||
|
||||
## 🚀Cabaran
|
||||
|
||||
Selidik cara untuk menguji ketepatan model Siri Masa. Kami menyentuh tentang MAPE dalam pelajaran ini, tetapi adakah terdapat kaedah lain yang boleh anda gunakan? Selidik dan anotasi mereka. Dokumen yang berguna boleh didapati [di sini](https://otexts.com/fpp2/accuracy.html)
|
||||
|
||||
## [Kuiz pasca-kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/44/)
|
||||
|
||||
## Kajian & Pembelajaran Sendiri
|
||||
|
||||
Pelajaran ini hanya menyentuh asas-asas Ramalan Siri Masa dengan ARIMA. Luangkan masa untuk mendalami pengetahuan anda dengan menyelidik [repositori ini](https://microsoft.github.io/forecasting/) dan jenis modelnya yang pelbagai untuk mempelajari cara lain membina model Siri Masa.
|
||||
|
||||
## Tugasan
|
||||
|
||||
[Model ARIMA baru](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,14 +0,0 @@
|
||||
# Model ARIMA Baru
|
||||
|
||||
## Arahan
|
||||
|
||||
Sekarang setelah anda membina model ARIMA, bina satu lagi dengan data baru (cuba salah satu [set data dari Duke](http://www2.stat.duke.edu/~mw/ts_data_sets.html)). Catatkan kerja anda dalam buku nota, visualkan data dan model anda, dan uji ketepatannya menggunakan MAPE.
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ---------------------------------- |
|
||||
| | Buku nota disediakan dengan model ARIMA baru yang dibina, diuji dan dijelaskan dengan visualisasi dan ketepatan dinyatakan. | Buku nota yang disediakan tidak dicatat atau mengandungi pepijat | Buku nota yang tidak lengkap disediakan |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional disarankan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,389 +0,0 @@
|
||||
# Ramalan Siri Masa dengan Support Vector Regressor
|
||||
|
||||
Dalam pelajaran sebelumnya, anda telah belajar cara menggunakan model ARIMA untuk membuat ramalan siri masa. Sekarang anda akan melihat model Support Vector Regressor yang merupakan model regressor yang digunakan untuk meramalkan data berterusan.
|
||||
|
||||
## [Kuiz Pra-ceramah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/51/)
|
||||
|
||||
## Pengenalan
|
||||
|
||||
Dalam pelajaran ini, anda akan menemui cara khusus untuk membina model dengan [**SVM**: **S**upport **V**ector **M**achine](https://en.wikipedia.org/wiki/Support-vector_machine) untuk regresi, atau **SVR: Support Vector Regressor**.
|
||||
|
||||
### SVR dalam konteks siri masa [^1]
|
||||
|
||||
Sebelum memahami kepentingan SVR dalam ramalan siri masa, berikut adalah beberapa konsep penting yang perlu anda ketahui:
|
||||
|
||||
- **Regresi:** Teknik pembelajaran terkawal untuk meramalkan nilai berterusan dari set input yang diberikan. Ideanya adalah untuk memadankan lengkung (atau garis) dalam ruang ciri yang mempunyai bilangan titik data maksimum. [Klik di sini](https://en.wikipedia.org/wiki/Regression_analysis) untuk maklumat lanjut.
|
||||
- **Support Vector Machine (SVM):** Jenis model pembelajaran mesin terkawal yang digunakan untuk klasifikasi, regresi dan pengesanan pencilan. Model ini adalah hyperplane dalam ruang ciri, yang dalam kes klasifikasi bertindak sebagai sempadan, dan dalam kes regresi bertindak sebagai garis padanan terbaik. Dalam SVM, fungsi Kernel biasanya digunakan untuk mengubah set data ke ruang dengan bilangan dimensi yang lebih tinggi, supaya mereka dapat dipisahkan dengan mudah. [Klik di sini](https://en.wikipedia.org/wiki/Support-vector_machine) untuk maklumat lanjut mengenai SVM.
|
||||
- **Support Vector Regressor (SVR):** Jenis SVM, untuk mencari garis padanan terbaik (yang dalam kes SVM adalah hyperplane) yang mempunyai bilangan titik data maksimum.
|
||||
|
||||
### Mengapa SVR? [^1]
|
||||
|
||||
Dalam pelajaran lepas anda belajar tentang ARIMA, yang merupakan kaedah statistik linear yang sangat berjaya untuk meramalkan data siri masa. Walau bagaimanapun, dalam banyak kes, data siri masa mempunyai *non-linearity*, yang tidak dapat dipetakan oleh model linear. Dalam kes sedemikian, keupayaan SVM untuk mempertimbangkan non-linearity dalam data untuk tugas regresi menjadikan SVR berjaya dalam ramalan siri masa.
|
||||
|
||||
## Latihan - bina model SVR
|
||||
|
||||
Langkah pertama untuk penyediaan data adalah sama seperti pelajaran sebelumnya mengenai [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA).
|
||||
|
||||
Buka folder [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/3-SVR/working) dalam pelajaran ini dan cari fail [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/3-SVR/working/notebook.ipynb).[^2]
|
||||
|
||||
1. Jalankan notebook dan import perpustakaan yang diperlukan: [^2]
|
||||
|
||||
```python
|
||||
import sys
|
||||
sys.path.append('../../')
|
||||
```
|
||||
|
||||
```python
|
||||
import os
|
||||
import warnings
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import datetime as dt
|
||||
import math
|
||||
|
||||
from sklearn.svm import SVR
|
||||
from sklearn.preprocessing import MinMaxScaler
|
||||
from common.utils import load_data, mape
|
||||
```
|
||||
|
||||
2. Muatkan data dari fail `/data/energy.csv` ke dalam dataframe Pandas dan lihat: [^2]
|
||||
|
||||
```python
|
||||
energy = load_data('../../data')[['load']]
|
||||
```
|
||||
|
||||
3. Plot semua data tenaga yang tersedia dari Januari 2012 hingga Disember 2014: [^2]
|
||||
|
||||
```python
|
||||
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Sekarang, mari bina model SVR kita.
|
||||
|
||||
### Buat dataset latihan dan ujian
|
||||
|
||||
Sekarang data anda dimuatkan, anda boleh memisahkannya ke dalam set latihan dan ujian. Kemudian anda akan mengubah bentuk data untuk mencipta dataset berdasarkan langkah masa yang diperlukan untuk SVR. Anda akan melatih model anda pada set latihan. Selepas model selesai latihan, anda akan menilai ketepatannya pada set latihan, set ujian dan kemudian keseluruhan dataset untuk melihat prestasi keseluruhan. Anda perlu memastikan bahawa set ujian meliputi tempoh masa yang lebih lewat dari set latihan untuk memastikan model tidak mendapat maklumat dari tempoh masa depan [^2] (situasi yang dikenali sebagai *Overfitting*).
|
||||
|
||||
1. Peruntukkan tempoh dua bulan dari 1 September hingga 31 Oktober 2014 ke set latihan. Set ujian akan merangkumi tempoh dua bulan dari 1 November hingga 31 Disember 2014: [^2]
|
||||
|
||||
```python
|
||||
train_start_dt = '2014-11-01 00:00:00'
|
||||
test_start_dt = '2014-12-30 00:00:00'
|
||||
```
|
||||
|
||||
2. Visualisasikan perbezaannya: [^2]
|
||||
|
||||
```python
|
||||
energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
|
||||
.join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
|
||||
.plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
### Sediakan data untuk latihan
|
||||
|
||||
Sekarang, anda perlu menyediakan data untuk latihan dengan melakukan penapisan dan penskalaan data anda. Tapis dataset anda untuk hanya merangkumi tempoh masa dan lajur yang anda perlukan, dan penskalaan untuk memastikan data diproyeksikan dalam julat 0,1.
|
||||
|
||||
1. Tapis dataset asal untuk hanya merangkumi tempoh masa yang disebutkan di atas per set dan hanya termasuk lajur 'load' yang diperlukan serta tarikh: [^2]
|
||||
|
||||
```python
|
||||
train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
|
||||
test = energy.copy()[energy.index >= test_start_dt][['load']]
|
||||
|
||||
print('Training data shape: ', train.shape)
|
||||
print('Test data shape: ', test.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
Training data shape: (1416, 1)
|
||||
Test data shape: (48, 1)
|
||||
```
|
||||
|
||||
2. Skala data latihan untuk berada dalam julat (0, 1): [^2]
|
||||
|
||||
```python
|
||||
scaler = MinMaxScaler()
|
||||
train['load'] = scaler.fit_transform(train)
|
||||
```
|
||||
|
||||
4. Sekarang, anda skala data ujian: [^2]
|
||||
|
||||
```python
|
||||
test['load'] = scaler.transform(test)
|
||||
```
|
||||
|
||||
### Cipta data dengan langkah masa [^1]
|
||||
|
||||
Untuk SVR, anda mengubah input data menjadi bentuk `[batch, timesteps]`. So, you reshape the existing `train_data` and `test_data` supaya terdapat dimensi baru yang merujuk kepada langkah masa.
|
||||
|
||||
```python
|
||||
# Converting to numpy arrays
|
||||
train_data = train.values
|
||||
test_data = test.values
|
||||
```
|
||||
|
||||
Untuk contoh ini, kita ambil `timesteps = 5`. Jadi, input kepada model adalah data untuk 4 langkah masa pertama, dan output akan menjadi data untuk langkah masa ke-5.
|
||||
|
||||
```python
|
||||
timesteps=5
|
||||
```
|
||||
|
||||
Menukar data latihan kepada tensor 2D menggunakan senarai bersarang:
|
||||
|
||||
```python
|
||||
train_data_timesteps=np.array([[j for j in train_data[i:i+timesteps]] for i in range(0,len(train_data)-timesteps+1)])[:,:,0]
|
||||
train_data_timesteps.shape
|
||||
```
|
||||
|
||||
```output
|
||||
(1412, 5)
|
||||
```
|
||||
|
||||
Menukar data ujian kepada tensor 2D:
|
||||
|
||||
```python
|
||||
test_data_timesteps=np.array([[j for j in test_data[i:i+timesteps]] for i in range(0,len(test_data)-timesteps+1)])[:,:,0]
|
||||
test_data_timesteps.shape
|
||||
```
|
||||
|
||||
```output
|
||||
(44, 5)
|
||||
```
|
||||
|
||||
Memilih input dan output dari data latihan dan ujian:
|
||||
|
||||
```python
|
||||
x_train, y_train = train_data_timesteps[:,:timesteps-1],train_data_timesteps[:,[timesteps-1]]
|
||||
x_test, y_test = test_data_timesteps[:,:timesteps-1],test_data_timesteps[:,[timesteps-1]]
|
||||
|
||||
print(x_train.shape, y_train.shape)
|
||||
print(x_test.shape, y_test.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
(1412, 4) (1412, 1)
|
||||
(44, 4) (44, 1)
|
||||
```
|
||||
|
||||
### Laksanakan SVR [^1]
|
||||
|
||||
Sekarang, tiba masanya untuk melaksanakan SVR. Untuk membaca lebih lanjut mengenai pelaksanaan ini, anda boleh merujuk kepada [dokumentasi ini](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html). Untuk pelaksanaan kita, kita ikut langkah-langkah ini:
|
||||
|
||||
1. Tentukan model dengan memanggil `SVR()` and passing in the model hyperparameters: kernel, gamma, c and epsilon
|
||||
2. Prepare the model for the training data by calling the `fit()` function
|
||||
3. Make predictions calling the `predict()` function
|
||||
|
||||
Sekarang kita cipta model SVR. Di sini kita gunakan [RBF kernel](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel), dan tetapkan hyperparameters gamma, C dan epsilon sebagai 0.5, 10 dan 0.05 masing-masing.
|
||||
|
||||
```python
|
||||
model = SVR(kernel='rbf',gamma=0.5, C=10, epsilon = 0.05)
|
||||
```
|
||||
|
||||
#### Latih model pada data latihan [^1]
|
||||
|
||||
```python
|
||||
model.fit(x_train, y_train[:,0])
|
||||
```
|
||||
|
||||
```output
|
||||
SVR(C=10, cache_size=200, coef0=0.0, degree=3, epsilon=0.05, gamma=0.5,
|
||||
kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)
|
||||
```
|
||||
|
||||
#### Buat ramalan model [^1]
|
||||
|
||||
```python
|
||||
y_train_pred = model.predict(x_train).reshape(-1,1)
|
||||
y_test_pred = model.predict(x_test).reshape(-1,1)
|
||||
|
||||
print(y_train_pred.shape, y_test_pred.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
(1412, 1) (44, 1)
|
||||
```
|
||||
|
||||
Anda telah membina SVR anda! Sekarang kita perlu menilai ia.
|
||||
|
||||
### Nilai model anda [^1]
|
||||
|
||||
Untuk penilaian, pertama kita akan skala kembali data ke skala asal kita. Kemudian, untuk memeriksa prestasi, kita akan plot siri masa asal dan ramalan, dan juga cetak keputusan MAPE.
|
||||
|
||||
Skala data ramalan dan output asal:
|
||||
|
||||
```python
|
||||
# Scaling the predictions
|
||||
y_train_pred = scaler.inverse_transform(y_train_pred)
|
||||
y_test_pred = scaler.inverse_transform(y_test_pred)
|
||||
|
||||
print(len(y_train_pred), len(y_test_pred))
|
||||
```
|
||||
|
||||
```python
|
||||
# Scaling the original values
|
||||
y_train = scaler.inverse_transform(y_train)
|
||||
y_test = scaler.inverse_transform(y_test)
|
||||
|
||||
print(len(y_train), len(y_test))
|
||||
```
|
||||
|
||||
#### Periksa prestasi model pada data latihan dan ujian [^1]
|
||||
|
||||
Kita ekstrak cap waktu dari dataset untuk ditunjukkan pada paksi-x plot kita. Perhatikan bahawa kita menggunakan ```timesteps-1``` nilai pertama sebagai input untuk output pertama, jadi cap waktu untuk output akan bermula selepas itu.
|
||||
|
||||
```python
|
||||
train_timestamps = energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)].index[timesteps-1:]
|
||||
test_timestamps = energy[test_start_dt:].index[timesteps-1:]
|
||||
|
||||
print(len(train_timestamps), len(test_timestamps))
|
||||
```
|
||||
|
||||
```output
|
||||
1412 44
|
||||
```
|
||||
|
||||
Plot ramalan untuk data latihan:
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(25,6))
|
||||
plt.plot(train_timestamps, y_train, color = 'red', linewidth=2.0, alpha = 0.6)
|
||||
plt.plot(train_timestamps, y_train_pred, color = 'blue', linewidth=0.8)
|
||||
plt.legend(['Actual','Predicted'])
|
||||
plt.xlabel('Timestamp')
|
||||
plt.title("Training data prediction")
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Cetak MAPE untuk data latihan
|
||||
|
||||
```python
|
||||
print('MAPE for training data: ', mape(y_train_pred, y_train)*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
MAPE for training data: 1.7195710200875551 %
|
||||
```
|
||||
|
||||
Plot ramalan untuk data ujian
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(10,3))
|
||||
plt.plot(test_timestamps, y_test, color = 'red', linewidth=2.0, alpha = 0.6)
|
||||
plt.plot(test_timestamps, y_test_pred, color = 'blue', linewidth=0.8)
|
||||
plt.legend(['Actual','Predicted'])
|
||||
plt.xlabel('Timestamp')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Cetak MAPE untuk data ujian
|
||||
|
||||
```python
|
||||
print('MAPE for testing data: ', mape(y_test_pred, y_test)*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
MAPE for testing data: 1.2623790187854018 %
|
||||
```
|
||||
|
||||
🏆 Anda mempunyai hasil yang sangat baik pada dataset ujian!
|
||||
|
||||
### Periksa prestasi model pada dataset penuh [^1]
|
||||
|
||||
```python
|
||||
# Extracting load values as numpy array
|
||||
data = energy.copy().values
|
||||
|
||||
# Scaling
|
||||
data = scaler.transform(data)
|
||||
|
||||
# Transforming to 2D tensor as per model input requirement
|
||||
data_timesteps=np.array([[j for j in data[i:i+timesteps]] for i in range(0,len(data)-timesteps+1)])[:,:,0]
|
||||
print("Tensor shape: ", data_timesteps.shape)
|
||||
|
||||
# Selecting inputs and outputs from data
|
||||
X, Y = data_timesteps[:,:timesteps-1],data_timesteps[:,[timesteps-1]]
|
||||
print("X shape: ", X.shape,"\nY shape: ", Y.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
Tensor shape: (26300, 5)
|
||||
X shape: (26300, 4)
|
||||
Y shape: (26300, 1)
|
||||
```
|
||||
|
||||
```python
|
||||
# Make model predictions
|
||||
Y_pred = model.predict(X).reshape(-1,1)
|
||||
|
||||
# Inverse scale and reshape
|
||||
Y_pred = scaler.inverse_transform(Y_pred)
|
||||
Y = scaler.inverse_transform(Y)
|
||||
```
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(30,8))
|
||||
plt.plot(Y, color = 'red', linewidth=2.0, alpha = 0.6)
|
||||
plt.plot(Y_pred, color = 'blue', linewidth=0.8)
|
||||
plt.legend(['Actual','Predicted'])
|
||||
plt.xlabel('Timestamp')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
```python
|
||||
print('MAPE: ', mape(Y_pred, Y)*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
MAPE: 2.0572089029888656 %
|
||||
```
|
||||
|
||||
|
||||
|
||||
🏆 Plot yang sangat bagus, menunjukkan model dengan ketepatan yang baik. Syabas!
|
||||
|
||||
---
|
||||
|
||||
## 🚀Cabaran
|
||||
|
||||
- Cuba ubah hyperparameters (gamma, C, epsilon) semasa mencipta model dan nilai pada data untuk melihat set hyperparameters mana yang memberikan hasil terbaik pada data ujian. Untuk mengetahui lebih lanjut mengenai hyperparameters ini, anda boleh merujuk kepada dokumen [di sini](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel).
|
||||
- Cuba gunakan fungsi kernel yang berbeza untuk model dan analisis prestasi mereka pada dataset. Dokumen yang berguna boleh didapati [di sini](https://scikit-learn.org/stable/modules/svm.html#kernel-functions).
|
||||
- Cuba gunakan nilai yang berbeza untuk `timesteps` untuk model melihat ke belakang untuk membuat ramalan.
|
||||
|
||||
## [Kuiz Pasca-ceramah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/52/)
|
||||
|
||||
## Ulasan & Kajian Kendiri
|
||||
|
||||
Pelajaran ini adalah untuk memperkenalkan aplikasi SVR untuk Ramalan Siri Masa. Untuk membaca lebih lanjut mengenai SVR, anda boleh merujuk kepada [blog ini](https://www.analyticsvidhya.com/blog/2020/03/support-vector-regression-tutorial-for-machine-learning/). [Dokumentasi ini pada scikit-learn](https://scikit-learn.org/stable/modules/svm.html) menyediakan penjelasan yang lebih komprehensif mengenai SVM secara umum, [SVRs](https://scikit-learn.org/stable/modules/svm.html#regression) dan juga butiran pelaksanaan lain seperti pelbagai [fungsi kernel](https://scikit-learn.org/stable/modules/svm.html#kernel-functions) yang boleh digunakan, dan parameter mereka.
|
||||
|
||||
## Tugasan
|
||||
|
||||
[Sebuah model SVR baru](assignment.md)
|
||||
|
||||
|
||||
|
||||
## Kredit
|
||||
|
||||
|
||||
[^1]: Teks, kod dan output dalam seksyen ini disumbangkan oleh [@AnirbanMukherjeeXD](https://github.com/AnirbanMukherjeeXD)
|
||||
[^2]: Teks, kod dan output dalam seksyen ini diambil dari [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,15 +0,0 @@
|
||||
# Model SVR Baru
|
||||
|
||||
## Arahan [^1]
|
||||
|
||||
Sekarang setelah anda telah membina model SVR, bina satu lagi dengan data baru (cuba salah satu [dataset dari Duke](http://www2.stat.duke.edu/~mw/ts_data_sets.html)). Anotasikan kerja anda dalam buku nota, visualisasikan data dan model anda, dan uji ketepatannya menggunakan plot yang sesuai dan MAPE. Juga cuba laraskan pelbagai hiperparameter dan juga menggunakan nilai berbeza untuk timesteps.
|
||||
## Rubrik [^1]
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | ------------------------------------------------------------ | -------------------------------------------------------- | ---------------------------------- |
|
||||
| | Buku nota dibentangkan dengan model SVR yang dibina, diuji dan dijelaskan dengan visualisasi dan ketepatan dinyatakan. | Buku nota yang dibentangkan tidak dianotasi atau mengandungi pepijat. | Buku nota yang tidak lengkap dibentangkan |
|
||||
|
||||
[^1]:Teks dalam bahagian ini berdasarkan [tugasan dari ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,26 +0,0 @@
|
||||
# Pengenalan kepada Ramalan Siri Masa
|
||||
|
||||
Apa itu ramalan siri masa? Ia mengenai meramalkan peristiwa masa depan dengan menganalisis trend masa lalu.
|
||||
|
||||
## Topik serantau: penggunaan elektrik di seluruh dunia ✨
|
||||
|
||||
Dalam dua pelajaran ini, anda akan diperkenalkan kepada ramalan siri masa, satu bidang pembelajaran mesin yang kurang dikenali tetapi sangat berharga untuk aplikasi industri dan perniagaan, antara bidang lain. Walaupun rangkaian neural boleh digunakan untuk meningkatkan kegunaan model-model ini, kita akan mengkajinya dalam konteks pembelajaran mesin klasik kerana model membantu meramalkan prestasi masa depan berdasarkan masa lalu.
|
||||
|
||||
Fokus serantau kita adalah penggunaan elektrik di dunia, satu set data yang menarik untuk mempelajari tentang ramalan penggunaan kuasa masa depan berdasarkan corak beban masa lalu. Anda boleh melihat bagaimana jenis ramalan ini sangat berguna dalam persekitaran perniagaan.
|
||||
|
||||
|
||||
|
||||
Foto oleh [Peddi Sai hrithik](https://unsplash.com/@shutter_log?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) menara elektrik di jalan raya di Rajasthan di [Unsplash](https://unsplash.com/s/photos/electric-india?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)
|
||||
|
||||
## Pelajaran
|
||||
|
||||
1. [Pengenalan kepada ramalan siri masa](1-Introduction/README.md)
|
||||
2. [Membina model siri masa ARIMA](2-ARIMA/README.md)
|
||||
3. [Membina Support Vector Regressor untuk ramalan siri masa](3-SVR/README.md)
|
||||
|
||||
## Kredit
|
||||
|
||||
"Pengenalan kepada ramalan siri masa" ditulis dengan ⚡️ oleh [Francesca Lazzeri](https://twitter.com/frlazzeri) dan [Jen Looper](https://twitter.com/jenlooper). Notebook pertama kali muncul dalam talian di [Azure "Deep Learning For Time Series" repo](https://github.com/Azure/DeepLearningForTimeSeriesForecasting) yang asalnya ditulis oleh Francesca Lazzeri. Pelajaran SVR ditulis oleh [Anirban Mukherjee](https://github.com/AnirbanMukherjeeXD)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,59 +0,0 @@
|
||||
## Memeriksa polisi
|
||||
|
||||
Oleh kerana Jadual-Q menyenaraikan "tarikan" setiap tindakan pada setiap keadaan, adalah mudah untuk menggunakannya bagi menentukan navigasi yang cekap dalam dunia kita. Dalam kes yang paling mudah, kita boleh memilih tindakan yang sepadan dengan nilai Jadual-Q tertinggi: (blok kod 9)
|
||||
|
||||
```python
|
||||
def qpolicy_strict(m):
|
||||
x,y = m.human
|
||||
v = probs(Q[x,y])
|
||||
a = list(actions)[np.argmax(v)]
|
||||
return a
|
||||
|
||||
walk(m,qpolicy_strict)
|
||||
```
|
||||
|
||||
> Jika anda mencuba kod di atas beberapa kali, anda mungkin perasan bahawa kadang-kadang ia "tergantung", dan anda perlu menekan butang HENTI dalam buku nota untuk menghentikannya. Ini berlaku kerana mungkin terdapat situasi apabila dua keadaan "menunjuk" antara satu sama lain dari segi nilai Q yang optimum, di mana agen akhirnya bergerak antara keadaan tersebut tanpa henti.
|
||||
|
||||
## 🚀Cabaran
|
||||
|
||||
> **Tugas 1:** Ubah suai `walk` function to limit the maximum length of path by a certain number of steps (say, 100), and watch the code above return this value from time to time.
|
||||
|
||||
> **Task 2:** Modify the `walk` function so that it does not go back to the places where it has already been previously. This will prevent `walk` from looping, however, the agent can still end up being "trapped" in a location from which it is unable to escape.
|
||||
|
||||
## Navigation
|
||||
|
||||
A better navigation policy would be the one that we used during training, which combines exploitation and exploration. In this policy, we will select each action with a certain probability, proportional to the values in the Q-Table. This strategy may still result in the agent returning back to a position it has already explored, but, as you can see from the code below, it results in a very short average path to the desired location (remember that `print_statistics` menjalankan simulasi 100 kali): (blok kod 10)
|
||||
|
||||
```python
|
||||
def qpolicy(m):
|
||||
x,y = m.human
|
||||
v = probs(Q[x,y])
|
||||
a = random.choices(list(actions),weights=v)[0]
|
||||
return a
|
||||
|
||||
print_statistics(qpolicy)
|
||||
```
|
||||
|
||||
Selepas menjalankan kod ini, anda sepatutnya mendapat panjang laluan purata yang lebih kecil daripada sebelumnya, dalam lingkungan 3-6.
|
||||
|
||||
## Menyiasat proses pembelajaran
|
||||
|
||||
Seperti yang telah kita sebutkan, proses pembelajaran adalah keseimbangan antara penerokaan dan penerokaan pengetahuan yang diperoleh tentang struktur ruang masalah. Kita telah melihat bahawa hasil pembelajaran (keupayaan untuk membantu agen mencari laluan pendek ke matlamat) telah bertambah baik, tetapi juga menarik untuk melihat bagaimana panjang laluan purata berkelakuan semasa proses pembelajaran:
|
||||
|
||||
## Ringkasan pembelajaran
|
||||
|
||||
- **Panjang laluan purata meningkat**. Apa yang kita lihat di sini adalah bahawa pada mulanya, panjang laluan purata meningkat. Ini mungkin disebabkan oleh fakta bahawa apabila kita tidak tahu apa-apa tentang persekitaran, kita cenderung terperangkap dalam keadaan buruk, air atau serigala. Apabila kita belajar lebih banyak dan mula menggunakan pengetahuan ini, kita boleh meneroka persekitaran lebih lama, tetapi kita masih tidak tahu di mana epal berada dengan baik.
|
||||
|
||||
- **Panjang laluan berkurangan, apabila kita belajar lebih banyak**. Setelah kita belajar cukup, ia menjadi lebih mudah untuk agen mencapai matlamat, dan panjang laluan mula berkurangan. Walau bagaimanapun, kita masih terbuka kepada penerokaan, jadi kita sering menyimpang dari laluan terbaik, dan meneroka pilihan baru, menjadikan laluan lebih panjang daripada yang optimum.
|
||||
|
||||
- **Panjang meningkat secara mendadak**. Apa yang kita juga perhatikan pada graf ini ialah pada satu ketika, panjang meningkat secara mendadak. Ini menunjukkan sifat stokastik proses, dan bahawa kita pada satu ketika boleh "merosakkan" pekali Jadual-Q dengan menulis semula mereka dengan nilai baru. Ini sepatutnya diminimumkan dengan mengurangkan kadar pembelajaran (contohnya, menjelang akhir latihan, kita hanya menyesuaikan nilai Jadual-Q dengan nilai kecil).
|
||||
|
||||
Secara keseluruhan, adalah penting untuk diingat bahawa kejayaan dan kualiti proses pembelajaran sangat bergantung kepada parameter, seperti kadar pembelajaran, pengurangan kadar pembelajaran, dan faktor diskaun. Ini sering dipanggil **hiperparameter**, untuk membezakannya daripada **parameter**, yang kita optimakan semasa latihan (contohnya, pekali Jadual-Q). Proses mencari nilai hiperparameter terbaik dipanggil **pengoptimuman hiperparameter**, dan ia layak mendapat topik yang berasingan.
|
||||
|
||||
## [Kuiz selepas kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/46/)
|
||||
|
||||
## Tugasan
|
||||
[Dunia yang Lebih Realistik](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,30 +0,0 @@
|
||||
# Dunia yang Lebih Realistik
|
||||
|
||||
Dalam situasi kita, Peter dapat bergerak hampir tanpa merasa lelah atau lapar. Dalam dunia yang lebih realistik, dia perlu duduk dan berehat dari semasa ke semasa, dan juga makan untuk mendapatkan tenaga. Mari kita buat dunia kita lebih realistik dengan melaksanakan peraturan berikut:
|
||||
|
||||
1. Dengan bergerak dari satu tempat ke tempat lain, Peter kehilangan **tenaga** dan mendapat sedikit **keletihan**.
|
||||
2. Peter boleh mendapatkan lebih banyak tenaga dengan memakan epal.
|
||||
3. Peter boleh menghilangkan keletihan dengan berehat di bawah pokok atau di atas rumput (iaitu berjalan ke lokasi papan dengan pokok atau rumput - padang hijau)
|
||||
4. Peter perlu mencari dan membunuh serigala
|
||||
5. Untuk membunuh serigala, Peter perlu mempunyai tahap tenaga dan keletihan tertentu, jika tidak, dia akan kalah dalam pertempuran.
|
||||
|
||||
## Arahan
|
||||
|
||||
Gunakan notebook asal [notebook.ipynb](../../../../8-Reinforcement/1-QLearning/notebook.ipynb) sebagai titik permulaan untuk penyelesaian anda.
|
||||
|
||||
Ubah fungsi ganjaran di atas mengikut peraturan permainan, jalankan algoritma pembelajaran pengukuhan untuk mempelajari strategi terbaik untuk memenangi permainan, dan bandingkan hasil jalan rawak dengan algoritma anda dari segi jumlah permainan yang dimenangi dan kalah.
|
||||
|
||||
> **Note**: Dalam dunia baru anda, keadaan adalah lebih kompleks, dan selain daripada kedudukan manusia, juga termasuk tahap keletihan dan tenaga. Anda boleh memilih untuk mewakili keadaan sebagai tuple (Board,energy,fatigue), atau mendefinisikan kelas untuk keadaan tersebut (anda juga boleh mengembangkannya daripada `Board`), atau bahkan mengubah kelas asal `Board` dalam [rlboard.py](../../../../8-Reinforcement/1-QLearning/rlboard.py).
|
||||
|
||||
Dalam penyelesaian anda, sila simpan kod yang bertanggungjawab untuk strategi jalan rawak, dan bandingkan hasil algoritma anda dengan jalan rawak pada akhir.
|
||||
|
||||
> **Note**: Anda mungkin perlu menyesuaikan hiperparameter untuk membuatnya berfungsi, terutamanya jumlah epoch. Oleh kerana kejayaan permainan (melawan serigala) adalah kejadian yang jarang berlaku, anda boleh mengharapkan masa latihan yang lebih lama.
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| | Notebook disediakan dengan definisi peraturan dunia baru, algoritma Q-Learning dan beberapa penjelasan teks. Q-Learning mampu meningkatkan hasil dengan ketara berbanding jalan rawak. | Notebook disediakan, Q-Learning dilaksanakan dan meningkatkan hasil berbanding jalan rawak, tetapi tidak dengan ketara; atau notebook kurang didokumentasikan dan kod tidak disusun dengan baik | Beberapa percubaan untuk mentakrifkan semula peraturan dunia dibuat, tetapi algoritma Q-Learning tidak berfungsi, atau fungsi ganjaran tidak sepenuhnya ditakrifkan |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,324 +0,0 @@
|
||||
## Prasyarat
|
||||
|
||||
Dalam pelajaran ini, kita akan menggunakan pustaka yang disebut **OpenAI Gym** untuk mensimulasikan berbagai **lingkungan**. Anda dapat menjalankan kode pelajaran ini secara lokal (misalnya dari Visual Studio Code), di mana simulasi akan terbuka di jendela baru. Saat menjalankan kode secara online, Anda mungkin perlu melakukan beberapa penyesuaian pada kode, seperti yang dijelaskan [di sini](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7).
|
||||
|
||||
## OpenAI Gym
|
||||
|
||||
Dalam pelajaran sebelumnya, aturan permainan dan keadaan diberikan oleh kelas `Board` yang kita definisikan sendiri. Di sini kita akan menggunakan **lingkungan simulasi** khusus, yang akan mensimulasikan fisika di balik keseimbangan tiang. Salah satu lingkungan simulasi paling populer untuk melatih algoritma pembelajaran penguatan disebut [Gym](https://gym.openai.com/), yang dikelola oleh [OpenAI](https://openai.com/). Dengan menggunakan gym ini kita dapat membuat berbagai **lingkungan** dari simulasi cartpole hingga permainan Atari.
|
||||
|
||||
> **Catatan**: Anda dapat melihat lingkungan lain yang tersedia dari OpenAI Gym [di sini](https://gym.openai.com/envs/#classic_control).
|
||||
|
||||
Pertama, mari kita instal gym dan impor pustaka yang diperlukan (kode blok 1):
|
||||
|
||||
```python
|
||||
import sys
|
||||
!{sys.executable} -m pip install gym
|
||||
|
||||
import gym
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import random
|
||||
```
|
||||
|
||||
## Latihan - inisialisasi lingkungan cartpole
|
||||
|
||||
Untuk bekerja dengan masalah keseimbangan cartpole, kita perlu menginisialisasi lingkungan yang sesuai. Setiap lingkungan terkait dengan:
|
||||
|
||||
- **Observation space** yang mendefinisikan struktur informasi yang kita terima dari lingkungan. Untuk masalah cartpole, kita menerima posisi tiang, kecepatan, dan beberapa nilai lainnya.
|
||||
|
||||
- **Action space** yang mendefinisikan tindakan yang mungkin dilakukan. Dalam kasus kita, action space bersifat diskrit, dan terdiri dari dua tindakan - **kiri** dan **kanan**. (kode blok 2)
|
||||
|
||||
1. Untuk menginisialisasi, ketik kode berikut:
|
||||
|
||||
```python
|
||||
env = gym.make("CartPole-v1")
|
||||
print(env.action_space)
|
||||
print(env.observation_space)
|
||||
print(env.action_space.sample())
|
||||
```
|
||||
|
||||
Untuk melihat bagaimana lingkungan bekerja, mari kita jalankan simulasi singkat selama 100 langkah. Pada setiap langkah, kita memberikan salah satu tindakan yang akan diambil - dalam simulasi ini kita hanya memilih tindakan secara acak dari `action_space`.
|
||||
|
||||
1. Jalankan kode di bawah ini dan lihat hasilnya.
|
||||
|
||||
✅ Ingat bahwa lebih disukai untuk menjalankan kode ini pada instalasi Python lokal! (kode blok 3)
|
||||
|
||||
```python
|
||||
env.reset()
|
||||
|
||||
for i in range(100):
|
||||
env.render()
|
||||
env.step(env.action_space.sample())
|
||||
env.close()
|
||||
```
|
||||
|
||||
Anda harus melihat sesuatu yang mirip dengan gambar ini:
|
||||
|
||||
|
||||
|
||||
1. Selama simulasi, kita perlu mendapatkan pengamatan untuk memutuskan bagaimana bertindak. Faktanya, fungsi langkah mengembalikan pengamatan saat ini, fungsi reward, dan flag selesai yang menunjukkan apakah masuk akal untuk melanjutkan simulasi atau tidak: (kode blok 4)
|
||||
|
||||
```python
|
||||
env.reset()
|
||||
|
||||
done = False
|
||||
while not done:
|
||||
env.render()
|
||||
obs, rew, done, info = env.step(env.action_space.sample())
|
||||
print(f"{obs} -> {rew}")
|
||||
env.close()
|
||||
```
|
||||
|
||||
Anda akan melihat sesuatu seperti ini di output notebook:
|
||||
|
||||
```text
|
||||
[ 0.03403272 -0.24301182 0.02669811 0.2895829 ] -> 1.0
|
||||
[ 0.02917248 -0.04828055 0.03248977 0.00543839] -> 1.0
|
||||
[ 0.02820687 0.14636075 0.03259854 -0.27681916] -> 1.0
|
||||
[ 0.03113408 0.34100283 0.02706215 -0.55904489] -> 1.0
|
||||
[ 0.03795414 0.53573468 0.01588125 -0.84308041] -> 1.0
|
||||
...
|
||||
[ 0.17299878 0.15868546 -0.20754175 -0.55975453] -> 1.0
|
||||
[ 0.17617249 0.35602306 -0.21873684 -0.90998894] -> 1.0
|
||||
```
|
||||
|
||||
Vektor pengamatan yang dikembalikan pada setiap langkah simulasi berisi nilai-nilai berikut:
|
||||
- Posisi kereta
|
||||
- Kecepatan kereta
|
||||
- Sudut tiang
|
||||
- Laju rotasi tiang
|
||||
|
||||
1. Dapatkan nilai min dan max dari angka-angka tersebut: (kode blok 5)
|
||||
|
||||
```python
|
||||
print(env.observation_space.low)
|
||||
print(env.observation_space.high)
|
||||
```
|
||||
|
||||
Anda mungkin juga memperhatikan bahwa nilai reward pada setiap langkah simulasi selalu 1. Ini karena tujuan kita adalah bertahan selama mungkin, yaitu menjaga tiang tetap dalam posisi vertikal selama mungkin.
|
||||
|
||||
✅ Faktanya, simulasi CartPole dianggap berhasil jika kita berhasil mendapatkan reward rata-rata 195 selama 100 percobaan berturut-turut.
|
||||
|
||||
## Diskritisasi State
|
||||
|
||||
Dalam Q-Learning, kita perlu membangun Q-Table yang mendefinisikan apa yang harus dilakukan pada setiap state. Untuk dapat melakukan ini, kita memerlukan state yang **diskrit**, lebih tepatnya, harus mengandung sejumlah nilai diskrit yang terbatas. Oleh karena itu, kita perlu **mendiskritkan** pengamatan kita, memetakan mereka ke dalam satu set state yang terbatas.
|
||||
|
||||
Ada beberapa cara kita bisa melakukannya:
|
||||
|
||||
- **Membagi menjadi bin**. Jika kita mengetahui interval dari nilai tertentu, kita bisa membagi interval ini menjadi beberapa **bin**, dan kemudian mengganti nilai dengan nomor bin yang dimasukinya. Ini bisa dilakukan menggunakan metode numpy [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html). Dalam kasus ini, kita akan mengetahui ukuran state dengan tepat, karena akan tergantung pada jumlah bin yang kita pilih untuk digitalisasi.
|
||||
|
||||
✅ Kita bisa menggunakan interpolasi linier untuk membawa nilai ke beberapa interval terbatas (misalnya, dari -20 hingga 20), dan kemudian mengonversi angka menjadi bilangan bulat dengan membulatkannya. Ini memberi kita sedikit kontrol lebih pada ukuran state, terutama jika kita tidak mengetahui rentang nilai input yang tepat. Misalnya, dalam kasus kita, 2 dari 4 nilai tidak memiliki batas atas/bawah pada nilai mereka, yang dapat mengakibatkan jumlah state yang tak terbatas.
|
||||
|
||||
Dalam contoh kita, kita akan menggunakan pendekatan kedua. Seperti yang mungkin Anda perhatikan nanti, meskipun batas atas/bawah tidak ditentukan, nilai-nilai tersebut jarang mengambil nilai di luar interval terbatas tertentu, sehingga state dengan nilai ekstrem akan sangat jarang.
|
||||
|
||||
1. Berikut adalah fungsi yang akan mengambil pengamatan dari model kita dan menghasilkan tuple dari 4 nilai integer: (kode blok 6)
|
||||
|
||||
```python
|
||||
def discretize(x):
|
||||
return tuple((x/np.array([0.25, 0.25, 0.01, 0.1])).astype(np.int))
|
||||
```
|
||||
|
||||
1. Mari kita juga eksplorasi metode diskritisasi lain menggunakan bin: (kode blok 7)
|
||||
|
||||
```python
|
||||
def create_bins(i,num):
|
||||
return np.arange(num+1)*(i[1]-i[0])/num+i[0]
|
||||
|
||||
print("Sample bins for interval (-5,5) with 10 bins\n",create_bins((-5,5),10))
|
||||
|
||||
ints = [(-5,5),(-2,2),(-0.5,0.5),(-2,2)] # intervals of values for each parameter
|
||||
nbins = [20,20,10,10] # number of bins for each parameter
|
||||
bins = [create_bins(ints[i],nbins[i]) for i in range(4)]
|
||||
|
||||
def discretize_bins(x):
|
||||
return tuple(np.digitize(x[i],bins[i]) for i in range(4))
|
||||
```
|
||||
|
||||
1. Sekarang mari kita jalankan simulasi singkat dan amati nilai lingkungan diskrit tersebut. Silakan coba keduanya `discretize` and `discretize_bins` dan lihat apakah ada perbedaan.
|
||||
|
||||
✅ discretize_bins mengembalikan nomor bin, yang berbasis 0. Jadi untuk nilai variabel input sekitar 0, ia mengembalikan nomor dari tengah interval (10). Dalam discretize, kita tidak peduli dengan rentang nilai output, memungkinkan mereka menjadi negatif, sehingga nilai state tidak bergeser, dan 0 sesuai dengan 0. (kode blok 8)
|
||||
|
||||
```python
|
||||
env.reset()
|
||||
|
||||
done = False
|
||||
while not done:
|
||||
#env.render()
|
||||
obs, rew, done, info = env.step(env.action_space.sample())
|
||||
#print(discretize_bins(obs))
|
||||
print(discretize(obs))
|
||||
env.close()
|
||||
```
|
||||
|
||||
✅ Hapus komentar pada baris yang dimulai dengan env.render jika Anda ingin melihat bagaimana lingkungan dieksekusi. Jika tidak, Anda dapat mengeksekusinya di latar belakang, yang lebih cepat. Kita akan menggunakan eksekusi "tak terlihat" ini selama proses Q-Learning kita.
|
||||
|
||||
## Struktur Q-Table
|
||||
|
||||
Dalam pelajaran sebelumnya, state adalah pasangan angka sederhana dari 0 hingga 8, dan dengan demikian nyaman untuk mewakili Q-Table dengan tensor numpy dengan bentuk 8x8x2. Jika kita menggunakan diskritisasi bin, ukuran vektor state kita juga diketahui, sehingga kita dapat menggunakan pendekatan yang sama dan mewakili state dengan array berbentuk 20x20x10x10x2 (di sini 2 adalah dimensi dari action space, dan dimensi pertama sesuai dengan jumlah bin yang kita pilih untuk digunakan untuk setiap parameter dalam observation space).
|
||||
|
||||
Namun, terkadang dimensi tepat dari observation space tidak diketahui. Dalam kasus fungsi `discretize`, kita mungkin tidak pernah yakin bahwa state kita tetap dalam batas tertentu, karena beberapa nilai asli tidak dibatasi. Oleh karena itu, kita akan menggunakan pendekatan yang sedikit berbeda dan mewakili Q-Table dengan kamus.
|
||||
|
||||
1. Gunakan pasangan *(state,action)* sebagai kunci kamus, dan nilai akan sesuai dengan nilai entri Q-Table. (kode blok 9)
|
||||
|
||||
```python
|
||||
Q = {}
|
||||
actions = (0,1)
|
||||
|
||||
def qvalues(state):
|
||||
return [Q.get((state,a),0) for a in actions]
|
||||
```
|
||||
|
||||
Di sini kita juga mendefinisikan fungsi `qvalues()`, yang mengembalikan daftar nilai Q-Table untuk state tertentu yang sesuai dengan semua tindakan yang mungkin. Jika entri tidak ada dalam Q-Table, kita akan mengembalikan 0 sebagai default.
|
||||
|
||||
## Mari Mulai Q-Learning
|
||||
|
||||
Sekarang kita siap mengajarkan Peter untuk menjaga keseimbangan!
|
||||
|
||||
1. Pertama, mari kita atur beberapa hyperparameter: (kode blok 10)
|
||||
|
||||
```python
|
||||
# hyperparameters
|
||||
alpha = 0.3
|
||||
gamma = 0.9
|
||||
epsilon = 0.90
|
||||
```
|
||||
|
||||
Di sini, `alpha` is the **learning rate** that defines to which extent we should adjust the current values of Q-Table at each step. In the previous lesson we started with 1, and then decreased `alpha` to lower values during training. In this example we will keep it constant just for simplicity, and you can experiment with adjusting `alpha` values later.
|
||||
|
||||
`gamma` is the **discount factor** that shows to which extent we should prioritize future reward over current reward.
|
||||
|
||||
`epsilon` is the **exploration/exploitation factor** that determines whether we should prefer exploration to exploitation or vice versa. In our algorithm, we will in `epsilon` percent of the cases select the next action according to Q-Table values, and in the remaining number of cases we will execute a random action. This will allow us to explore areas of the search space that we have never seen before.
|
||||
|
||||
✅ In terms of balancing - choosing random action (exploration) would act as a random punch in the wrong direction, and the pole would have to learn how to recover the balance from those "mistakes"
|
||||
|
||||
### Improve the algorithm
|
||||
|
||||
We can also make two improvements to our algorithm from the previous lesson:
|
||||
|
||||
- **Calculate average cumulative reward**, over a number of simulations. We will print the progress each 5000 iterations, and we will average out our cumulative reward over that period of time. It means that if we get more than 195 point - we can consider the problem solved, with even higher quality than required.
|
||||
|
||||
- **Calculate maximum average cumulative result**, `Qmax`, and we will store the Q-Table corresponding to that result. When you run the training you will notice that sometimes the average cumulative result starts to drop, and we want to keep the values of Q-Table that correspond to the best model observed during training.
|
||||
|
||||
1. Collect all cumulative rewards at each simulation at `rewards` vektor untuk plot lebih lanjut. (kode blok 11)
|
||||
|
||||
```python
|
||||
def probs(v,eps=1e-4):
|
||||
v = v-v.min()+eps
|
||||
v = v/v.sum()
|
||||
return v
|
||||
|
||||
Qmax = 0
|
||||
cum_rewards = []
|
||||
rewards = []
|
||||
for epoch in range(100000):
|
||||
obs = env.reset()
|
||||
done = False
|
||||
cum_reward=0
|
||||
# == do the simulation ==
|
||||
while not done:
|
||||
s = discretize(obs)
|
||||
if random.random()<epsilon:
|
||||
# exploitation - chose the action according to Q-Table probabilities
|
||||
v = probs(np.array(qvalues(s)))
|
||||
a = random.choices(actions,weights=v)[0]
|
||||
else:
|
||||
# exploration - randomly chose the action
|
||||
a = np.random.randint(env.action_space.n)
|
||||
|
||||
obs, rew, done, info = env.step(a)
|
||||
cum_reward+=rew
|
||||
ns = discretize(obs)
|
||||
Q[(s,a)] = (1 - alpha) * Q.get((s,a),0) + alpha * (rew + gamma * max(qvalues(ns)))
|
||||
cum_rewards.append(cum_reward)
|
||||
rewards.append(cum_reward)
|
||||
# == Periodically print results and calculate average reward ==
|
||||
if epoch%5000==0:
|
||||
print(f"{epoch}: {np.average(cum_rewards)}, alpha={alpha}, epsilon={epsilon}")
|
||||
if np.average(cum_rewards) > Qmax:
|
||||
Qmax = np.average(cum_rewards)
|
||||
Qbest = Q
|
||||
cum_rewards=[]
|
||||
```
|
||||
|
||||
Apa yang mungkin Anda perhatikan dari hasil tersebut:
|
||||
|
||||
- **Dekat dengan tujuan kita**. Kita sangat dekat mencapai tujuan mendapatkan 195 reward kumulatif selama 100+ percobaan berturut-turut dari simulasi, atau kita mungkin telah mencapainya! Bahkan jika kita mendapatkan angka yang lebih kecil, kita masih tidak tahu, karena kita rata-rata lebih dari 5000 percobaan, dan hanya 100 percobaan yang diperlukan dalam kriteria formal.
|
||||
|
||||
- **Reward mulai menurun**. Kadang-kadang reward mulai menurun, yang berarti kita dapat "menghancurkan" nilai yang sudah dipelajari dalam Q-Table dengan yang membuat situasi lebih buruk.
|
||||
|
||||
Pengamatan ini lebih jelas terlihat jika kita plot kemajuan pelatihan.
|
||||
|
||||
## Plotting Kemajuan Pelatihan
|
||||
|
||||
Selama pelatihan, kita telah mengumpulkan nilai reward kumulatif pada setiap iterasi ke dalam vektor `rewards`. Berikut adalah tampilannya saat kita plot terhadap nomor iterasi:
|
||||
|
||||
```python
|
||||
plt.plot(rewards)
|
||||
```
|
||||
|
||||
|
||||
|
||||
Dari grafik ini, tidak mungkin untuk mengatakan apa pun, karena sifat dari proses pelatihan stokastik panjang sesi pelatihan sangat bervariasi. Untuk lebih memahami grafik ini, kita dapat menghitung **rata-rata berjalan** selama serangkaian eksperimen, katakanlah 100. Ini dapat dilakukan dengan mudah menggunakan `np.convolve`: (kode blok 12)
|
||||
|
||||
```python
|
||||
def running_average(x,window):
|
||||
return np.convolve(x,np.ones(window)/window,mode='valid')
|
||||
|
||||
plt.plot(running_average(rewards,100))
|
||||
```
|
||||
|
||||
|
||||
|
||||
## Memvariasikan hyperparameter
|
||||
|
||||
Untuk membuat pembelajaran lebih stabil, masuk akal untuk menyesuaikan beberapa hyperparameter kita selama pelatihan. Secara khusus:
|
||||
|
||||
- **Untuk learning rate**, `alpha`, we may start with values close to 1, and then keep decreasing the parameter. With time, we will be getting good probability values in the Q-Table, and thus we should be adjusting them slightly, and not overwriting completely with new values.
|
||||
|
||||
- **Increase epsilon**. We may want to increase the `epsilon` slowly, in order to explore less and exploit more. It probably makes sense to start with lower value of `epsilon`, dan naik hingga hampir 1.
|
||||
|
||||
> **Tugas 1**: Bermainlah dengan nilai hyperparameter dan lihat apakah Anda dapat mencapai reward kumulatif yang lebih tinggi. Apakah Anda mendapatkan di atas 195?
|
||||
|
||||
> **Tugas 2**: Untuk secara formal menyelesaikan masalah, Anda perlu mendapatkan 195 reward rata-rata di 100 percobaan berturut-turut. Ukur itu selama pelatihan dan pastikan bahwa Anda telah menyelesaikan masalah secara formal!
|
||||
|
||||
## Melihat hasilnya dalam aksi
|
||||
|
||||
Akan menarik untuk benar-benar melihat bagaimana model yang dilatih berperilaku. Mari kita jalankan simulasi dan mengikuti strategi pemilihan tindakan yang sama seperti selama pelatihan, sampling sesuai dengan distribusi probabilitas di Q-Table: (kode blok 13)
|
||||
|
||||
```python
|
||||
obs = env.reset()
|
||||
done = False
|
||||
while not done:
|
||||
s = discretize(obs)
|
||||
env.render()
|
||||
v = probs(np.array(qvalues(s)))
|
||||
a = random.choices(actions,weights=v)[0]
|
||||
obs,_,done,_ = env.step(a)
|
||||
env.close()
|
||||
```
|
||||
|
||||
Anda harus melihat sesuatu seperti ini:
|
||||
|
||||
|
||||
|
||||
---
|
||||
|
||||
## 🚀Tantangan
|
||||
|
||||
> **Tugas 3**: Di sini, kita menggunakan salinan akhir dari Q-Table, yang mungkin bukan yang terbaik. Ingat bahwa kita telah menyimpan Q-Table dengan performa terbaik ke dalam `Qbest` variable! Try the same example with the best-performing Q-Table by copying `Qbest` over to `Q` and see if you notice the difference.
|
||||
|
||||
> **Task 4**: Here we were not selecting the best action on each step, but rather sampling with corresponding probability distribution. Would it make more sense to always select the best action, with the highest Q-Table value? This can be done by using `np.argmax` fungsi untuk menemukan nomor tindakan yang sesuai dengan nilai Q-Table tertinggi. Implementasikan strategi ini dan lihat apakah itu meningkatkan keseimbangan.
|
||||
|
||||
## [Kuis setelah kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/48/)
|
||||
|
||||
## Tugas
|
||||
[Latih Mountain Car](assignment.md)
|
||||
|
||||
## Kesimpulan
|
||||
|
||||
Kita sekarang telah belajar bagaimana melatih agen untuk mencapai hasil yang baik hanya dengan memberikan mereka fungsi reward yang mendefinisikan keadaan permainan yang diinginkan, dan dengan memberi mereka kesempatan untuk menjelajahi ruang pencarian secara cerdas. Kita telah berhasil menerapkan algoritma Q-Learning dalam kasus lingkungan diskrit dan kontinu, tetapi dengan tindakan diskrit.
|
||||
|
||||
Penting juga untuk mempelajari situasi di mana state tindakan juga kontinu, dan ketika observation space jauh lebih kompleks, seperti gambar dari layar permainan Atari. Dalam masalah tersebut, kita sering perlu menggunakan teknik pembelajaran mesin yang lebih kuat, seperti jaringan saraf, untuk mencapai hasil yang baik. Topik yang lebih maju ini adalah subjek dari kursus AI tingkat lanjut kita yang akan datang.
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,43 +0,0 @@
|
||||
# Latih Kereta Gunung
|
||||
|
||||
[OpenAI Gym](http://gym.openai.com) telah direka sedemikian rupa sehingga semua persekitaran menyediakan API yang sama - iaitu kaedah yang sama `reset`, `step` dan `render`, dan abstraksi yang sama dari **ruang tindakan** dan **ruang pemerhatian**. Oleh itu, seharusnya mungkin untuk menyesuaikan algoritma pembelajaran pengukuhan yang sama ke persekitaran yang berbeza dengan perubahan kod yang minimum.
|
||||
|
||||
## Persekitaran Kereta Gunung
|
||||
|
||||
[Persekitaran Kereta Gunung](https://gym.openai.com/envs/MountainCar-v0/) mengandungi sebuah kereta yang terperangkap di dalam lembah:
|
||||
Matlamatnya adalah untuk keluar dari lembah dan menangkap bendera, dengan melakukan salah satu tindakan berikut pada setiap langkah:
|
||||
|
||||
| Nilai | Makna |
|
||||
|---|---|
|
||||
| 0 | Mempercepat ke kiri |
|
||||
| 1 | Tidak mempercepat |
|
||||
| 2 | Mempercepat ke kanan |
|
||||
|
||||
Trik utama masalah ini, bagaimanapun, adalah bahawa enjin kereta tidak cukup kuat untuk mendaki gunung dalam satu kali laluan. Oleh itu, satu-satunya cara untuk berjaya adalah dengan memandu ke depan dan ke belakang untuk membina momentum.
|
||||
|
||||
Ruang pemerhatian terdiri daripada hanya dua nilai:
|
||||
|
||||
| Nombor | Pemerhatian | Min | Maks |
|
||||
|-----|--------------|-----|-----|
|
||||
| 0 | Kedudukan Kereta | -1.2| 0.6 |
|
||||
| 1 | Kelajuan Kereta | -0.07 | 0.07 |
|
||||
|
||||
Sistem ganjaran untuk kereta gunung agak rumit:
|
||||
|
||||
* Ganjaran 0 diberikan jika agen mencapai bendera (kedudukan = 0.5) di atas gunung.
|
||||
* Ganjaran -1 diberikan jika kedudukan agen kurang dari 0.5.
|
||||
|
||||
Episod akan tamat jika kedudukan kereta lebih dari 0.5, atau panjang episod lebih dari 200.
|
||||
## Arahan
|
||||
|
||||
Sesuaikan algoritma pembelajaran pengukuhan kami untuk menyelesaikan masalah kereta gunung. Mulakan dengan kod [notebook.ipynb](../../../../8-Reinforcement/2-Gym/notebook.ipynb) yang ada, gantikan persekitaran baru, ubah fungsi diskritisasi keadaan, dan cuba buat algoritma yang ada untuk dilatih dengan perubahan kod yang minimum. Optimumkan hasil dengan menyesuaikan hiperparameter.
|
||||
|
||||
> **Note**: Penyesuaian hiperparameter mungkin diperlukan untuk membuat algoritma konvergen.
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Peningkatan |
|
||||
| -------- | --------- | -------- | ----------------- |
|
||||
| | Algoritma Q-Learning berjaya disesuaikan dari contoh CartPole, dengan perubahan kod yang minimum, yang mampu menyelesaikan masalah menangkap bendera di bawah 200 langkah. | Algoritma Q-Learning baru telah diadopsi dari Internet, tetapi didokumentasikan dengan baik; atau algoritma yang ada diadopsi, tetapi tidak mencapai hasil yang diinginkan | Pelajar tidak dapat mengadopsi algoritma dengan berjaya, tetapi telah membuat langkah-langkah besar menuju penyelesaian (melaksanakan diskritisasi keadaan, struktur data Q-Table, dll.) |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,4 +0,0 @@
|
||||
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,56 +0,0 @@
|
||||
# Pengenalan kepada pembelajaran pengukuhan
|
||||
|
||||
Pembelajaran pengukuhan, RL, dianggap sebagai salah satu paradigma pembelajaran mesin asas, selain pembelajaran diselia dan pembelajaran tanpa penyeliaan. RL berkaitan dengan keputusan: membuat keputusan yang betul atau sekurang-kurangnya belajar daripadanya.
|
||||
|
||||
Bayangkan anda mempunyai persekitaran simulasi seperti pasaran saham. Apa yang berlaku jika anda mengenakan peraturan tertentu? Adakah ia memberi kesan positif atau negatif? Jika sesuatu yang negatif berlaku, anda perlu mengambil _pengukuhan negatif_ ini, belajar daripadanya, dan mengubah haluan. Jika hasilnya positif, anda perlu membina dari _pengukuhan positif_ itu.
|
||||
|
||||
|
||||
|
||||
> Peter dan kawan-kawannya perlu melarikan diri dari serigala yang lapar! Imej oleh [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
## Topik serantau: Peter dan Serigala (Rusia)
|
||||
|
||||
[Peter dan Serigala](https://en.wikipedia.org/wiki/Peter_and_the_Wolf) adalah kisah dongeng muzik yang ditulis oleh komposer Rusia [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev). Ia adalah cerita tentang pelopor muda Peter, yang dengan berani keluar dari rumahnya ke kawasan hutan untuk mengejar serigala. Dalam bahagian ini, kita akan melatih algoritma pembelajaran mesin yang akan membantu Peter:
|
||||
|
||||
- **Meneroka** kawasan sekitar dan membina peta navigasi yang optimum
|
||||
- **Belajar** cara menggunakan papan selaju dan mengimbangi di atasnya, untuk bergerak dengan lebih pantas.
|
||||
|
||||
[](https://www.youtube.com/watch?v=Fmi5zHg4QSM)
|
||||
|
||||
> 🎥 Klik imej di atas untuk mendengar Peter dan Serigala oleh Prokofiev
|
||||
|
||||
## Pembelajaran pengukuhan
|
||||
|
||||
Dalam bahagian sebelum ini, anda telah melihat dua contoh masalah pembelajaran mesin:
|
||||
|
||||
- **Diselia**, di mana kita mempunyai set data yang mencadangkan penyelesaian sampel kepada masalah yang ingin kita selesaikan. [Klasifikasi](../4-Classification/README.md) dan [regresi](../2-Regression/README.md) adalah tugas pembelajaran diselia.
|
||||
- **Tanpa penyeliaan**, di mana kita tidak mempunyai data latihan berlabel. Contoh utama pembelajaran tanpa penyeliaan ialah [Pengelompokan](../5-Clustering/README.md).
|
||||
|
||||
Dalam bahagian ini, kami akan memperkenalkan anda kepada jenis masalah pembelajaran baharu yang tidak memerlukan data latihan berlabel. Terdapat beberapa jenis masalah sedemikian:
|
||||
|
||||
- **[Pembelajaran separa diselia](https://wikipedia.org/wiki/Semi-supervised_learning)**, di mana kita mempunyai banyak data tidak berlabel yang boleh digunakan untuk pra-latihan model.
|
||||
- **[Pembelajaran pengukuhan](https://wikipedia.org/wiki/Reinforcement_learning)**, di mana agen belajar bagaimana untuk bertindak dengan melakukan eksperimen dalam beberapa persekitaran simulasi.
|
||||
|
||||
### Contoh - permainan komputer
|
||||
|
||||
Katakan anda ingin mengajar komputer untuk bermain permainan, seperti catur, atau [Super Mario](https://wikipedia.org/wiki/Super_Mario). Untuk komputer bermain permainan, kita perlu ia meramalkan langkah mana yang perlu diambil dalam setiap keadaan permainan. Walaupun ini mungkin kelihatan seperti masalah klasifikasi, ia tidak - kerana kita tidak mempunyai set data dengan keadaan dan tindakan yang sepadan. Walaupun kita mungkin mempunyai beberapa data seperti perlawanan catur sedia ada atau rakaman pemain bermain Super Mario, kemungkinan besar data itu tidak akan cukup meliputi sejumlah besar keadaan yang mungkin.
|
||||
|
||||
Daripada mencari data permainan sedia ada, **Pembelajaran Pengukuhan** (RL) adalah berdasarkan idea *membuat komputer bermain* banyak kali dan memerhatikan hasilnya. Oleh itu, untuk menggunakan Pembelajaran Pengukuhan, kita memerlukan dua perkara:
|
||||
|
||||
- **Persekitaran** dan **simulator** yang membolehkan kita bermain permainan banyak kali. Simulator ini akan menentukan semua peraturan permainan serta keadaan dan tindakan yang mungkin.
|
||||
|
||||
- **Fungsi ganjaran**, yang akan memberitahu kita seberapa baik kita melakukannya semasa setiap langkah atau permainan.
|
||||
|
||||
Perbezaan utama antara jenis pembelajaran mesin lain dan RL ialah dalam RL kita biasanya tidak tahu sama ada kita menang atau kalah sehingga kita menyelesaikan permainan. Oleh itu, kita tidak boleh mengatakan sama ada langkah tertentu sahaja adalah baik atau tidak - kita hanya menerima ganjaran pada akhir permainan. Dan matlamat kita adalah untuk mereka bentuk algoritma yang akan membolehkan kita melatih model di bawah keadaan yang tidak pasti. Kita akan belajar tentang satu algoritma RL yang dipanggil **Q-learning**.
|
||||
|
||||
## Pelajaran
|
||||
|
||||
1. [Pengenalan kepada pembelajaran pengukuhan dan Q-Learning](1-QLearning/README.md)
|
||||
2. [Menggunakan persekitaran simulasi gim](2-Gym/README.md)
|
||||
|
||||
## Kredit
|
||||
|
||||
"Pengenalan kepada Pembelajaran Pengukuhan" ditulis dengan ♥️ oleh [Dmitry Soshnikov](http://soshnikov.com)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,149 +0,0 @@
|
||||
# Postscript: Pembelajaran Mesin di Dunia Nyata
|
||||
|
||||
|
||||
> Sketchnote oleh [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
Dalam kurikulum ini, anda telah mempelajari banyak cara untuk menyiapkan data untuk pelatihan dan membuat model pembelajaran mesin. Anda telah membangun serangkaian model regresi klasik, klastering, klasifikasi, pemrosesan bahasa alami, dan deret waktu. Selamat! Sekarang, anda mungkin bertanya-tanya apa tujuan semua ini... apa aplikasi dunia nyata untuk model-model ini?
|
||||
|
||||
Meskipun banyak minat dalam industri telah tertarik oleh AI, yang biasanya memanfaatkan pembelajaran mendalam, masih ada aplikasi berharga untuk model pembelajaran mesin klasik. Anda mungkin bahkan menggunakan beberapa aplikasi ini hari ini! Dalam pelajaran ini, anda akan menjelajahi bagaimana delapan industri dan domain materi pelajaran yang berbeda menggunakan jenis model ini untuk membuat aplikasi mereka lebih berkinerja, andal, cerdas, dan berharga bagi pengguna.
|
||||
|
||||
## [Kuis sebelum kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/49/)
|
||||
|
||||
## 💰 Keuangan
|
||||
|
||||
Sektor keuangan menawarkan banyak peluang untuk pembelajaran mesin. Banyak masalah di area ini dapat dimodelkan dan diselesaikan dengan menggunakan ML.
|
||||
|
||||
### Deteksi penipuan kartu kredit
|
||||
|
||||
Kami mempelajari tentang [k-means clustering](../../5-Clustering/2-K-Means/README.md) sebelumnya dalam kursus ini, tetapi bagaimana cara menggunakannya untuk menyelesaikan masalah terkait penipuan kartu kredit?
|
||||
|
||||
K-means clustering berguna selama teknik deteksi penipuan kartu kredit yang disebut **deteksi outlier**. Outlier, atau penyimpangan dalam pengamatan tentang satu set data, dapat memberi tahu kita apakah kartu kredit digunakan secara normal atau jika ada sesuatu yang tidak biasa terjadi. Seperti yang ditunjukkan dalam makalah yang ditautkan di bawah ini, anda dapat menyortir data kartu kredit menggunakan algoritma k-means clustering dan menetapkan setiap transaksi ke klaster berdasarkan seberapa besar penyimpangan yang muncul. Kemudian, anda dapat mengevaluasi klaster yang paling berisiko untuk transaksi penipuan versus yang sah.
|
||||
[Referensi](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.680.1195&rep=rep1&type=pdf)
|
||||
|
||||
### Manajemen kekayaan
|
||||
|
||||
Dalam manajemen kekayaan, individu atau perusahaan menangani investasi atas nama klien mereka. Tugas mereka adalah mempertahankan dan menumbuhkan kekayaan dalam jangka panjang, sehingga penting untuk memilih investasi yang berkinerja baik.
|
||||
|
||||
Salah satu cara untuk mengevaluasi bagaimana kinerja investasi tertentu adalah melalui regresi statistik. [Regresi linear](../../2-Regression/1-Tools/README.md) adalah alat yang berharga untuk memahami bagaimana suatu dana berkinerja relatif terhadap beberapa tolok ukur. Kita juga dapat menyimpulkan apakah hasil regresi signifikan secara statistik atau tidak, atau seberapa besar pengaruhnya terhadap investasi klien. Anda bahkan dapat memperluas analisis anda menggunakan regresi berganda, di mana faktor risiko tambahan dapat diperhitungkan. Untuk contoh bagaimana ini akan bekerja untuk dana tertentu, lihat makalah di bawah ini tentang evaluasi kinerja dana menggunakan regresi.
|
||||
[Referensi](http://www.brightwoodventures.com/evaluating-fund-performance-using-regression/)
|
||||
|
||||
## 🎓 Pendidikan
|
||||
|
||||
Sektor pendidikan juga merupakan area yang sangat menarik di mana ML dapat diterapkan. Ada masalah menarik yang harus dipecahkan seperti mendeteksi kecurangan pada ujian atau esai atau mengelola bias, disengaja atau tidak, dalam proses koreksi.
|
||||
|
||||
### Memprediksi perilaku siswa
|
||||
|
||||
[Coursera](https://coursera.com), penyedia kursus online terbuka, memiliki blog teknologi yang hebat di mana mereka membahas banyak keputusan teknis. Dalam studi kasus ini, mereka memplot garis regresi untuk mencoba mengeksplorasi korelasi antara rating NPS (Net Promoter Score) yang rendah dan retensi atau putus kursus.
|
||||
[Referensi](https://medium.com/coursera-engineering/controlled-regression-quantifying-the-impact-of-course-quality-on-learner-retention-31f956bd592a)
|
||||
|
||||
### Mengurangi bias
|
||||
|
||||
[Grammarly](https://grammarly.com), asisten menulis yang memeriksa kesalahan ejaan dan tata bahasa, menggunakan sistem [pemrosesan bahasa alami](../../6-NLP/README.md) yang canggih di seluruh produknya. Mereka menerbitkan studi kasus menarik di blog teknologi mereka tentang bagaimana mereka menangani bias gender dalam pembelajaran mesin, yang anda pelajari dalam [pelajaran pengenalan tentang keadilan](../../1-Introduction/3-fairness/README.md).
|
||||
[Referensi](https://www.grammarly.com/blog/engineering/mitigating-gender-bias-in-autocorrect/)
|
||||
|
||||
## 👜 Ritel
|
||||
|
||||
Sektor ritel pasti dapat memanfaatkan penggunaan ML, mulai dari menciptakan perjalanan pelanggan yang lebih baik hingga menyimpan inventaris dengan cara yang optimal.
|
||||
|
||||
### Memperpersonalisasi perjalanan pelanggan
|
||||
|
||||
Di Wayfair, perusahaan yang menjual barang-barang rumah tangga seperti furnitur, membantu pelanggan menemukan produk yang tepat untuk selera dan kebutuhan mereka sangat penting. Dalam artikel ini, insinyur dari perusahaan tersebut menjelaskan bagaimana mereka menggunakan ML dan NLP untuk "menampilkan hasil yang tepat bagi pelanggan". Secara khusus, Query Intent Engine mereka telah dibangun untuk menggunakan ekstraksi entitas, pelatihan klasifikasi, ekstraksi aset dan opini, serta penandaan sentimen pada ulasan pelanggan. Ini adalah contoh klasik bagaimana NLP bekerja dalam ritel online.
|
||||
[Referensi](https://www.aboutwayfair.com/tech-innovation/how-we-use-machine-learning-and-natural-language-processing-to-empower-search)
|
||||
|
||||
### Manajemen inventaris
|
||||
|
||||
Perusahaan inovatif dan gesit seperti [StitchFix](https://stitchfix.com), layanan kotak yang mengirim pakaian kepada konsumen, sangat bergantung pada ML untuk rekomendasi dan manajemen inventaris. Tim styling mereka bekerja sama dengan tim merchandising mereka, sebenarnya: "salah satu ilmuwan data kami bermain-main dengan algoritma genetik dan menerapkannya pada pakaian untuk memprediksi apa yang akan menjadi pakaian yang sukses yang tidak ada hari ini. Kami membawa itu ke tim merchandise dan sekarang mereka dapat menggunakannya sebagai alat."
|
||||
[Referensi](https://www.zdnet.com/article/how-stitch-fix-uses-machine-learning-to-master-the-science-of-styling/)
|
||||
|
||||
## 🏥 Perawatan Kesehatan
|
||||
|
||||
Sektor perawatan kesehatan dapat memanfaatkan ML untuk mengoptimalkan tugas penelitian dan juga masalah logistik seperti readmisi pasien atau menghentikan penyebaran penyakit.
|
||||
|
||||
### Mengelola uji klinis
|
||||
|
||||
Toksisitas dalam uji klinis adalah masalah besar bagi pembuat obat. Berapa banyak toksisitas yang dapat ditoleransi? Dalam studi ini, menganalisis berbagai metode uji klinis menghasilkan pengembangan pendekatan baru untuk memprediksi kemungkinan hasil uji klinis. Secara khusus, mereka dapat menggunakan random forest untuk menghasilkan [klasifikasi](../../4-Classification/README.md) yang dapat membedakan antara kelompok obat.
|
||||
[Referensi](https://www.sciencedirect.com/science/article/pii/S2451945616302914)
|
||||
|
||||
### Manajemen readmisi rumah sakit
|
||||
|
||||
Perawatan rumah sakit mahal, terutama ketika pasien harus readmisi. Makalah ini membahas perusahaan yang menggunakan ML untuk memprediksi potensi readmisi menggunakan algoritma [klastering](../../5-Clustering/README.md). Klaster ini membantu analis untuk "menemukan kelompok readmisi yang mungkin memiliki penyebab yang sama".
|
||||
[Referensi](https://healthmanagement.org/c/healthmanagement/issuearticle/hospital-readmissions-and-machine-learning)
|
||||
|
||||
### Manajemen penyakit
|
||||
|
||||
Pandemi baru-baru ini telah menyoroti cara-cara di mana pembelajaran mesin dapat membantu menghentikan penyebaran penyakit. Dalam artikel ini, anda akan mengenali penggunaan ARIMA, kurva logistik, regresi linear, dan SARIMA. "Pekerjaan ini adalah upaya untuk menghitung laju penyebaran virus ini dan dengan demikian memprediksi kematian, pemulihan, dan kasus yang dikonfirmasi, sehingga dapat membantu kita untuk mempersiapkan diri dengan lebih baik dan bertahan hidup."
|
||||
[Referensi](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7979218/)
|
||||
|
||||
## 🌲 Ekologi dan Teknologi Hijau
|
||||
|
||||
Alam dan ekologi terdiri dari banyak sistem sensitif di mana interaksi antara hewan dan alam menjadi fokus. Penting untuk dapat mengukur sistem ini dengan akurat dan bertindak dengan tepat jika sesuatu terjadi, seperti kebakaran hutan atau penurunan populasi hewan.
|
||||
|
||||
### Manajemen hutan
|
||||
|
||||
Anda mempelajari tentang [Reinforcement Learning](../../8-Reinforcement/README.md) dalam pelajaran sebelumnya. Ini bisa sangat berguna ketika mencoba memprediksi pola di alam. Secara khusus, ini dapat digunakan untuk melacak masalah ekologi seperti kebakaran hutan dan penyebaran spesies invasif. Di Kanada, sekelompok peneliti menggunakan Reinforcement Learning untuk membangun model dinamika kebakaran hutan dari citra satelit. Menggunakan "spatially spreading process (SSP)" yang inovatif, mereka membayangkan kebakaran hutan sebagai "agen di setiap sel dalam lanskap." "Set tindakan yang dapat diambil api dari lokasi pada waktu tertentu termasuk menyebar ke utara, selatan, timur, atau barat atau tidak menyebar.
|
||||
|
||||
Pendekatan ini membalik pengaturan RL yang biasa karena dinamika Proses Keputusan Markov (MDP) yang sesuai adalah fungsi yang diketahui untuk penyebaran kebakaran segera." Baca lebih lanjut tentang algoritma klasik yang digunakan oleh kelompok ini di tautan di bawah.
|
||||
[Referensi](https://www.frontiersin.org/articles/10.3389/fict.2018.00006/full)
|
||||
|
||||
### Pemantauan gerakan hewan
|
||||
|
||||
Sementara pembelajaran mendalam telah menciptakan revolusi dalam melacak gerakan hewan secara visual (anda dapat membuat [pelacak beruang kutub](https://docs.microsoft.com/learn/modules/build-ml-model-with-azure-stream-analytics/?WT.mc_id=academic-77952-leestott) anda sendiri di sini), ML klasik masih memiliki tempat dalam tugas ini.
|
||||
|
||||
Sensor untuk melacak gerakan hewan ternak dan IoT memanfaatkan jenis pemrosesan visual ini, tetapi teknik ML yang lebih dasar berguna untuk memproses data awal. Misalnya, dalam makalah ini, postur domba dipantau dan dianalisis menggunakan berbagai algoritma klasifikasi. Anda mungkin mengenali kurva ROC pada halaman 335.
|
||||
[Referensi](https://druckhaus-hofmann.de/gallery/31-wj-feb-2020.pdf)
|
||||
|
||||
### ⚡️ Manajemen Energi
|
||||
|
||||
Dalam pelajaran kami tentang [peramalan deret waktu](../../7-TimeSeries/README.md), kami mengajukan konsep meteran parkir pintar untuk menghasilkan pendapatan bagi kota berdasarkan pemahaman tentang penawaran dan permintaan. Artikel ini membahas secara rinci bagaimana klastering, regresi, dan peramalan deret waktu digabungkan untuk membantu memprediksi penggunaan energi masa depan di Irlandia, berdasarkan meteran pintar.
|
||||
[Referensi](https://www-cdn.knime.com/sites/default/files/inline-images/knime_bigdata_energy_timeseries_whitepaper.pdf)
|
||||
|
||||
## 💼 Asuransi
|
||||
|
||||
Sektor asuransi adalah sektor lain yang menggunakan ML untuk membangun dan mengoptimalkan model keuangan dan aktuaria yang layak.
|
||||
|
||||
### Manajemen Volatilitas
|
||||
|
||||
MetLife, penyedia asuransi jiwa, terbuka dengan cara mereka menganalisis dan mengurangi volatilitas dalam model keuangan mereka. Dalam artikel ini anda akan melihat visualisasi klasifikasi biner dan ordinal. Anda juga akan menemukan visualisasi peramalan.
|
||||
[Referensi](https://investments.metlife.com/content/dam/metlifecom/us/investments/insights/research-topics/macro-strategy/pdf/MetLifeInvestmentManagement_MachineLearnedRanking_070920.pdf)
|
||||
|
||||
## 🎨 Seni, Budaya, dan Sastra
|
||||
|
||||
Dalam seni, misalnya dalam jurnalisme, ada banyak masalah menarik. Mendeteksi berita palsu adalah masalah besar karena terbukti mempengaruhi opini orang dan bahkan menjatuhkan demokrasi. Museum juga dapat memanfaatkan penggunaan ML dalam segala hal mulai dari menemukan hubungan antara artefak hingga perencanaan sumber daya.
|
||||
|
||||
### Deteksi berita palsu
|
||||
|
||||
Mendeteksi berita palsu telah menjadi permainan kucing dan tikus dalam media saat ini. Dalam artikel ini, peneliti menyarankan bahwa sistem yang menggabungkan beberapa teknik ML yang telah kita pelajari dapat diuji dan model terbaik diterapkan: "Sistem ini didasarkan pada pemrosesan bahasa alami untuk mengekstrak fitur dari data dan kemudian fitur-fitur ini digunakan untuk pelatihan pengklasifikasi pembelajaran mesin seperti Naive Bayes, Support Vector Machine (SVM), Random Forest (RF), Stochastic Gradient Descent (SGD), dan Logistic Regression (LR)."
|
||||
[Referensi](https://www.irjet.net/archives/V7/i6/IRJET-V7I6688.pdf)
|
||||
|
||||
Artikel ini menunjukkan bagaimana menggabungkan berbagai domain ML dapat menghasilkan hasil yang menarik yang dapat membantu menghentikan penyebaran berita palsu dan menciptakan kerusakan nyata; dalam hal ini, dorongan utama adalah penyebaran rumor tentang pengobatan COVID yang memicu kekerasan massa.
|
||||
|
||||
### Museum ML
|
||||
|
||||
Museum berada di ambang revolusi AI di mana mengkatalogkan dan mendigitalkan koleksi serta menemukan hubungan antara artefak menjadi lebih mudah seiring dengan kemajuan teknologi. Proyek seperti [In Codice Ratio](https://www.sciencedirect.com/science/article/abs/pii/S0306457321001035#:~:text=1.,studies%20over%20large%20historical%20sources.) membantu membuka misteri koleksi yang tidak dapat diakses seperti Arsip Vatikan. Namun, aspek bisnis dari museum juga mendapat manfaat dari model ML.
|
||||
|
||||
Misalnya, Art Institute of Chicago membangun model untuk memprediksi apa yang diminati oleh audiens dan kapan mereka akan menghadiri pameran. Tujuannya adalah untuk menciptakan pengalaman pengunjung yang dipersonalisasi dan dioptimalkan setiap kali pengguna mengunjungi museum. "Selama tahun fiskal 2017, model tersebut memprediksi kehadiran dan penerimaan dengan akurasi dalam 1 persen, kata Andrew Simnick, wakil presiden senior di Art Institute."
|
||||
[Reference](https://www.chicagobusiness.com/article/20180518/ISSUE01/180519840/art-institute-of-chicago-uses-data-to-make-exhibit-choices)
|
||||
|
||||
## 🏷 Pemasaran
|
||||
|
||||
### Segmentasi pelanggan
|
||||
|
||||
Strategi pemasaran yang paling berkesan menargetkan pelanggan dengan cara yang berbeza berdasarkan pelbagai pengelompokan. Dalam artikel ini, penggunaan algoritma Kluster dibincangkan untuk menyokong pemasaran yang berbeza. Pemasaran berbeza membantu syarikat meningkatkan pengiktirafan jenama, mencapai lebih ramai pelanggan, dan menjana lebih banyak wang.
|
||||
[Reference](https://ai.inqline.com/machine-learning-for-marketing-customer-segmentation/)
|
||||
|
||||
## 🚀 Cabaran
|
||||
|
||||
Kenal pasti sektor lain yang mendapat manfaat daripada beberapa teknik yang anda pelajari dalam kurikulum ini, dan ketahui bagaimana ia menggunakan ML.
|
||||
|
||||
## [Kuiz selepas kuliah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/50/)
|
||||
|
||||
## Ulasan & Kajian Kendiri
|
||||
|
||||
Pasukan sains data Wayfair mempunyai beberapa video menarik tentang bagaimana mereka menggunakan ML di syarikat mereka. Ia berbaloi untuk [dilihat](https://www.youtube.com/channel/UCe2PjkQXqOuwkW1gw6Ameuw/videos)!
|
||||
|
||||
## Tugasan
|
||||
|
||||
[Perburuan harta karun ML](assignment.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,16 +0,0 @@
|
||||
# Pemburuan Harta Karun ML
|
||||
|
||||
## Arahan
|
||||
|
||||
Dalam pelajaran ini, anda telah belajar tentang banyak kes penggunaan dunia nyata yang diselesaikan menggunakan ML klasik. Walaupun penggunaan pembelajaran mendalam, teknik dan alat baru dalam AI, serta memanfaatkan rangkaian neural telah membantu mempercepat pengeluaran alat untuk membantu dalam sektor-sektor ini, ML klasik yang menggunakan teknik dalam kurikulum ini masih mempunyai nilai yang besar.
|
||||
|
||||
Dalam tugasan ini, bayangkan anda sedang menyertai hackathon. Gunakan apa yang anda pelajari dalam kurikulum untuk mencadangkan penyelesaian menggunakan ML klasik untuk menyelesaikan masalah dalam salah satu sektor yang dibincangkan dalam pelajaran ini. Buat satu pembentangan di mana anda membincangkan bagaimana anda akan melaksanakan idea anda. Mata bonus jika anda boleh mengumpulkan data contoh dan membina model ML untuk menyokong konsep anda!
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | ------------------------------------------------------------------- | ------------------------------------------------ | ---------------------- |
|
||||
| | Pembentangan PowerPoint dipersembahkan - bonus untuk membina model | Pembentangan asas yang tidak inovatif dipersembahkan | Kerja tidak lengkap |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,141 +0,0 @@
|
||||
# Postscript: Debugging Model dalam Pembelajaran Mesin menggunakan Komponen Papan Pemuka AI Bertanggungjawab
|
||||
|
||||
## [Kuiz pra-ceramah](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/5/)
|
||||
|
||||
## Pengenalan
|
||||
|
||||
Pembelajaran mesin memberi kesan kepada kehidupan seharian kita. AI sedang menemui jalannya ke dalam beberapa sistem yang paling penting yang mempengaruhi kita sebagai individu serta masyarakat kita, dari penjagaan kesihatan, kewangan, pendidikan, dan pekerjaan. Contohnya, sistem dan model terlibat dalam tugas membuat keputusan harian, seperti diagnosis penjagaan kesihatan atau mengesan penipuan. Akibatnya, kemajuan dalam AI bersama dengan penerimaan yang dipercepatkan sedang dihadapi dengan harapan masyarakat yang berkembang dan peraturan yang semakin meningkat sebagai tindak balas. Kita sentiasa melihat kawasan di mana sistem AI terus gagal memenuhi jangkaan; mereka mendedahkan cabaran baru; dan kerajaan mula mengawal penyelesaian AI. Oleh itu, adalah penting bahawa model ini dianalisis untuk memberikan hasil yang adil, boleh dipercayai, inklusif, telus, dan bertanggungjawab untuk semua orang.
|
||||
|
||||
Dalam kurikulum ini, kita akan melihat alat praktikal yang boleh digunakan untuk menilai jika model mempunyai isu AI bertanggungjawab. Teknik debugging pembelajaran mesin tradisional cenderung berdasarkan pengiraan kuantitatif seperti ketepatan agregat atau purata kehilangan ralat. Bayangkan apa yang boleh berlaku apabila data yang anda gunakan untuk membina model ini kekurangan demografi tertentu, seperti kaum, jantina, pandangan politik, agama, atau secara tidak seimbang mewakili demografi tersebut. Bagaimana pula apabila output model ditafsirkan untuk memihak kepada beberapa demografi? Ini boleh memperkenalkan perwakilan berlebihan atau kurang kumpulan ciri sensitif ini yang mengakibatkan isu keadilan, keterangkuman, atau kebolehpercayaan daripada model. Faktor lain ialah, model pembelajaran mesin dianggap kotak hitam, yang menjadikannya sukar untuk memahami dan menerangkan apa yang memacu ramalan model. Semua ini adalah cabaran yang dihadapi oleh saintis data dan pembangun AI apabila mereka tidak mempunyai alat yang mencukupi untuk debug dan menilai keadilan atau kebolehpercayaan model.
|
||||
|
||||
Dalam pelajaran ini, anda akan mempelajari tentang debugging model anda menggunakan:
|
||||
|
||||
- **Analisis Ralat**: mengenal pasti di mana dalam taburan data anda model mempunyai kadar ralat yang tinggi.
|
||||
- **Gambaran Keseluruhan Model**: melakukan analisis perbandingan merentasi kohort data yang berbeza untuk menemui perbezaan dalam metrik prestasi model anda.
|
||||
- **Analisis Data**: menyiasat di mana mungkin terdapat perwakilan berlebihan atau kurang data anda yang boleh mengubah model anda untuk memihak kepada satu demografi data berbanding yang lain.
|
||||
- **Kepentingan Ciri**: memahami ciri-ciri yang memacu ramalan model anda pada peringkat global atau peringkat tempatan.
|
||||
|
||||
## Prasyarat
|
||||
|
||||
Sebagai prasyarat, sila tinjau [Alat AI Bertanggungjawab untuk pembangun](https://www.microsoft.com/ai/ai-lab-responsible-ai-dashboard)
|
||||
|
||||
> 
|
||||
|
||||
## Analisis Ralat
|
||||
|
||||
Metrik prestasi model tradisional yang digunakan untuk mengukur ketepatan kebanyakannya adalah pengiraan berdasarkan ramalan betul vs salah. Sebagai contoh, menentukan bahawa model adalah tepat 89% masa dengan kehilangan ralat 0.001 boleh dianggap sebagai prestasi yang baik. Kesilapan selalunya tidak diedarkan secara seragam dalam set data asas anda. Anda mungkin mendapat skor ketepatan model 89% tetapi mendapati bahawa terdapat kawasan berbeza dalam data anda di mana model gagal 42% masa. Akibat daripada corak kegagalan ini dengan kumpulan data tertentu boleh membawa kepada isu keadilan atau kebolehpercayaan. Adalah penting untuk memahami kawasan di mana model berprestasi baik atau tidak. Kawasan data di mana terdapat banyak ketidaktepatan dalam model anda mungkin menjadi demografi data yang penting.
|
||||
|
||||
|
||||
|
||||
Komponen Analisis Ralat pada papan pemuka RAI menggambarkan bagaimana kegagalan model diedarkan merentasi pelbagai kohort dengan visualisasi pokok. Ini berguna dalam mengenal pasti ciri atau kawasan di mana terdapat kadar ralat yang tinggi dengan set data anda. Dengan melihat dari mana kebanyakan ketidaktepatan model datang, anda boleh mula menyiasat punca akar. Anda juga boleh mencipta kohort data untuk melakukan analisis. Kohort data ini membantu dalam proses debugging untuk menentukan mengapa prestasi model baik dalam satu kohort, tetapi salah dalam kohort lain.
|
||||
|
||||
|
||||
|
||||
Penunjuk visual pada peta pokok membantu dalam mencari kawasan masalah dengan lebih cepat. Sebagai contoh, semakin gelap warna merah pada nod pokok, semakin tinggi kadar ralat.
|
||||
|
||||
Peta haba adalah satu lagi fungsi visualisasi yang boleh digunakan pengguna dalam menyiasat kadar ralat menggunakan satu atau dua ciri untuk mencari penyumbang kepada kesilapan model merentasi keseluruhan set data atau kohort.
|
||||
|
||||
|
||||
|
||||
Gunakan analisis ralat apabila anda perlu:
|
||||
|
||||
* Mendapatkan pemahaman mendalam tentang bagaimana kegagalan model diedarkan merentasi set data dan merentasi beberapa dimensi input dan ciri.
|
||||
* Memecahkan metrik prestasi agregat untuk secara automatik menemui kohort yang salah untuk memaklumkan langkah mitigasi yang disasarkan anda.
|
||||
|
||||
## Gambaran Keseluruhan Model
|
||||
|
||||
Menilai prestasi model pembelajaran mesin memerlukan pemahaman holistik tentang tingkah lakunya. Ini boleh dicapai dengan mengkaji lebih daripada satu metrik seperti kadar ralat, ketepatan, ingatan, ketepatan, atau MAE (Ralat Mutlak Purata) untuk mencari perbezaan antara metrik prestasi. Satu metrik prestasi mungkin kelihatan hebat, tetapi ketidaktepatan boleh didedahkan dalam metrik lain. Di samping itu, membandingkan metrik untuk perbezaan merentasi keseluruhan set data atau kohort membantu menjelaskan di mana model berprestasi baik atau tidak. Ini amat penting dalam melihat prestasi model di kalangan ciri sensitif vs tidak sensitif (contohnya, bangsa pesakit, jantina, atau umur) untuk mendedahkan potensi ketidakadilan yang mungkin ada pada model. Sebagai contoh, mendapati bahawa model lebih salah dalam kohort yang mempunyai ciri sensitif boleh mendedahkan potensi ketidakadilan yang mungkin ada pada model.
|
||||
|
||||
Komponen Gambaran Keseluruhan Model papan pemuka RAI membantu bukan sahaja dalam menganalisis metrik prestasi perwakilan data dalam kohort, tetapi ia memberi pengguna keupayaan untuk membandingkan tingkah laku model merentasi kohort yang berbeza.
|
||||
|
||||
|
||||
|
||||
Fungsi analisis berasaskan ciri komponen membolehkan pengguna mengecilkan subkumpulan data dalam ciri tertentu untuk mengenal pasti anomali pada tahap granular. Sebagai contoh, papan pemuka mempunyai kecerdasan terbina dalam untuk secara automatik menjana kohort untuk ciri yang dipilih pengguna (contohnya, *"time_in_hospital < 3"* atau *"time_in_hospital >= 7"*). Ini membolehkan pengguna mengasingkan ciri tertentu daripada kumpulan data yang lebih besar untuk melihat sama ada ia adalah pengaruh utama hasil yang salah model.
|
||||
|
||||
|
||||
|
||||
Komponen Gambaran Keseluruhan Model menyokong dua kelas metrik perbezaan:
|
||||
|
||||
**Perbezaan dalam prestasi model**: Set metrik ini mengira perbezaan (perbezaan) dalam nilai metrik prestasi yang dipilih merentasi subkumpulan data. Berikut adalah beberapa contoh:
|
||||
|
||||
* Perbezaan dalam kadar ketepatan
|
||||
* Perbezaan dalam kadar ralat
|
||||
* Perbezaan dalam ketepatan
|
||||
* Perbezaan dalam ingatan
|
||||
* Perbezaan dalam ralat mutlak purata (MAE)
|
||||
|
||||
**Perbezaan dalam kadar pemilihan**: Metrik ini mengandungi perbezaan dalam kadar pemilihan (ramalan yang menguntungkan) di kalangan subkumpulan. Contoh ini ialah perbezaan dalam kadar kelulusan pinjaman. Kadar pemilihan bermaksud pecahan titik data dalam setiap kelas yang diklasifikasikan sebagai 1 (dalam klasifikasi binari) atau taburan nilai ramalan (dalam regresi).
|
||||
|
||||
## Analisis Data
|
||||
|
||||
> "Jika anda menyeksa data cukup lama, ia akan mengaku apa sahaja" - Ronald Coase
|
||||
|
||||
Kenyataan ini kedengaran melampau, tetapi adalah benar bahawa data boleh dimanipulasi untuk menyokong apa-apa kesimpulan. Manipulasi sedemikian kadangkala boleh berlaku tanpa disedari. Sebagai manusia, kita semua mempunyai prasangka, dan selalunya sukar untuk mengetahui secara sedar apabila anda memperkenalkan prasangka dalam data. Menjamin keadilan dalam AI dan pembelajaran mesin tetap menjadi cabaran yang kompleks.
|
||||
|
||||
Data adalah titik buta yang besar untuk metrik prestasi model tradisional. Anda mungkin mempunyai skor ketepatan yang tinggi, tetapi ini tidak selalu mencerminkan bias data yang mendasari yang mungkin ada dalam set data anda. Sebagai contoh, jika set data pekerja mempunyai 27% wanita dalam jawatan eksekutif dalam syarikat dan 73% lelaki pada tahap yang sama, model AI pengiklanan pekerjaan yang dilatih pada data ini mungkin menyasarkan kebanyakan penonton lelaki untuk jawatan pekerjaan peringkat kanan. Mempunyai ketidakseimbangan ini dalam data mengubah ramalan model untuk memihak kepada satu jantina. Ini mendedahkan isu keadilan di mana terdapat bias jantina dalam model AI.
|
||||
|
||||
Komponen Analisis Data pada papan pemuka RAI membantu mengenal pasti kawasan di mana terdapat perwakilan berlebihan dan kurang dalam set data. Ia membantu pengguna mendiagnosis punca ralat dan isu keadilan yang diperkenalkan daripada ketidakseimbangan data atau kekurangan perwakilan kumpulan data tertentu. Ini memberi pengguna keupayaan untuk memvisualisasikan set data berdasarkan hasil yang diramalkan dan sebenar, kumpulan ralat, dan ciri khusus. Kadangkala menemui kumpulan data yang kurang diwakili juga boleh mendedahkan bahawa model tidak belajar dengan baik, oleh itu ketidaktepatan yang tinggi. Mempunyai model yang mempunyai bias data bukan sahaja isu keadilan tetapi menunjukkan bahawa model tidak inklusif atau boleh dipercayai.
|
||||
|
||||
|
||||
|
||||
Gunakan analisis data apabila anda perlu:
|
||||
|
||||
* Terokai statistik set data anda dengan memilih penapis yang berbeza untuk membahagikan data anda kepada dimensi yang berbeza (juga dikenali sebagai kohort).
|
||||
* Fahami taburan set data anda merentasi kohort dan kumpulan ciri yang berbeza.
|
||||
* Tentukan sama ada penemuan anda yang berkaitan dengan keadilan, analisis ralat, dan sebab-akibat (yang diperoleh daripada komponen papan pemuka lain) adalah hasil daripada taburan set data anda.
|
||||
* Tentukan di kawasan mana untuk mengumpul lebih banyak data untuk mengurangkan ralat yang datang daripada isu perwakilan, hingar label, hingar ciri, bias label, dan faktor serupa.
|
||||
|
||||
## Kebolehfahaman Model
|
||||
|
||||
Model pembelajaran mesin cenderung menjadi kotak hitam. Memahami ciri data utama yang memacu ramalan model boleh menjadi mencabar. Adalah penting untuk memberikan ketelusan mengapa model membuat ramalan tertentu. Sebagai contoh, jika sistem AI meramalkan bahawa pesakit diabetes berisiko dimasukkan semula ke hospital dalam masa kurang daripada 30 hari, ia harus dapat memberikan data sokongan yang membawa kepada ramalannya. Mempunyai penunjuk data sokongan membawa ketelusan untuk membantu klinik atau hospital dapat membuat keputusan yang berpengetahuan. Di samping itu, dapat menerangkan mengapa model membuat ramalan untuk pesakit individu membolehkan akauntabiliti dengan peraturan kesihatan. Apabila anda menggunakan model pembelajaran mesin dengan cara yang mempengaruhi kehidupan orang, adalah penting untuk memahami dan menerangkan apa yang mempengaruhi tingkah laku model. Kebolehterangan dan kebolehfahaman model membantu menjawab soalan dalam senario seperti:
|
||||
|
||||
* Debug model: Mengapa model saya membuat kesilapan ini? Bagaimana saya boleh memperbaiki model saya?
|
||||
* Kerjasama manusia-AI: Bagaimana saya boleh memahami dan mempercayai keputusan model?
|
||||
* Pematuhan peraturan: Adakah model saya memenuhi keperluan undang-undang?
|
||||
|
||||
Komponen Kepentingan Ciri papan pemuka RAI membantu anda debug dan mendapatkan pemahaman yang komprehensif tentang bagaimana model membuat ramalan. Ia juga alat yang berguna untuk profesional pembelajaran mesin dan pembuat keputusan untuk menerangkan dan menunjukkan bukti ciri yang mempengaruhi tingkah laku model untuk pematuhan peraturan. Seterusnya, pengguna boleh meneroka kedua-dua penjelasan global dan tempatan untuk mengesahkan ciri yang memacu ramalan model. Penjelasan global menyenaraikan ciri teratas yang mempengaruhi ramalan keseluruhan model. Penjelasan tempatan memaparkan ciri yang membawa kepada ramalan model untuk kes individu. Keupayaan untuk menilai penjelasan tempatan juga berguna dalam debugging atau mengaudit kes tertentu untuk lebih memahami dan mentafsir mengapa model membuat ramalan yang tepat atau tidak tepat.
|
||||
|
||||
|
||||
|
||||
* Penjelasan global: Sebagai contoh, ciri apa yang mempengaruhi tingkah laku keseluruhan model kemasukan semula hospital diabetes?
|
||||
* Penjelasan tempatan: Sebagai contoh, mengapa pesakit diabetes berumur lebih 60 tahun dengan kemasukan hospital sebelumnya diramalkan akan dimasukkan semula atau tidak dimasukkan semula dalam masa 30 hari kembali ke hospital?
|
||||
|
||||
Dalam proses debugging untuk memeriksa prestasi model merentasi kohort yang berbeza, Kepentingan Ciri menunjukkan tahap pengaruh ciri merentasi kohort. Ia membantu mendedahkan anomali apabila membandingkan tahap pengaruh ciri dalam memacu ramalan yang salah model. Komponen Kepentingan Ciri boleh menunjukkan nilai mana dalam ciri yang mempengaruhi secara positif atau negatif hasil model. Sebagai contoh, jika model membuat ramalan yang tidak tepat, komponen memberi anda keupayaan untuk menyelidiki dan mengenal pasti ciri atau nilai ciri yang memacu ramalan tersebut. Tahap perincian ini membantu bukan sahaja dalam debugging tetapi menyediakan ketelusan dan akauntabiliti dalam situasi audit. Akhirnya, komponen boleh membantu anda mengenal pasti isu keadilan. Sebagai ilustrasi, jika ciri sensitif seperti etnik atau jantina sangat mempengaruhi dalam memacu ramalan model, ini boleh menjadi tanda bias kaum atau jantina dalam model.
|
||||
|
||||
|
||||
|
||||
Gunakan kebolehfahaman apabila anda perlu:
|
||||
|
||||
* Tentukan sejauh mana ramalan sistem AI anda boleh dipercayai dengan memahami ciri yang paling penting untuk ramalan.
|
||||
* Pendekatan debugging model anda dengan memahaminya terlebih dahulu dan mengenal pasti sama ada model menggunakan ciri yang sihat atau hanya korelasi palsu.
|
||||
* Mendedahkan sumber potensi ketidakadilan dengan memahami sama ada model membuat ramalan berdasarkan ciri sensitif atau ciri yang sangat berkorelasi dengannya.
|
||||
* Membina kepercayaan pengguna dalam keputusan model anda dengan menjana penjelasan tempatan untuk menggambarkan hasil mereka.
|
||||
* Menyelesaikan audit peraturan sistem AI untuk mengesahkan model dan memantau kesan keputusan model terhadap manusia.
|
||||
|
||||
## Kesimpulan
|
||||
|
||||
Semua komponen papan pemuka RAI adalah alat praktikal untuk membantu anda membina model pembelajaran mesin yang kurang berbahaya dan lebih dipercayai kepada masyarakat. Ia meningkatkan pencegahan ancaman kepada hak asasi manusia; mendiskriminasi atau mengecualikan kumpulan tertentu daripada peluang hidup; dan risiko kecederaan fizikal atau psikologi. Ia juga membantu membina kepercayaan dalam keputusan model anda dengan menjana penjelasan tempatan untuk menggambarkan hasil mereka. Beberapa potensi bahaya boleh diklasifikasikan sebagai:
|
||||
|
||||
- **Peruntukan**, jika jantina atau etnik contohnya lebih diutamakan daripada yang lain.
|
||||
- **Kualiti perkhidmatan**. Jika anda melatih data untuk satu senario tertentu tetapi realitinya jauh lebih kompleks, ia membawa kepada perkhidmatan yang kurang berprestasi.
|
||||
- **Stereotaip**. Mengaitkan kumpulan tertentu dengan atribut yang telah ditetapkan.
|
||||
- **Penghinaan**. Untuk mengkritik dan melabel sesuatu atau seseorang secara tidak adil.
|
||||
- **Perwakilan berlebihan atau kurang**. Idea ini adalah bahawa kumpulan tertentu tidak dilihat dalam profesion tertentu, dan mana-mana perkhidmatan atau fungsi yang terus mempromosikannya menyumbang kepada bahaya.
|
||||
|
||||
### Papan pemuka Azure RAI
|
||||
|
||||
[Papan pemuka Azure RAI](https://learn.microsoft.com/en-us/azure/machine-learning/concept-responsible-ai-dashboard?WT.mc_id=aiml-90525-ruyakubu) dibina atas alat sumber terbuka yang dibangunkan oleh institusi akademik dan organisasi terkemuka termasuk Microsoft yang penting untuk saintis data dan pembangun AI untuk lebih memahami tingkah laku model, menemui dan mengurangkan isu yang tidak diingini daripada model AI.
|
||||
|
||||
- Pelajari cara menggunakan komponen yang berbeza dengan menyemak [dokumentasi papan pemuka RAI.](https://learn.microsoft.com/en-us/azure/machine-learning/how-to-responsible-ai-dashboard?WT.mc_id=aiml-90525-ruyakubu)
|
||||
|
||||
- Lihat beberapa [notebook sampel papan pemuka RAI](https://github.com/Azure/RAI-vNext-Preview/tree/main/examples/notebooks) untuk debugging lebih banyak senario AI bertanggungjawab dalam Pembelajaran Mesin Azure.
|
||||
|
||||
---
|
||||
## 🚀 Cabaran
|
||||
|
||||
Untuk mengelakkan prasangka statistik atau data daripada diperkenalkan pada mulanya, kita harus:
|
||||
|
||||
- mempunyai kepelbagaian latar belakang dan perspektif di kalangan orang yang
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,14 +0,0 @@
|
||||
# Terokai Papan Pemuka AI Bertanggungjawab (RAI)
|
||||
|
||||
## Arahan
|
||||
|
||||
Dalam pelajaran ini, anda telah belajar tentang papan pemuka RAI, satu suite komponen yang dibina di atas alat "sumber terbuka" untuk membantu saintis data melaksanakan analisis ralat, penerokaan data, penilaian keadilan, kebolehfahaman model, penilaian kontra-fakta/apa-jika dan analisis kausal pada sistem AI. Untuk tugasan ini, terokai beberapa [notebook](https://github.com/Azure/RAI-vNext-Preview/tree/main/examples/notebooks) sampel papan pemuka RAI dan laporkan penemuan anda dalam bentuk kertas kerja atau pembentangan.
|
||||
|
||||
## Rubrik
|
||||
|
||||
| Kriteria | Cemerlang | Memadai | Perlu Penambahbaikan |
|
||||
| -------- | --------- | -------- | ----------------- |
|
||||
| | Kertas kerja atau pembentangan powerpoint dibentangkan yang membincangkan komponen papan pemuka RAI, notebook yang dijalankan, dan kesimpulan yang diperoleh daripada menjalankannya | Kertas kerja dibentangkan tanpa kesimpulan | Tiada kertas kerja dibentangkan |
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab ke atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,21 +0,0 @@
|
||||
# Postskrip: Aplikasi dunia nyata pembelajaran mesin klasik
|
||||
|
||||
Dalam bahagian kurikulum ini, anda akan diperkenalkan kepada beberapa aplikasi dunia nyata pembelajaran mesin klasik. Kami telah mencari di internet untuk menemukan kertas putih dan artikel mengenai aplikasi yang menggunakan strategi ini, mengelakkan rangkaian neural, pembelajaran mendalam dan AI sebanyak mungkin. Ketahui bagaimana pembelajaran mesin digunakan dalam sistem perniagaan, aplikasi ekologi, kewangan, seni dan budaya, dan banyak lagi.
|
||||
|
||||
|
||||
|
||||
> Foto oleh <a href="https://unsplash.com/@childeye?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Alexis Fauvet</a> di <a href="https://unsplash.com/s/photos/artificial-intelligence?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## Pelajaran
|
||||
|
||||
1. [Aplikasi Dunia Nyata untuk Pembelajaran Mesin](1-Applications/README.md)
|
||||
2. [Mendebug Model dalam Pembelajaran Mesin menggunakan komponen papan pemuka AI yang Bertanggungjawab](2-Debugging-ML-Models/README.md)
|
||||
|
||||
## Kredit
|
||||
|
||||
"Aplikasi Dunia Nyata" ditulis oleh sekumpulan individu, termasuk [Jen Looper](https://twitter.com/jenlooper) dan [Ornella Altunyan](https://twitter.com/ornelladotcom).
|
||||
|
||||
"Mendebug Model dalam Pembelajaran Mesin menggunakan komponen papan pemuka AI yang Bertanggungjawab" ditulis oleh [Ruth Yakubu](https://twitter.com/ruthieyakubu)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,12 +0,0 @@
|
||||
# Microsoft Open Source Code of Conduct
|
||||
|
||||
Projek ini telah mengadopsi [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
|
||||
|
||||
Sumber:
|
||||
|
||||
- [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/)
|
||||
- [Microsoft Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
|
||||
- Hubungi [opencode@microsoft.com](mailto:opencode@microsoft.com) untuk pertanyaan atau kekhawatiran
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,19 +0,0 @@
|
||||
# Menyumbang
|
||||
|
||||
Projek ini mengalu-alukan sumbangan dan cadangan. Kebanyakan sumbangan memerlukan anda
|
||||
bersetuju dengan Perjanjian Lesen Penyumbang (CLA) yang menyatakan bahawa anda mempunyai hak untuk,
|
||||
dan sebenarnya, memberi kami hak untuk menggunakan sumbangan anda. Untuk maklumat lanjut, sila lawati
|
||||
https://cla.microsoft.com.
|
||||
|
||||
> Penting: apabila menterjemah teks dalam repo ini, sila pastikan anda tidak menggunakan terjemahan mesin. Kami akan mengesahkan terjemahan melalui komuniti, jadi sila hanya tawarkan diri untuk terjemahan dalam bahasa yang anda mahir.
|
||||
|
||||
Apabila anda menghantar permintaan tarik, CLA-bot akan secara automatik menentukan sama ada anda perlu
|
||||
menyediakan CLA dan menghias PR dengan sewajarnya (contohnya, label, komen). Hanya ikut
|
||||
arahan yang diberikan oleh bot. Anda hanya perlu melakukan ini sekali sahaja di semua repositori yang menggunakan CLA kami.
|
||||
|
||||
Projek ini telah menerima pakai [Kod Etika Sumber Terbuka Microsoft](https://opensource.microsoft.com/codeofconduct/).
|
||||
Untuk maklumat lanjut, lihat [Soalan Lazim Kod Etika](https://opensource.microsoft.com/codeofconduct/faq/)
|
||||
atau hubungi [opencode@microsoft.com](mailto:opencode@microsoft.com) dengan sebarang soalan atau komen tambahan.
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,156 +0,0 @@
|
||||
[](https://github.com/microsoft/ML-For-Beginners/blob/master/LICENSE)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/graphs/contributors/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/issues/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/pulls/)
|
||||
[](http://makeapullrequest.com)
|
||||
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/watchers/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/network/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/stargazers/)
|
||||
|
||||
[](https://discord.gg/zxKYvhSnVp?WT.mc_id=academic-000002-leestott)
|
||||
|
||||
# Pembelajaran Mesin untuk Pemula - Kurikulum
|
||||
|
||||
> 🌍 Mari kita menjelajahi dunia sambil mempelajari Pembelajaran Mesin melalui budaya dunia 🌍
|
||||
|
||||
Advokat Cloud di Microsoft dengan senang hati menawarkan kurikulum selama 12 minggu, 26 pelajaran tentang **Pembelajaran Mesin**. Dalam kurikulum ini, Anda akan mempelajari apa yang kadang-kadang disebut sebagai **pembelajaran mesin klasik**, terutama menggunakan Scikit-learn sebagai pustaka dan menghindari pembelajaran mendalam, yang dibahas dalam [kurikulum AI untuk Pemula](https://aka.ms/ai4beginners). Pasangkan pelajaran ini dengan kurikulum ['Data Science untuk Pemula'](https://aka.ms/ds4beginners), juga!
|
||||
|
||||
Jelajahi dunia bersama kami saat kami menerapkan teknik klasik ini pada data dari berbagai wilayah di dunia. Setiap pelajaran mencakup kuis sebelum dan setelah pelajaran, instruksi tertulis untuk menyelesaikan pelajaran, solusi, tugas, dan banyak lagi. Pedagogi berbasis proyek kami memungkinkan Anda belajar sambil membangun, cara yang terbukti untuk membuat keterampilan baru 'melekat'.
|
||||
|
||||
**✍️ Terima kasih yang tulus kepada penulis kami** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu, dan Amy Boyd
|
||||
|
||||
**🎨 Terima kasih juga kepada ilustrator kami** Tomomi Imura, Dasani Madipalli, dan Jen Looper
|
||||
|
||||
**🙏 Terima kasih khusus 🙏 kepada penulis, pengulas, dan kontributor konten Duta Mahasiswa Microsoft kami**, terutama Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila, dan Snigdha Agarwal
|
||||
|
||||
**🤩 Terima kasih ekstra kepada Duta Mahasiswa Microsoft Eric Wanjau, Jasleen Sondhi, dan Vidushi Gupta untuk pelajaran R kami!**
|
||||
|
||||
# Memulai
|
||||
|
||||
Ikuti langkah-langkah ini:
|
||||
1. **Fork Repository**: Klik tombol "Fork" di sudut kanan atas halaman ini.
|
||||
2. **Clone Repository**: `git clone https://github.com/microsoft/ML-For-Beginners.git`
|
||||
|
||||
> [temukan semua sumber daya tambahan untuk kursus ini dalam koleksi Microsoft Learn kami](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
|
||||
|
||||
|
||||
**[Mahasiswa](https://aka.ms/student-page)**, untuk menggunakan kurikulum ini, fork seluruh repo ke akun GitHub Anda sendiri dan selesaikan latihan sendiri atau dengan kelompok:
|
||||
|
||||
- Mulailah dengan kuis sebelum kuliah.
|
||||
- Baca kuliah dan selesaikan aktivitasnya, berhenti dan merenung pada setiap pemeriksaan pengetahuan.
|
||||
- Cobalah membuat proyek dengan memahami pelajaran daripada menjalankan kode solusi; namun kode tersebut tersedia di folder `/solution` di setiap pelajaran yang berorientasi proyek.
|
||||
- Ambil kuis setelah kuliah.
|
||||
- Selesaikan tantangan.
|
||||
- Selesaikan tugas.
|
||||
- Setelah menyelesaikan kelompok pelajaran, kunjungi [Papan Diskusi](https://github.com/microsoft/ML-For-Beginners/discussions) dan "belajar dengan suara keras" dengan mengisi rubrik PAT yang sesuai. 'PAT' adalah Alat Penilaian Kemajuan yang merupakan rubrik yang Anda isi untuk melanjutkan pembelajaran Anda. Anda juga dapat bereaksi terhadap PAT lain sehingga kita bisa belajar bersama.
|
||||
|
||||
> Untuk studi lebih lanjut, kami merekomendasikan mengikuti modul dan jalur pembelajaran [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) ini.
|
||||
|
||||
**Guru**, kami telah [menyertakan beberapa saran](for-teachers.md) tentang cara menggunakan kurikulum ini.
|
||||
|
||||
---
|
||||
|
||||
## Video walkthroughs
|
||||
|
||||
Beberapa pelajaran tersedia dalam bentuk video pendek. Anda dapat menemukan semuanya di dalam pelajaran, atau di [daftar putar ML untuk Pemula di saluran YouTube Microsoft Developer](https://aka.ms/ml-beginners-videos) dengan mengklik gambar di bawah ini.
|
||||
|
||||
[](https://aka.ms/ml-beginners-videos)
|
||||
|
||||
---
|
||||
|
||||
## Temui Tim
|
||||
|
||||
[](https://youtu.be/Tj1XWrDSYJU "Video promosi")
|
||||
|
||||
**Gif oleh** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal)
|
||||
|
||||
> 🎥 Klik gambar di atas untuk video tentang proyek dan orang-orang yang membuatnya!
|
||||
|
||||
---
|
||||
|
||||
## Pedagogi
|
||||
|
||||
Kami telah memilih dua prinsip pedagogis saat membangun kurikulum ini: memastikan bahwa itu berbasis proyek **praktis** dan bahwa itu mencakup **kuis yang sering**. Selain itu, kurikulum ini memiliki **tema umum** untuk memberikan kohesi.
|
||||
|
||||
Dengan memastikan bahwa konten selaras dengan proyek, prosesnya menjadi lebih menarik bagi siswa dan retensi konsep akan ditingkatkan. Selain itu, kuis dengan risiko rendah sebelum kelas menetapkan niat siswa untuk mempelajari topik, sementara kuis kedua setelah kelas memastikan retensi lebih lanjut. Kurikulum ini dirancang agar fleksibel dan menyenangkan serta dapat diambil secara keseluruhan atau sebagian. Proyek dimulai dari yang kecil dan menjadi semakin kompleks pada akhir siklus 12 minggu. Kurikulum ini juga mencakup catatan tambahan tentang aplikasi dunia nyata dari ML, yang dapat digunakan sebagai kredit tambahan atau sebagai dasar untuk diskusi.
|
||||
|
||||
> Temukan [Kode Etik](CODE_OF_CONDUCT.md), [Kontribusi](CONTRIBUTING.md), dan panduan [Terjemahan](TRANSLATIONS.md) kami. Kami menyambut umpan balik konstruktif Anda!
|
||||
|
||||
## Setiap pelajaran mencakup
|
||||
|
||||
- sketchnote opsional
|
||||
- video tambahan opsional
|
||||
- video walkthrough (beberapa pelajaran saja)
|
||||
- kuis pemanasan sebelum kuliah
|
||||
- pelajaran tertulis
|
||||
- untuk pelajaran berbasis proyek, panduan langkah demi langkah tentang cara membangun proyek
|
||||
- pemeriksaan pengetahuan
|
||||
- tantangan
|
||||
- bacaan tambahan
|
||||
- tugas
|
||||
- kuis setelah kuliah
|
||||
|
||||
> **Catatan tentang bahasa**: Pelajaran ini terutama ditulis dalam Python, tetapi banyak juga yang tersedia dalam R. Untuk menyelesaikan pelajaran R, buka folder `/solution` dan cari pelajaran R. Mereka termasuk ekstensi .rmd yang merupakan file **R Markdown** yang dapat didefinisikan secara sederhana sebagai penyematan `code chunks` (dari R atau bahasa lain) dan `YAML header` (yang memandu cara memformat keluaran seperti PDF) dalam `Markdown document`. Dengan demikian, ini berfungsi sebagai kerangka kerja penulisan yang luar biasa untuk ilmu data karena memungkinkan Anda menggabungkan kode Anda, hasilnya, dan pemikiran Anda dengan memungkinkan Anda menuliskannya dalam Markdown. Selain itu, dokumen R Markdown dapat dirender ke format keluaran seperti PDF, HTML, atau Word.
|
||||
|
||||
> **Catatan tentang kuis**: Semua kuis terdapat dalam [folder Aplikasi Kuis](../../quiz-app), untuk total 52 kuis dengan tiga pertanyaan masing-masing. Mereka terhubung dari dalam pelajaran tetapi aplikasi kuis dapat dijalankan secara lokal; ikuti instruksi di folder `quiz-app` untuk menghosting secara lokal atau menyebarkan ke Azure.
|
||||
|
||||
| Nomor Pelajaran | Topik | Kelompok Pelajaran | Tujuan Pembelajaran | Pelajaran Terkait | Penulis |
|
||||
| :-----------: | :------------------------------------------------------------: | :-------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: |
|
||||
| 01 | Pengenalan pembelajaran mesin | [Pengenalan](1-Introduction/README.md) | Pelajari konsep dasar di balik pembelajaran mesin | [Pelajaran](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
|
||||
| 02 | Sejarah pembelajaran mesin | [Pengenalan](1-Introduction/README.md) | Pelajari sejarah di balik bidang ini | [Pelajaran](1-Introduction/2-history-of-ML/README.md) | Jen dan Amy |
|
||||
| 03 | Keadilan dan pembelajaran mesin | [Pengenalan](1-Introduction/README.md) | Apa saja isu filosofis penting seputar keadilan yang harus dipertimbangkan siswa saat membangun dan menerapkan model ML? | [Pelajaran](1-Introduction/3-fairness/README.md) | Tomomi |
|
||||
| 04 | Teknik untuk pembelajaran mesin | [Introduction](1-Introduction/README.md) | Teknik apa yang digunakan oleh peneliti ML untuk membina model ML? | [Lesson](1-Introduction/4-techniques-of-ML/README.md) | Chris dan Jen |
|
||||
| 05 | Pengenalan kepada regresi | [Regression](2-Regression/README.md) | Mulakan dengan Python dan Scikit-learn untuk model regresi | <ul><li>[Python](2-Regression/1-Tools/README.md)</li><li>[R](../../2-Regression/1-Tools/solution/R/lesson_1.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 06 | Harga labu Amerika Utara 🎃 | [Regression](2-Regression/README.md) | Visualisasikan dan bersihkan data sebagai persiapan untuk ML | <ul><li>[Python](2-Regression/2-Data/README.md)</li><li>[R](../../2-Regression/2-Data/solution/R/lesson_2.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 07 | Harga labu Amerika Utara 🎃 | [Regression](2-Regression/README.md) | Bina model regresi linear dan polinomial | <ul><li>[Python](2-Regression/3-Linear/README.md)</li><li>[R](../../2-Regression/3-Linear/solution/R/lesson_3.html)</li></ul> | <ul><li>Jen dan Dmitry</li><li>Eric Wanjau</li></ul> |
|
||||
| 08 | Harga labu Amerika Utara 🎃 | [Regression](2-Regression/README.md) | Bina model regresi logistik | <ul><li>[Python](2-Regression/4-Logistic/README.md) </li><li>[R](../../2-Regression/4-Logistic/solution/R/lesson_4.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 09 | Aplikasi Web 🔌 | [Web App](3-Web-App/README.md) | Bina aplikasi web untuk menggunakan model yang telah dilatih | [Python](3-Web-App/1-Web-App/README.md) | Jen |
|
||||
| 10 | Pengenalan kepada klasifikasi | [Classification](4-Classification/README.md) | Bersihkan, sediakan, dan visualisasikan data anda; pengenalan kepada klasifikasi | <ul><li> [Python](4-Classification/1-Introduction/README.md) </li><li>[R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | <ul><li>Jen dan Cassie</li><li>Eric Wanjau</li></ul> |
|
||||
| 11 | Masakan Asia dan India yang lazat 🍜 | [Classification](4-Classification/README.md) | Pengenalan kepada pengelasan | <ul><li> [Python](4-Classification/2-Classifiers-1/README.md)</li><li>[R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | <ul><li>Jen dan Cassie</li><li>Eric Wanjau</li></ul> |
|
||||
| 12 | Masakan Asia dan India yang lazat 🍜 | [Classification](4-Classification/README.md) | Lebih banyak pengelasan | <ul><li> [Python](4-Classification/3-Classifiers-2/README.md)</li><li>[R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | <ul><li>Jen dan Cassie</li><li>Eric Wanjau</li></ul> |
|
||||
| 13 | Masakan Asia dan India yang lazat 🍜 | [Classification](4-Classification/README.md) | Bina aplikasi web cadangan menggunakan model anda | [Python](4-Classification/4-Applied/README.md) | Jen |
|
||||
| 14 | Pengenalan kepada pengelompokan | [Clustering](5-Clustering/README.md) | Bersihkan, sediakan, dan visualisasikan data anda; Pengenalan kepada pengelompokan | <ul><li> [Python](5-Clustering/1-Visualize/README.md)</li><li>[R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 15 | Menjelajah Selera Muzik Nigeria 🎧 | [Clustering](5-Clustering/README.md) | Jelajahi kaedah pengelompokan K-Means | <ul><li> [Python](5-Clustering/2-K-Means/README.md)</li><li>[R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 16 | Pengenalan kepada pemprosesan bahasa semula jadi ☕️ | [Natural language processing](6-NLP/README.md) | Pelajari asas NLP dengan membina bot ringkas | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
|
||||
| 17 | Tugas Biasa dalam NLP ☕️ | [Natural language processing](6-NLP/README.md) | Mendalami pengetahuan NLP dengan memahami tugas-tugas biasa yang diperlukan semasa mengendalikan struktur bahasa | [Python](6-NLP/2-Tasks/README.md) | Stephen |
|
||||
| 18 | Terjemahan dan analisis sentimen ♥️ | [Natural language processing](6-NLP/README.md) | Terjemahan dan analisis sentimen dengan Jane Austen | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
|
||||
| 19 | Hotel romantik di Eropah ♥️ | [Natural language processing](6-NLP/README.md) | Analisis sentimen dengan ulasan hotel 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
|
||||
| 20 | Hotel romantik di Eropah ♥️ | [Natural language processing](6-NLP/README.md) | Analisis sentimen dengan ulasan hotel 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
|
||||
| 21 | Pengenalan kepada ramalan siri masa | [Time series](7-TimeSeries/README.md) | Pengenalan kepada ramalan siri masa | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
|
||||
| 22 | ⚡️ Penggunaan Tenaga Dunia ⚡️ - ramalan siri masa dengan ARIMA | [Time series](7-TimeSeries/README.md) | Ramalan siri masa dengan ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
|
||||
| 23 | ⚡️ Penggunaan Tenaga Dunia ⚡️ - ramalan siri masa dengan SVR | [Time series](7-TimeSeries/README.md) | Ramalan siri masa dengan Support Vector Regressor | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
|
||||
| 24 | Pengenalan kepada pembelajaran pengukuhan | [Reinforcement learning](8-Reinforcement/README.md) | Pengenalan kepada pembelajaran pengukuhan dengan Q-Learning | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
|
||||
| 25 | Bantu Peter mengelak serigala! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | Pembelajaran pengukuhan Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
|
||||
| Postscript | Senario dan aplikasi ML di dunia sebenar | [ML in the Wild](9-Real-World/README.md) | Aplikasi dunia sebenar yang menarik dan mendedahkan tentang ML klasik | [Lesson](9-Real-World/1-Applications/README.md) | Team |
|
||||
| Postscript | Debugging Model dalam ML menggunakan papan pemuka RAI | [ML in the Wild](9-Real-World/README.md) | Debugging Model dalam Pembelajaran Mesin menggunakan komponen papan pemuka AI Bertanggungjawab | [Lesson](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
|
||||
|
||||
> [cari semua sumber tambahan untuk kursus ini dalam koleksi Microsoft Learn kami](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
|
||||
|
||||
## Akses Luar Talian
|
||||
|
||||
Anda boleh menjalankan dokumentasi ini secara luar talian dengan menggunakan [Docsify](https://docsify.js.org/#/). Fork repo ini, [pasang Docsify](https://docsify.js.org/#/quickstart) pada mesin tempatan anda, dan kemudian dalam folder root repo ini, taipkan `docsify serve`. Laman web akan disediakan pada port 3000 di localhost anda: `localhost:3000`.
|
||||
|
||||
## PDF
|
||||
Cari pdf kurikulum dengan pautan [di sini](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
|
||||
|
||||
## Bantuan Diperlukan
|
||||
|
||||
Adakah anda ingin menyumbang terjemahan? Sila baca [panduan terjemahan kami](TRANSLATIONS.md) dan tambah isu berasaskan templat untuk menguruskan beban kerja [di sini](https://github.com/microsoft/ML-For-Beginners/issues).
|
||||
|
||||
## Kurikulum Lain
|
||||
|
||||
Pasukan kami menghasilkan kurikulum lain! Lihat:
|
||||
|
||||
- [AI untuk Pemula](https://aka.ms/ai4beginners)
|
||||
- [Sains Data untuk Pemula](https://aka.ms/datascience-beginners)
|
||||
- [**Versi 2.0 Baru** - Generative AI untuk Pemula](https://aka.ms/genai-beginners)
|
||||
- [**BARU** Keselamatan Siber untuk Pemula](https://github.com/microsoft/Security-101??WT.mc_id=academic-96948-sayoung)
|
||||
- [Pembangunan Web untuk Pemula](https://aka.ms/webdev-beginners)
|
||||
- [IoT untuk Pemula](https://aka.ms/iot-beginners)
|
||||
- [Pembelajaran Mesin untuk Pemula](https://aka.ms/ml4beginners)
|
||||
- [Pembangunan XR untuk Pemula](https://aka.ms/xr-dev-for-beginners)
|
||||
- [Menguasai GitHub Copilot untuk Pengaturcaraan Berpasangan AI](https://aka.ms/GitHubCopilotAI)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,40 +0,0 @@
|
||||
## Keselamatan
|
||||
|
||||
Microsoft mengambil serius keselamatan produk dan perkhidmatan perisian kami, termasuk semua repositori kod sumber yang diuruskan melalui organisasi GitHub kami, yang merangkumi [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), dan [organisasi GitHub kami](https://opensource.microsoft.com/).
|
||||
|
||||
Jika anda percaya anda telah menemui kelemahan keselamatan dalam mana-mana repositori milik Microsoft yang memenuhi [definisi kelemahan keselamatan Microsoft](https://docs.microsoft.com/previous-versions/tn-archive/cc751383(v=technet.10)?WT.mc_id=academic-77952-leestott), sila laporkan kepada kami seperti yang diterangkan di bawah.
|
||||
|
||||
## Melaporkan Isu Keselamatan
|
||||
|
||||
**Sila jangan laporkan kelemahan keselamatan melalui isu GitHub awam.**
|
||||
|
||||
Sebaliknya, sila laporkan kepada Pusat Tindak Balas Keselamatan Microsoft (MSRC) di [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report).
|
||||
|
||||
Jika anda lebih suka menghantar tanpa log masuk, hantarkan e-mel kepada [secure@microsoft.com](mailto:secure@microsoft.com). Jika boleh, enkripsikan mesej anda dengan kunci PGP kami; sila muat turun dari halaman [Microsoft Security Response Center PGP Key](https://www.microsoft.com/en-us/msrc/pgp-key-msrc).
|
||||
|
||||
Anda sepatutnya menerima maklum balas dalam masa 24 jam. Jika atas sebab tertentu anda tidak menerimanya, sila susuli melalui e-mel untuk memastikan kami menerima mesej asal anda. Maklumat tambahan boleh didapati di [microsoft.com/msrc](https://www.microsoft.com/msrc).
|
||||
|
||||
Sila sertakan maklumat yang diminta di bawah (sebanyak yang anda boleh sediakan) untuk membantu kami lebih memahami sifat dan skop isu yang mungkin berlaku:
|
||||
|
||||
* Jenis isu (contohnya buffer overflow, SQL injection, cross-site scripting, dll.)
|
||||
* Laluan penuh fail sumber yang berkaitan dengan manifestasi isu tersebut
|
||||
* Lokasi kod sumber yang terjejas (tag/cabang/komit atau URL langsung)
|
||||
* Sebarang konfigurasi khas yang diperlukan untuk menghasilkan isu tersebut
|
||||
* Arahan langkah demi langkah untuk menghasilkan isu tersebut
|
||||
* Kod bukti konsep atau eksploitasi (jika boleh)
|
||||
* Kesan isu tersebut, termasuk bagaimana penyerang mungkin mengeksploitasi isu tersebut
|
||||
|
||||
Maklumat ini akan membantu kami menilai laporan anda dengan lebih cepat.
|
||||
|
||||
Jika anda melaporkan untuk ganjaran bug, laporan yang lebih lengkap boleh menyumbang kepada anugerah ganjaran yang lebih tinggi. Sila lawati halaman [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) kami untuk maklumat lanjut mengenai program aktif kami.
|
||||
|
||||
## Bahasa Pilihan
|
||||
|
||||
Kami lebih suka semua komunikasi dalam Bahasa Inggeris.
|
||||
|
||||
## Polisi
|
||||
|
||||
Microsoft mengikuti prinsip [Pendedahan Kelemahan Terkoordinasi](https://www.microsoft.com/en-us/msrc/cvd).
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,13 +0,0 @@
|
||||
# Sokongan
|
||||
## Cara untuk mengemukakan isu dan mendapatkan bantuan
|
||||
|
||||
Projek ini menggunakan GitHub Issues untuk menjejaki pepijat dan permintaan ciri. Sila cari isu yang sedia ada sebelum mengemukakan isu baru untuk mengelakkan pendua. Untuk isu baru, kemukakan pepijat atau permintaan ciri anda sebagai Isu baru.
|
||||
|
||||
Untuk bantuan dan soalan mengenai penggunaan projek ini, kemukakan isu.
|
||||
|
||||
## Polisi Sokongan Microsoft
|
||||
|
||||
Sokongan untuk repositori ini adalah terhad kepada sumber-sumber yang disenaraikan di atas.
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,37 +0,0 @@
|
||||
# Menyumbang dengan menterjemahkan pelajaran
|
||||
|
||||
Kami mengalu-alukan terjemahan untuk pelajaran dalam kurikulum ini!
|
||||
## Garis Panduan
|
||||
|
||||
Terdapat folder dalam setiap folder pelajaran dan folder pengenalan pelajaran yang mengandungi fail markdown yang telah diterjemahkan.
|
||||
|
||||
> Nota, sila jangan terjemahkan sebarang kod dalam fail sampel kod; perkara yang perlu diterjemahkan hanyalah README, tugasan, dan kuiz. Terima kasih!
|
||||
|
||||
Fail yang diterjemahkan harus mengikuti konvensyen penamaan ini:
|
||||
|
||||
**README._[language]_.md**
|
||||
|
||||
di mana _[language]_ adalah singkatan dua huruf bahasa mengikut standard ISO 639-1 (contohnya `README.es.md` untuk bahasa Sepanyol dan `README.nl.md` untuk bahasa Belanda).
|
||||
|
||||
**assignment._[language]_.md**
|
||||
|
||||
Serupa dengan Readme, sila terjemahkan tugasan juga.
|
||||
|
||||
> Penting: apabila menterjemahkan teks dalam repo ini, sila pastikan anda tidak menggunakan terjemahan mesin. Kami akan mengesahkan terjemahan melalui komuniti, jadi sila hanya menawarkan diri untuk terjemahan dalam bahasa yang anda mahir.
|
||||
|
||||
**Kuiz**
|
||||
|
||||
1. Tambahkan terjemahan anda kepada aplikasi kuiz dengan menambah fail di sini: https://github.com/microsoft/ML-For-Beginners/tree/main/quiz-app/src/assets/translations, dengan konvensyen penamaan yang betul (en.json, fr.json). **Sila jangan terjemahkan perkataan 'true' atau 'false' walau bagaimanapun. terima kasih!**
|
||||
|
||||
2. Tambahkan kod bahasa anda ke dropdown dalam fail App.vue aplikasi kuiz.
|
||||
|
||||
3. Edit fail [translations index.js](https://github.com/microsoft/ML-For-Beginners/blob/main/quiz-app/src/assets/translations/index.js) aplikasi kuiz untuk menambah bahasa anda.
|
||||
|
||||
4. Akhir sekali, edit SEMUA pautan kuiz dalam fail README.md yang telah diterjemahkan untuk terus menuju ke kuiz yang telah diterjemahkan: https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/1 menjadi https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/1?loc=id
|
||||
|
||||
**TERIMA KASIH**
|
||||
|
||||
Kami sangat menghargai usaha anda!
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,46 +0,0 @@
|
||||
- Pengenalan
|
||||
- [Pengenalan kepada Pembelajaran Mesin](../1-Introduction/1-intro-to-ML/README.md)
|
||||
- [Sejarah Pembelajaran Mesin](../1-Introduction/2-history-of-ML/README.md)
|
||||
- [Pembelajaran Mesin dan Keadilan](../1-Introduction/3-fairness/README.md)
|
||||
- [Teknik-teknik Pembelajaran Mesin](../1-Introduction/4-techniques-of-ML/README.md)
|
||||
|
||||
- Regresi
|
||||
- [Alat-alat yang Digunakan](../2-Regression/1-Tools/README.md)
|
||||
- [Data](../2-Regression/2-Data/README.md)
|
||||
- [Regresi Linear](../2-Regression/3-Linear/README.md)
|
||||
- [Regresi Logistik](../2-Regression/4-Logistic/README.md)
|
||||
|
||||
- Bina Aplikasi Web
|
||||
- [Aplikasi Web](../3-Web-App/1-Web-App/README.md)
|
||||
|
||||
- Klasifikasi
|
||||
- [Pengenalan kepada Klasifikasi](../4-Classification/1-Introduction/README.md)
|
||||
- [Pengelas 1](../4-Classification/2-Classifiers-1/README.md)
|
||||
- [Pengelas 2](../4-Classification/3-Classifiers-2/README.md)
|
||||
- [Pembelajaran Mesin Terapan](../4-Classification/4-Applied/README.md)
|
||||
|
||||
- Pengelompokan
|
||||
- [Visualisasikan Data Anda](../5-Clustering/1-Visualize/README.md)
|
||||
- [K-Means](../5-Clustering/2-K-Means/README.md)
|
||||
|
||||
- NLP
|
||||
- [Pengenalan kepada NLP](../6-NLP/1-Introduction-to-NLP/README.md)
|
||||
- [Tugas-tugas NLP](../6-NLP/2-Tasks/README.md)
|
||||
- [Terjemahan dan Sentimen](../6-NLP/3-Translation-Sentiment/README.md)
|
||||
- [Ulasan Hotel 1](../6-NLP/4-Hotel-Reviews-1/README.md)
|
||||
- [Ulasan Hotel 2](../6-NLP/5-Hotel-Reviews-2/README.md)
|
||||
|
||||
- Ramalan Siri Masa
|
||||
- [Pengenalan kepada Ramalan Siri Masa](../7-TimeSeries/1-Introduction/README.md)
|
||||
- [ARIMA](../7-TimeSeries/2-ARIMA/README.md)
|
||||
- [SVR](../7-TimeSeries/3-SVR/README.md)
|
||||
|
||||
- Pembelajaran Pengukuhan
|
||||
- [Q-Learning](../8-Reinforcement/1-QLearning/README.md)
|
||||
- [Gym](../8-Reinforcement/2-Gym/README.md)
|
||||
|
||||
- Pembelajaran Mesin Dunia Nyata
|
||||
- [Aplikasi](../9-Real-World/1-Applications/README.md)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,26 +0,0 @@
|
||||
## Untuk Pendidik
|
||||
|
||||
Adakah anda ingin menggunakan kurikulum ini di dalam kelas anda? Sila berbuat demikian!
|
||||
|
||||
Malah, anda boleh menggunakannya dalam GitHub sendiri dengan menggunakan GitHub Classroom.
|
||||
|
||||
Untuk melakukannya, fork repo ini. Anda akan perlu mencipta repo untuk setiap pelajaran, jadi anda perlu mengekstrak setiap folder ke dalam repo yang berasingan. Dengan cara itu, [GitHub Classroom](https://classroom.github.com/classrooms) boleh mengambil setiap pelajaran secara berasingan.
|
||||
|
||||
Arahan penuh ini [full instructions](https://github.blog/2020-03-18-set-up-your-digital-classroom-with-github-classroom/) akan memberikan anda idea bagaimana untuk menubuhkan kelas anda.
|
||||
|
||||
## Menggunakan repo seperti sediakala
|
||||
|
||||
Jika anda ingin menggunakan repo ini seperti yang ada sekarang, tanpa menggunakan GitHub Classroom, itu juga boleh dilakukan. Anda perlu berkomunikasi dengan pelajar anda pelajaran mana yang perlu diikuti bersama.
|
||||
|
||||
Dalam format dalam talian (Zoom, Teams, atau lain-lain) anda mungkin membentuk bilik pecahan untuk kuiz, dan mentor pelajar untuk membantu mereka bersedia untuk belajar. Kemudian jemput pelajar untuk kuiz dan menghantar jawapan mereka sebagai 'issues' pada masa tertentu. Anda mungkin melakukan perkara yang sama dengan tugasan, jika anda mahu pelajar bekerja secara kolaboratif di tempat terbuka.
|
||||
|
||||
Jika anda lebih suka format yang lebih peribadi, minta pelajar anda fork kurikulum ini, pelajaran demi pelajaran, ke dalam repo GitHub mereka sendiri sebagai repo peribadi, dan beri anda akses. Kemudian mereka boleh menyelesaikan kuiz dan tugasan secara peribadi dan menghantarnya kepada anda melalui issues pada repo kelas anda.
|
||||
|
||||
Terdapat banyak cara untuk membuat ini berfungsi dalam format kelas dalam talian. Sila beritahu kami apa yang paling sesuai untuk anda!
|
||||
|
||||
## Sila berikan pendapat anda!
|
||||
|
||||
Kami ingin membuat kurikulum ini berfungsi untuk anda dan pelajar anda. Sila beri kami [maklum balas](https://forms.microsoft.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR2humCsRZhxNuI79cm6n0hRUQzRVVU9VVlU5UlFLWTRLWlkyQUxORTg5WS4u).
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,115 +0,0 @@
|
||||
# Kuiz
|
||||
|
||||
Kuiz-kuiz ini adalah kuiz sebelum dan selepas kuliah untuk kurikulum ML di https://aka.ms/ml-beginners
|
||||
|
||||
## Persediaan Projek
|
||||
|
||||
```
|
||||
npm install
|
||||
```
|
||||
|
||||
### Kompil dan muat semula secara langsung untuk pembangunan
|
||||
|
||||
```
|
||||
npm run serve
|
||||
```
|
||||
|
||||
### Kompil dan kecilkan untuk produksi
|
||||
|
||||
```
|
||||
npm run build
|
||||
```
|
||||
|
||||
### Lint dan betulkan fail
|
||||
|
||||
```
|
||||
npm run lint
|
||||
```
|
||||
|
||||
### Sesuaikan konfigurasi
|
||||
|
||||
Lihat [Rujukan Konfigurasi](https://cli.vuejs.org/config/).
|
||||
|
||||
Kredit: Terima kasih kepada versi asal aplikasi kuiz ini: https://github.com/arpan45/simple-quiz-vue
|
||||
|
||||
## Melancarkan ke Azure
|
||||
|
||||
Berikut adalah panduan langkah demi langkah untuk membantu anda memulakan:
|
||||
|
||||
1. Fork Repositori GitHub
|
||||
Pastikan kod aplikasi web statik anda berada dalam repositori GitHub anda. Fork repositori ini.
|
||||
|
||||
2. Buat Aplikasi Web Statik Azure
|
||||
- Buat akaun [Azure](http://azure.microsoft.com)
|
||||
- Pergi ke [portal Azure](https://portal.azure.com)
|
||||
- Klik "Create a resource" dan cari "Static Web App".
|
||||
- Klik "Create".
|
||||
|
||||
3. Konfigurasikan Aplikasi Web Statik
|
||||
- Asas: Langganan: Pilih langganan Azure anda.
|
||||
- Kumpulan Sumber: Buat kumpulan sumber baru atau gunakan yang sedia ada.
|
||||
- Nama: Berikan nama untuk aplikasi web statik anda.
|
||||
- Wilayah: Pilih wilayah yang paling dekat dengan pengguna anda.
|
||||
|
||||
- #### Butiran Pelancaran:
|
||||
- Sumber: Pilih "GitHub".
|
||||
- Akaun GitHub: Benarkan Azure mengakses akaun GitHub anda.
|
||||
- Organisasi: Pilih organisasi GitHub anda.
|
||||
- Repositori: Pilih repositori yang mengandungi aplikasi web statik anda.
|
||||
- Cabang: Pilih cabang yang anda ingin lancarkan.
|
||||
|
||||
- #### Butiran Pembinaan:
|
||||
- Pratetap Pembinaan: Pilih rangka kerja yang digunakan oleh aplikasi anda (contoh: React, Angular, Vue, dsb.).
|
||||
- Lokasi Aplikasi: Nyatakan folder yang mengandungi kod aplikasi anda (contoh: / jika berada di akar).
|
||||
- Lokasi API: Jika anda mempunyai API, nyatakan lokasinya (pilihan).
|
||||
- Lokasi Output: Nyatakan folder di mana output pembinaan dijana (contoh: build atau dist).
|
||||
|
||||
4. Semak dan Buat
|
||||
Semak tetapan anda dan klik "Create". Azure akan menyediakan sumber yang diperlukan dan membuat aliran kerja GitHub Actions dalam repositori anda.
|
||||
|
||||
5. Aliran Kerja GitHub Actions
|
||||
Azure akan secara automatik membuat fail aliran kerja GitHub Actions dalam repositori anda (.github/workflows/azure-static-web-apps-<name>.yml). Aliran kerja ini akan mengendalikan proses pembinaan dan pelancaran.
|
||||
|
||||
6. Pantau Pelancaran
|
||||
Pergi ke tab "Actions" dalam repositori GitHub anda.
|
||||
Anda sepatutnya melihat aliran kerja sedang berjalan. Aliran kerja ini akan membina dan melancarkan aplikasi web statik anda ke Azure.
|
||||
Setelah aliran kerja selesai, aplikasi anda akan hidup di URL Azure yang disediakan.
|
||||
|
||||
### Fail Aliran Kerja Contoh
|
||||
|
||||
Berikut adalah contoh bagaimana fail aliran kerja GitHub Actions mungkin kelihatan:
|
||||
name: Azure Static Web Apps CI/CD
|
||||
```
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- main
|
||||
pull_request:
|
||||
types: [opened, synchronize, reopened, closed]
|
||||
branches:
|
||||
- main
|
||||
|
||||
jobs:
|
||||
build_and_deploy_job:
|
||||
runs-on: ubuntu-latest
|
||||
name: Build and Deploy Job
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- name: Build And Deploy
|
||||
id: builddeploy
|
||||
uses: Azure/static-web-apps-deploy@v1
|
||||
with:
|
||||
azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
|
||||
repo_token: ${{ secrets.GITHUB_TOKEN }}
|
||||
action: "upload"
|
||||
app_location: "/quiz-app" # App source code path
|
||||
api_location: ""API source code path optional
|
||||
output_location: "dist" #Built app content directory - optional
|
||||
```
|
||||
|
||||
### Sumber Tambahan
|
||||
- [Dokumentasi Azure Static Web Apps](https://learn.microsoft.com/azure/static-web-apps/getting-started)
|
||||
- [Dokumentasi GitHub Actions](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,146 +0,0 @@
|
||||
Attribution-ShareAlike 4.0 International
|
||||
|
||||
=======================================================================
|
||||
|
||||
Creative Commons Corporation ("Creative Commons") bukan firma undang-undang dan tidak menyediakan perkhidmatan atau nasihat undang-undang. Pengedaran lesen awam Creative Commons tidak mewujudkan hubungan peguam-klien atau hubungan lain. Creative Commons menyediakan lesen dan maklumat berkaitan berdasarkan "as-is". Creative Commons tidak memberikan sebarang jaminan mengenai lesen mereka, bahan yang dilesenkan di bawah terma dan syarat mereka, atau maklumat berkaitan. Creative Commons menafikan semua tanggungjawab atas kerosakan yang diakibatkan oleh penggunaannya sejauh mana yang mungkin.
|
||||
|
||||
Menggunakan Lesen Awam Creative Commons
|
||||
|
||||
Lesen awam Creative Commons menyediakan satu set terma dan syarat standard yang boleh digunakan oleh pencipta dan pemegang hak lain untuk berkongsi karya asli dan bahan lain yang tertakluk kepada hak cipta dan hak tertentu lain yang dinyatakan dalam lesen awam di bawah. Pertimbangan berikut adalah untuk tujuan maklumat sahaja, tidak menyeluruh, dan bukan sebahagian daripada lesen kami.
|
||||
|
||||
Pertimbangan untuk pemberi lesen: Lesen awam kami ditujukan untuk digunakan oleh mereka yang diberi kuasa untuk memberikan kebenaran awam untuk menggunakan bahan dengan cara yang sebaliknya dihadkan oleh hak cipta dan hak tertentu lain. Lesen kami tidak boleh dibatalkan. Pemberi lesen harus membaca dan memahami terma dan syarat lesen yang mereka pilih sebelum menggunakannya. Pemberi lesen juga harus mendapatkan semua hak yang diperlukan sebelum mengaplikasikan lesen kami supaya awam boleh menggunakan bahan seperti yang diharapkan. Pemberi lesen harus dengan jelas menandakan sebarang bahan yang tidak tertakluk kepada lesen. Ini termasuk bahan lain yang dilesenkan oleh CC, atau bahan yang digunakan di bawah pengecualian atau had kepada hak cipta. Pertimbangan lebih lanjut untuk pemberi lesen: wiki.creativecommons.org/Considerations_for_licensors
|
||||
|
||||
Pertimbangan untuk awam: Dengan menggunakan salah satu lesen awam kami, pemberi lesen memberikan kebenaran awam untuk menggunakan bahan yang dilesenkan di bawah terma dan syarat tertentu. Jika kebenaran pemberi lesen tidak diperlukan atas sebarang sebab - contohnya, kerana pengecualian atau had yang berkenaan kepada hak cipta - maka penggunaan itu tidak diatur oleh lesen. Lesen kami hanya memberikan kebenaran di bawah hak cipta dan hak tertentu lain yang pemberi lesen mempunyai kuasa untuk memberikan. Penggunaan bahan yang dilesenkan mungkin masih dihadkan atas sebab lain, termasuk kerana orang lain mempunyai hak cipta atau hak lain dalam bahan tersebut. Pemberi lesen mungkin membuat permintaan khas, seperti meminta semua perubahan ditandakan atau diterangkan. Walaupun tidak diwajibkan oleh lesen kami, anda digalakkan untuk menghormati permintaan tersebut jika munasabah. Pertimbangan lebih lanjut untuk awam: wiki.creativecommons.org/Considerations_for_licensees
|
||||
|
||||
=======================================================================
|
||||
|
||||
Creative Commons Attribution-ShareAlike 4.0 International Public License
|
||||
|
||||
Dengan menggunakan Hak Dilesenkan (ditakrifkan di bawah), Anda menerima dan bersetuju untuk terikat dengan terma dan syarat Creative Commons Attribution-ShareAlike 4.0 International Public License ("Lesen Awam"). Setakat mana Lesen Awam ini boleh ditafsirkan sebagai kontrak, Anda diberikan Hak Dilesenkan sebagai pertimbangan atas penerimaan Anda terhadap terma dan syarat ini, dan Pemberi Lesen memberikan Anda hak tersebut sebagai pertimbangan atas manfaat yang diterima Pemberi Lesen daripada membuat Bahan Dilesenkan tersedia di bawah terma dan syarat ini.
|
||||
|
||||
Seksyen 1 -- Definisi.
|
||||
|
||||
a. Bahan Diadaptasi bermaksud bahan yang tertakluk kepada Hak Cipta dan Hak Serupa yang berasal dari atau berdasarkan Bahan Dilesenkan dan di mana Bahan Dilesenkan diterjemahkan, diubah, disusun, diubahsuai, atau diubah dalam cara yang memerlukan kebenaran di bawah Hak Cipta dan Hak Serupa yang dipegang oleh Pemberi Lesen. Untuk tujuan Lesen Awam ini, di mana Bahan Dilesenkan adalah karya muzik, persembahan, atau rakaman bunyi, Bahan Diadaptasi selalu dihasilkan di mana Bahan Dilesenkan disinkronkan dalam hubungan masa dengan imej bergerak.
|
||||
|
||||
b. Lesen Adapter bermaksud lesen yang Anda gunakan untuk Hak Cipta dan Hak Serupa Anda dalam sumbangan Anda kepada Bahan Diadaptasi mengikut terma dan syarat Lesen Awam ini.
|
||||
|
||||
c. Lesen Serasi BY-SA bermaksud lesen yang disenaraikan di creativecommons.org/compatiblelicenses, diluluskan oleh Creative Commons sebagai setara dengan Lesen Awam ini.
|
||||
|
||||
d. Hak Cipta dan Hak Serupa bermaksud hak cipta dan/atau hak serupa yang berkaitan rapat dengan hak cipta termasuk, tanpa had, persembahan, siaran, rakaman bunyi, dan Hak Pangkalan Data Sui Generis, tanpa mengira bagaimana hak tersebut dilabel atau dikategorikan. Untuk tujuan Lesen Awam ini, hak yang dinyatakan dalam Seksyen 2(b)(1)-(2) bukan Hak Cipta dan Hak Serupa.
|
||||
|
||||
e. Langkah Teknologi Berkesan bermaksud langkah-langkah yang, tanpa kuasa yang betul, tidak boleh dielakkan di bawah undang-undang yang memenuhi kewajipan di bawah Artikel 11 Perjanjian Hak Cipta WIPO yang diterima pakai pada 20 Disember 1996, dan/atau perjanjian antarabangsa serupa.
|
||||
|
||||
f. Pengecualian dan Had bermaksud penggunaan adil, perjanjian adil, dan/atau sebarang pengecualian atau had lain kepada Hak Cipta dan Hak Serupa yang berlaku kepada penggunaan Anda terhadap Bahan Dilesenkan.
|
||||
|
||||
g. Elemen Lesen bermaksud atribut lesen yang disenaraikan dalam nama Lesen Awam Creative Commons. Elemen Lesen bagi Lesen Awam ini adalah Atribusi dan KongsiSerupa.
|
||||
|
||||
h. Bahan Dilesenkan bermaksud karya seni atau sastera, pangkalan data, atau bahan lain yang Pemberi Lesen menggunakan Lesen Awam ini.
|
||||
|
||||
i. Hak Dilesenkan bermaksud hak yang diberikan kepada Anda tertakluk kepada terma dan syarat Lesen Awam ini, yang terhad kepada semua Hak Cipta dan Hak Serupa yang berlaku kepada penggunaan Anda terhadap Bahan Dilesenkan dan yang Pemberi Lesen mempunyai kuasa untuk melesenkan.
|
||||
|
||||
j. Pemberi Lesen bermaksud individu atau entiti yang memberikan hak di bawah Lesen Awam ini.
|
||||
|
||||
k. Kongsi bermaksud menyediakan bahan kepada awam dengan apa-apa cara atau proses yang memerlukan kebenaran di bawah Hak Dilesenkan, seperti penghasilan semula, paparan awam, persembahan awam, pengedaran, penyebaran, komunikasi, atau pengimportan, dan membuat bahan tersedia kepada awam termasuk dengan cara yang anggota awam boleh mengakses bahan dari tempat dan pada masa yang dipilih secara individu oleh mereka.
|
||||
|
||||
l. Hak Pangkalan Data Sui Generis bermaksud hak selain daripada hak cipta yang berpunca daripada Arahan 96/9/EC Parlimen Eropah dan Majlis pada 11 Mac 1996 mengenai perlindungan undang-undang pangkalan data, seperti yang dipinda dan/atau digantikan, serta hak setara di mana-mana sahaja di dunia.
|
||||
|
||||
m. Anda bermaksud individu atau entiti yang menggunakan Hak Dilesenkan di bawah Lesen Awam ini. Anda mempunyai makna yang sepadan.
|
||||
|
||||
Seksyen 2 -- Skop.
|
||||
|
||||
a. Pemberian lesen.
|
||||
|
||||
1. Tertakluk kepada terma dan syarat Lesen Awam ini, Pemberi Lesen dengan ini memberikan Anda lesen seluruh dunia, bebas royalti, tidak boleh disublesenkan, tidak eksklusif, tidak boleh dibatalkan untuk menggunakan Hak Dilesenkan dalam Bahan Dilesenkan untuk:
|
||||
|
||||
a. menghasilkan semula dan Berkongsi Bahan Dilesenkan, secara keseluruhan atau sebahagian; dan
|
||||
|
||||
b. menghasilkan, menghasilkan semula, dan Berkongsi Bahan Diadaptasi.
|
||||
|
||||
2. Pengecualian dan Had. Untuk mengelakkan keraguan, di mana Pengecualian dan Had berlaku kepada penggunaan Anda, Lesen Awam ini tidak berlaku, dan Anda tidak perlu mematuhi terma dan syaratnya.
|
||||
|
||||
3. Tempoh. Tempoh Lesen Awam ini dinyatakan dalam Seksyen 6(a).
|
||||
|
||||
4. Media dan format; pengubahsuaian teknikal dibenarkan. Pemberi Lesen memberi kuasa kepada Anda untuk menggunakan Hak Dilesenkan dalam semua media dan format sama ada yang diketahui sekarang atau yang akan datang, dan untuk membuat pengubahsuaian teknikal yang diperlukan untuk melakukannya. Pemberi Lesen mengetepikan dan/atau bersetuju untuk tidak menegaskan sebarang hak atau kuasa untuk melarang Anda daripada membuat pengubahsuaian teknikal yang diperlukan untuk menggunakan Hak Dilesenkan, termasuk pengubahsuaian teknikal yang diperlukan untuk mengelakkan Langkah Teknologi Berkesan. Untuk tujuan Lesen Awam ini, hanya membuat pengubahsuaian yang dibenarkan oleh Seksyen 2(a)(4) tidak pernah menghasilkan Bahan Diadaptasi.
|
||||
|
||||
5. Penerima hiliran.
|
||||
|
||||
a. Tawaran daripada Pemberi Lesen -- Bahan Dilesenkan. Setiap penerima Bahan Dilesenkan secara automatik menerima tawaran daripada Pemberi Lesen untuk menggunakan Hak Dilesenkan di bawah terma dan syarat Lesen Awam ini.
|
||||
|
||||
b. Tawaran tambahan daripada Pemberi Lesen -- Bahan Diadaptasi. Setiap penerima Bahan Diadaptasi daripada Anda secara automatik menerima tawaran daripada Pemberi Lesen untuk menggunakan Hak Dilesenkan dalam Bahan Diadaptasi di bawah syarat-syarat Lesen Adapter yang Anda gunakan.
|
||||
|
||||
c. Tiada sekatan hiliran. Anda tidak boleh menawarkan atau mengenakan sebarang terma atau syarat tambahan atau berbeza, atau menggunakan sebarang Langkah Teknologi Berkesan kepada, Bahan Dilesenkan jika melakukannya menghalang penggunaan Hak Dilesenkan oleh mana-mana penerima Bahan Dilesenkan.
|
||||
|
||||
6. Tiada sokongan. Tiada apa-apa dalam Lesen Awam ini yang membentuk atau boleh ditafsirkan sebagai kebenaran untuk menyatakan atau mengimplikasikan bahawa Anda, atau penggunaan Anda terhadap Bahan Dilesenkan, dikaitkan dengan, atau disokong, disahkan, atau diberikan status rasmi oleh, Pemberi Lesen atau pihak lain yang ditetapkan untuk menerima atribusi seperti yang dinyatakan dalam Seksyen 3(a)(1)(A)(i).
|
||||
|
||||
b. Hak lain.
|
||||
|
||||
1. Hak moral, seperti hak integriti, tidak dilesenkan di bawah Lesen Awam ini, begitu juga hak publisiti, privasi, dan/atau hak personaliti serupa lain; walau bagaimanapun, sejauh yang mungkin, Pemberi Lesen mengetepikan dan/atau bersetuju untuk tidak menegaskan hak tersebut yang dipegang oleh Pemberi Lesen sejauh yang diperlukan untuk membolehkan Anda menggunakan Hak Dilesenkan, tetapi tidak sebaliknya.
|
||||
|
||||
2. Hak paten dan tanda dagangan tidak dilesenkan di bawah Lesen Awam ini.
|
||||
|
||||
3. Sejauh yang mungkin, Pemberi Lesen mengetepikan sebarang hak untuk mengutip royalti daripada Anda untuk penggunaan Hak Dilesenkan, sama ada secara langsung atau melalui persatuan pengutipan di bawah sebarang skim pelesenan sukarela atau boleh diketepikan secara undang-undang atau wajib. Dalam semua kes lain, Pemberi Lesen secara jelas mengekalkan sebarang hak untuk mengutip royalti tersebut.
|
||||
|
||||
Seksyen 3 -- Syarat Lesen.
|
||||
|
||||
Penggunaan Anda terhadap Hak Dilesenkan secara jelas tertakluk kepada syarat-syarat berikut.
|
||||
|
||||
a. Atribusi.
|
||||
|
||||
1. Jika Anda Berkongsi Bahan Dilesenkan (termasuk dalam bentuk yang diubah), Anda mesti:
|
||||
|
||||
a. mengekalkan yang berikut jika ia disediakan oleh Pemberi Lesen dengan Bahan Dilesenkan:
|
||||
|
||||
i. pengenalan pencipta Bahan Dilesenkan dan mana-mana pihak lain yang ditetapkan untuk menerima atribusi, dengan cara yang munasabah yang diminta oleh Pemberi Lesen (termasuk dengan nama samaran jika ditetapkan);
|
||||
|
||||
ii. notis hak cipta;
|
||||
|
||||
iii. notis yang merujuk kepada Lesen Awam ini;
|
||||
|
||||
iv. notis yang merujuk kepada penafian jaminan;
|
||||
|
||||
v. URI atau pautan hiperteks ke Bahan Dilesenkan sejauh mana yang munasabah;
|
||||
|
||||
b. menunjukkan jika Anda mengubah Bahan Dilesenkan dan mengekalkan petunjuk sebarang pengubahsuaian sebelumnya; dan
|
||||
|
||||
c. menunjukkan bahawa Bahan Dilesenkan adalah dilesenkan di bawah Lesen Awam ini, dan menyertakan teks, atau URI atau pautan hiperteks ke, Lesen Awam ini.
|
||||
|
||||
2. Anda boleh memenuhi syarat dalam Seksyen 3(a)(1) dengan cara yang munasabah berdasarkan medium, cara, dan konteks di mana Anda Berkongsi Bahan Dilesenkan. Contohnya, mungkin munasabah untuk memenuhi syarat dengan menyediakan URI atau pautan hiperteks ke sumber yang mengandungi maklumat yang diperlukan.
|
||||
|
||||
3. Jika diminta oleh Pemberi Lesen, Anda mesti mengeluarkan sebarang maklumat yang diperlukan oleh Seksyen 3(a)(1)(A) sejauh yang munasabah.
|
||||
|
||||
b. KongsiSerupa.
|
||||
|
||||
Sebagai tambahan kepada syarat dalam Seksyen 3(a), jika Anda Berkongsi Bahan Diadaptasi yang Anda hasilkan, syarat berikut juga terpakai.
|
||||
|
||||
1. Lesen Adapter yang Anda gunakan mesti merupakan lesen Creative Commons dengan Elemen Lesen yang sama, versi ini atau yang lebih baru, atau Lesen Serasi BY-SA.
|
||||
|
||||
2. Anda mesti menyertakan teks, atau URI atau pautan hiperteks ke, Lesen Adapter yang Anda gunakan. Anda boleh memenuhi syarat ini dengan cara yang munasabah berdasarkan medium, cara, dan konteks di mana Anda Berkongsi Bahan Diadaptasi.
|
||||
|
||||
3. Anda tidak boleh menawarkan atau mengenakan sebarang terma atau syarat tambahan atau berbeza, atau menggunakan sebarang Langkah Teknologi Berkesan kepada, Bahan Diadaptasi yang menghalang penggunaan hak yang diberikan di bawah Lesen Adapter yang Anda gunakan.
|
||||
|
||||
Seksyen 4 -- Hak Pangkalan Data Sui Generis.
|
||||
|
||||
Di mana Hak Dilesenkan termasuk Hak Pangkalan Data Sui Generis yang berlaku kepada penggunaan Anda terhadap Bahan Dilesenkan:
|
||||
|
||||
a. untuk mengelakkan keraguan, Seksyen 2(a)(1) memberikan Anda hak untuk mengekstrak, menggunakan semula, menghasilkan semula, dan Berkongsi semua atau sebahagian besar kandungan pangkalan data;
|
||||
|
||||
b. jika Anda menyertakan semua atau sebahagian besar kandungan pangkalan data dalam pangkalan data yang Anda mempunyai Hak Pangkalan Data Sui Generis, maka pangkalan data yang Anda mempunyai Hak Pangkalan Data Sui Generis (tetapi bukan kandungan individunya) adalah Bahan Diadaptasi, termasuk untuk tujuan Seksyen 3(b); dan
|
||||
|
||||
c. Anda mesti mematuhi syarat dalam Seksyen 3(a) jika Anda Berkongsi semua atau sebahagian besar kandungan pangkalan data.
|
||||
|
||||
Untuk mengelakkan keraguan, Seksyen 4 ini melengkapi dan tidak menggantikan kewajipan Anda di bawah Lesen Awam ini di mana Hak Dilesenkan termasuk Hak Cipta dan Hak Serupa lain.
|
||||
|
||||
Seksyen 5 -- Penafian Jaminan dan Had Tanggungjawab.
|
||||
|
||||
a. KECUALI JIKA DISEBUTKAN SECARA BERASINGAN OLEH PEMBERI LESEN, SEJAUH YANG MUNGKIN, PEMBERI LESEN MENAWARKAN BAHAN DILESENKAN "AS-IS" DAN "AS-AVAILABLE", DAN TIDAK MEMBUAT SEBARANG PERNYATAAN ATAU JAMINAN JENIS APA PUN MENGENAI BAHAN DILESENKAN, SAMA ADA DINYATAKAN, TERSIRAT, BERKANUN, ATAU LAINNYA. INI TERMASUK, TANPA HAD, JAMINAN HAK MILIK, KESESUAIAN UNTUK TUJUAN TERTENTU, TIDAK MELANGGAR HAK, KETIADAAN KECACATAN TERSEMBUNYI ATAU LAIN, KETEPATAN, ATAU KEHADIRAN ATAU KETIADAAN KESALAHAN, SAMA ADA DIKETAHUI ATAU TIDAK DIKETAHUI ATAU DAPAT DIKESAN. DI MANA PENAFIAN JAMINAN TIDAK DIBENARKAN SEPENUHNYA ATAU SEBAHAGIAN, PENAFIAN INI MUNGKIN TIDAK TERPAKAI KEPADA ANDA.
|
||||
|
||||
b. SEJAUH YANG MUNGKIN, DALAM APA JUA KEADAAN PEMBERI LESEN TIDAK AKAN BERTANGGUNGJAWAB KEPADA ANDA ATAS SEBARANG TEORI UNDANG-UNDANG (TERMASUK, TANPA HAD, KECUAIAN) ATAU SEBALIKNYA UNTUK SEBARANG KERUGIAN LANGSUNG, KHAS, TIDAK LANGSUNG, INSIDENTAL, KONSEKUENSI, PUNITIF, CONTOH, ATAU LAINNYA, KOS, PERBELANJAAN, ATAU KEROSAKAN YANG TIMBUL DARIPADA LESEN AWAM INI ATAU PENGGUNAAN BAHAN DILESENKAN, WALAUPUN PEMBERI LESEN TELAH DINASIHATKAN TENTANG KEMUNGKINAN KERUGIAN, KOS, PERBELANJAAN, ATAU KEROSAKAN TERSEBUT. DI MANA HAD TANGGUNGJAWAB TIDAK DIBENARKAN SEPENUHNYA ATAU SEBAHAGIAN, HAD INI MUNGKIN TIDAK TERPAKAI KEPADA ANDA.
|
||||
|
||||
c. Penafian jaminan dan had tanggungjawab yang dinyatakan di atas hendaklah ditafsirkan dengan cara yang, sejauh yang mungkin, paling hampir dengan penafian dan pengecualian tanggungjawab sepenuhnya.
|
||||
|
||||
Seksyen 6 -- Tempoh dan Penamatan.
|
||||
|
||||
a. Lesen Aw
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat penting, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,10 +0,0 @@
|
||||
Semua sketchnotes kurikulum boleh dimuat turun di sini.
|
||||
|
||||
🖨 Untuk cetakan dalam resolusi tinggi, versi TIFF boleh didapati di [repo ini](https://github.com/girliemac/a-picture-is-worth-a-1000-words/tree/main/ml/tiff).
|
||||
|
||||
🎨 Dicipta oleh: [Tomomi Imura](https://github.com/girliemac) (Twitter: [@girlie_mac](https://twitter.com/girlie_mac))
|
||||
|
||||
[](https://creativecommons.org/licenses/by-sa/4.0/)
|
||||
|
||||
**Penafian**:
|
||||
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI berasaskan mesin. Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab ke atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.
|
||||
@ -1,148 +0,0 @@
|
||||
# Introdução ao aprendizado de máquina
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/1/)
|
||||
|
||||
---
|
||||
|
||||
[](https://youtu.be/6mSx_KJxcHI "ML para iniciantes - Introdução ao Aprendizado de Máquina para Iniciantes")
|
||||
|
||||
> 🎥 Clique na imagem acima para um vídeo curto que explora esta lição.
|
||||
|
||||
Bem-vindo a este curso sobre aprendizado de máquina clássica para iniciantes! Seja você totalmente novo neste tópico ou um praticante experiente de ML buscando se atualizar em uma área, estamos felizes em tê-lo conosco! Queremos criar um espaço amigável para o seu estudo de ML e ficaremos felizes em avaliar, responder e incorporar seu [feedback](https://github.com/microsoft/ML-For-Beginners/discussions).
|
||||
|
||||
[](https://youtu.be/h0e2HAPTGF4 "Introdução ao ML")
|
||||
|
||||
> 🎥 Clique na imagem acima para um vídeo: John Guttag do MIT apresenta o aprendizado de máquina
|
||||
|
||||
---
|
||||
## Começando com aprendizado de máquina
|
||||
|
||||
Antes de iniciar este currículo, você precisa ter seu computador configurado e pronto para executar notebooks localmente.
|
||||
|
||||
- **Configure sua máquina com esses vídeos**. Use os links a seguir para aprender [como instalar o Python](https://youtu.be/CXZYvNRIAKM) em seu sistema e [configurar um editor de texto](https://youtu.be/EU8eayHWoZg) para desenvolvimento.
|
||||
- **Aprenda Python**. Também é recomendado ter um entendimento básico de [Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott), uma linguagem de programação útil para cientistas de dados que usamos neste curso.
|
||||
- **Aprenda Node.js e JavaScript**. Também usamos JavaScript algumas vezes neste curso ao construir aplicativos web, então você precisará ter [node](https://nodejs.org) e [npm](https://www.npmjs.com/) instalados, além de [Visual Studio Code](https://code.visualstudio.com/) disponível para desenvolvimento em Python e JavaScript.
|
||||
- **Crie uma conta no GitHub**. Como você nos encontrou aqui no [GitHub](https://github.com), você pode já ter uma conta, mas se não, crie uma e depois faça um fork deste currículo para usar por conta própria. (Sinta-se à vontade para nos dar uma estrela também 😊)
|
||||
- **Explore o Scikit-learn**. Familiarize-se com o [Scikit-learn](https://scikit-learn.org/stable/user_guide.html), um conjunto de bibliotecas de ML que referenciamos nessas lições.
|
||||
|
||||
---
|
||||
## O que é aprendizado de máquina?
|
||||
|
||||
O termo 'aprendizado de máquina' é um dos termos mais populares e frequentemente utilizados atualmente. Há uma possibilidade não trivial de que você tenha ouvido esse termo pelo menos uma vez se tiver algum tipo de familiaridade com tecnologia, não importa em qual domínio você trabalhe. No entanto, a mecânica do aprendizado de máquina é um mistério para a maioria das pessoas. Para um iniciante em aprendizado de máquina, o assunto pode às vezes parecer opressor. Portanto, é importante entender o que realmente é o aprendizado de máquina e aprender sobre isso passo a passo, através de exemplos práticos.
|
||||
|
||||
---
|
||||
## A curva de hype
|
||||
|
||||
|
||||
|
||||
> O Google Trends mostra a recente 'curva de hype' do termo 'aprendizado de máquina'
|
||||
|
||||
---
|
||||
## Um universo misterioso
|
||||
|
||||
Vivemos em um universo cheio de mistérios fascinantes. Grandes cientistas como Stephen Hawking, Albert Einstein e muitos outros dedicaram suas vidas à busca de informações significativas que desvendam os mistérios do mundo ao nosso redor. Esta é a condição humana de aprender: uma criança humana aprende coisas novas e descobre a estrutura de seu mundo ano após ano à medida que cresce até a idade adulta.
|
||||
|
||||
---
|
||||
## O cérebro da criança
|
||||
|
||||
O cérebro e os sentidos de uma criança percebem os fatos de seu entorno e gradualmente aprendem os padrões ocultos da vida que ajudam a criança a criar regras lógicas para identificar padrões aprendidos. O processo de aprendizado do cérebro humano torna os humanos a criatura viva mais sofisticada deste mundo. Aprender continuamente ao descobrir padrões ocultos e depois inovar sobre esses padrões nos permite nos tornarmos cada vez melhores ao longo de nossa vida. Essa capacidade de aprendizado e capacidade de evolução está relacionada a um conceito chamado [plasticidade cerebral](https://www.simplypsychology.org/brain-plasticity.html). Superficialmente, podemos traçar algumas semelhanças motivacionais entre o processo de aprendizado do cérebro humano e os conceitos de aprendizado de máquina.
|
||||
|
||||
---
|
||||
## O cérebro humano
|
||||
|
||||
O [cérebro humano](https://www.livescience.com/29365-human-brain.html) percebe coisas do mundo real, processa as informações percebidas, toma decisões racionais e realiza certas ações com base nas circunstâncias. Isso é o que chamamos de comportamento inteligente. Quando programamos um fac-símile do processo de comportamento inteligente em uma máquina, isso é chamado de inteligência artificial (IA).
|
||||
|
||||
---
|
||||
## Alguns termos
|
||||
|
||||
Embora os termos possam ser confundidos, aprendizado de máquina (ML) é um subconjunto importante da inteligência artificial. **ML se preocupa em usar algoritmos especializados para descobrir informações significativas e encontrar padrões ocultos a partir de dados percebidos para corroborar o processo de tomada de decisão racional**.
|
||||
|
||||
---
|
||||
## IA, ML, Aprendizado Profundo
|
||||
|
||||
|
||||
|
||||
> Um diagrama mostrando as relações entre IA, ML, aprendizado profundo e ciência de dados. Infográfico por [Jen Looper](https://twitter.com/jenlooper) inspirado por [este gráfico](https://softwareengineering.stackexchange.com/questions/366996/distinction-between-ai-ml-neural-networks-deep-learning-and-data-mining)
|
||||
|
||||
---
|
||||
## Conceitos a serem abordados
|
||||
|
||||
Neste currículo, vamos cobrir apenas os conceitos fundamentais de aprendizado de máquina que um iniciante deve conhecer. Abordamos o que chamamos de 'aprendizado de máquina clássico' principalmente usando o Scikit-learn, uma excelente biblioteca que muitos alunos usam para aprender o básico. Para entender conceitos mais amplos de inteligência artificial ou aprendizado profundo, um forte conhecimento fundamental de aprendizado de máquina é indispensável, e por isso gostaríamos de oferecê-lo aqui.
|
||||
|
||||
---
|
||||
## Neste curso você aprenderá:
|
||||
|
||||
- conceitos fundamentais de aprendizado de máquina
|
||||
- a história do ML
|
||||
- ML e justiça
|
||||
- técnicas de ML de regressão
|
||||
- técnicas de ML de classificação
|
||||
- técnicas de ML de agrupamento
|
||||
- técnicas de ML de processamento de linguagem natural
|
||||
- técnicas de ML de previsão de séries temporais
|
||||
- aprendizado por reforço
|
||||
- aplicações do mundo real para ML
|
||||
|
||||
---
|
||||
## O que não abordaremos
|
||||
|
||||
- aprendizado profundo
|
||||
- redes neurais
|
||||
- IA
|
||||
|
||||
Para proporcionar uma melhor experiência de aprendizado, evitaremos as complexidades das redes neurais, 'aprendizado profundo' - modelagem de múltiplas camadas usando redes neurais - e IA, que discutiremos em um currículo diferente. Também ofereceremos um futuro currículo de ciência de dados para focar nesse aspecto deste campo mais amplo.
|
||||
|
||||
---
|
||||
## Por que estudar aprendizado de máquina?
|
||||
|
||||
O aprendizado de máquina, de uma perspectiva de sistemas, é definido como a criação de sistemas automatizados que podem aprender padrões ocultos a partir de dados para ajudar na tomada de decisões inteligentes.
|
||||
|
||||
Essa motivação é vagamente inspirada em como o cérebro humano aprende certas coisas com base nos dados que percebe do mundo exterior.
|
||||
|
||||
✅ Pense por um minuto por que uma empresa gostaria de tentar usar estratégias de aprendizado de máquina em vez de criar um mecanismo baseado em regras codificadas.
|
||||
|
||||
---
|
||||
## Aplicações do aprendizado de máquina
|
||||
|
||||
As aplicações do aprendizado de máquina estão agora quase em todos os lugares e são tão onipresentes quanto os dados que fluem em nossas sociedades, gerados por nossos smartphones, dispositivos conectados e outros sistemas. Considerando o imenso potencial dos algoritmos de aprendizado de máquina de última geração, os pesquisadores têm explorado sua capacidade de resolver problemas reais multidimensionais e multidisciplinares com grandes resultados positivos.
|
||||
|
||||
---
|
||||
## Exemplos de ML aplicado
|
||||
|
||||
**Você pode usar aprendizado de máquina de várias maneiras**:
|
||||
|
||||
- Para prever a probabilidade de doença a partir do histórico médico ou relatórios de um paciente.
|
||||
- Para aproveitar dados meteorológicos para prever eventos climáticos.
|
||||
- Para entender o sentimento de um texto.
|
||||
- Para detectar notícias falsas e parar a disseminação de propaganda.
|
||||
|
||||
Finanças, economia, ciências da terra, exploração espacial, engenharia biomédica, ciência cognitiva e até mesmo campos das humanidades adaptaram o aprendizado de máquina para resolver os difíceis problemas de processamento de dados de seu domínio.
|
||||
|
||||
---
|
||||
## Conclusão
|
||||
|
||||
O aprendizado de máquina automatiza o processo de descoberta de padrões ao encontrar insights significativos a partir de dados do mundo real ou gerados. Ele se mostrou altamente valioso em aplicações comerciais, de saúde e financeiras, entre outras.
|
||||
|
||||
No futuro próximo, entender os fundamentos do aprendizado de máquina será uma necessidade para pessoas de qualquer domínio devido à sua ampla adoção.
|
||||
|
||||
---
|
||||
# 🚀 Desafio
|
||||
|
||||
Desenhe, em papel ou usando um aplicativo online como [Excalidraw](https://excalidraw.com/), sua compreensão das diferenças entre IA, ML, aprendizado profundo e ciência de dados. Adicione algumas ideias de problemas que cada uma dessas técnicas é boa em resolver.
|
||||
|
||||
# [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/2/)
|
||||
|
||||
---
|
||||
# Revisão e Autoestudo
|
||||
|
||||
Para aprender mais sobre como você pode trabalhar com algoritmos de ML na nuvem, siga este [Caminho de Aprendizagem](https://docs.microsoft.com/learn/paths/create-no-code-predictive-models-azure-machine-learning/?WT.mc_id=academic-77952-leestott).
|
||||
|
||||
Faça um [Caminho de Aprendizagem](https://docs.microsoft.com/learn/modules/introduction-to-machine-learning/?WT.mc_id=academic-77952-leestott) sobre os fundamentos do ML.
|
||||
|
||||
---
|
||||
# Tarefa
|
||||
|
||||
[Comece a usar](assignment.md)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,12 +0,0 @@
|
||||
# Levante-se e Comece
|
||||
|
||||
## Instruções
|
||||
|
||||
Nesta tarefa não avaliada, você deve revisar Python e configurar seu ambiente para que possa executar notebooks.
|
||||
|
||||
Siga este [Caminho de Aprendizado em Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott) e, em seguida, configure seus sistemas assistindo a estes vídeos introdutórios:
|
||||
|
||||
https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.
|
||||
@ -1,152 +0,0 @@
|
||||
# História do aprendizado de máquina
|
||||
|
||||
|
||||
> Sketchnote por [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/3/)
|
||||
|
||||
---
|
||||
|
||||
[](https://youtu.be/N6wxM4wZ7V0 "ML para iniciantes - História do Aprendizado de Máquina")
|
||||
|
||||
> 🎥 Clique na imagem acima para um vídeo curto que aborda esta lição.
|
||||
|
||||
Nesta lição, vamos explorar os principais marcos na história do aprendizado de máquina e da inteligência artificial.
|
||||
|
||||
A história da inteligência artificial (IA) como um campo está entrelaçada com a história do aprendizado de máquina, uma vez que os algoritmos e os avanços computacionais que sustentam o aprendizado de máquina contribuíram para o desenvolvimento da IA. É útil lembrar que, embora esses campos como áreas distintas de investigação tenham começado a se cristalizar na década de 1950, importantes [descobertas algorítmicas, estatísticas, matemáticas, computacionais e técnicas](https://wikipedia.org/wiki/Timeline_of_machine_learning) precederam e se sobrepuseram a essa era. De fato, as pessoas vêm refletindo sobre essas questões há [centenas de anos](https://wikipedia.org/wiki/History_of_artificial_intelligence): este artigo discute as bases intelectuais históricas da ideia de uma 'máquina pensante'.
|
||||
|
||||
---
|
||||
## Descobertas Notáveis
|
||||
|
||||
- 1763, 1812 [Teorema de Bayes](https://wikipedia.org/wiki/Bayes%27_theorem) e seus predecessores. Este teorema e suas aplicações fundamentam a inferência, descrevendo a probabilidade de um evento ocorrer com base em conhecimento prévio.
|
||||
- 1805 [Teoria dos Mínimos Quadrados](https://wikipedia.org/wiki/Least_squares) pelo matemático francês Adrien-Marie Legendre. Esta teoria, que você aprenderá em nossa unidade de Regressão, ajuda no ajuste de dados.
|
||||
- 1913 [Cadeias de Markov](https://wikipedia.org/wiki/Markov_chain), nomeadas em homenagem ao matemático russo Andrey Markov, são usadas para descrever uma sequência de eventos possíveis com base em um estado anterior.
|
||||
- 1957 [Perceptron](https://wikipedia.org/wiki/Perceptron) é um tipo de classificador linear inventado pelo psicólogo americano Frank Rosenblatt que fundamenta os avanços em aprendizado profundo.
|
||||
|
||||
---
|
||||
|
||||
- 1967 [Vizinho Mais Próximo](https://wikipedia.org/wiki/Nearest_neighbor) é um algoritmo originalmente projetado para mapear rotas. Em um contexto de aprendizado de máquina, é usado para detectar padrões.
|
||||
- 1970 [Retropropagação](https://wikipedia.org/wiki/Backpropagation) é usada para treinar [redes neurais feedforward](https://wikipedia.org/wiki/Feedforward_neural_network).
|
||||
- 1982 [Redes Neurais Recorrentes](https://wikipedia.org/wiki/Recurrent_neural_network) são redes neurais artificiais derivadas de redes neurais feedforward que criam gráficos temporais.
|
||||
|
||||
✅ Faça uma pequena pesquisa. Quais outras datas se destacam como fundamentais na história do aprendizado de máquina e da IA?
|
||||
|
||||
---
|
||||
## 1950: Máquinas que pensam
|
||||
|
||||
Alan Turing, uma pessoa verdadeiramente notável que foi votada [pelo público em 2019](https://wikipedia.org/wiki/Icons:_The_Greatest_Person_of_the_20th_Century) como o maior cientista do século 20, é creditado por ajudar a estabelecer a base para o conceito de uma 'máquina que pode pensar.' Ele enfrentou céticos e sua própria necessidade de evidência empírica desse conceito, em parte, criando o [Teste de Turing](https://www.bbc.com/news/technology-18475646), que você explorará em nossas lições de PLN.
|
||||
|
||||
---
|
||||
## 1956: Projeto de Pesquisa de Verão de Dartmouth
|
||||
|
||||
"O Projeto de Pesquisa de Verão de Dartmouth sobre inteligência artificial foi um evento seminal para a inteligência artificial como um campo," e foi aqui que o termo 'inteligência artificial' foi cunhado ([fonte](https://250.dartmouth.edu/highlights/artificial-intelligence-ai-coined-dartmouth)).
|
||||
|
||||
> Cada aspecto do aprendizado ou qualquer outra característica da inteligência pode, em princípio, ser descrito de forma tão precisa que uma máquina pode ser feita para simular isso.
|
||||
|
||||
---
|
||||
|
||||
O pesquisador principal, o professor de matemática John McCarthy, esperava "prosseguir com base na conjectura de que cada aspecto do aprendizado ou qualquer outra característica da inteligência pode, em princípio, ser descrito de forma tão precisa que uma máquina pode ser feita para simular isso." Os participantes incluíam outro luminar do campo, Marvin Minsky.
|
||||
|
||||
O workshop é creditado por ter iniciado e incentivado várias discussões, incluindo "a ascensão de métodos simbólicos, sistemas focados em domínios limitados (sistemas especialistas iniciais) e sistemas dedutivos versus sistemas indutivos." ([fonte](https://wikipedia.org/wiki/Dartmouth_workshop)).
|
||||
|
||||
---
|
||||
## 1956 - 1974: "Os anos dourados"
|
||||
|
||||
Da década de 1950 até meados da década de 70, o otimismo era alto na esperança de que a IA pudesse resolver muitos problemas. Em 1967, Marvin Minsky afirmou com confiança que "Dentro de uma geração... o problema de criar 'inteligência artificial' será substancialmente resolvido." (Minsky, Marvin (1967), Computation: Finite and Infinite Machines, Englewood Cliffs, N.J.: Prentice-Hall)
|
||||
|
||||
A pesquisa em processamento de linguagem natural floresceu, as buscas foram refinadas e tornadas mais poderosas, e o conceito de 'micro-mundos' foi criado, onde tarefas simples eram completadas usando instruções em linguagem simples.
|
||||
|
||||
---
|
||||
|
||||
A pesquisa foi bem financiada por agências governamentais, avanços foram feitos em computação e algoritmos, e protótipos de máquinas inteligentes foram construídos. Algumas dessas máquinas incluem:
|
||||
|
||||
* [Shakey, o robô](https://wikipedia.org/wiki/Shakey_the_robot), que podia manobrar e decidir como realizar tarefas 'inteligentemente'.
|
||||
|
||||
|
||||
> Shakey em 1972
|
||||
|
||||
---
|
||||
|
||||
* Eliza, um dos primeiros 'chatbots', podia conversar com as pessoas e agir como um 'terapeuta' primitivo. Você aprenderá mais sobre Eliza nas lições de PLN.
|
||||
|
||||
|
||||
> Uma versão de Eliza, um chatbot
|
||||
|
||||
---
|
||||
|
||||
* "Mundo dos blocos" foi um exemplo de um micro-mundo onde blocos podiam ser empilhados e classificados, e experimentos em ensinar máquinas a tomar decisões podiam ser testados. Avanços construídos com bibliotecas como [SHRDLU](https://wikipedia.org/wiki/SHRDLU) ajudaram a impulsionar o processamento de linguagem para frente.
|
||||
|
||||
[](https://www.youtube.com/watch?v=QAJz4YKUwqw "mundo dos blocos com SHRDLU")
|
||||
|
||||
> 🎥 Clique na imagem acima para um vídeo: Mundo dos blocos com SHRDLU
|
||||
|
||||
---
|
||||
## 1974 - 1980: "Inverno da IA"
|
||||
|
||||
Na metade da década de 1970, tornou-se evidente que a complexidade de fazer 'máquinas inteligentes' havia sido subestimada e que sua promessa, dada a potência computacional disponível, havia sido exagerada. O financiamento secou e a confiança no campo diminuiu. Algumas questões que impactaram a confiança incluíram:
|
||||
---
|
||||
- **Limitações**. A potência computacional era muito limitada.
|
||||
- **Explosão combinatória**. A quantidade de parâmetros que precisavam ser treinados cresceu exponencialmente à medida que mais era solicitado dos computadores, sem uma evolução paralela da potência e capacidade computacional.
|
||||
- **Escassez de dados**. Havia uma escassez de dados que dificultou o processo de teste, desenvolvimento e refinamento de algoritmos.
|
||||
- **Estamos fazendo as perguntas certas?**. As próprias perguntas que estavam sendo feitas começaram a ser questionadas. Pesquisadores começaram a enfrentar críticas sobre suas abordagens:
|
||||
- Os testes de Turing foram colocados em questão por meio, entre outras ideias, da 'teoria da sala chinesa', que postulava que "programar um computador digital pode fazê-lo parecer entender a linguagem, mas não poderia produzir uma verdadeira compreensão." ([fonte](https://plato.stanford.edu/entries/chinese-room/))
|
||||
- A ética de introduzir inteligências artificiais como o "terapeuta" ELIZA na sociedade foi desafiada.
|
||||
|
||||
---
|
||||
|
||||
Ao mesmo tempo, várias escolas de pensamento em IA começaram a se formar. Uma dicotomia foi estabelecida entre práticas de ["IA desleixada" vs. "IA organizada"](https://wikipedia.org/wiki/Neats_and_scruffies). _Laboratórios desleixados_ ajustavam programas por horas até obterem os resultados desejados. _Laboratórios organizados_ "focavam em lógica e resolução formal de problemas". ELIZA e SHRDLU eram sistemas _desleixados_ bem conhecidos. Na década de 1980, à medida que surgiu a demanda por tornar os sistemas de aprendizado de máquina reprodutíveis, a abordagem _organizada_ gradualmente tomou a dianteira, pois seus resultados são mais explicáveis.
|
||||
|
||||
---
|
||||
## Sistemas especialistas dos anos 1980
|
||||
|
||||
À medida que o campo crescia, seu benefício para os negócios tornava-se mais claro, e na década de 1980 também houve uma proliferação de 'sistemas especialistas'. "Sistemas especialistas foram uma das primeiras formas verdadeiramente bem-sucedidas de software de inteligência artificial (IA)." ([fonte](https://wikipedia.org/wiki/Expert_system)).
|
||||
|
||||
Esse tipo de sistema é na verdade _híbrido_, consistindo parcialmente de um motor de regras que define requisitos de negócios e um motor de inferência que aproveita o sistema de regras para deduzir novos fatos.
|
||||
|
||||
Essa era também viu um aumento na atenção dada às redes neurais.
|
||||
|
||||
---
|
||||
## 1987 - 1993: 'Resfriamento' da IA
|
||||
|
||||
A proliferação de hardware especializado para sistemas especialistas teve o efeito infeliz de se tornar excessivamente especializado. O surgimento dos computadores pessoais também competiu com esses grandes sistemas centralizados e especializados. A democratização da computação havia começado, e isso eventualmente abriu caminho para a explosão moderna de big data.
|
||||
|
||||
---
|
||||
## 1993 - 2011
|
||||
|
||||
Esta época viu uma nova era para o aprendizado de máquina e a IA serem capazes de resolver alguns dos problemas que haviam sido causados anteriormente pela falta de dados e potência computacional. A quantidade de dados começou a aumentar rapidamente e se tornar mais amplamente disponível, para o melhor e para o pior, especialmente com o advento do smartphone por volta de 2007. A potência computacional expandiu-se exponencialmente, e os algoritmos evoluíram junto com isso. O campo começou a ganhar maturidade à medida que os dias de liberdade do passado começaram a se cristalizar em uma verdadeira disciplina.
|
||||
|
||||
---
|
||||
## Agora
|
||||
|
||||
Hoje, o aprendizado de máquina e a IA tocam quase todas as partes de nossas vidas. Esta era exige uma compreensão cuidadosa dos riscos e dos potenciais efeitos desses algoritmos na vida humana. Como afirmou Brad Smith, da Microsoft, "A tecnologia da informação levanta questões que vão ao cerne das proteções fundamentais dos direitos humanos, como privacidade e liberdade de expressão. Essas questões aumentam a responsabilidade das empresas de tecnologia que criam esses produtos. Em nossa visão, elas também exigem uma regulamentação governamental cuidadosa e o desenvolvimento de normas em torno de usos aceitáveis" ([fonte](https://www.technologyreview.com/2019/12/18/102365/the-future-of-ais-impact-on-society/)).
|
||||
|
||||
---
|
||||
|
||||
Resta saber o que o futuro reserva, mas é importante entender esses sistemas computacionais e o software e os algoritmos que eles executam. Esperamos que este currículo ajude você a obter uma melhor compreensão para que possa decidir por si mesmo.
|
||||
|
||||
[](https://www.youtube.com/watch?v=mTtDfKgLm54 "A história do aprendizado profundo")
|
||||
> 🎥 Clique na imagem acima para um vídeo: Yann LeCun discute a história do aprendizado profundo nesta palestra
|
||||
|
||||
---
|
||||
## 🚀Desafio
|
||||
|
||||
Aprofunde-se em um desses momentos históricos e aprenda mais sobre as pessoas por trás deles. Existem personagens fascinantes, e nenhuma descoberta científica foi criada em um vácuo cultural. O que você descobre?
|
||||
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/4/)
|
||||
|
||||
---
|
||||
## Revisão e Autoestudo
|
||||
|
||||
Aqui estão itens para assistir e ouvir:
|
||||
|
||||
[Este podcast onde Amy Boyd discute a evolução da IA](http://runasradio.com/Shows/Show/739)
|
||||
[](https://www.youtube.com/watch?v=EJt3_bFYKss "A história da IA por Amy Boyd")
|
||||
|
||||
---
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Crie uma linha do tempo](assignment.md)
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que as traduções automáticas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,14 +0,0 @@
|
||||
# Criar uma linha do tempo
|
||||
|
||||
## Instruções
|
||||
|
||||
Usando [este repositório](https://github.com/Digital-Humanities-Toolkit/timeline-builder), crie uma linha do tempo de algum aspecto da história dos algoritmos, matemática, estatística, IA ou ML, ou uma combinação desses. Você pode se concentrar em uma pessoa, uma ideia ou um longo período de pensamento. Certifique-se de adicionar elementos multimídia.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Necessita de Melhoria |
|
||||
| --------- | ------------------------------------------------ | --------------------------------------- | --------------------------------------------------------------- |
|
||||
| | Uma linha do tempo implantada é apresentada como uma página do GitHub | O código está incompleto e não implantado | A linha do tempo está incompleta, mal pesquisada e não implantada |
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,14 +0,0 @@
|
||||
# Explore a Caixa de Ferramentas de IA Responsável
|
||||
|
||||
## Instruções
|
||||
|
||||
Nesta lição, você aprendeu sobre a Caixa de Ferramentas de IA Responsável, um "projeto de código aberto, orientado pela comunidade, para ajudar cientistas de dados a analisar e melhorar sistemas de IA." Para esta tarefa, explore um dos [notebooks](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) da RAI Toolbox e relate suas descobertas em um artigo ou apresentação.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Necessita Melhoria |
|
||||
| --------- | -------- | -------- | ------------------ |
|
||||
| | Um artigo ou apresentação em powerpoint é apresentado discutindo os sistemas do Fairlearn, o notebook que foi executado e as conclusões tiradas da execução | Um artigo é apresentado sem conclusões | Nenhum artigo é apresentado |
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas resultantes do uso desta tradução.
|
||||
@ -1,121 +0,0 @@
|
||||
# Técnicas de Aprendizado de Máquina
|
||||
|
||||
O processo de construir, usar e manter modelos de aprendizado de máquina e os dados que eles utilizam é muito diferente de muitos outros fluxos de trabalho de desenvolvimento. Nesta lição, vamos desmistificar o processo e delinear as principais técnicas que você precisa conhecer. Você irá:
|
||||
|
||||
- Compreender os processos que sustentam o aprendizado de máquina em um nível alto.
|
||||
- Explorar conceitos básicos como 'modelos', 'previsões' e 'dados de treinamento'.
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/7/)
|
||||
|
||||
[](https://youtu.be/4NGM0U2ZSHU "ML para iniciantes - Técnicas de Aprendizado de Máquina")
|
||||
|
||||
> 🎥 Clique na imagem acima para um vídeo curto que aborda esta lição.
|
||||
|
||||
## Introdução
|
||||
|
||||
Em um nível alto, a arte de criar processos de aprendizado de máquina (ML) é composta por uma série de etapas:
|
||||
|
||||
1. **Decida a questão**. A maioria dos processos de ML começa fazendo uma pergunta que não pode ser respondida por um simples programa condicional ou motor baseado em regras. Essas perguntas geralmente giram em torno de previsões baseadas em uma coleção de dados.
|
||||
2. **Coletar e preparar dados**. Para poder responder à sua pergunta, você precisa de dados. A qualidade e, às vezes, a quantidade dos seus dados determinarão o quão bem você pode responder à sua pergunta inicial. Visualizar dados é um aspecto importante desta fase. Esta fase também inclui dividir os dados em um grupo de treinamento e um grupo de teste para construir um modelo.
|
||||
3. **Escolher um método de treinamento**. Dependendo da sua pergunta e da natureza dos seus dados, você precisa escolher como deseja treinar um modelo para refletir melhor seus dados e fazer previsões precisas. Esta é a parte do seu processo de ML que requer expertise específica e, frequentemente, uma quantidade considerável de experimentação.
|
||||
4. **Treinar o modelo**. Usando seus dados de treinamento, você usará vários algoritmos para treinar um modelo para reconhecer padrões nos dados. O modelo pode aproveitar pesos internos que podem ser ajustados para privilegiar certas partes dos dados em detrimento de outras para construir um modelo melhor.
|
||||
5. **Avaliar o modelo**. Você usa dados que nunca foram vistos antes (seus dados de teste) do conjunto coletado para ver como o modelo está se saindo.
|
||||
6. **Ajuste de parâmetros**. Com base no desempenho do seu modelo, você pode refazer o processo usando diferentes parâmetros ou variáveis que controlam o comportamento dos algoritmos usados para treinar o modelo.
|
||||
7. **Prever**. Use novas entradas para testar a precisão do seu modelo.
|
||||
|
||||
## Que pergunta fazer
|
||||
|
||||
Os computadores são particularmente habilidosos em descobrir padrões ocultos nos dados. Essa utilidade é muito útil para pesquisadores que têm perguntas sobre um determinado domínio que não podem ser facilmente respondidas criando um motor de regras baseado em condições. Dado uma tarefa atuarial, por exemplo, um cientista de dados pode ser capaz de construir regras personalizadas sobre a mortalidade de fumantes versus não fumantes.
|
||||
|
||||
Quando muitas outras variáveis são trazidas à equação, no entanto, um modelo de ML pode se mostrar mais eficiente para prever taxas de mortalidade futuras com base em históricos de saúde passados. Um exemplo mais otimista pode ser fazer previsões meteorológicas para o mês de abril em uma determinada localização com base em dados que incluem latitude, longitude, mudanças climáticas, proximidade ao oceano, padrões da corrente de jato e mais.
|
||||
|
||||
✅ Este [conjunto de slides](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) sobre modelos climáticos oferece uma perspectiva histórica sobre o uso de ML na análise do tempo.
|
||||
|
||||
## Tarefas pré-construção
|
||||
|
||||
Antes de começar a construir seu modelo, há várias tarefas que você precisa concluir. Para testar sua pergunta e formar uma hipótese com base nas previsões de um modelo, você precisa identificar e configurar vários elementos.
|
||||
|
||||
### Dados
|
||||
|
||||
Para poder responder à sua pergunta com qualquer tipo de certeza, você precisa de uma boa quantidade de dados do tipo certo. Existem duas coisas que você precisa fazer neste momento:
|
||||
|
||||
- **Coletar dados**. Tendo em mente a lição anterior sobre justiça na análise de dados, colete seus dados com cuidado. Esteja ciente das fontes desses dados, quaisquer preconceitos inerentes que eles possam ter e documente sua origem.
|
||||
- **Preparar dados**. Existem várias etapas no processo de preparação de dados. Você pode precisar compilar dados e normalizá-los se eles vierem de fontes diversas. Você pode melhorar a qualidade e a quantidade dos dados por meio de vários métodos, como converter strings em números (como fazemos em [Agrupamento](../../5-Clustering/1-Visualize/README.md)). Você também pode gerar novos dados, com base nos originais (como fazemos em [Classificação](../../4-Classification/1-Introduction/README.md)). Você pode limpar e editar os dados (como faremos antes da lição sobre [Web App](../../3-Web-App/README.md)). Finalmente, você também pode precisar randomizá-los e embaralhá-los, dependendo das suas técnicas de treinamento.
|
||||
|
||||
✅ Após coletar e processar seus dados, reserve um momento para ver se sua forma permitirá que você aborde sua pergunta pretendida. Pode ser que os dados não se desempenhem bem na sua tarefa específica, como descobrimos em nossas lições de [Agrupamento](../../5-Clustering/1-Visualize/README.md)!
|
||||
|
||||
### Recursos e Alvo
|
||||
|
||||
Um [recurso](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) é uma propriedade mensurável dos seus dados. Em muitos conjuntos de dados, ele é expresso como um cabeçalho de coluna como 'data', 'tamanho' ou 'cor'. Sua variável de recurso, geralmente representada como `X` no código, representa a variável de entrada que será usada para treinar o modelo.
|
||||
|
||||
Um alvo é uma coisa que você está tentando prever. O alvo é geralmente representado como `y` no código e representa a resposta à pergunta que você está tentando fazer aos seus dados: em dezembro, qual **cor** de abóboras será a mais barata? em San Francisco, quais bairros terão o melhor **preço** imobiliário? Às vezes, o alvo também é referido como atributo de rótulo.
|
||||
|
||||
### Selecionando sua variável de recurso
|
||||
|
||||
🎓 **Seleção de Recursos e Extração de Recursos** Como você sabe qual variável escolher ao construir um modelo? Você provavelmente passará por um processo de seleção de recursos ou extração de recursos para escolher as variáveis certas para o modelo mais performático. No entanto, eles não são a mesma coisa: "A extração de recursos cria novos recursos a partir de funções dos recursos originais, enquanto a seleção de recursos retorna um subconjunto dos recursos." ([fonte](https://wikipedia.org/wiki/Feature_selection))
|
||||
|
||||
### Visualize seus dados
|
||||
|
||||
Um aspecto importante do conjunto de ferramentas do cientista de dados é o poder de visualizar dados usando várias bibliotecas excelentes, como Seaborn ou MatPlotLib. Representar seus dados visualmente pode permitir que você descubra correlações ocultas que pode aproveitar. Suas visualizações também podem ajudá-lo a descobrir preconceitos ou dados desequilibrados (como descobrimos em [Classificação](../../4-Classification/2-Classifiers-1/README.md)).
|
||||
|
||||
### Divida seu conjunto de dados
|
||||
|
||||
Antes de treinar, você precisa dividir seu conjunto de dados em duas ou mais partes de tamanhos desiguais que ainda representem bem os dados.
|
||||
|
||||
- **Treinamento**. Esta parte do conjunto de dados é ajustada ao seu modelo para treiná-lo. Este conjunto constitui a maioria do conjunto de dados original.
|
||||
- **Teste**. Um conjunto de dados de teste é um grupo independente de dados, frequentemente coletado a partir dos dados originais, que você usa para confirmar o desempenho do modelo construído.
|
||||
- **Validação**. Um conjunto de validação é um grupo independente menor de exemplos que você usa para ajustar os hiperparâmetros ou a arquitetura do modelo, para melhorar o modelo. Dependendo do tamanho dos seus dados e da pergunta que você está fazendo, pode ser que você não precise construir este terceiro conjunto (como notamos em [Previsão de Séries Temporais](../../7-TimeSeries/1-Introduction/README.md)).
|
||||
|
||||
## Construindo um modelo
|
||||
|
||||
Usando seus dados de treinamento, seu objetivo é construir um modelo, ou uma representação estatística dos seus dados, usando vários algoritmos para **treiná-lo**. Treinar um modelo expõe-o a dados e permite que ele faça suposições sobre padrões percebidos que descobre, valida e aceita ou rejeita.
|
||||
|
||||
### Decida um método de treinamento
|
||||
|
||||
Dependendo da sua pergunta e da natureza dos seus dados, você escolherá um método para treiná-lo. Passando pela [documentação do Scikit-learn](https://scikit-learn.org/stable/user_guide.html) - que usamos neste curso - você pode explorar várias maneiras de treinar um modelo. Dependendo da sua experiência, pode ser que você tenha que tentar vários métodos diferentes para construir o melhor modelo. Você provavelmente passará por um processo em que os cientistas de dados avaliam o desempenho de um modelo alimentando-o com dados não vistos, verificando precisão, preconceitos e outros problemas que degradam a qualidade, e selecionando o método de treinamento mais apropriado para a tarefa em questão.
|
||||
|
||||
### Treinar um modelo
|
||||
|
||||
Armado com seus dados de treinamento, você está pronto para 'ajustá-lo' para criar um modelo. Você notará que em muitas bibliotecas de ML encontrará o código 'model.fit' - é neste momento que você envia sua variável de recurso como um array de valores (geralmente 'X') e uma variável alvo (geralmente 'y').
|
||||
|
||||
### Avaliar o modelo
|
||||
|
||||
Uma vez que o processo de treinamento esteja completo (pode levar muitas iterações, ou 'épocas', para treinar um grande modelo), você poderá avaliar a qualidade do modelo usando dados de teste para medir seu desempenho. Esses dados são um subconjunto dos dados originais que o modelo não analisou anteriormente. Você pode imprimir uma tabela de métricas sobre a qualidade do seu modelo.
|
||||
|
||||
🎓 **Ajuste de modelo**
|
||||
|
||||
No contexto de aprendizado de máquina, o ajuste de modelo refere-se à precisão da função subjacente do modelo enquanto ele tenta analisar dados com os quais não está familiarizado.
|
||||
|
||||
🎓 **Subajuste** e **sobreajuste** são problemas comuns que degradam a qualidade do modelo, pois o modelo se ajusta de forma inadequada ou excessiva. Isso faz com que o modelo faça previsões que estão muito alinhadas ou muito soltas em relação aos seus dados de treinamento. Um modelo sobreajustado prevê os dados de treinamento muito bem porque aprendeu os detalhes e o ruído dos dados muito bem. Um modelo subajustado não é preciso, pois não consegue analisar com precisão seus dados de treinamento nem dados que ainda não 'viu'.
|
||||
|
||||
|
||||
> Infográfico por [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
## Ajuste de parâmetros
|
||||
|
||||
Uma vez que seu treinamento inicial esteja completo, observe a qualidade do modelo e considere melhorá-lo ajustando seus 'hiperparâmetros'. Leia mais sobre o processo [na documentação](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
|
||||
|
||||
## Previsão
|
||||
|
||||
Este é o momento em que você pode usar dados completamente novos para testar a precisão do seu modelo. Em um ambiente de ML 'aplicado', onde você está construindo ativos da web para usar o modelo em produção, esse processo pode envolver a coleta de entrada do usuário (um pressionamento de botão, por exemplo) para definir uma variável e enviá-la ao modelo para inferência ou avaliação.
|
||||
|
||||
Nestes módulos, você descobrirá como usar essas etapas para preparar, construir, testar, avaliar e prever - todos os gestos de um cientista de dados e mais, à medida que avança em sua jornada para se tornar um engenheiro de ML 'full stack'.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
Desenhe um fluxograma refletindo as etapas de um praticante de ML. Onde você se vê agora no processo? Onde você prevê que encontrará dificuldades? O que parece fácil para você?
|
||||
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/8/)
|
||||
|
||||
## Revisão & Autoestudo
|
||||
|
||||
Pesquise online por entrevistas com cientistas de dados que discutem seu trabalho diário. Aqui está [uma](https://www.youtube.com/watch?v=Z3IjgbbCEfs).
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Entrevistar um cientista de dados](assignment.md)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações erradas decorrentes do uso desta tradução.
|
||||
@ -1,14 +0,0 @@
|
||||
# Entrevista com um cientista de dados
|
||||
|
||||
## Instruções
|
||||
|
||||
Na sua empresa, em um grupo de usuários, ou entre seus amigos ou colegas de classe, converse com alguém que trabalha profissionalmente como cientista de dados. Escreva um breve artigo (500 palavras) sobre suas ocupações diárias. Eles são especialistas ou trabalham 'full stack'?
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Necessita Melhoria |
|
||||
| --------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------ | ---------------------- |
|
||||
| | Um ensaio com o comprimento correto, com fontes atribuídas, é apresentado como um arquivo .doc | O ensaio está mal atribuído ou é mais curto do que o comprimento exigido | Nenhum ensaio é apresentado |
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,26 +0,0 @@
|
||||
# Introdução ao aprendizado de máquina
|
||||
|
||||
Nesta seção do currículo, você será apresentado aos conceitos básicos que fundamentam o campo do aprendizado de máquina, o que é e aprenderá sobre sua história e as técnicas que os pesquisadores usam para trabalhar com isso. Vamos explorar juntos este novo mundo de ML!
|
||||
|
||||
|
||||
> Foto de <a href="https://unsplash.com/@bill_oxford?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Bill Oxford</a> em <a href="https://unsplash.com/s/photos/globe?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
### Aulas
|
||||
|
||||
1. [Introdução ao aprendizado de máquina](1-intro-to-ML/README.md)
|
||||
1. [A História do aprendizado de máquina e da IA](2-history-of-ML/README.md)
|
||||
1. [Justiça e aprendizado de máquina](3-fairness/README.md)
|
||||
1. [Técnicas de aprendizado de máquina](4-techniques-of-ML/README.md)
|
||||
|
||||
### Créditos
|
||||
|
||||
"Introdução ao Aprendizado de Máquina" foi escrito com ♥️ por uma equipe de pessoas, incluindo [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan), [Ornella Altunyan](https://twitter.com/ornelladotcom) e [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
"A História do Aprendizado de Máquina" foi escrito com ♥️ por [Jen Looper](https://twitter.com/jenlooper) e [Amy Boyd](https://twitter.com/AmyKateNicho)
|
||||
|
||||
"Justiça e Aprendizado de Máquina" foi escrito com ♥️ por [Tomomi Imura](https://twitter.com/girliemac)
|
||||
|
||||
"Técnicas de Aprendizado de Máquina" foi escrito com ♥️ por [Jen Looper](https://twitter.com/jenlooper) e [Chris Noring](https://twitter.com/softchris)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,228 +0,0 @@
|
||||
# Comece com Python e Scikit-learn para modelos de regressão
|
||||
|
||||
|
||||
|
||||
> Sketchnote por [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/9/)
|
||||
|
||||
> ### [Esta lição está disponível em R!](../../../../2-Regression/1-Tools/solution/R/lesson_1.html)
|
||||
|
||||
## Introdução
|
||||
|
||||
Nestes quatro módulos, você vai descobrir como construir modelos de regressão. Vamos discutir brevemente para que servem. Mas antes de fazer qualquer coisa, certifique-se de que você tem as ferramentas certas para iniciar o processo!
|
||||
|
||||
Nesta lição, você aprenderá a:
|
||||
|
||||
- Configurar seu computador para tarefas de aprendizado de máquina local.
|
||||
- Trabalhar com notebooks Jupyter.
|
||||
- Usar Scikit-learn, incluindo instalação.
|
||||
- Explorar a regressão linear com um exercício prático.
|
||||
|
||||
## Instalações e configurações
|
||||
|
||||
[](https://youtu.be/-DfeD2k2Kj0 "ML para iniciantes - Configure suas ferramentas para construir modelos de Machine Learning")
|
||||
|
||||
> 🎥 Clique na imagem acima para um vídeo curto mostrando como configurar seu computador para ML.
|
||||
|
||||
1. **Instale o Python**. Certifique-se de que o [Python](https://www.python.org/downloads/) está instalado em seu computador. Você usará o Python para muitas tarefas de ciência de dados e aprendizado de máquina. A maioria dos sistemas já inclui uma instalação do Python. Existem também [Pacotes de Codificação Python](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) úteis disponíveis para facilitar a configuração para alguns usuários.
|
||||
|
||||
Alguns usos do Python, no entanto, exigem uma versão do software, enquanto outros exigem uma versão diferente. Por essa razão, é útil trabalhar dentro de um [ambiente virtual](https://docs.python.org/3/library/venv.html).
|
||||
|
||||
2. **Instale o Visual Studio Code**. Certifique-se de que você tem o Visual Studio Code instalado em seu computador. Siga estas instruções para [instalar o Visual Studio Code](https://code.visualstudio.com/) para a instalação básica. Você vai usar Python no Visual Studio Code neste curso, então pode querer revisar como [configurar o Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) para desenvolvimento em Python.
|
||||
|
||||
> Familiarize-se com Python trabalhando nesta coleção de [módulos de aprendizado](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott)
|
||||
>
|
||||
> [](https://youtu.be/yyQM70vi7V8 "Configurar Python com Visual Studio Code")
|
||||
>
|
||||
> 🎥 Clique na imagem acima para um vídeo: usando Python no VS Code.
|
||||
|
||||
3. **Instale o Scikit-learn**, seguindo [estas instruções](https://scikit-learn.org/stable/install.html). Como você precisa garantir que está usando Python 3, é recomendado que você use um ambiente virtual. Observe que, se você estiver instalando esta biblioteca em um Mac M1, há instruções especiais na página vinculada acima.
|
||||
|
||||
4. **Instale o Jupyter Notebook**. Você precisará [instalar o pacote Jupyter](https://pypi.org/project/jupyter/).
|
||||
|
||||
## Seu ambiente de autoria em ML
|
||||
|
||||
Você vai usar **notebooks** para desenvolver seu código Python e criar modelos de aprendizado de máquina. Este tipo de arquivo é uma ferramenta comum para cientistas de dados, e pode ser identificado por seu sufixo ou extensão `.ipynb`.
|
||||
|
||||
Os notebooks são um ambiente interativo que permite ao desenvolvedor codificar, adicionar notas e escrever documentação em torno do código, o que é bastante útil para projetos experimentais ou orientados à pesquisa.
|
||||
|
||||
[](https://youtu.be/7E-jC8FLA2E "ML para iniciantes - Configure Jupyter Notebooks para começar a construir modelos de regressão")
|
||||
|
||||
> 🎥 Clique na imagem acima para um vídeo curto mostrando este exercício.
|
||||
|
||||
### Exercício - trabalhar com um notebook
|
||||
|
||||
Nesta pasta, você encontrará o arquivo _notebook.ipynb_.
|
||||
|
||||
1. Abra _notebook.ipynb_ no Visual Studio Code.
|
||||
|
||||
Um servidor Jupyter será iniciado com Python 3+. Você encontrará áreas do notebook que podem ser `run`, pedaços de código. Você pode executar um bloco de código selecionando o ícone que parece um botão de play.
|
||||
|
||||
2. Selecione o ícone `md` e adicione um pouco de markdown, e o seguinte texto **# Bem-vindo ao seu notebook**.
|
||||
|
||||
Em seguida, adicione algum código Python.
|
||||
|
||||
3. Digite **print('hello notebook')** no bloco de código.
|
||||
4. Selecione a seta para executar o código.
|
||||
|
||||
Você deve ver a declaração impressa:
|
||||
|
||||
```output
|
||||
hello notebook
|
||||
```
|
||||
|
||||
|
||||
|
||||
Você pode intercalar seu código com comentários para auto-documentar o notebook.
|
||||
|
||||
✅ Pense por um minuto sobre como o ambiente de trabalho de um desenvolvedor web é diferente do de um cientista de dados.
|
||||
|
||||
## Pronto para usar o Scikit-learn
|
||||
|
||||
Agora que o Python está configurado em seu ambiente local e você está confortável com notebooks Jupyter, vamos nos familiarizar também com o Scikit-learn (pronuncie como `sci` as in `science`). O Scikit-learn fornece uma [API extensa](https://scikit-learn.org/stable/modules/classes.html#api-ref) para ajudá-lo a realizar tarefas de ML.
|
||||
|
||||
De acordo com seu [site](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn é uma biblioteca de aprendizado de máquina de código aberto que suporta aprendizado supervisionado e não supervisionado. Também fornece várias ferramentas para ajuste de modelos, pré-processamento de dados, seleção e avaliação de modelos, e muitas outras utilidades."
|
||||
|
||||
Neste curso, você usará o Scikit-learn e outras ferramentas para construir modelos de aprendizado de máquina para realizar o que chamamos de tarefas de 'aprendizado de máquina tradicional'. Evitamos deliberadamente redes neurais e aprendizado profundo, pois eles são melhor abordados em nosso futuro currículo 'IA para Iniciantes'.
|
||||
|
||||
O Scikit-learn torna fácil construir modelos e avaliá-los para uso. Ele é principalmente focado no uso de dados numéricos e contém vários conjuntos de dados prontos para uso como ferramentas de aprendizado. Também inclui modelos pré-construídos para os alunos experimentarem. Vamos explorar o processo de carregar dados pré-embalados e usar um estimador embutido para o primeiro modelo de ML com Scikit-learn com alguns dados básicos.
|
||||
|
||||
## Exercício - seu primeiro notebook Scikit-learn
|
||||
|
||||
> Este tutorial foi inspirado no [exemplo de regressão linear](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) no site do Scikit-learn.
|
||||
|
||||
[](https://youtu.be/2xkXL5EUpS0 "ML para iniciantes - Seu Primeiro Projeto de Regressão Linear em Python")
|
||||
|
||||
> 🎥 Clique na imagem acima para um vídeo curto mostrando este exercício.
|
||||
|
||||
No arquivo _notebook.ipynb_ associado a esta lição, limpe todas as células pressionando o ícone 'lixeira'.
|
||||
|
||||
Nesta seção, você trabalhará com um pequeno conjunto de dados sobre diabetes que está embutido no Scikit-learn para fins de aprendizado. Imagine que você deseja testar um tratamento para pacientes diabéticos. Modelos de Aprendizado de Máquina podem ajudá-lo a determinar quais pacientes responderiam melhor ao tratamento, com base em combinações de variáveis. Mesmo um modelo de regressão muito básico, quando visualizado, pode mostrar informações sobre variáveis que ajudariam a organizar seus ensaios clínicos teóricos.
|
||||
|
||||
✅ Existem muitos tipos de métodos de regressão, e qual você escolher depende da resposta que está buscando. Se você deseja prever a altura provável de uma pessoa de uma determinada idade, usaria regressão linear, já que está buscando um **valor numérico**. Se você está interessado em descobrir se um tipo de cozinha deve ser considerado vegano ou não, você está buscando uma **atribuição de categoria**, então usaria regressão logística. Você aprenderá mais sobre regressão logística mais adiante. Pense um pouco sobre algumas perguntas que você pode fazer aos dados e qual desses métodos seria mais apropriado.
|
||||
|
||||
Vamos começar esta tarefa.
|
||||
|
||||
### Importar bibliotecas
|
||||
|
||||
Para esta tarefa, importaremos algumas bibliotecas:
|
||||
|
||||
- **matplotlib**. É uma [ferramenta de gráficos](https://matplotlib.org/) útil e a usaremos para criar um gráfico de linha.
|
||||
- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) é uma biblioteca útil para manipular dados numéricos em Python.
|
||||
- **sklearn**. Esta é a biblioteca [Scikit-learn](https://scikit-learn.org/stable/user_guide.html).
|
||||
|
||||
Importe algumas bibliotecas para ajudar com suas tarefas.
|
||||
|
||||
1. Adicione as importações digitando o seguinte código:
|
||||
|
||||
```python
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
from sklearn import datasets, linear_model, model_selection
|
||||
```
|
||||
|
||||
Acima, você está importando `matplotlib`, `numpy` and you are importing `datasets`, `linear_model` and `model_selection` from `sklearn`. `model_selection` is used for splitting data into training and test sets.
|
||||
|
||||
### The diabetes dataset
|
||||
|
||||
The built-in [diabetes dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) includes 442 samples of data around diabetes, with 10 feature variables, some of which include:
|
||||
|
||||
- age: age in years
|
||||
- bmi: body mass index
|
||||
- bp: average blood pressure
|
||||
- s1 tc: T-Cells (a type of white blood cells)
|
||||
|
||||
✅ This dataset includes the concept of 'sex' as a feature variable important to research around diabetes. Many medical datasets include this type of binary classification. Think a bit about how categorizations such as this might exclude certain parts of a population from treatments.
|
||||
|
||||
Now, load up the X and y data.
|
||||
|
||||
> 🎓 Remember, this is supervised learning, and we need a named 'y' target.
|
||||
|
||||
In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The input `return_X_y=True` signals that `X` will be a data matrix, and `y` será o alvo da regressão.
|
||||
|
||||
2. Adicione alguns comandos de impressão para mostrar a forma da matriz de dados e seu primeiro elemento:
|
||||
|
||||
```python
|
||||
X, y = datasets.load_diabetes(return_X_y=True)
|
||||
print(X.shape)
|
||||
print(X[0])
|
||||
```
|
||||
|
||||
O que você está recebendo como resposta é uma tupla. O que você está fazendo é atribuir os dois primeiros valores da tupla a `X` and `y` respectivamente. Aprenda mais [sobre tuplas](https://wikipedia.org/wiki/Tuple).
|
||||
|
||||
Você pode ver que esses dados têm 442 itens moldados em arrays de 10 elementos:
|
||||
|
||||
```text
|
||||
(442, 10)
|
||||
[ 0.03807591 0.05068012 0.06169621 0.02187235 -0.0442235 -0.03482076
|
||||
-0.04340085 -0.00259226 0.01990842 -0.01764613]
|
||||
```
|
||||
|
||||
✅ Pense um pouco sobre a relação entre os dados e o alvo da regressão. A regressão linear prevê relações entre a característica X e a variável alvo y. Você consegue encontrar o [alvo](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) para o conjunto de dados de diabetes na documentação? O que este conjunto de dados está demonstrando, dado aquele alvo?
|
||||
|
||||
3. Em seguida, selecione uma parte deste conjunto de dados para plotar selecionando a 3ª coluna do conjunto de dados. Você pode fazer isso usando `:` operator to select all rows, and then selecting the 3rd column using the index (2). You can also reshape the data to be a 2D array - as required for plotting - by using `reshape(n_rows, n_columns)`. Se um dos parâmetros for -1, a dimensão correspondente é calculada automaticamente.
|
||||
|
||||
```python
|
||||
X = X[:, 2]
|
||||
X = X.reshape((-1,1))
|
||||
```
|
||||
|
||||
✅ A qualquer momento, imprima os dados para verificar sua forma.
|
||||
|
||||
4. Agora que você tem os dados prontos para serem plotados, você pode ver se uma máquina pode ajudar a determinar uma divisão lógica entre os números neste conjunto de dados. Para fazer isso, você precisa dividir tanto os dados (X) quanto o alvo (y) em conjuntos de teste e treinamento. O Scikit-learn tem uma maneira simples de fazer isso; você pode dividir seus dados de teste em um determinado ponto.
|
||||
|
||||
```python
|
||||
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
|
||||
```
|
||||
|
||||
5. Agora você está pronto para treinar seu modelo! Carregue o modelo de regressão linear e treine-o com seus conjuntos de treinamento X e y usando `model.fit()`:
|
||||
|
||||
```python
|
||||
model = linear_model.LinearRegression()
|
||||
model.fit(X_train, y_train)
|
||||
```
|
||||
|
||||
✅ `model.fit()` is a function you'll see in many ML libraries such as TensorFlow
|
||||
|
||||
5. Then, create a prediction using test data, using the function `predict()`. Isso será usado para traçar a linha entre os grupos de dados
|
||||
|
||||
```python
|
||||
y_pred = model.predict(X_test)
|
||||
```
|
||||
|
||||
6. Agora é hora de mostrar os dados em um gráfico. O Matplotlib é uma ferramenta muito útil para essa tarefa. Crie um gráfico de dispersão de todos os dados de teste X e y, e use a previsão para traçar uma linha no lugar mais apropriado, entre as agrupamentos de dados do modelo.
|
||||
|
||||
```python
|
||||
plt.scatter(X_test, y_test, color='black')
|
||||
plt.plot(X_test, y_pred, color='blue', linewidth=3)
|
||||
plt.xlabel('Scaled BMIs')
|
||||
plt.ylabel('Disease Progression')
|
||||
plt.title('A Graph Plot Showing Diabetes Progression Against BMI')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
✅ Pense um pouco sobre o que está acontecendo aqui. Uma linha reta está passando por muitos pequenos pontos de dados, mas o que ela está fazendo exatamente? Você consegue ver como deve ser capaz de usar essa linha para prever onde um novo ponto de dado não visto deve se encaixar em relação ao eixo y do gráfico? Tente colocar em palavras o uso prático deste modelo.
|
||||
|
||||
Parabéns, você construiu seu primeiro modelo de regressão linear, criou uma previsão com ele e o exibiu em um gráfico!
|
||||
|
||||
---
|
||||
## 🚀Desafio
|
||||
|
||||
Plote uma variável diferente deste conjunto de dados. Dica: edite esta linha: `X = X[:,2]`. Dado o alvo deste conjunto de dados, o que você é capaz de descobrir sobre a progressão do diabetes como doença?
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/10/)
|
||||
|
||||
## Revisão & Autoestudo
|
||||
|
||||
Neste tutorial, você trabalhou com regressão linear simples, em vez de regressão linear univariada ou múltipla. Leia um pouco sobre as diferenças entre esses métodos, ou dê uma olhada [neste vídeo](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef).
|
||||
|
||||
Leia mais sobre o conceito de regressão e pense sobre quais tipos de perguntas podem ser respondidas por essa técnica. Faça este [tutorial](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) para aprofundar sua compreensão.
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Um conjunto de dados diferente](assignment.md)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas resultantes do uso desta tradução.
|
||||
@ -1,16 +0,0 @@
|
||||
# Regressão com Scikit-learn
|
||||
|
||||
## Instruções
|
||||
|
||||
Dê uma olhada no [conjunto de dados Linnerud](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_linnerud.html#sklearn.datasets.load_linnerud) no Scikit-learn. Este conjunto de dados possui múltiplos [alvos](https://scikit-learn.org/stable/datasets/toy_dataset.html#linnerrud-dataset): 'Consiste em três variáveis de exercício (dados) e três variáveis fisiológicas (alvo) coletadas de vinte homens de meia-idade em um clube de fitness'.
|
||||
|
||||
Com suas próprias palavras, descreva como criar um modelo de regressão que plotaria a relação entre a circunferência da cintura e quantas flexões são realizadas. Faça o mesmo para os outros pontos de dados neste conjunto.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critério | Exemplar | Adequado | Necessita Melhoria |
|
||||
| ------------------------------ | ----------------------------------- | ----------------------------- | -------------------------- |
|
||||
| Enviar um parágrafo descritivo | Parágrafo bem escrito é enviado | Algumas frases são enviadas | Nenhuma descrição é fornecida |
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
Este é um espaço reservado temporário. Por favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
Este é um espaço reservado temporário.
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,215 +0,0 @@
|
||||
# Construa um modelo de regressão usando Scikit-learn: prepare e visualize os dados
|
||||
|
||||
|
||||
|
||||
Infográfico por [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/11/)
|
||||
|
||||
> ### [Esta lição está disponível em R!](../../../../2-Regression/2-Data/solution/R/lesson_2.html)
|
||||
|
||||
## Introdução
|
||||
|
||||
Agora que você está equipado com as ferramentas necessárias para começar a enfrentar a construção de modelos de aprendizado de máquina com Scikit-learn, você está pronto para começar a fazer perguntas sobre seus dados. Ao trabalhar com dados e aplicar soluções de ML, é muito importante entender como fazer a pergunta certa para desbloquear adequadamente os potenciais do seu conjunto de dados.
|
||||
|
||||
Nesta lição, você aprenderá:
|
||||
|
||||
- Como preparar seus dados para a construção do modelo.
|
||||
- Como usar o Matplotlib para visualização de dados.
|
||||
|
||||
## Fazendo a pergunta certa sobre seus dados
|
||||
|
||||
A pergunta que você precisa responder determinará quais tipos de algoritmos de ML você irá utilizar. E a qualidade da resposta que você obtém dependerá fortemente da natureza dos seus dados.
|
||||
|
||||
Dê uma olhada nos [dados](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) fornecidos para esta lição. Você pode abrir este arquivo .csv no VS Code. Uma rápida olhada imediatamente mostra que há campos em branco e uma mistura de strings e dados numéricos. Também há uma coluna estranha chamada 'Package' onde os dados são uma mistura de 'sacos', 'caixas' e outros valores. Os dados, na verdade, estão um pouco bagunçados.
|
||||
|
||||
[](https://youtu.be/5qGjczWTrDQ "ML para iniciantes - Como Analisar e Limpar um Conjunto de Dados")
|
||||
|
||||
> 🎥 Clique na imagem acima para um vídeo curto que mostra como preparar os dados para esta lição.
|
||||
|
||||
Na verdade, não é muito comum receber um conjunto de dados que esteja completamente pronto para ser usado na criação de um modelo de ML. Nesta lição, você aprenderá como preparar um conjunto de dados bruto usando bibliotecas padrão do Python. Você também aprenderá várias técnicas para visualizar os dados.
|
||||
|
||||
## Estudo de caso: 'o mercado de abóboras'
|
||||
|
||||
Nesta pasta, você encontrará um arquivo .csv na pasta raiz `data` chamado [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv), que inclui 1757 linhas de dados sobre o mercado de abóboras, organizados em grupos por cidade. Estes são dados brutos extraídos dos [Relatórios Padrão dos Mercados de Produtos Especiais](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuídos pelo Departamento de Agricultura dos Estados Unidos.
|
||||
|
||||
### Preparando os dados
|
||||
|
||||
Esses dados estão no domínio público. Eles podem ser baixados em muitos arquivos separados, por cidade, no site do USDA. Para evitar muitos arquivos separados, nós concatenamos todos os dados das cidades em uma única planilha, assim já _preparamos_ os dados um pouco. A seguir, vamos dar uma olhada mais de perto nos dados.
|
||||
|
||||
### Os dados das abóboras - conclusões iniciais
|
||||
|
||||
O que você nota sobre esses dados? Você já viu que há uma mistura de strings, números, campos em branco e valores estranhos que você precisa entender.
|
||||
|
||||
Que pergunta você pode fazer sobre esses dados, usando uma técnica de Regressão? Que tal "Prever o preço de uma abóbora à venda durante um determinado mês". Olhando novamente para os dados, há algumas mudanças que você precisa fazer para criar a estrutura de dados necessária para a tarefa.
|
||||
|
||||
## Exercício - analisar os dados das abóboras
|
||||
|
||||
Vamos usar [Pandas](https://pandas.pydata.org/), (o nome se refere a `Python Data Analysis`) uma ferramenta muito útil para moldar dados, para analisar e preparar esses dados de abóbora.
|
||||
|
||||
### Primeiro, verifique as datas ausentes
|
||||
|
||||
Você precisará primeiro tomar medidas para verificar as datas ausentes:
|
||||
|
||||
1. Converta as datas para um formato de mês (essas são datas dos EUA, então o formato é `MM/DD/YYYY`).
|
||||
2. Extraia o mês para uma nova coluna.
|
||||
|
||||
Abra o arquivo _notebook.ipynb_ no Visual Studio Code e importe a planilha para um novo dataframe do Pandas.
|
||||
|
||||
1. Use a função `head()` para visualizar as cinco primeiras linhas.
|
||||
|
||||
```python
|
||||
import pandas as pd
|
||||
pumpkins = pd.read_csv('../data/US-pumpkins.csv')
|
||||
pumpkins.head()
|
||||
```
|
||||
|
||||
✅ Que função você usaria para visualizar as últimas cinco linhas?
|
||||
|
||||
1. Verifique se há dados ausentes no dataframe atual:
|
||||
|
||||
```python
|
||||
pumpkins.isnull().sum()
|
||||
```
|
||||
|
||||
Há dados ausentes, mas talvez isso não importe para a tarefa em questão.
|
||||
|
||||
1. Para tornar seu dataframe mais fácil de trabalhar, selecione apenas as colunas que você precisa, usando `loc` function which extracts from the original dataframe a group of rows (passed as first parameter) and columns (passed as second parameter). The expression `:` no caso abaixo significa "todas as linhas".
|
||||
|
||||
```python
|
||||
columns_to_select = ['Package', 'Low Price', 'High Price', 'Date']
|
||||
pumpkins = pumpkins.loc[:, columns_to_select]
|
||||
```
|
||||
|
||||
### Segundo, determine o preço médio da abóbora
|
||||
|
||||
Pense em como determinar o preço médio de uma abóbora em um determinado mês. Quais colunas você escolheria para essa tarefa? Dica: você precisará de 3 colunas.
|
||||
|
||||
Solução: tire a média das colunas `Low Price` and `High Price` para preencher a nova coluna de Preço e converta a coluna de Data para mostrar apenas o mês. Felizmente, de acordo com a verificação acima, não há dados ausentes para datas ou preços.
|
||||
|
||||
1. Para calcular a média, adicione o seguinte código:
|
||||
|
||||
```python
|
||||
price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2
|
||||
|
||||
month = pd.DatetimeIndex(pumpkins['Date']).month
|
||||
|
||||
```
|
||||
|
||||
✅ Sinta-se à vontade para imprimir quaisquer dados que você gostaria de verificar usando `print(month)`.
|
||||
|
||||
2. Agora, copie seus dados convertidos para um novo dataframe do Pandas:
|
||||
|
||||
```python
|
||||
new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
|
||||
```
|
||||
|
||||
Imprimir seu dataframe mostrará um conjunto de dados limpo e organizado sobre o qual você pode construir seu novo modelo de regressão.
|
||||
|
||||
### Mas espere! Há algo estranho aqui
|
||||
|
||||
Se você olhar a coluna `Package` column, pumpkins are sold in many different configurations. Some are sold in '1 1/9 bushel' measures, and some in '1/2 bushel' measures, some per pumpkin, some per pound, and some in big boxes with varying widths.
|
||||
|
||||
> Pumpkins seem very hard to weigh consistently
|
||||
|
||||
Digging into the original data, it's interesting that anything with `Unit of Sale` equalling 'EACH' or 'PER BIN' also have the `Package` type per inch, per bin, or 'each'. Pumpkins seem to be very hard to weigh consistently, so let's filter them by selecting only pumpkins with the string 'bushel' in their `Package`.
|
||||
|
||||
1. Adicione um filtro no topo do arquivo, abaixo da importação inicial do .csv:
|
||||
|
||||
```python
|
||||
pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
|
||||
```
|
||||
|
||||
Se você imprimir os dados agora, verá que está obtendo apenas cerca de 415 linhas de dados contendo abóboras por alqueire.
|
||||
|
||||
### Mas espere! Há mais uma coisa a fazer
|
||||
|
||||
Você notou que a quantidade de alqueire varia por linha? Você precisa normalizar o preço para mostrar o preço por alqueire, então faça algumas contas para padronizá-lo.
|
||||
|
||||
1. Adicione estas linhas após o bloco que cria o novo dataframe de novas_abóboras:
|
||||
|
||||
```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)
|
||||
```
|
||||
|
||||
✅ De acordo com [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), o peso de um alqueire depende do tipo de produto, já que é uma medida de volume. "Um alqueire de tomates, por exemplo, deve pesar 56 libras... Folhas e verduras ocupam mais espaço com menos peso, então um alqueire de espinafre pesa apenas 20 libras." É tudo bastante complicado! Vamos não nos preocupar com a conversão de alqueire para libras e, em vez disso, precificar por alqueire. Todo esse estudo sobre alqueires de abóboras, no entanto, mostra o quão importante é entender a natureza dos seus dados!
|
||||
|
||||
Agora, você pode analisar o preço por unidade com base na medida de alqueire. Se você imprimir os dados mais uma vez, poderá ver como está padronizado.
|
||||
|
||||
✅ Você notou que as abóboras vendidas por meio alqueire são muito caras? Você consegue descobrir por quê? Dica: pequenas abóboras são muito mais caras do que as grandes, provavelmente porque há muito mais delas por alqueire, dada a quantidade de espaço não utilizado ocupada por uma grande abóbora oca.
|
||||
|
||||
## Estratégias de Visualização
|
||||
|
||||
Parte do papel do cientista de dados é demonstrar a qualidade e a natureza dos dados com os quais estão trabalhando. Para fazer isso, eles costumam criar visualizações interessantes, ou gráficos, mostrando diferentes aspectos dos dados. Dessa forma, eles conseguem mostrar visualmente relacionamentos e lacunas que, de outra forma, seriam difíceis de descobrir.
|
||||
|
||||
[](https://youtu.be/SbUkxH6IJo0 "ML para iniciantes - Como Visualizar Dados com Matplotlib")
|
||||
|
||||
> 🎥 Clique na imagem acima para um vídeo curto que mostra como visualizar os dados para esta lição.
|
||||
|
||||
As visualizações também podem ajudar a determinar a técnica de aprendizado de máquina mais apropriada para os dados. Um gráfico de dispersão que parece seguir uma linha, por exemplo, indica que os dados são um bom candidato para um exercício de regressão linear.
|
||||
|
||||
Uma biblioteca de visualização de dados que funciona bem em notebooks Jupyter é [Matplotlib](https://matplotlib.org/) (que você também viu na lição anterior).
|
||||
|
||||
> Obtenha mais experiência com visualização de dados em [esses tutoriais](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott).
|
||||
|
||||
## Exercício - experimente com Matplotlib
|
||||
|
||||
Tente criar alguns gráficos básicos para exibir o novo dataframe que você acabou de criar. O que um gráfico de linhas básico mostraria?
|
||||
|
||||
1. Importe o Matplotlib no topo do arquivo, abaixo da importação do Pandas:
|
||||
|
||||
```python
|
||||
import matplotlib.pyplot as plt
|
||||
```
|
||||
|
||||
1. Execute novamente todo o notebook para atualizar.
|
||||
1. Na parte inferior do notebook, adicione uma célula para plotar os dados como um box:
|
||||
|
||||
```python
|
||||
price = new_pumpkins.Price
|
||||
month = new_pumpkins.Month
|
||||
plt.scatter(price, month)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Este é um gráfico útil? Há algo nele que te surpreende?
|
||||
|
||||
Não é particularmente útil, pois tudo o que faz é exibir seus dados como uma dispersão de pontos em um determinado mês.
|
||||
|
||||
### Torne-o útil
|
||||
|
||||
Para que os gráficos exibam dados úteis, geralmente é necessário agrupar os dados de alguma forma. Vamos tentar criar um gráfico onde o eixo y mostra os meses e os dados demonstram a distribuição dos dados.
|
||||
|
||||
1. Adicione uma célula para criar um gráfico de barras agrupadas:
|
||||
|
||||
```python
|
||||
new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
|
||||
plt.ylabel("Pumpkin Price")
|
||||
```
|
||||
|
||||
|
||||
|
||||
Esta é uma visualização de dados mais útil! Parece indicar que o preço mais alto das abóboras ocorre em setembro e outubro. Isso atende à sua expectativa? Por que ou por que não?
|
||||
|
||||
---
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
Explore os diferentes tipos de visualização que o Matplotlib oferece. Quais tipos são mais apropriados para problemas de regressão?
|
||||
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/12/)
|
||||
|
||||
## Revisão e Estudo Pessoal
|
||||
|
||||
Dê uma olhada nas muitas maneiras de visualizar dados. Faça uma lista das várias bibliotecas disponíveis e observe quais são melhores para determinados tipos de tarefas, por exemplo, visualizações 2D vs. 3D. O que você descobre?
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Explorando visualização](assignment.md)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações erradas decorrentes do uso desta tradução.
|
||||
@ -1,11 +0,0 @@
|
||||
# Explorando Visualizações
|
||||
|
||||
Existem várias bibliotecas diferentes disponíveis para visualização de dados. Crie algumas visualizações usando os dados da Pumpkin nesta lição com matplotlib e seaborn em um notebook de exemplo. Quais bibliotecas são mais fáceis de trabalhar?
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Precisa de Melhoria |
|
||||
| --------- | -------- | -------- | ------------------- |
|
||||
| | Um notebook é enviado com duas explorações/visualizações | Um notebook é enviado com uma exploração/visualização | Um notebook não é enviado |
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
Este é um espaço reservado temporário. Por favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
Este é um espaço reservado temporário.
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,14 +0,0 @@
|
||||
# Criar um Modelo de Regressão
|
||||
|
||||
## Instruções
|
||||
|
||||
Nesta lição, você aprendeu como construir um modelo usando Regressão Linear e Polinomial. Usando esse conhecimento, encontre um conjunto de dados ou utilize um dos conjuntos integrados do Scikit-learn para construir um novo modelo. Explique em seu notebook por que você escolheu a técnica que escolheu e demonstre a precisão do seu modelo. Se não for preciso, explique o porquê.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Necessita Melhorias |
|
||||
| --------- | ----------------------------------------------------------- | -------------------------- | --------------------------------- |
|
||||
| | apresenta um notebook completo com uma solução bem documentada | a solução está incompleta | a solução é falha ou apresenta bugs |
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
Isto é um espaço reservado temporárioPor favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
Isto é um espaço reservado temporário
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações erradas decorrentes do uso desta tradução.
|
||||
@ -1,391 +0,0 @@
|
||||
# Regressão logística para prever categorias
|
||||
|
||||
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/15/)
|
||||
|
||||
> ### [Esta lição está disponível em R!](../../../../2-Regression/4-Logistic/solution/R/lesson_4.html)
|
||||
|
||||
## Introdução
|
||||
|
||||
Nesta última lição sobre Regressão, uma das técnicas básicas _clássicas_ de ML, vamos dar uma olhada na Regressão Logística. Você usaria essa técnica para descobrir padrões para prever categorias binárias. Este doce é chocolate ou não? Esta doença é contagiosa ou não? Este cliente escolherá este produto ou não?
|
||||
|
||||
Nesta lição, você aprenderá:
|
||||
|
||||
- Uma nova biblioteca para visualização de dados
|
||||
- Técnicas para regressão logística
|
||||
|
||||
✅ Aprofunde seu entendimento sobre como trabalhar com esse tipo de regressão neste [módulo de Aprendizado](https://docs.microsoft.com/learn/modules/train-evaluate-classification-models?WT.mc_id=academic-77952-leestott)
|
||||
|
||||
## Pré-requisitos
|
||||
|
||||
Depois de trabalhar com os dados de abóbora, já estamos familiarizados o suficiente para perceber que há uma categoria binária com a qual podemos trabalhar: `Color`.
|
||||
|
||||
Vamos construir um modelo de regressão logística para prever isso, dado algumas variáveis, _qual cor uma determinada abóbora provavelmente será_ (laranja 🎃 ou branca 👻).
|
||||
|
||||
> Por que estamos falando sobre classificação binária em uma lição sobre regressão? Apenas por conveniência linguística, já que a regressão logística é [realmente um método de classificação](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), embora seja baseada em linearidade. Aprenda sobre outras maneiras de classificar dados no próximo grupo de lições.
|
||||
|
||||
## Defina a questão
|
||||
|
||||
Para nossos propósitos, vamos expressar isso como binário: 'Branca' ou 'Não Branca'. Há também uma categoria 'listrada' em nosso conjunto de dados, mas há poucas instâncias dela, então não a usaremos. Ela desaparece assim que removemos os valores nulos do conjunto de dados, de qualquer forma.
|
||||
|
||||
> 🎃 Curiosidade, às vezes chamamos abóboras brancas de abóboras 'fantasmas'. Elas não são muito fáceis de esculpir, então não são tão populares quanto as laranjas, mas são muito legais! Então, também poderíamos reformular nossa pergunta como: 'Fantasma' ou 'Não Fantasma'. 👻
|
||||
|
||||
## Sobre a regressão logística
|
||||
|
||||
A regressão logística difere da regressão linear, que você aprendeu anteriormente, em algumas maneiras importantes.
|
||||
|
||||
[](https://youtu.be/KpeCT6nEpBY "ML para iniciantes - Entendendo a Regressão Logística para Classificação em Machine Learning")
|
||||
|
||||
> 🎥 Clique na imagem acima para um breve vídeo sobre a regressão logística.
|
||||
|
||||
### Classificação binária
|
||||
|
||||
A regressão logística não oferece os mesmos recursos que a regressão linear. A primeira oferece uma previsão sobre uma categoria binária ("branca ou não branca"), enquanto a última é capaz de prever valores contínuos, por exemplo, dado a origem de uma abóbora e o tempo de colheita, _quanto seu preço irá aumentar_.
|
||||
|
||||
|
||||
> Infográfico por [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
||||
|
||||
### Outras classificações
|
||||
|
||||
Existem outros tipos de regressão logística, incluindo multinomial e ordinal:
|
||||
|
||||
- **Multinomial**, que envolve ter mais de uma categoria - "Laranja, Branca e Listrada".
|
||||
- **Ordinal**, que envolve categorias ordenadas, útil se quisermos ordenar nossos resultados logicamente, como nossas abóboras que são ordenadas por um número finito de tamanhos (mini, sm, med, lg, xl, xxl).
|
||||
|
||||
|
||||
|
||||
### Variáveis NÃO precisam estar correlacionadas
|
||||
|
||||
Lembre-se de como a regressão linear funcionava melhor com variáveis mais correlacionadas? A regressão logística é o oposto - as variáveis não precisam estar alinhadas. Isso funciona para esses dados que têm correlações um tanto fracas.
|
||||
|
||||
### Você precisa de muitos dados limpos
|
||||
|
||||
A regressão logística dará resultados mais precisos se você usar mais dados; nosso pequeno conjunto de dados não é ideal para essa tarefa, então tenha isso em mente.
|
||||
|
||||
[](https://youtu.be/B2X4H9vcXTs "ML para iniciantes - Análise e Preparação de Dados para Regressão Logística")
|
||||
|
||||
> 🎥 Clique na imagem acima para um breve vídeo sobre a preparação de dados para regressão linear
|
||||
|
||||
✅ Pense sobre os tipos de dados que se prestariam bem à regressão logística
|
||||
|
||||
## Exercício - organizar os dados
|
||||
|
||||
Primeiro, limpe um pouco os dados, removendo valores nulos e selecionando apenas algumas das colunas:
|
||||
|
||||
1. Adicione o seguinte código:
|
||||
|
||||
```python
|
||||
|
||||
columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color']
|
||||
pumpkins = full_pumpkins.loc[:, columns_to_select]
|
||||
|
||||
pumpkins.dropna(inplace=True)
|
||||
```
|
||||
|
||||
Você sempre pode dar uma olhada em seu novo dataframe:
|
||||
|
||||
```python
|
||||
pumpkins.info
|
||||
```
|
||||
|
||||
### Visualização - gráfico categórico
|
||||
|
||||
Neste ponto, você carregou novamente o [notebook inicial](../../../../2-Regression/4-Logistic/notebook.ipynb) com dados de abóbora e o limpou para preservar um conjunto de dados contendo algumas variáveis, incluindo `Color`. Vamos visualizar o dataframe no notebook usando uma biblioteca diferente: [Seaborn](https://seaborn.pydata.org/index.html), que é construída sobre o Matplotlib que usamos anteriormente.
|
||||
|
||||
Seaborn oferece algumas maneiras interessantes de visualizar seus dados. Por exemplo, você pode comparar distribuições dos dados para cada `Variety` e `Color` em um gráfico categórico.
|
||||
|
||||
1. Crie tal gráfico usando o `catplot` function, using our pumpkin data `pumpkins`, e especificando uma mapeação de cores para cada categoria de abóbora (laranja ou branca):
|
||||
|
||||
```python
|
||||
import seaborn as sns
|
||||
|
||||
palette = {
|
||||
'ORANGE': 'orange',
|
||||
'WHITE': 'wheat',
|
||||
}
|
||||
|
||||
sns.catplot(
|
||||
data=pumpkins, y="Variety", hue="Color", kind="count",
|
||||
palette=palette,
|
||||
)
|
||||
```
|
||||
|
||||
|
||||
|
||||
Observando os dados, você pode ver como os dados de Cor se relacionam com a Variety.
|
||||
|
||||
✅ Dado este gráfico categórico, quais são algumas explorações interessantes que você pode imaginar?
|
||||
|
||||
### Pré-processamento de dados: codificação de características e rótulos
|
||||
|
||||
Nosso conjunto de dados de abóbora contém valores de string para todas as suas colunas. Trabalhar com dados categóricos é intuitivo para os humanos, mas não para as máquinas. Algoritmos de aprendizado de máquina funcionam bem com números. É por isso que a codificação é uma etapa muito importante na fase de pré-processamento de dados, já que nos permite transformar dados categóricos em dados numéricos, sem perder nenhuma informação. Uma boa codificação leva à construção de um bom modelo.
|
||||
|
||||
Para a codificação de características, existem dois tipos principais de codificadores:
|
||||
|
||||
1. Codificador ordinal: ele se adapta bem a variáveis ordinais, que são variáveis categóricas onde seus dados seguem uma ordem lógica, como a coluna `Item Size` em nosso conjunto de dados. Ele cria um mapeamento de modo que cada categoria seja representada por um número, que é a ordem da categoria na coluna.
|
||||
|
||||
```python
|
||||
from sklearn.preprocessing import OrdinalEncoder
|
||||
|
||||
item_size_categories = [['sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo']]
|
||||
ordinal_features = ['Item Size']
|
||||
ordinal_encoder = OrdinalEncoder(categories=item_size_categories)
|
||||
```
|
||||
|
||||
2. Codificador categórico: ele se adapta bem a variáveis nominais, que são variáveis categóricas onde seus dados não seguem uma ordem lógica, como todas as características diferentes de `Item Size` em nosso conjunto de dados. É uma codificação one-hot, o que significa que cada categoria é representada por uma coluna binária: a variável codificada é igual a 1 se a abóbora pertence àquela Variety e 0 caso contrário.
|
||||
|
||||
```python
|
||||
from sklearn.preprocessing import OneHotEncoder
|
||||
|
||||
categorical_features = ['City Name', 'Package', 'Variety', 'Origin']
|
||||
categorical_encoder = OneHotEncoder(sparse_output=False)
|
||||
```
|
||||
|
||||
Em seguida, o `ColumnTransformer` é usado para combinar vários codificadores em um único passo e aplicá-los às colunas apropriadas.
|
||||
|
||||
```python
|
||||
from sklearn.compose import ColumnTransformer
|
||||
|
||||
ct = ColumnTransformer(transformers=[
|
||||
('ord', ordinal_encoder, ordinal_features),
|
||||
('cat', categorical_encoder, categorical_features)
|
||||
])
|
||||
|
||||
ct.set_output(transform='pandas')
|
||||
encoded_features = ct.fit_transform(pumpkins)
|
||||
```
|
||||
|
||||
Por outro lado, para codificar o rótulo, usamos a classe `LabelEncoder` do scikit-learn, que é uma classe utilitária para ajudar a normalizar rótulos de modo que contenham apenas valores entre 0 e n_classes-1 (aqui, 0 e 1).
|
||||
|
||||
```python
|
||||
from sklearn.preprocessing import LabelEncoder
|
||||
|
||||
label_encoder = LabelEncoder()
|
||||
encoded_label = label_encoder.fit_transform(pumpkins['Color'])
|
||||
```
|
||||
|
||||
Uma vez que tenhamos codificado as características e o rótulo, podemos mesclá-los em um novo dataframe `encoded_pumpkins`.
|
||||
|
||||
```python
|
||||
encoded_pumpkins = encoded_features.assign(Color=encoded_label)
|
||||
```
|
||||
|
||||
✅ Quais são as vantagens de usar um codificador ordinal para o `Item Size` column?
|
||||
|
||||
### Analyse relationships between variables
|
||||
|
||||
Now that we have pre-processed our data, we can analyse the relationships between the features and the label to grasp an idea of how well the model will be able to predict the label given the features.
|
||||
The best way to perform this kind of analysis is plotting the data. We'll be using again the Seaborn `catplot` function, to visualize the relationships between `Item Size`, `Variety` e `Color` em um gráfico categórico. Para melhor plotar os dados, usaremos a coluna codificada `Item Size` column and the unencoded `Variety`.
|
||||
|
||||
```python
|
||||
palette = {
|
||||
'ORANGE': 'orange',
|
||||
'WHITE': 'wheat',
|
||||
}
|
||||
pumpkins['Item Size'] = encoded_pumpkins['ord__Item Size']
|
||||
|
||||
g = sns.catplot(
|
||||
data=pumpkins,
|
||||
x="Item Size", y="Color", row='Variety',
|
||||
kind="box", orient="h",
|
||||
sharex=False, margin_titles=True,
|
||||
height=1.8, aspect=4, palette=palette,
|
||||
)
|
||||
g.set(xlabel="Item Size", ylabel="").set(xlim=(0,6))
|
||||
g.set_titles(row_template="{row_name}")
|
||||
```
|
||||
|
||||
|
||||
|
||||
### Use um gráfico de enxame
|
||||
|
||||
Como Color é uma categoria binária (Branca ou Não), ela precisa de 'uma [abordagem especializada](https://seaborn.pydata.org/tutorial/categorical.html?highlight=bar) para visualização'. Existem outras maneiras de visualizar a relação dessa categoria com outras variáveis.
|
||||
|
||||
Você pode visualizar variáveis lado a lado com gráficos do Seaborn.
|
||||
|
||||
1. Tente um gráfico de 'enxame' para mostrar a distribuição dos valores:
|
||||
|
||||
```python
|
||||
palette = {
|
||||
0: 'orange',
|
||||
1: 'wheat'
|
||||
}
|
||||
sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)
|
||||
```
|
||||
|
||||
|
||||
|
||||
**Cuidado**: o código acima pode gerar um aviso, já que o seaborn não consegue representar tal quantidade de pontos de dados em um gráfico de enxame. Uma possível solução é diminuir o tamanho do marcador, usando o parâmetro 'size'. No entanto, esteja ciente de que isso afeta a legibilidade do gráfico.
|
||||
|
||||
> **🧮 Mostre-me a Matemática**
|
||||
>
|
||||
> A regressão logística baseia-se no conceito de 'máxima verossimilhança' usando [funções sigmoides](https://wikipedia.org/wiki/Sigmoid_function). Uma 'Função Sigmoide' em um gráfico parece uma forma de 'S'. Ela pega um valor e o mapeia para algum lugar entre 0 e 1. Sua curva também é chamada de 'curva logística'. Sua fórmula é assim:
|
||||
>
|
||||
> 
|
||||
>
|
||||
> onde o ponto médio da sigmoide se encontra no ponto 0 de x, L é o valor máximo da curva e k é a inclinação da curva. Se o resultado da função for mais que 0.5, o rótulo em questão receberá a classe '1' da escolha binária. Se não, será classificado como '0'.
|
||||
|
||||
## Construa seu modelo
|
||||
|
||||
Construir um modelo para encontrar essas classificações binárias é surpreendentemente simples no Scikit-learn.
|
||||
|
||||
[](https://youtu.be/MmZS2otPrQ8 "ML para iniciantes - Regressão Logística para classificação de dados")
|
||||
|
||||
> 🎥 Clique na imagem acima para um breve vídeo sobre a construção de um modelo de regressão linear
|
||||
|
||||
1. Selecione as variáveis que você deseja usar em seu modelo de classificação e divida os conjuntos de treinamento e teste chamando `train_test_split()`:
|
||||
|
||||
```python
|
||||
from sklearn.model_selection import train_test_split
|
||||
|
||||
X = encoded_pumpkins[encoded_pumpkins.columns.difference(['Color'])]
|
||||
y = encoded_pumpkins['Color']
|
||||
|
||||
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
||||
|
||||
```
|
||||
|
||||
2. Agora você pode treinar seu modelo, chamando `fit()` com seus dados de treinamento, e imprimir seu resultado:
|
||||
|
||||
```python
|
||||
from sklearn.metrics import f1_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('F1-score: ', f1_score(y_test, predictions))
|
||||
```
|
||||
|
||||
Dê uma olhada no placar do seu modelo. Não está ruim, considerando que você tem apenas cerca de 1000 linhas de dados:
|
||||
|
||||
```output
|
||||
precision recall f1-score support
|
||||
|
||||
0 0.94 0.98 0.96 166
|
||||
1 0.85 0.67 0.75 33
|
||||
|
||||
accuracy 0.92 199
|
||||
macro avg 0.89 0.82 0.85 199
|
||||
weighted avg 0.92 0.92 0.92 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 1 0 0 0 0 0 0 0 0 1 0 0 0 0
|
||||
0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 1 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 1 0 0 0 0 0 0 0 0 1 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 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0
|
||||
0 0 0 0 1 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 1
|
||||
0 0 0 1 0 0 0 0 0 0 0 0 1 1]
|
||||
F1-score: 0.7457627118644068
|
||||
```
|
||||
|
||||
## Melhor compreensão através de uma matriz de confusão
|
||||
|
||||
Embora você possa obter um relatório de placar [termos](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html?highlight=classification_report#sklearn.metrics.classification_report) imprimindo os itens acima, você pode entender seu modelo mais facilmente usando uma [matriz de confusão](https://scikit-learn.org/stable/modules/model_evaluation.html#confusion-matrix) para nos ajudar a entender como o modelo está se saindo.
|
||||
|
||||
> 🎓 Uma '[matriz de confusão](https://wikipedia.org/wiki/Confusion_matrix)' (ou 'matriz de erro') é uma tabela que expressa os verdadeiros positivos e negativos do seu modelo, assim avaliando a precisão das previsões.
|
||||
|
||||
1. Para usar uma matriz de confusão, chame `confusion_matrix()`:
|
||||
|
||||
```python
|
||||
from sklearn.metrics import confusion_matrix
|
||||
confusion_matrix(y_test, predictions)
|
||||
```
|
||||
|
||||
Dê uma olhada na matriz de confusão do seu modelo:
|
||||
|
||||
```output
|
||||
array([[162, 4],
|
||||
[ 11, 22]])
|
||||
```
|
||||
|
||||
No Scikit-learn, as linhas da matriz de confusão (eixo 0) são rótulos reais e as colunas (eixo 1) são rótulos previstos.
|
||||
|
||||
| | 0 | 1 |
|
||||
| :---: | :---: | :---: |
|
||||
| 0 | TN | FP |
|
||||
| 1 | FN | TP |
|
||||
|
||||
O que está acontecendo aqui? Vamos supor que nosso modelo é solicitado a classificar abóboras entre duas categorias binárias, a categoria 'branca' e a categoria 'não-branca'.
|
||||
|
||||
- Se seu modelo prevê uma abóbora como não branca e ela pertence à categoria 'não-branca' na realidade, chamamos isso de verdadeiro negativo, mostrado pelo número no canto superior esquerdo.
|
||||
- Se seu modelo prevê uma abóbora como branca e ela pertence à categoria 'não-branca' na realidade, chamamos isso de falso negativo, mostrado pelo número no canto inferior esquerdo.
|
||||
- Se seu modelo prevê uma abóbora como não branca e ela pertence à categoria 'branca' na realidade, chamamos isso de falso positivo, mostrado pelo número no canto superior direito.
|
||||
- Se seu modelo prevê uma abóbora como branca e ela pertence à categoria 'branca' na realidade, chamamos isso de verdadeiro positivo, mostrado pelo número no canto inferior direito.
|
||||
|
||||
Como você pode ter adivinhado, é preferível ter um número maior de verdadeiros positivos e verdadeiros negativos e um número menor de falsos positivos e falsos negativos, o que implica que o modelo está se saindo melhor.
|
||||
|
||||
Como a matriz de confusão se relaciona com precisão e recall? Lembre-se, o relatório de classificação impresso acima mostrou precisão (0.85) e recall (0.67).
|
||||
|
||||
Precisão = tp / (tp + fp) = 22 / (22 + 4) = 0.8461538461538461
|
||||
|
||||
Recall = tp / (tp + fn) = 22 / (22 + 11) = 0.6666666666666666
|
||||
|
||||
✅ Q: De acordo com a matriz de confusão, como o modelo se saiu? A: Não muito mal; há um bom número de verdadeiros negativos, mas também alguns falsos negativos.
|
||||
|
||||
Vamos revisitar os termos que vimos anteriormente com a ajuda do mapeamento da matriz de confusão de TP/TN e FP/FN:
|
||||
|
||||
🎓 Precisão: TP/(TP + FP) A fração de instâncias relevantes entre as instâncias recuperadas (por exemplo, quais rótulos foram bem rotulados)
|
||||
|
||||
🎓 Recall: TP/(TP + FN) A fração de instâncias relevantes que foram recuperadas, sejam bem rotuladas ou não
|
||||
|
||||
🎓 f1-score: (2 * precisão * recall)/(precisão + recall) Uma média ponderada da precisão e recall, com o melhor sendo 1 e o pior sendo 0
|
||||
|
||||
🎓 Suporte: O número de ocorrências de cada rótulo recuperado
|
||||
|
||||
🎓 Precisão: (TP + TN)/(TP + TN + FP + FN) A porcentagem de rótulos previstos com precisão para uma amostra.
|
||||
|
||||
🎓 Média Macro: O cálculo da média não ponderada das métricas para cada rótulo, sem levar em conta o desequilíbrio de rótulos.
|
||||
|
||||
🎓 Média Ponderada: O cálculo da média das métricas para cada rótulo, levando em conta o desequilíbrio de rótulos, ponderando-os por seu suporte (o número de instâncias verdadeiras para cada rótulo).
|
||||
|
||||
✅ Você consegue pensar em qual métrica deve observar se quiser que seu modelo reduza o número de falsos negativos?
|
||||
|
||||
## Visualize a curva ROC deste modelo
|
||||
|
||||
[](https://youtu.be/GApO575jTA0 "ML para iniciantes - Analisando o Desempenho da Regressão Logística com Curvas ROC")
|
||||
|
||||
> 🎥 Clique na imagem acima para um breve vídeo sobre curvas ROC
|
||||
|
||||
Vamos fazer mais uma visualização para ver a chamada curva 'ROC':
|
||||
|
||||
```python
|
||||
from sklearn.metrics import roc_curve, roc_auc_score
|
||||
import matplotlib
|
||||
import matplotlib.pyplot as plt
|
||||
%matplotlib inline
|
||||
|
||||
y_scores = model.predict_proba(X_test)
|
||||
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])
|
||||
|
||||
fig = plt.figure(figsize=(6, 6))
|
||||
plt.plot([0, 1], [0, 1], 'k--')
|
||||
plt.plot(fpr, tpr)
|
||||
plt.xlabel('False Positive Rate')
|
||||
plt.ylabel('True Positive Rate')
|
||||
plt.title('ROC Curve')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
Usando Matplotlib, plote o [Característica de Operação Recebida](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html?highlight=roc) ou ROC do modelo. As curvas ROC são frequentemente usadas para obter uma visão da saída de um classificador em termos de seus verdadeiros vs. falsos positivos. "As curvas ROC normalmente apresentam a taxa de verdadeiro positivo no eixo Y e a taxa de falso positivo no eixo X." Assim, a inclinação da curva e o espaço entre a linha do ponto médio e a curva são importantes: você quer uma curva que rapidamente suba e passe pela linha. No nosso caso, há falsos positivos para começar, e então a linha sobe e passa corretamente:
|
||||
|
||||
|
||||
|
||||
Finalmente, use a API [`roc_auc_score` do scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html?highlight=roc_auc#sklearn.metrics.roc_auc_score) para calcular a 'Área Sob a Curva' (AUC) real:
|
||||
|
||||
```python
|
||||
auc = roc_auc_score(y_test,y_scores[:,1])
|
||||
print(auc)
|
||||
```
|
||||
|
||||
O resultado é `0.9749908725812341`. Dado que a AUC varia de 0 a 1, você quer uma pontuação alta, pois um modelo que está 100% correto em suas previsões terá uma AUC de 1; neste caso, o modelo é _muito bom_.
|
||||
|
||||
Nas próximas lições sobre classificações, você aprenderá como iterar para melhorar as pontuações do seu modelo. Mas por enquanto, parabéns! Você completou essas lições de regressão!
|
||||
|
||||
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,14 +0,0 @@
|
||||
# Tentando Novamente a Regressão
|
||||
|
||||
## Instruções
|
||||
|
||||
Na lição, você usou um subconjunto dos dados de abóbora. Agora, volte para os dados originais e tente usar todos eles, limpos e padronizados, para construir um modelo de Regressão Logística.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Necessita Melhorias |
|
||||
| --------- | ---------------------------------------------------------------------- | ----------------------------------------------------------- | ----------------------------------------------------------- |
|
||||
| | Um caderno é apresentado com um modelo bem explicado e de bom desempenho | Um caderno é apresentado com um modelo que tem desempenho mínimo | Um caderno é apresentado com um modelo de baixo desempenho ou nenhum |
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
Isto é um espaço reservado temporário. Por favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
Isto é um espaço reservado temporário.
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações erradas que possam surgir do uso desta tradução.
|
||||
@ -1,43 +0,0 @@
|
||||
# Modelos de regressão para aprendizado de máquina
|
||||
## Tópico regional: Modelos de regressão para preços de abóbora na América do Norte 🎃
|
||||
|
||||
Na América do Norte, abóboras são frequentemente esculpidas em rostos assustadores para o Halloween. Vamos descobrir mais sobre esses fascinantes vegetais!
|
||||
|
||||
|
||||
> Foto por <a href="https://unsplash.com/@teutschmann?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Beth Teutschmann</a> em <a href="https://unsplash.com/s/photos/jack-o-lanterns?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## O que você vai aprender
|
||||
|
||||
[](https://youtu.be/5QnJtDad4iQ "Vídeo de Introdução à Regressão - Clique para Assistir!")
|
||||
> 🎥 Clique na imagem acima para um vídeo rápido de introdução a esta lição
|
||||
|
||||
As lições nesta seção abordam tipos de regressão no contexto de aprendizado de máquina. Modelos de regressão podem ajudar a determinar a _relação_ entre variáveis. Esse tipo de modelo pode prever valores como comprimento, temperatura ou idade, revelando assim relações entre variáveis à medida que analisa pontos de dados.
|
||||
|
||||
Nesta série de lições, você descobrirá as diferenças entre regressão linear e logística, e quando deve preferir uma em vez da outra.
|
||||
|
||||
[](https://youtu.be/XA3OaoW86R8 "ML para iniciantes - Introdução a Modelos de Regressão para Aprendizado de Máquina")
|
||||
|
||||
> 🎥 Clique na imagem acima para um vídeo curto apresentando modelos de regressão.
|
||||
|
||||
Neste grupo de lições, você será preparado para começar tarefas de aprendizado de máquina, incluindo a configuração do Visual Studio Code para gerenciar notebooks, o ambiente comum para cientistas de dados. Você descobrirá o Scikit-learn, uma biblioteca para aprendizado de máquina, e construirá seus primeiros modelos, focando em modelos de regressão neste capítulo.
|
||||
|
||||
> Existem ferramentas de baixo código úteis que podem ajudá-lo a aprender sobre como trabalhar com modelos de regressão. Experimente [Azure ML para esta tarefa](https://docs.microsoft.com/learn/modules/create-regression-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
|
||||
|
||||
### Lições
|
||||
|
||||
1. [Ferramentas do ofício](1-Tools/README.md)
|
||||
2. [Gerenciando dados](2-Data/README.md)
|
||||
3. [Regressão linear e polinomial](3-Linear/README.md)
|
||||
4. [Regressão logística](4-Logistic/README.md)
|
||||
|
||||
---
|
||||
### Créditos
|
||||
|
||||
"ML com regressão" foi escrito com ♥️ por [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
♥️ Contribuidores do quiz incluem: [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan) e [Ornella Altunyan](https://twitter.com/ornelladotcom)
|
||||
|
||||
O conjunto de dados de abóbora é sugerido por [este projeto no Kaggle](https://www.kaggle.com/usda/a-year-of-pumpkin-prices) e seus dados são provenientes dos [Relatórios Padrão dos Mercados de Culturas Especiais](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuídos pelo Departamento de Agricultura dos Estados Unidos. Adicionamos alguns pontos sobre a cor com base na variedade para normalizar a distribuição. Esses dados estão em domínio público.
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,348 +0,0 @@
|
||||
# Construa um App Web para usar um Modelo de ML
|
||||
|
||||
Nesta lição, você irá treinar um modelo de ML em um conjunto de dados que está fora deste mundo: _avistamentos de OVNIs no último século_, extraídos do banco de dados da NUFORC.
|
||||
|
||||
Você aprenderá:
|
||||
|
||||
- Como 'pickle' um modelo treinado
|
||||
- Como usar esse modelo em um app Flask
|
||||
|
||||
Continuaremos a usar notebooks para limpar os dados e treinar nosso modelo, mas você pode levar o processo um passo adiante explorando como usar um modelo 'no mundo real', por assim dizer: em um app web.
|
||||
|
||||
Para fazer isso, você precisa construir um app web usando Flask.
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/17/)
|
||||
|
||||
## Construindo um app
|
||||
|
||||
Existem várias maneiras de construir apps web para consumir modelos de aprendizado de máquina. Sua arquitetura web pode influenciar a forma como seu modelo é treinado. Imagine que você está trabalhando em uma empresa onde o grupo de ciência de dados treinou um modelo que eles querem que você use em um app.
|
||||
|
||||
### Considerações
|
||||
|
||||
Há muitas perguntas que você precisa fazer:
|
||||
|
||||
- **É um app web ou um app móvel?** Se você estiver construindo um app móvel ou precisar usar o modelo em um contexto de IoT, você poderia usar [TensorFlow Lite](https://www.tensorflow.org/lite/) e usar o modelo em um app Android ou iOS.
|
||||
- **Onde o modelo residirá?** Na nuvem ou localmente?
|
||||
- **Suporte offline.** O app precisa funcionar offline?
|
||||
- **Que tecnologia foi usada para treinar o modelo?** A tecnologia escolhida pode influenciar as ferramentas que você precisa usar.
|
||||
- **Usando TensorFlow.** Se você estiver treinando um modelo usando TensorFlow, por exemplo, esse ecossistema fornece a capacidade de converter um modelo TensorFlow para uso em um app web usando [TensorFlow.js](https://www.tensorflow.org/js/).
|
||||
- **Usando PyTorch.** Se você estiver construindo um modelo usando uma biblioteca como [PyTorch](https://pytorch.org/), você tem a opção de exportá-lo no formato [ONNX](https://onnx.ai/) (Open Neural Network Exchange) para uso em apps web JavaScript que podem usar o [Onnx Runtime](https://www.onnxruntime.ai/). Esta opção será explorada em uma lição futura para um modelo treinado com Scikit-learn.
|
||||
- **Usando Lobe.ai ou Azure Custom Vision.** Se você estiver usando um sistema de ML SaaS (Software como Serviço) como [Lobe.ai](https://lobe.ai/) ou [Azure Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77952-leestott) para treinar um modelo, esse tipo de software fornece maneiras de exportar o modelo para muitas plataformas, incluindo a construção de uma API sob medida para ser consultada na nuvem pelo seu aplicativo online.
|
||||
|
||||
Você também tem a oportunidade de construir um app web Flask completo que seria capaz de treinar o modelo em um navegador web. Isso também pode ser feito usando TensorFlow.js em um contexto JavaScript.
|
||||
|
||||
Para nossos propósitos, uma vez que temos trabalhado com notebooks baseados em Python, vamos explorar os passos que você precisa seguir para exportar um modelo treinado de tal notebook para um formato legível por um app web construído em Python.
|
||||
|
||||
## Ferramenta
|
||||
|
||||
Para esta tarefa, você precisa de duas ferramentas: Flask e Pickle, ambas que rodam em Python.
|
||||
|
||||
✅ O que é [Flask](https://palletsprojects.com/p/flask/)? Definido como um 'micro-framework' por seus criadores, o Flask fornece os recursos básicos dos frameworks web usando Python e um motor de templates para construir páginas web. Dê uma olhada neste [módulo Learn](https://docs.microsoft.com/learn/modules/python-flask-build-ai-web-app?WT.mc_id=academic-77952-leestott) para praticar a construção com Flask.
|
||||
|
||||
✅ O que é [Pickle](https://docs.python.org/3/library/pickle.html)? Pickle 🥒 é um módulo Python que serializa e desserializa uma estrutura de objeto Python. Quando você 'pickle' um modelo, você serializa ou achata sua estrutura para uso na web. Tenha cuidado: pickle não é intrinsecamente seguro, então tenha cuidado se solicitado a 'un-pickle' um arquivo. Um arquivo pickled tem o sufixo `.pkl`.
|
||||
|
||||
## Exercício - limpe seus dados
|
||||
|
||||
Nesta lição, você usará dados de 80.000 avistamentos de OVNIs, coletados pela [NUFORC](https://nuforc.org) (O Centro Nacional de Relato de OVNIs). Esses dados têm algumas descrições interessantes de avistamentos de OVNIs, por exemplo:
|
||||
|
||||
- **Descrição de exemplo longa.** "Um homem emerge de um feixe de luz que brilha em um campo gramado à noite e ele corre em direção ao estacionamento da Texas Instruments".
|
||||
- **Descrição de exemplo curta.** "as luzes nos perseguiram".
|
||||
|
||||
A planilha [ufos.csv](../../../../3-Web-App/1-Web-App/data/ufos.csv) inclui colunas sobre o `city`, `state` e `country` onde o avistamento ocorreu, o `shape` do objeto e seus `latitude` e `longitude`.
|
||||
|
||||
No [notebook](../../../../3-Web-App/1-Web-App/notebook.ipynb) em branco incluído nesta lição:
|
||||
|
||||
1. importe `pandas`, `matplotlib` e `numpy` como você fez em lições anteriores e importe a planilha ufos. Você pode dar uma olhada em um conjunto de dados de exemplo:
|
||||
|
||||
```python
|
||||
import pandas as pd
|
||||
import numpy as np
|
||||
|
||||
ufos = pd.read_csv('./data/ufos.csv')
|
||||
ufos.head()
|
||||
```
|
||||
|
||||
1. Converta os dados de ufos para um pequeno dataframe com títulos novos. Verifique os valores únicos no campo `Country`.
|
||||
|
||||
```python
|
||||
ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
|
||||
|
||||
ufos.Country.unique()
|
||||
```
|
||||
|
||||
1. Agora, você pode reduzir a quantidade de dados com os quais precisamos lidar, excluindo quaisquer valores nulos e apenas importando avistamentos entre 1-60 segundos:
|
||||
|
||||
```python
|
||||
ufos.dropna(inplace=True)
|
||||
|
||||
ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
|
||||
|
||||
ufos.info()
|
||||
```
|
||||
|
||||
1. Importe a biblioteca `LabelEncoder` do Scikit-learn para converter os valores de texto dos países em números:
|
||||
|
||||
✅ LabelEncoder codifica dados alfabeticamente
|
||||
|
||||
```python
|
||||
from sklearn.preprocessing import LabelEncoder
|
||||
|
||||
ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
|
||||
|
||||
ufos.head()
|
||||
```
|
||||
|
||||
Seus dados devem parecer com isso:
|
||||
|
||||
```output
|
||||
Seconds Country Latitude Longitude
|
||||
2 20.0 3 53.200000 -2.916667
|
||||
3 20.0 4 28.978333 -96.645833
|
||||
14 30.0 4 35.823889 -80.253611
|
||||
23 60.0 4 45.582778 -122.352222
|
||||
24 3.0 3 51.783333 -0.783333
|
||||
```
|
||||
|
||||
## Exercício - construa seu modelo
|
||||
|
||||
Agora você pode se preparar para treinar um modelo dividindo os dados em grupos de treinamento e teste.
|
||||
|
||||
1. Selecione os três recursos que você deseja treinar como seu vetor X, e o vetor y será `Country`. You want to be able to input `Seconds`, `Latitude` and `Longitude` e obtenha um id de país para retornar.
|
||||
|
||||
```python
|
||||
from sklearn.model_selection import train_test_split
|
||||
|
||||
Selected_features = ['Seconds','Latitude','Longitude']
|
||||
|
||||
X = ufos[Selected_features]
|
||||
y = ufos['Country']
|
||||
|
||||
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
||||
```
|
||||
|
||||
1. Treine seu modelo usando regressão logística:
|
||||
|
||||
```python
|
||||
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))
|
||||
```
|
||||
|
||||
A precisão não é ruim **(cerca de 95%)**, não surpreendentemente, já que `Country` and `Latitude/Longitude` correlate.
|
||||
|
||||
The model you created isn't very revolutionary as you should be able to infer a `Country` from its `Latitude` and `Longitude`, mas é um bom exercício tentar treinar a partir de dados brutos que você limpou, exportou e, em seguida, usar este modelo em um app web.
|
||||
|
||||
## Exercício - 'pickle' seu modelo
|
||||
|
||||
Agora, é hora de _pickle_ seu modelo! Você pode fazer isso em algumas linhas de código. Uma vez que está _pickled_, carregue seu modelo pickled e teste-o contra um array de dados de exemplo contendo valores para segundos, latitude e longitude,
|
||||
|
||||
```python
|
||||
import pickle
|
||||
model_filename = 'ufo-model.pkl'
|
||||
pickle.dump(model, open(model_filename,'wb'))
|
||||
|
||||
model = pickle.load(open('ufo-model.pkl','rb'))
|
||||
print(model.predict([[50,44,-12]]))
|
||||
```
|
||||
|
||||
O modelo retorna **'3'**, que é o código do país para o Reino Unido. Uau! 👽
|
||||
|
||||
## Exercício - construa um app Flask
|
||||
|
||||
Agora você pode construir um app Flask para chamar seu modelo e retornar resultados semelhantes, mas de uma maneira visualmente mais agradável.
|
||||
|
||||
1. Comece criando uma pasta chamada **web-app** ao lado do arquivo _notebook.ipynb_ onde seu arquivo _ufo-model.pkl_ reside.
|
||||
|
||||
1. Dentro dessa pasta, crie mais três pastas: **static**, com uma pasta **css** dentro dela, e **templates**. Você deve agora ter os seguintes arquivos e diretórios:
|
||||
|
||||
```output
|
||||
web-app/
|
||||
static/
|
||||
css/
|
||||
templates/
|
||||
notebook.ipynb
|
||||
ufo-model.pkl
|
||||
```
|
||||
|
||||
✅ Consulte a pasta de soluções para uma visão do app finalizado
|
||||
|
||||
1. O primeiro arquivo a ser criado na pasta _web-app_ é o arquivo **requirements.txt**. Como o _package.json_ em um app JavaScript, este arquivo lista as dependências exigidas pelo app. Em **requirements.txt**, adicione as linhas:
|
||||
|
||||
```text
|
||||
scikit-learn
|
||||
pandas
|
||||
numpy
|
||||
flask
|
||||
```
|
||||
|
||||
1. Agora, execute este arquivo navegando para _web-app_:
|
||||
|
||||
```bash
|
||||
cd web-app
|
||||
```
|
||||
|
||||
1. No seu terminal, digite `pip install`, para instalar as bibliotecas listadas em _requirements.txt_:
|
||||
|
||||
```bash
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
|
||||
1. Agora, você está pronto para criar mais três arquivos para finalizar o app:
|
||||
|
||||
1. Crie **app.py** na raiz.
|
||||
2. Crie **index.html** no diretório _templates_.
|
||||
3. Crie **styles.css** no diretório _static/css_.
|
||||
|
||||
1. Construa o arquivo _styles.css_ com alguns estilos:
|
||||
|
||||
```css
|
||||
body {
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
font-family: 'Helvetica';
|
||||
background: black;
|
||||
color: #fff;
|
||||
text-align: center;
|
||||
letter-spacing: 1.4px;
|
||||
font-size: 30px;
|
||||
}
|
||||
|
||||
input {
|
||||
min-width: 150px;
|
||||
}
|
||||
|
||||
.grid {
|
||||
width: 300px;
|
||||
border: 1px solid #2d2d2d;
|
||||
display: grid;
|
||||
justify-content: center;
|
||||
margin: 20px auto;
|
||||
}
|
||||
|
||||
.box {
|
||||
color: #fff;
|
||||
background: #2d2d2d;
|
||||
padding: 12px;
|
||||
display: inline-block;
|
||||
}
|
||||
```
|
||||
|
||||
1. Em seguida, construa o arquivo _index.html_:
|
||||
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<title>🛸 UFO Appearance Prediction! 👽</title>
|
||||
<link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<div class="grid">
|
||||
|
||||
<div class="box">
|
||||
|
||||
<p>According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?</p>
|
||||
|
||||
<form action="{{ url_for('predict')}}" method="post">
|
||||
<input type="number" name="seconds" placeholder="Seconds" required="required" min="0" max="60" />
|
||||
<input type="text" name="latitude" placeholder="Latitude" required="required" />
|
||||
<input type="text" name="longitude" placeholder="Longitude" required="required" />
|
||||
<button type="submit" class="btn">Predict country where the UFO is seen</button>
|
||||
</form>
|
||||
|
||||
<p>{{ prediction_text }}</p>
|
||||
|
||||
</div>
|
||||
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
|
||||
Dê uma olhada na templateção neste arquivo. Note a sintaxe 'bigode' ao redor das variáveis que serão fornecidas pelo app, como o texto da previsão: `{{}}`. There's also a form that posts a prediction to the `/predict` route.
|
||||
|
||||
Finally, you're ready to build the python file that drives the consumption of the model and the display of predictions:
|
||||
|
||||
1. In `app.py` adicione:
|
||||
|
||||
```python
|
||||
import numpy as np
|
||||
from flask import Flask, request, render_template
|
||||
import pickle
|
||||
|
||||
app = Flask(__name__)
|
||||
|
||||
model = pickle.load(open("./ufo-model.pkl", "rb"))
|
||||
|
||||
|
||||
@app.route("/")
|
||||
def home():
|
||||
return render_template("index.html")
|
||||
|
||||
|
||||
@app.route("/predict", methods=["POST"])
|
||||
def predict():
|
||||
|
||||
int_features = [int(x) for x in request.form.values()]
|
||||
final_features = [np.array(int_features)]
|
||||
prediction = model.predict(final_features)
|
||||
|
||||
output = prediction[0]
|
||||
|
||||
countries = ["Australia", "Canada", "Germany", "UK", "US"]
|
||||
|
||||
return render_template(
|
||||
"index.html", prediction_text="Likely country: {}".format(countries[output])
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
app.run(debug=True)
|
||||
```
|
||||
|
||||
> 💡 Dica: quando você adiciona [`debug=True`](https://www.askpython.com/python-modules/flask/flask-debug-mode) while running the web app using Flask, any changes you make to your application will be reflected immediately without the need to restart the server. Beware! Don't enable this mode in a production app.
|
||||
|
||||
If you run `python app.py` or `python3 app.py` - your web server starts up, locally, and you can fill out a short form to get an answer to your burning question about where UFOs have been sighted!
|
||||
|
||||
Before doing that, take a look at the parts of `app.py`:
|
||||
|
||||
1. First, dependencies are loaded and the app starts.
|
||||
1. Then, the model is imported.
|
||||
1. Then, index.html is rendered on the home route.
|
||||
|
||||
On the `/predict` route, several things happen when the form is posted:
|
||||
|
||||
1. The form variables are gathered and converted to a numpy array. They are then sent to the model and a prediction is returned.
|
||||
2. The Countries that we want displayed are re-rendered as readable text from their predicted country code, and that value is sent back to index.html to be rendered in the template.
|
||||
|
||||
Using a model this way, with Flask and a pickled model, is relatively straightforward. The hardest thing is to understand what shape the data is that must be sent to the model to get a prediction. That all depends on how the model was trained. This one has three data points to be input in order to get a prediction.
|
||||
|
||||
In a professional setting, you can see how good communication is necessary between the folks who train the model and those who consume it in a web or mobile app. In our case, it's only one person, you!
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Challenge
|
||||
|
||||
Instead of working in a notebook and importing the model to the Flask app, you could train the model right within the Flask app! Try converting your Python code in the notebook, perhaps after your data is cleaned, to train the model from within the app on a route called `train`. Quais são os prós e contras de seguir esse método?
|
||||
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/18/)
|
||||
|
||||
## Revisão & Autoestudo
|
||||
|
||||
Existem muitas maneiras de construir um app web para consumir modelos de ML. Faça uma lista das maneiras que você poderia usar JavaScript ou Python para construir um app web para aproveitar o aprendizado de máquina. Considere a arquitetura: o modelo deve permanecer no app ou viver na nuvem? Se for o último, como você acessaria? Desenhe um modelo arquitetônico para uma solução web de ML aplicada.
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Experimente um modelo diferente](assignment.md)
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,14 +0,0 @@
|
||||
# Tente um modelo diferente
|
||||
|
||||
## Instruções
|
||||
|
||||
Agora que você construiu um aplicativo web usando um modelo de Regressão treinado, use um dos modelos de uma lição anterior de Regressão para refazer este aplicativo web. Você pode manter o estilo ou projetá-lo de forma diferente para refletir os dados da abóbora. Tenha cuidado para mudar as entradas para refletir o método de treinamento do seu modelo.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Necessita de Melhoria |
|
||||
| -------------------------- | -------------------------------------------------------- | -------------------------------------------------------- | -------------------------------------- |
|
||||
| | O aplicativo web funciona como esperado e está implantado na nuvem | O aplicativo web contém falhas ou apresenta resultados inesperados | O aplicativo web não funciona corretamente |
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que as traduções automáticas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas resultantes do uso desta tradução.
|
||||
@ -1,24 +0,0 @@
|
||||
# Construa um aplicativo web para usar seu modelo de ML
|
||||
|
||||
Nesta seção do currículo, você será introduzido a um tópico aplicado de ML: como salvar seu modelo Scikit-learn como um arquivo que pode ser usado para fazer previsões dentro de uma aplicação web. Uma vez que o modelo esteja salvo, você aprenderá como utilizá-lo em um aplicativo web construído em Flask. Primeiro, você criará um modelo usando alguns dados sobre avistamentos de OVNIs! Em seguida, você construirá um aplicativo web que permitirá que você insira um número de segundos com um valor de latitude e um valor de longitude para prever qual país relatou ter visto um OVNI.
|
||||
|
||||
|
||||
|
||||
Foto de <a href="https://unsplash.com/@mdherren?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Michael Herren</a> em <a href="https://unsplash.com/s/photos/ufo?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## Aulas
|
||||
|
||||
1. [Construa um Aplicativo Web](1-Web-App/README.md)
|
||||
|
||||
## Créditos
|
||||
|
||||
"Construa um Aplicativo Web" foi escrito com ♥️ por [Jen Looper](https://twitter.com/jenlooper).
|
||||
|
||||
♥️ Os quizzes foram escritos por Rohan Raj.
|
||||
|
||||
O conjunto de dados é originado de [Kaggle](https://www.kaggle.com/NUFORC/ufo-sightings).
|
||||
|
||||
A arquitetura do aplicativo web foi sugerida em parte por [este artigo](https://towardsdatascience.com/how-to-easily-deploy-machine-learning-models-using-flask-b95af8fe34d4) e [este repositório](https://github.com/abhinavsagar/machine-learning-deployment) por Abhinav Sagar.
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,302 +0,0 @@
|
||||
# Introdução à classificação
|
||||
|
||||
Nestas quatro lições, você explorará um foco fundamental do aprendizado de máquina clássico - _classificação_. Vamos percorrer o uso de vários algoritmos de classificação com um conjunto de dados sobre todas as brilhantes culinárias da Ásia e da Índia. Espero que você esteja com fome!
|
||||
|
||||
|
||||
|
||||
> Celebre as culinárias pan-asiáticas nestas lições! Imagem por [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
A classificação é uma forma de [aprendizado supervisionado](https://wikipedia.org/wiki/Supervised_learning) que possui muito em comum com técnicas de regressão. Se o aprendizado de máquina se trata de prever valores ou nomes para coisas usando conjuntos de dados, então a classificação geralmente se divide em dois grupos: _classificação binária_ e _classificação multiclasse_.
|
||||
|
||||
[](https://youtu.be/eg8DJYwdMyg "Introdução à classificação")
|
||||
|
||||
> 🎥 Clique na imagem acima para assistir a um vídeo: John Guttag do MIT apresenta a classificação
|
||||
|
||||
Lembre-se:
|
||||
|
||||
- **A regressão linear** ajudou você a prever relações entre variáveis e fazer previsões precisas sobre onde um novo ponto de dados se encaixaria em relação a essa linha. Por exemplo, você poderia prever _qual seria o preço de uma abóbora em setembro vs. dezembro_.
|
||||
- **A regressão logística** ajudou você a descobrir "categorias binárias": neste ponto de preço, _esta abóbora é laranja ou não-laranja_?
|
||||
|
||||
A classificação usa vários algoritmos para determinar outras maneiras de identificar o rótulo ou a classe de um ponto de dados. Vamos trabalhar com esses dados de culinária para ver se, ao observar um grupo de ingredientes, conseguimos determinar sua culinária de origem.
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/19/)
|
||||
|
||||
> ### [Esta lição está disponível em R!](../../../../4-Classification/1-Introduction/solution/R/lesson_10.html)
|
||||
|
||||
### Introdução
|
||||
|
||||
A classificação é uma das atividades fundamentais do pesquisador em aprendizado de máquina e do cientista de dados. Desde a classificação básica de um valor binário ("este e-mail é spam ou não?"), até a classificação e segmentação de imagens complexas usando visão computacional, é sempre útil ser capaz de classificar dados em categorias e fazer perguntas sobre eles.
|
||||
|
||||
Para declarar o processo de uma maneira mais científica, seu método de classificação cria um modelo preditivo que permite mapear a relação entre variáveis de entrada e variáveis de saída.
|
||||
|
||||
|
||||
|
||||
> Problemas binários vs. multiclasse para algoritmos de classificação lidarem. Infográfico por [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
Antes de iniciar o processo de limpeza de nossos dados, visualizá-los e prepará-los para nossas tarefas de ML, vamos aprender um pouco sobre as várias maneiras que o aprendizado de máquina pode ser aproveitado para classificar dados.
|
||||
|
||||
Derivada de [estatísticas](https://wikipedia.org/wiki/Statistical_classification), a classificação usando aprendizado de máquina clássico utiliza características, como `smoker`, `weight` e `age` para determinar _probabilidade de desenvolver a doença X_. Como uma técnica de aprendizado supervisionado semelhante aos exercícios de regressão que você realizou anteriormente, seus dados são rotulados e os algoritmos de ML usam esses rótulos para classificar e prever classes (ou 'características') de um conjunto de dados e atribuí-los a um grupo ou resultado.
|
||||
|
||||
✅ Reserve um momento para imaginar um conjunto de dados sobre culinárias. O que um modelo multiclasse seria capaz de responder? O que um modelo binário seria capaz de responder? E se você quisesse determinar se uma determinada culinária provavelmente usaria feno-grego? E se você quisesse ver se, dado um presente de uma sacola de compras cheia de anis estrelado, alcachofras, couve-flor e raiz-forte, você conseguiria criar um prato indiano típico?
|
||||
|
||||
[](https://youtu.be/GuTeDbaNoEU "Cestas de mistério malucas")
|
||||
|
||||
> 🎥 Clique na imagem acima para assistir a um vídeo. A premissa do programa 'Chopped' é a 'cesta de mistério', onde os chefs têm que fazer um prato a partir de uma escolha aleatória de ingredientes. Com certeza, um modelo de ML teria ajudado!
|
||||
|
||||
## Olá 'classificador'
|
||||
|
||||
A pergunta que queremos fazer sobre este conjunto de dados de culinária é na verdade uma **pergunta multiclasse**, pois temos várias culinárias nacionais potenciais para trabalhar. Dada uma quantidade de ingredientes, em qual dessas muitas classes os dados se encaixarão?
|
||||
|
||||
O Scikit-learn oferece vários algoritmos diferentes para classificar dados, dependendo do tipo de problema que você deseja resolver. Nas próximas duas lições, você aprenderá sobre vários desses algoritmos.
|
||||
|
||||
## Exercício - limpe e equilibre seus dados
|
||||
|
||||
A primeira tarefa a ser realizada, antes de iniciar este projeto, é limpar e **equilibrar** seus dados para obter melhores resultados. Comece com o arquivo em branco _notebook.ipynb_ na raiz desta pasta.
|
||||
|
||||
A primeira coisa a instalar é o [imblearn](https://imbalanced-learn.org/stable/). Este é um pacote do Scikit-learn que permitirá que você equilibre melhor os dados (você aprenderá mais sobre essa tarefa em um minuto).
|
||||
|
||||
1. Para instalar `imblearn`, execute `pip install`, assim:
|
||||
|
||||
```python
|
||||
pip install imblearn
|
||||
```
|
||||
|
||||
1. Importe os pacotes que você precisa para importar seus dados e visualizá-los, também importe `SMOTE` de `imblearn`.
|
||||
|
||||
```python
|
||||
import pandas as pd
|
||||
import matplotlib.pyplot as plt
|
||||
import matplotlib as mpl
|
||||
import numpy as np
|
||||
from imblearn.over_sampling import SMOTE
|
||||
```
|
||||
|
||||
Agora você está preparado para ler e importar os dados a seguir.
|
||||
|
||||
1. A próxima tarefa será importar os dados:
|
||||
|
||||
```python
|
||||
df = pd.read_csv('../data/cuisines.csv')
|
||||
```
|
||||
|
||||
Usando `read_csv()` will read the content of the csv file _cusines.csv_ and place it in the variable `df`.
|
||||
|
||||
1. Verifique a forma dos dados:
|
||||
|
||||
```python
|
||||
df.head()
|
||||
```
|
||||
|
||||
As primeiras cinco linhas parecem assim:
|
||||
|
||||
```output
|
||||
| | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
|
||||
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
|
||||
| 0 | 65 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 1 | 66 | indian | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 2 | 67 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 3 | 68 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 4 | 69 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
|
||||
```
|
||||
|
||||
1. Obtenha informações sobre esses dados chamando `info()`:
|
||||
|
||||
```python
|
||||
df.info()
|
||||
```
|
||||
|
||||
Sua saída se parece com:
|
||||
|
||||
```output
|
||||
<class 'pandas.core.frame.DataFrame'>
|
||||
RangeIndex: 2448 entries, 0 to 2447
|
||||
Columns: 385 entries, Unnamed: 0 to zucchini
|
||||
dtypes: int64(384), object(1)
|
||||
memory usage: 7.2+ MB
|
||||
```
|
||||
|
||||
## Exercício - aprendendo sobre culinárias
|
||||
|
||||
Agora o trabalho começa a se tornar mais interessante. Vamos descobrir a distribuição dos dados, por culinária
|
||||
|
||||
1. Plote os dados como barras chamando `barh()`:
|
||||
|
||||
```python
|
||||
df.cuisine.value_counts().plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Há um número finito de culinárias, mas a distribuição dos dados é desigual. Você pode corrigir isso! Antes de fazê-lo, explore um pouco mais.
|
||||
|
||||
1. Descubra quanto de dados está disponível por culinária e imprima:
|
||||
|
||||
```python
|
||||
thai_df = df[(df.cuisine == "thai")]
|
||||
japanese_df = df[(df.cuisine == "japanese")]
|
||||
chinese_df = df[(df.cuisine == "chinese")]
|
||||
indian_df = df[(df.cuisine == "indian")]
|
||||
korean_df = df[(df.cuisine == "korean")]
|
||||
|
||||
print(f'thai df: {thai_df.shape}')
|
||||
print(f'japanese df: {japanese_df.shape}')
|
||||
print(f'chinese df: {chinese_df.shape}')
|
||||
print(f'indian df: {indian_df.shape}')
|
||||
print(f'korean df: {korean_df.shape}')
|
||||
```
|
||||
|
||||
a saída se parece com:
|
||||
|
||||
```output
|
||||
thai df: (289, 385)
|
||||
japanese df: (320, 385)
|
||||
chinese df: (442, 385)
|
||||
indian df: (598, 385)
|
||||
korean df: (799, 385)
|
||||
```
|
||||
|
||||
## Descobrindo ingredientes
|
||||
|
||||
Agora você pode se aprofundar nos dados e aprender quais são os ingredientes típicos por culinária. Você deve eliminar dados recorrentes que criam confusão entre as culinárias, então vamos aprender sobre esse problema.
|
||||
|
||||
1. Crie uma função `create_ingredient()` em Python para criar um dataframe de ingredientes. Esta função começará removendo uma coluna não útil e classificará os ingredientes por sua contagem:
|
||||
|
||||
```python
|
||||
def create_ingredient_df(df):
|
||||
ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
|
||||
ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
|
||||
ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
|
||||
inplace=False)
|
||||
return ingredient_df
|
||||
```
|
||||
|
||||
Agora você pode usar essa função para ter uma ideia dos dez ingredientes mais populares por culinária.
|
||||
|
||||
1. Chame `create_ingredient()` and plot it calling `barh()`:
|
||||
|
||||
```python
|
||||
thai_ingredient_df = create_ingredient_df(thai_df)
|
||||
thai_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Faça o mesmo para os dados japoneses:
|
||||
|
||||
```python
|
||||
japanese_ingredient_df = create_ingredient_df(japanese_df)
|
||||
japanese_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Agora para os ingredientes chineses:
|
||||
|
||||
```python
|
||||
chinese_ingredient_df = create_ingredient_df(chinese_df)
|
||||
chinese_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Plote os ingredientes indianos:
|
||||
|
||||
```python
|
||||
indian_ingredient_df = create_ingredient_df(indian_df)
|
||||
indian_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Finalmente, plote os ingredientes coreanos:
|
||||
|
||||
```python
|
||||
korean_ingredient_df = create_ingredient_df(korean_df)
|
||||
korean_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Agora, elimine os ingredientes mais comuns que criam confusão entre culinárias distintas, chamando `drop()`:
|
||||
|
||||
Todos adoram arroz, alho e gengibre!
|
||||
|
||||
```python
|
||||
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
|
||||
labels_df = df.cuisine #.unique()
|
||||
feature_df.head()
|
||||
```
|
||||
|
||||
## Equilibrar o conjunto de dados
|
||||
|
||||
Agora que você limpou os dados, use [SMOTE](https://imbalanced-learn.org/dev/references/generated/imblearn.over_sampling.SMOTE.html) - "Técnica de Sobreamostragem Sintética de Minorias" - para equilibrá-los.
|
||||
|
||||
1. Chame `fit_resample()`, essa estratégia gera novas amostras por interpolação.
|
||||
|
||||
```python
|
||||
oversample = SMOTE()
|
||||
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
|
||||
```
|
||||
|
||||
Ao equilibrar seus dados, você terá melhores resultados ao classificá-los. Pense em uma classificação binária. Se a maior parte dos seus dados pertence a uma classe, um modelo de ML irá prever essa classe com mais frequência, apenas porque há mais dados para isso. Equilibrar os dados remove qualquer viés e ajuda a eliminar esse desequilíbrio.
|
||||
|
||||
1. Agora você pode verificar o número de rótulos por ingrediente:
|
||||
|
||||
```python
|
||||
print(f'new label count: {transformed_label_df.value_counts()}')
|
||||
print(f'old label count: {df.cuisine.value_counts()}')
|
||||
```
|
||||
|
||||
Sua saída se parece com:
|
||||
|
||||
```output
|
||||
new label count: korean 799
|
||||
chinese 799
|
||||
indian 799
|
||||
japanese 799
|
||||
thai 799
|
||||
Name: cuisine, dtype: int64
|
||||
old label count: korean 799
|
||||
indian 598
|
||||
chinese 442
|
||||
japanese 320
|
||||
thai 289
|
||||
Name: cuisine, dtype: int64
|
||||
```
|
||||
|
||||
Os dados estão limpos, equilibrados e muito deliciosos!
|
||||
|
||||
1. O último passo é salvar seus dados equilibrados, incluindo rótulos e características, em um novo dataframe que pode ser exportado para um arquivo:
|
||||
|
||||
```python
|
||||
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
|
||||
```
|
||||
|
||||
1. Você pode dar mais uma olhada nos dados usando `transformed_df.head()` and `transformed_df.info()`. Salve uma cópia desses dados para uso em lições futuras:
|
||||
|
||||
```python
|
||||
transformed_df.head()
|
||||
transformed_df.info()
|
||||
transformed_df.to_csv("../data/cleaned_cuisines.csv")
|
||||
```
|
||||
|
||||
Este novo CSV agora pode ser encontrado na pasta de dados raiz.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
Este currículo contém vários conjuntos de dados interessantes. Explore as pastas `data` e veja se alguma contém conjuntos de dados que seriam apropriados para classificação binária ou multiclasse? Que perguntas você faria sobre este conjunto de dados?
|
||||
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/20/)
|
||||
|
||||
## Revisão & Autoestudo
|
||||
|
||||
Explore a API do SMOTE. Para quais casos de uso ela é mais adequada? Que problemas ela resolve?
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Explore métodos de classificação](assignment.md)
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,14 +0,0 @@
|
||||
# Explore métodos de classificação
|
||||
|
||||
## Instruções
|
||||
|
||||
Na [documentação do Scikit-learn](https://scikit-learn.org/stable/supervised_learning.html), você encontrará uma extensa lista de maneiras de classificar dados. Faça uma pequena caça ao tesouro nesses documentos: seu objetivo é procurar métodos de classificação e combinar um conjunto de dados deste currículo, uma pergunta que você pode fazer sobre ele e uma técnica de classificação. Crie uma planilha ou tabela em um arquivo .doc e explique como o conjunto de dados funcionaria com o algoritmo de classificação.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Necessita Melhoria |
|
||||
| --------- | ---------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| | um documento é apresentado com uma visão geral de 5 algoritmos juntamente com uma técnica de classificação. A visão geral é bem explicada e detalhada. | um documento é apresentado com uma visão geral de 3 algoritmos juntamente com uma técnica de classificação. A visão geral é bem explicada e detalhada. | um documento é apresentado com uma visão geral de menos de três algoritmos juntamente com uma técnica de classificação e a visão geral não é bem explicada nem detalhada. |
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se a tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue