Cara menggunakan scikit php

Dalam modul ini, Anda mengunduh dataset, menjalankan praproses dataset, memisahkan dataset ke pelatihan dan validasi, kemudian mengeksekusi dataset di bucket Amazon S3 Anda.

Waktu untuk Menyelesaikan Modul: 20 Menit

Model ML Anda akan dilatih di dataset 20newsgroups yang berisi 20.000 postingan grup berita berisi 20 topik. Dataset 20newsgroups dikuratori oleh Carnegie Mellon, University School of Computer Science, dan tersedia secara umum dari scikit-learn.

Langkah 1. Ambil dataset
Untuk mempersiapkan data, latih model ML dan terapkan, Anda harus terlebih dulu mengimpor sejumlah perpustakaan dan menentukan beberapa variabel lingkungan di lingkungan Jupyter notebook Anda. Salin dan tempel kode berikut ke sel kode di instans Jupyter notebook, lalu pilih Jalankan.
Catatan: Pastikan mengganti nama BUCKET sagemaker-xx dengan nama bucket S3 Anda.
```
import numpy as np
import os
import matplotlib.pyplot as plt
import sagemaker
import seaborn as sns
from sklearn.datasets import fetch_20newsgroups
from sklearn.datasets.twenty_newsgroups import strip_newsgroup_header, strip_newsgroup_quoting, strip_newsgroup_footer
newsgroups_train = fetch_20newsgroups(subset='train')['data']
newsgroups_test = fetch_20newsgroups(subset = 'test')['data']
NUM_TOPICS = 30
NUM_NEIGHBORS = 10
BUCKET = 'sagemaker-xx'
PREFIX = '20newsgroups'
```
Saat kode berjalan, tanda * akan muncul di antara kurung kotak. Setelah beberapa saat, eksekusi kode akan selesai, dan tanda * akan berganti menjadi angka 1.

(Klik untuk memperbesar)
Dataset scikit-learn secara alami dipecah menjadi set pelatihan dan set tes. Anda menyelesaikan beberapa prapemrosesan di set tes, kemudian menyisihkannya untuk digunakan hanya untuk pengujian. Anda memisahkan set pelatihan menjadi set pelatihan dan validasi untuk menguji kinerja model selama pelatihan.
Langkah 2. Praproses data
Dalam pemrosesan bahasa alami, salah satu tugas pertama sebelum melatih model machine learning adalah melakukan prapemrosesan pada data teks mentah ke nilai numerik yang dapat dibaca mesin. Proses ini biasanya memerlukan urutan langkah-langkah.
Pertama, Anda menggunakan API yang diberikan oleh scikit-learn untuk melepaskan header, footer, dan kutipan dari dataset.
Di Jupyter notebook Anda, salin dan tempelkan kode berikut ke sel kode Anda, lalu pilih Jalankan.
```
for i in range(len(newsgroups_train)):
    newsgroups_train[i] = strip_newsgroup_header(newsgroups_train[i])
    newsgroups_train[i] = strip_newsgroup_quoting(newsgroups_train[i])
    newsgroups_train[i] = strip_newsgroup_footer(newsgroups_train[i])
```
(Klik untuk memperbesar)

Sekarang, lihat salah satu contoh pelatihan. Salin dan tempel kode berikut ke Jupyter notebook Anda.
Seperti yang dapat Anda lihat, data tersebut hanya berupa paragraf teks biasa. Agar data tersebut dapat dibaca mesin, Anda perlu melakukan “tokenisasi” pada data ini ke format numerik dengan menetapkan “token” ke setiap kata di kalimat tersebut. Anda dapat membatasi jumlah total token hingga 2.000 dengan terlebih dahulu menghitung token yang paling umum dan hanya mempertahankan 2.000 teratas. Pembatasan ini ditetapkan karena kata yang kurang umum akan memiliki dampak yang semakin berkurang pada model topik dan dapat diabaikan. Kemudian, untuk setiap dokumen, Anda menggunakan model Bag of Words (BoW) untuk mengonversi dokumen ke vektor yang terus melacak jumlah setiap kali token muncul di contoh pelatihan tersebut.

(Klik untuk memperbesar)
Dalam contoh ini, Anda menggunakan WordNetLemmatizer, lemmatizer dari paket nltk, dan menggunakan CountVectorizer di scikit-learn untuk menjalankan penghitungan token. WordNetLemmatizer menggunakan kata benda sebagai kelas kata (POS) untuk lematisasi kata menjadi lema. Lematisasi bertujuan mengembalikan kata aktual, sementara stemming, pendekatan prapemrosesan lainnya, dapat sering mengembalikan kata nonkamus atau pangkal akar yang kerap kali kurang bermanfaat dalam machine learning.
Dalam daftar pemahaman, Anda menerapkan aturan sederhana: hanya mempertimbangkan kata yang tidak lebih panjang dari 2 karakter, dimulai dengan huruf, dan cocok dengan token_pattern.
Dalam Jupyter notebook Anda, salin dan tempelkan kode berikut dan pilih Jalankan.
```
!pip install nltk
import nltk
nltk.download('punkt')
nltk.download('wordnet')
from nltk import word_tokenize          
from nltk.stem import WordNetLemmatizer 
import re
token_pattern = re.compile(r"(?u)\b\w\w+\b")
class LemmaTokenizer(object):
    def __init__(self):
        self.wnl = WordNetLemmatizer()
    def __call__(self, doc):
        return [self.wnl.lemmatize(t) for t in word_tokenize(doc) if len(t) >= 2 and re.match("[a-z].*",t) 
                and re.match(token_pattern, t)]
```
(Klik untuk memperbesar)
Dengan tokenizer ditetapkan, kini Anda dapat menjalankan penghitungan token sembari membatasi vocab_size ke 2.000.
Dalam Jupyter notebook Anda, salin dan tempelkan kode berikut dan pilih Jalankan.
```
import time
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer
vocab_size = 2000
print('Tokenizing and counting, this may take a few minutes...')
start_time = time.time()
vectorizer = CountVectorizer(input='content', analyzer='word', stop_words='english',
                             tokenizer=LemmaTokenizer(), max_features=vocab_size, max_df=0.95, min_df=2)
vectors = vectorizer.fit_transform(newsgroups_train)
vocab_list = vectorizer.get_feature_names()
print('vocab size:', len(vocab_list))

# random shuffle
idx = np.arange(vectors.shape[0])
newidx = np.random.permutation(idx) # this will be the labels fed into the KNN model for training
# Need to store these permutations:

vectors = vectors[newidx]

print('Done. Time elapsed: {:.2f}s'.format(time.time() - start_time))
```
Sekarang, lihat kode lebih dekat.
API CountVectorizer menggunakan tiga hyperparameter yang dapat membantu dengan overfitting atau underfitting sembari melatih model berikutnya.
Hyperparameter pertama adalah max_features yang Anda tetapkan untuk menjadi ukuran kosakata. Seperti yang disebutkan, kosakata yang sangat banyak terdiri dari kata yang jarang dapat menambahkan kata yang tidak perlu ke data, yang akan menyebabkan Anda melatih model yang buruk.
Hyperparameter kedua dan ketiga adalah max_df dan min_df. Parameter min_df mengabaikan kata yang muncul di kurang dari min_df % dokumen dan max_df mengabaikan kata yang muncul di lebih dari max_df % pada dokumen. Parameter max_df memastikan bahwa kata yang sangat umum yang tidak diambil oleh stop word akan dihapus. Secara umum, pendekatan ini adalah praktik yang baik karena model topik berusaha mengidentifikasi topik dengan menemukan kelompok kata yang berbeda yang berkumpul menjadi satu topik. Jika beberapa kata muncul di semua dokumen, kata-kata ini akan mengurangi ekspresi model. Sebaliknya, meningkatkan parameter min_df memastikan bahwa kata yang sangat jarang tidak disertakan, yang akan mengurangi kecenderungan model menjadi overfitting.
Untuk menghasilkan set pelatihan dan validasi, Anda terlebih dulu mengacak vektor BOW yang dihasilkan oleh API CountVectorizer. Sementara menjalankan pengacakan, Anda tetap melacak indeks asli serta indeks yang diacak. Nantinya di lab ini, ketika Anda menggunakan model KNN untuk mencari dokumen yang mirip dengan dokumen yang tidak terlihat, Anda perlu mengetahui indeks asli yang terkait dengan data pelatihan sebelum mengacak.

(Klik untuk memperbesar)

Langkah 3. Mengeksekusi dataset pelatihan dan validasi di Amazon S3

Dengan prapemrosesan yang siap, Anda kini siap untuk membuat dataset pelatihan dan validasi dan mengeksekusinya di bucket S3 Anda.

Pertama, konversi vektor ke representasi yang jarang.

Salin dan tempel kode berikut ke Jupyter notebook Anda, lalu pilih Jalankan.

import scipy.sparse as sparse
vectors = sparse.csr_matrix(vectors, dtype=np.float32)
print(type(vectors), vectors.dtype)

(Klik untuk memperbesar)

Sekarang, pisahkan menjadi data pelatihan dan data tes.

Data pelatihan (80%) digunakan selama putaran pelatihan model. Anda menggunakan pengoptimalan berbasis gradien untuk menyempurnakan parameter model secara konstan. Pengoptimalan berbasis gradien adalah cara untuk menemukan nilai parameter model yang memperkecil kesalahan model dengan menggunakan gradien fungsi kehilangan model.
Data tes (sisa 20% pelanggan) digunakan untuk mengevaluasi kinerja model dan mengukur seberapa baik model yang dilatih menyamaratakan data tidak terlihat.

Catatan: Pendekatan berikut untuk memisahkan data hanya berfungsi jika seluruh dataset telah diacak terlebih dulu. Secara opsional, Anda dapat menggunakan API sklearn.modelselection train_test_split untuk menjalankan pemisahan dan menetapkan nilai awal random_state ke nilai numerik untuk memastikan pengulangan.

Salin kode berikut ke dalam sel kode baru dan pilih Jalankan untuk memisahkan data:

# Convert data into training and validation data
n_train = int(0.8 * vectors.shape[0])

# split train and test
train_vectors = vectors[:n_train, :]
val_vectors = vectors[n_train:, :]

# further split test set into validation set (val_vectors) and test  set (test_vectors)

print(train_vectors.shape,val_vectors.shape)

(Klik untuk memperbesar)

Berikutnya, tetapkan jalur pelatihan dan validasi, serta jalur output tempat artefak NTM akan disimpan setelah pelatihan model.

Salin dan tempelkan kode berikut ke sel kode baru dan pilih Jalankan.

from sagemaker import get_execution_role

role = get_execution_role()

bucket = BUCKET
prefix = PREFIX

train_prefix = os.path.join(prefix, 'train')
val_prefix = os.path.join(prefix, 'val')
output_prefix = os.path.join(prefix, 'output')

s3_train_data = os.path.join('s3://', bucket, train_prefix)
s3_val_data = os.path.join('s3://', bucket, val_prefix)
output_path = os.path.join('s3://', bucket, output_prefix)
print('Training set location', s3_train_data)
print('Validation set location', s3_val_data)
print('Trained model will be saved at', output_path)

(Klik untuk memperbesar)

NTM mendukung format protobuf CSV dan RecordIO untuk data dalam saluran pelatihan, validasi, dan pengujian. Fungsi pembantu berikut mengonversi vektor mentah ke format RecordIO, dan menggunakan parameter n_parts, secara opsional memecah dataset menjadi shard yang dapat digunakan untuk pelatihan yang didistribusikan.

Untuk mengonversi vektor, salin dan tempel kode berikut ke sel kode baru dan pilih Jalankan.

def split_convert_upload(sparray, bucket, prefix, fname_template='data_part{}.pbr', n_parts=2):
    import io
    import boto3
    import sagemaker.amazon.common as smac
    
    chunk_size = sparray.shape[0]// n_parts
    for i in range(n_parts):

        # Calculate start and end indices
        start = i*chunk_size
        end = (i+1)*chunk_size
        if i+1 == n_parts:
            end = sparray.shape[0]
        
        # Convert to record protobuf
        buf = io.BytesIO()
        smac.write_spmatrix_to_sparse_tensor(array=sparray[start:end], file=buf, labels=None)
        buf.seek(0)
        
        # Upload to s3 location specified by bucket and prefix
        fname = os.path.join(prefix, fname_template.format(i))
        boto3.resource('s3').Bucket(bucket).Object(fname).upload_fileobj(buf)
        print('Uploaded data to s3://{}'.format(os.path.join(bucket, fname)))
split_convert_upload(train_vectors, bucket=bucket, prefix=train_prefix, fname_template='train_part{}.pbr', n_parts=8)
split_convert_upload(val_vectors, bucket=bucket, prefix=val_prefix, fname_template='val_part{}.pbr', n_parts=1)

(Klik untuk memperbesar)

Berhasil! Anda telah menyiapkan dan mengeksekusi dataset!

Dalam modul ini, Anda mengimpor dan mengambil dataset yang Anda gunakan untuk sistem rekomendasi konten. Kemudian, Anda menyiapkan dataset melalui prapemrosesan, lematisasi, dan tokenisasi. Terakhir, Anda memisahkan dataset menjadi set pelatihan dan validasi, kemudian menjalankannya di bucket Amazon S3 Anda.

Di modul berikutnya, Anda melatih model topik dengan Algoritme NTM Amazon SageMaker dan menerapkan model tersebut ke Amazon SageMaker.

Dukungan AWS dukungan untuk Internet Explorer berakhir pada 07/31/2022. Peramban yang didukung adalah Chrome, Firefox, Edge, dan Safari. Pelajari selengkapnya »