Saturday, June 9, 2018

Dasar Array NumPy

10:26 AM
Manipulasi data dalam Python hampir identik dengan manipulasi array NumPy: bahkan alat yang lebih baru seperti Pandas dibangun di sekitar array NumPy. Bagian ini akan menyajikan beberapa contoh penggunaan manipulasi array NumPy untuk mengakses data dan subarray, dan untuk membagi, membentuk kembali, dan menggabungkan array.

Script pada materi ini dapat di download di https://drive.google.com/open?id=11BhARn-6HxSNttWO91lXkwbwLJYmBW67

Atribut Array NumPy
Pertama mari kita bahas beberapa atribut array yang berguna. Kita akan mulai dengan mendefinisikan tiga larik acak, larik satu dimensi, dua dimensi, dan tiga dimensi. Kami akan menggunakan generate nomor acak Numpy, yang akan dibibit dengan nilai yang ditetapkan untuk memastikan bahwa susunan acak yang sama dihasilkan setiap kali kode ini dijalankan:
import numpy as np
np.random.seed(0)  # seed for reproducibility

x1 = np.random.randint(10, size=6)  # One-dimensional array
x2 = np.random.randint(10, size=(3, 4))  # Two-dimensional array
x3 = np.random.randint(10, size=(3, 4, 5))  # Three-dimensional array

Setiap larik memiliki atribut ndim (jumlah dimensi), shape (ukuran setiap dimensi), dan size (ukuran total larik):
print("x3 ndim: ", x3.ndim)
print("x3 shape:", x3.shape)
print("x3 size: ", x3.size)

x3 ndim:  3
x3 shape: (3, 4, 5)
x3 size:  60

Atribut lain yang berguna adalah dtype, tipe data dari array:
print("itemsize:", x3.itemsize, "bytes")
print("nbytes:", x3.nbytes, "bytes")

itemsize: 8 bytes
nbytes: 480 bytes
Secara umum, bahwa nbytes sama dengan itemsize kali size.

Array Indexing: Mengakses Element Tunggal
Jika Anda sudah familiar dengan pengindeksan list standar Python, pengindeksan di NumPy akan terasa cukup akrab. Dalam larik satu dimensi, nilai ((dihitung dari nol) dapat diakses dengan menentukan indeks yang diinginkan dalam tanda kurung siku, seperti halnya list Python:
x1
array([5, 0, 3, 3, 7, 9])
x1[0]
5
x1[4]
7

Untuk mengindeks dari ujung akhir larik, Anda dapat menggunakan indeks negatif:
x1[-1]
9
x1[-2]
7

Dalam susunan multi-dimensi, item dapat diakses menggunakan tuple indeks yang dipisahkan koma:
x2
array([[3, 5, 2, 4],
       [7, 6, 8, 8],
       [1, 6, 7, 7]])

x2[0, 0]
3

x2[2, 0]
1

x2[2, -1]
7

Nilai juga dapat dimodifikasi menggunakan notasi indeks di atas:
x2[0, 0] = 12
x2
array([[12,  5,  2,  4],
       [ 7,  6,  8,  8],
       [ 1,  6,  7,  7]])

Perlu diingat bahwa, tidak seperti list Python, array NumPy memiliki tipe tetap. Ini berarti, misalnya, jika Anda mencoba memasukkan nilai titik-mengambang ke array bilangan bulat, nilainya akan dipotong secara diam-diam.

x1[0] = 3.14159  # this will be truncated!
x1
array([3, 0, 3, 3, 7, 9])

Array Slicing: Pengaksesan Subarrays
Sama seperti kita dapat menggunakan tanda kurung siku untuk mengakses elemen-elemen array individual, kita juga dapat menggunakannya untuk mengakses subarray dengan notasi slice, ditandai dengan karakter titik dua (:). Sintaks slicing NumPy mengikuti dari list Python standar; untuk mengakses sebagian array x, gunakan ini:
x[start:stop:step]
Jika salah satu dari ini tidak ditentukan, mereka default ke nilai awal = 0, stop = ukuran dimensi, langkah = 1. Kita akan mengakses sub-larik dalam satu dimensi dan dalam beberapa dimensi.

One-dimensional subarrays
x = np.arange(10)
x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

x[:5]  # first five elements
array([0, 1, 2, 3, 4])

x[5:]  # elements after index 5
array([5, 6, 7, 8, 9])

x[4:7]  # middle sub-array
array([4, 5, 6])

x[::2]  # every other element
array([0, 2, 4, 6, 8])

x[1::2]  # every other element, starting at index 1
array([1, 3, 5, 7, 9])

Kasus yang berpotensi membingungkan adalah ketika nilai langkahnya negatif. Dalam hal ini, default untuk mulai dan berhenti bertukar. Ini menjadi cara mudah untuk membalikkan suatu array:

x[::-1]  # all elements, reversed
array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

x[5::-2]  # reversed every other from index 5
array([5, 3, 1])

Multi-dimensional subarrays
Irisan multi-dimensi bekerja dengan cara yang sama, dengan beberapa slices dipisahkan oleh koma. Sebagai contoh:
x2
array([[12,  5,  2,  4],
       [ 7,  6,  8,  8],
       [ 1,  6,  7,  7]])

x2[:2, :3]  # two rows, three columns
array([[12,  5,  2],
       [ 7,  6,  8]])

x2[:3, ::2]  # all rows, every other column
array([[12,  2],
       [ 7,  8],
       [ 1,  7]])

Akhirnya, dimensi subarray bahkan dapat dibalik bersama-sama:
x2[::-1, ::-1]
array([[ 7,  7,  6,  1],
       [ 8,  8,  6,  7],
       [ 4,  2,  5, 12]])

Akses array rows dan columns
Satu rutin yang biasa dibutuhkan adalah mengakses baris atau kolom tunggal dari suatu array. Ini dapat dilakukan dengan menggabungkan pengindeksan dan pengirisan/slicing, menggunakan irisan kosong yang ditandai oleh satu titik dua (:):

print(x2[:, 0])  # first column of x2
[12  7  1]

print(x2[0, :])  # first row of x2
[12  5  2  4]

Dalam kasus akses baris, slice kosong dapat dihilangkan untuk sintaks yang lebih ringkas:
print(x2[0])  # equivalent to x2[0, :]
[12  5  2  4]

Subarrays as no-copy views
Satu hal yang penting dan sangat berguna untuk diketahui tentang irisan larik adalah mereka mengembalikan  views/tampilan alih-alih copy/salinan data larik. Ini adalah salah satu area di mana NumPy array mengiris berbeda dari memotong daftar Python: dalam daftar, irisan akan salinan. Pertimbangkan array dua dimensi kami dari sebelumnya:






Lanjut lain waktu ...

Friday, June 8, 2018

MATPLOTLIB Session 1: Menyesuaikan Warna dan Gaya

11:46 PM
Ada beberapa cara untuk menentukan warna dalam matplotlib. Beberapa diantaranya adalah sebagai berikut:

- Triplet: Warna-warna ini dapat digambarkan sebagai triplet nilai nyata — komponen warna merah, biru, dan hijau. Komponen harus dalam interval [0, 1]. Dengan demikian, sintaks Python (1.0, 0.0, 0.0) akan mengkode warna merah yang murni, sementara (1.0, 0.0, 1.0) muncul sebagai warna merah muda yang kuat.
- Quadruplets: Ini berfungsi sebagai triplet, dan komponen keempat mendefinisikan nilai transparansi. Nilai ini juga harus dalam interval [0, 1]. Saat merender gambar ke file gambar, menggunakan warna transparan memungkinkan untuk membuat angka yang menyatu dengan latar belakang.

- Predefined: Matplotlib akan menafsirkan nama warna standar HTML sebagai warna aktual. Misalnya, string "red" akan diterima sebagai warna dan akan diartikan sebagai merah terang. Beberapa warna memiliki alias satu huruf, yang ditunjukkan dalam tabel berikut: b=Blue, g=Green, r=Red, c=Cyan, m=Magenta, y=Yellow, k=Black, w=White

- HTML Color String: matplotlib dapat menafsirkan string warna HTML sebagai warna sebenarnya. String semacam ini didefinisikan sebagai #RRGGBB di mana RR, GG, dan BB adalah nilai 8-bit untuk komponen merah, hijau, dan biru dalam heksadesimal.

- Grey Level String: matplotlib akan menafsirkan representasi string dari nilai titik mengambang sebagai bayangan abu-abu, seperti 0,75 untuk abu-abu terang sedang.Mengatur warna plot kurva dengan mengatur parameter warna dari fungsi pyplot.plot () sebagai berikut:
import numpy as np
import matplotlib.pyplot as plt

def pdf(X, mu, sigma):
    a = 1. / (sigma * np.sqrt(2. * np.pi))
    b = -1. / (2. * sigma ** 2)
    return a * np.exp(b * (X - mu) ** 2)

X = np.linspace(-6, 6, 1000)

for i in range(5):
    samples = np.random.standard_normal(50)
    mu, sigma = np.mean(samples), np.std(samples)
    plt.plot(X, pdf(X, mu, sigma), color = '.75')

plt.plot(X, pdf(X, 0., 1.), color = 'k')
plt.show()


lanjut nanti ....

Saturday, June 2, 2018

Klasifikasi Sederhana Dengan SVM - Support Vector Machine

9:35 AM
Support Vector Machine atau disingkat SVM adalah salah satu teknik klasifikasi.
Berikut ilustrasi singkat mengenai penggunaan SVM.  Anggap saja terdapat dua kelompok data dengan sebaran seperti berikut ini:
Dari sebaran data di atas kemudian timbul pertanyaan baru. Bagaimana kita dapat mengelompokkan datanya (meng-cluster data)? tentu dengan cara membagi data tersebut bukan. Dan berikut bebereapa contoh pembagian kelompok data jika ditarik garis lurus yang linear.
Dari gambaran di atas maka tentu banyak sekali kemungkinan pembagian kelompok data yang bisa dilakukan. Tugas berikutnya adalah bagaimana mencari pembagi terbaik dari sebaran data tersebut.

Dari kemungkinan garis pembagi di atas (dari gambar di atas terdapat 3 garis hyperplane pembagi), pasti Anda akan berpikir bahwa gambar berikut ini adalah yang terbaik. Yup...benar sekali, itulah Support Vector Machine
Mengapa pembagi di atas adalah yang terbaik? baik sekarang kita coba analisa gambar di bawah ini.

dari gambar bantu di atas tampak bahwa garis tersebut adalah "jalan terluas yang memisahkan kedua kelompok". Bila kembali ke gambar sebelumnya dan kita bandingkan maka gambar di atas adalah yang terbaik.
gambar di atas jelas kurang terbagi dengan baik, karena "di satu sisi sempit dan di sisi lainnya lebih luas".

Jarak yang memisahkan antara garis pemisah dengan kedua kelompok data terdekat disebut dengan margin, yaitu jarak terjauh yang paling memungkinkan antara garis dengan dua kelompok data yang terdekat dengan garis.

Sehingga perlu dipahami bahwa jarak lebar kotak abu-abu disebut dengan support vector (margin) dan garis tengah pemisah disebut dengan hyperplane.
Ok sekarang kita coba menerapkan SVM untuk memecahkan masalah pada kasus nyata.
Kita akan membuat klasifikasi antara kue cupcakes dan muffin, dimana secara umum keduanya memiliki bahan dasar yang hampir serupa, selain itu perbedaannya pada bahan topping-nya
Cupcakes vs Muffins

Tantangan
Mengklasifikasi resep cupcakes atau muffin. Ketika diberikan resep, kemudian memprediksi apakah itu adalah cupcake atau muffin

Tahapan
1. Menemukan datanya
2. Menerapkan model data science, pada kasus ini digunakan SVM
3. Meninjau ulang hasilnya

1. Menemukan Data Resep
Resep dapat dicari di google, kemudian mencatat datanya
Dari google kita dapatkan 10 resep muffin dan 10 resep cupcake teratas seperti tampak data di atas. Di sini timbul masalah karena ternyata "setiap resep menghasilkan jumlah adonan yang berbeda". Solusinya adalah dengan melakukan normalisasi data. Caranya dengan mengkonversi setiap nilai item menjadi bentuk persen, dimana setiap baris totalnya adalah 100% (atau mendekati).

Konversi amount based menjadi percent based:
Setelah data direkap, maka akan direpresenatasikan sebagai berikut:
Anda dapat mendownload data resep dengan format csv di https://drive.google.com/open?id=1DMvLLzlYP6AU4-NT5LRmlt5DRXzWhWWh. File CSV tersebut akan kita import dengan library Panda Python untuk diolah lebih lanjut.

2. Menerapkan Model Data Science (Model SVM)
Sekarang kita mulai memasuki script Python dengan langkah sebagai berikut:

  • Import Libraries
  • Import Data
  • Menyiapkan Data
  • Fit Modelnya
  • Visualisasi Hasil
  • Memprediksi Kasus Baru

STEP 1: Import Libraries
# Packages for analysis
import pandas as pd
import numpy as np
from sklearn import svm

# Packages for visuals
import matplotlib.pyplot as plt
import seaborn as sns; sns.set(font_scale=1.2)

# Allows charts to appear in the notebook
%matplotlib inline

# Pickle package
import pickle
STEP 2: Import Data
# Read in muffin and cupcake ingredient data
recipes = pd.read_csv('recipes_muffins_cupcakes.csv')
recipes
STEP 3: Persiapan Data
# Plot two ingredients
sns.lmplot('Flour', 'Sugar', data=recipes, hue='Type',
           palette='Set1', fit_reg=False, scatter_kws={"s": 70});
# Specify inputs for the model
# ingredients = recipes[['Flour', 'Milk', 'Sugar', 'Butter', 'Egg', 'Baking Powder', 'Vanilla', 'Salt']].as_matrix()
ingredients = recipes[['Flour','Sugar']].as_matrix()
type_label = np.where(recipes['Type']=='Muffin', 0, 1)

# Feature names
recipe_features = recipes.columns.values[1:].tolist()
recipe_features
STEP 4: Fit Modelnya
# Fit the SVM model
model = svm.SVC(kernel='linear')
model.fit(ingredients, type_label)
STEP 5: Visualisasi Hasilnya
# Get the separating hyperplane
w = model.coef_[0]
a = -w[0] / w[1]
xx = np.linspace(30, 60)
yy = a * xx - (model.intercept_[0]) / w[1]

# Plot the parallels to the separating hyperplane that pass through the support vectors
b = model.support_vectors_[0]
yy_down = a * xx + (b[1] - a * b[0])
b = model.support_vectors_[-1]
yy_up = a * xx + (b[1] - a * b[0])


# Plot the hyperplane
sns.lmplot('Flour', 'Sugar', data=recipes, hue='Type', palette='Set1', fit_reg=False, scatter_kws={"s": 70})
plt.plot(xx, yy, linewidth=2, color='black');

# Look at the margins and support vectors
sns.lmplot('Flour', 'Sugar', data=recipes, hue='Type', palette='Set1', fit_reg=False, scatter_kws={"s": 70})
plt.plot(xx, yy, linewidth=2, color='black')
plt.plot(xx, yy_down, 'k--')
plt.plot(xx, yy_up, 'k--')
plt.scatter(model.support_vectors_[:, 0], model.support_vectors_[:, 1], s=80, facecolors='none');

STEP 6: Prediksi Kasus Baru
# Create a function to guess when a recipe is a muffin or a cupcake
def muffin_or_cupcake(flour, sugar):
    if(model.predict([[flour, sugar]]))==0:
        print('You\'re looking at a muffin recipe!')
    else:
        print('You\'re looking at a cupcake recipe!')


# Predict if 50 parts flour and 20 parts sugar
muffin_or_cupcake(50, 20)

# Plot the point to visually see where the point lies
sns.lmplot('Flour', 'Sugar', data=recipes, hue='Type', palette='Set1', fit_reg=False, scatter_kws={"s": 70})
plt.plot(xx, yy, linewidth=2, color='black')
plt.plot(50, 20, 'yo', markersize='9');
# Predict if 40 parts flour and 20 parts sugar
muffin_or_cupcake(40,20)

Berikut kode program keseluruhan:
# Packages for analysis
import pandas as pd
import numpy as np
from sklearn import svm

# Packages for visuals
import matplotlib.pyplot as plt
import seaborn as sns; sns.set(font_scale=1.2)

# Allows charts to appear in the notebook
%matplotlib inline

# Pickle package
import pickle

# Read in muffin and cupcake ingredient data
recipes = pd.read_csv('recipes_muffins_cupcakes.csv')
recipes

# Plot two ingredients
sns.lmplot('Flour', 'Sugar', data=recipes, hue='Type',
           palette='Set1', fit_reg=False, scatter_kws={"s": 70});
 
# Specify inputs for the model
# ingredients = recipes[['Flour', 'Milk', 'Sugar', 'Butter', 'Egg', 'Baking Powder', 'Vanilla', 'Salt']].as_matrix()
ingredients = recipes[['Flour','Sugar']].as_matrix()
type_label = np.where(recipes['Type']=='Muffin', 0, 1)

# Feature names
recipe_features = recipes.columns.values[1:].tolist()
recipe_features

# Fit the SVM model
model = svm.SVC(kernel='linear')
model.fit(ingredients, type_label)

# Get the separating hyperplane
w = model.coef_[0]
a = -w[0] / w[1]
xx = np.linspace(30, 60)
yy = a * xx - (model.intercept_[0]) / w[1]

# Plot the parallels to the separating hyperplane that pass through the support vectors
b = model.support_vectors_[0]
yy_down = a * xx + (b[1] - a * b[0])
b = model.support_vectors_[-1]
yy_up = a * xx + (b[1] - a * b[0])

# Plot the hyperplane
sns.lmplot('Flour', 'Sugar', data=recipes, hue='Type', palette='Set1', fit_reg=False, scatter_kws={"s": 70})
plt.plot(xx, yy, linewidth=2, color='black');

# Look at the margins and support vectors
sns.lmplot('Flour', 'Sugar', data=recipes, hue='Type', palette='Set1', fit_reg=False, scatter_kws={"s": 70})
plt.plot(xx, yy, linewidth=2, color='black')
plt.plot(xx, yy_down, 'k--')
plt.plot(xx, yy_up, 'k--')
plt.scatter(model.support_vectors_[:, 0], model.support_vectors_[:, 1],
            s=80, facecolors='none');

# Create a function to guess when a recipe is a muffin or a cupcake
def muffin_or_cupcake(flour, sugar):
    if(model.predict([[flour, sugar]]))==0:
        print('You\'re looking at a muffin recipe!')
    else:
        print('You\'re looking at a cupcake recipe!')

# Predict if 50 parts flour and 20 parts sugar
muffin_or_cupcake(50, 20)

# Plot the point to visually see where the point lies
sns.lmplot('Flour', 'Sugar', data=recipes, hue='Type', palette='Set1', fit_reg=False, scatter_kws={"s": 70})
plt.plot(xx, yy, linewidth=2, color='black')
plt.plot(50, 20, 'yo', markersize='9');

# Predict if 40 parts flour and 20 parts sugar
muffin_or_cupcake(40,20)

Untuk script python lengkapnya silahkan download di Resep.ipynb.

___---SELAMAT MENCOBA, SEMOGA BERMANFAAT---___

Sunday, May 27, 2018

Regresi Linear Sederhana Dengan Sci-kit Learn

1:51 AM
Linear Regresi Sederhana
Data pelatihan digunakan untuk memperkirakan parameter model dalam masalah pembelajaran yang diawasi. Observasi terakhir dari variabel explanatory dan variabel responnya yang sesuai terdiri dari data pelatihan. Model dapat digunakan untuk memprediksi nilai variabel respon untuk nilai-nilai variabel explanatory yang belum pernah diamati sebelumnya.

Ingat bahwa tujuan dalam masalah regresi adalah memprediksi nilai variabel respons kontinyu. Dalam bab ini, kita akan memeriksa beberapa contoh model regresi linier. Kami akan membahas data pelatihan, model, algoritma pembelajaran, dan metrik evaluasi untuk setiap pendekatan. Untuk memulai, mari kita pertimbangkan regresi linier sederhana. Regresi linear sederhana dapat digunakan untuk memodelkan hubungan linear antara satu variabel respon dan satu variabel explanatory. Regresi linear telah diterapkan pada banyak masalah ilmiah dan sosial yang penting; contoh yang akan kita pertimbangkan mungkin bukan salah satunya.

Misalkan Anda ingin tahu harga pizza. Anda mungkin hanya melihat menu. Dalam kasus pembelajaran mesin, kami akan menggunakan regresi linier sederhana, bukan untuk memprediksi harga pizza berdasarkan atribut pizza yang dapat diamati. Mari kita memodelkan hubungan antara ukuran pizza dan harganya. Pertama, kita akan menulis program dengan scikit-learn yang dapat memprediksi harga pizza yang diberikan ukurannya. Kemudian, kita akan membahas bagaimana regresi linier sederhana bekerja dan bagaimana itu dapat digeneralisasikan untuk bekerja dengan jenis masalah lainnya. Mari kita asumsikan bahwa Anda telah mencatat diameter dan harga pizza yang sebelumnya telah Anda makan di jurnal pizza Anda. Observasi ini terdiri dari data pelatihan kami:
Kita dapat memvisualisasikan data pelatihan kami dengan memplotkannya pada grafik menggunakan matplotlib:
import matplotlib.pyplot as plt
X = [[6], [8], [10], [14], [18]]
y = [[7], [9], [13], [17.5], [18]]
plt.figure()
plt.title('Pizza price plotted against diameter')
plt.xlabel('Diameter in inches')
plt.ylabel('Price in dollars')
plt.plot(X, y, 'k.')
plt.axis([0, 25, 0, 25])
plt.grid(True)
plt.show()

Script di atas menghasilkan grafik berikut. Diameter dari pizza diplot pada sumbu x dan harga diplot pada sumbu y.
Kita dapat melihat dari grafik data pelatihan bahwa ada hubungan positif antara diameter pizza dan harganya, yang harus dikuatkan oleh pengalaman makan pizza kita sendiri. Ketika diameter pizza meningkat, harganya juga akan meningkat. Program prediktor harga pizza berikut memodelkan hubungan ini menggunakan regresi linier. Mari kita tinjau program berikut dan diskusikan cara kerja regresi linear:
import matplotlib.pyplot as plt
X = [[6], [8], [10], [14], [18]]
y = [[7], [9], [13], [17.5], [18]]
plt.figure()
plt.title('Pizza price plotted against diameter')
plt.xlabel('Diameter in inches')
plt.ylabel('Price in dollars')
plt.plot(X, y, 'k.')
plt.axis([0, 25, 0, 25])
plt.grid(True)
plt.show()

from sklearn.linear_model import LinearRegression
# Training data
X = [[6], [8], [10], [14], [18]]
y = [[7], [9], [13], [17.5], [18]]
# Create and fit the model
model = LinearRegression()
model.fit(X, y)
print 'A 12" pizza should cost: $%.2f' % model.predict([[12]])

Regresi linear sederhana mengasumsikan bahwa hubungan linear ada diantara variabel respon dan variabel explanatory; memodelkan hubungan ini dengan permukaan linier yang disebut hyperplane. Hyperplane adalah subruang yang memiliki satu dimensi lebih kecil dari ruang ambient yang memuatnya. Dalam regresi linier sederhana, ada satu dimensi untuk variabel respon dan dimensi lain untuk variabel explanatory, membuat total dua dimensi. Hyperplane regresi, oleh karena itu, memiliki satu dimensi; hyperplane dengan satu dimensi adalah garis.

Kelas sklearn.linear_model.LinearRegression adalah estimator. Estimator memprediksi nilai berdasarkan data yang diamati. Dalam scikit-learn, semua estimator menerapkan metode fit() dan predict(). Metode sebelumnya digunakan untuk mempelajari parameter model, dan metode yang terakhir digunakan untuk memprediksi nilai variabel respon untuk variabel explanatory menggunakan parameter yang dipelajari. Sangat mudah untuk bereksperimen dengan model yang berbeda menggunakan scikit-learn karena semua estimator menerapkan metode fit dan predict.

Metode fit LinearRegression mempelajari parameter dari model berikut untuk regresi linier sederhana:
y adalah nilai prediksi dari variabel respon; dalam contoh ini, harga pizza yang diprediksi. x adalah variabel explanatory. Intercept term 𝞪 dan koefisien 𝞫 adalah parameter dari model yang dipelajari oleh algoritma pembelajaran. Garis yang diplot dalam gambar berikut memodelkan hubungan antara ukuran pizza dan harganya. Dengan menggunakan model ini, kita akan mengharapkan harga pizza 8 inci menjadi sekitar $ 7,33, dan harga pizza 20 inci menjadi $ 18,75.
Menggunakan data latih untuk mempelajari nilai-nilai parameter pada regresi linier sederhana yang menghasilkan model pasangan terbaik disebut ordinary least squares atau linear least squares.

Mengevaluasi kesesuaian model dengan fungsi biaya (Cost Function)
Garis regresi yang dihasilkan oleh beberapa set nilai parameter diplot dalam gambar berikut. Bagaimana kita bisa menilai parameter mana yang menghasilkan garis regresi terbaik?
Fungsi biaya, juga disebut fungsi kerugian, digunakan untuk menentukan dan mengukur kesalahan suatu model. Perbedaan antara harga yang diprediksi oleh model dan harga yang diamati dari pizza dalam set pelatihan disebut residual atau kesalahan pelatihan. Kemudian, kami akan mengevaluasi model pada serangkaian data uji yang terpisah; perbedaan antara nilai prediksi dan yang teramati dalam data pengujian disebut kesalahan prediksi (prediciton error) atau kesalahan pengujian (test error).

Residu untuk model ditunjukkan oleh garis vertikal antara titik-titik untuk contoh pelatihan dan hyperplane regresi di plot berikut:
Kita dapat menghasilkan prediktor harga pizza terbaik dengan meminimalkan jumlah residual. Model kita cocok jika nilai yang diprediksinya untuk variabel respon mendekati nilai yang diamati untuk semua contoh pelatihan. Ukuran kebugaran model ini disebut sisa jumlah fungsi biaya kuadrat (sum of squares cost function). Secara formal, fungsi ini menilai kesesuaian suatu model dengan menjumlahkan residual kuadrat untuk semua contoh pelatihan kita. Jumlah kuadrat sisa dihitung dengan rumus dalam persamaan berikut, di mana yi adalah nilai yang diamati dan f(xi) adalah nilai prediksi:
Mari hitung jumlah sisa kuadrat untuk model kami dengan menambahkan dua baris berikut ke skrip sebelumnya:

import matplotlib.pyplot as plt
X = [[6], [8], [10], [14], [18]]
y = [[7], [9], [13], [17.5], [18]]
plt.figure()
plt.title('Pizza price plotted against diameter')
plt.xlabel('Diameter in inches')
plt.ylabel('Price in dollars')
plt.plot(X, y, 'k.')
plt.axis([0, 25, 0, 25])
plt.grid(True)
plt.show()

from sklearn.linear_model import LinearRegression
# Training data
X = [[6], [8], [10], [14], [18]]
y = [[7], [9], [13], [17.5], [18]]
# Create and fit the model
model = LinearRegression()
model.fit(X, y)
print 'A 12" pizza should cost: $%.2f' % model.predict([[18]])

import numpy as np
print 'Residual sum of squares: %.2f' % np.mean((model.predict(X)- y) ** 2)
Sekarang kita memiliki fungsi biaya (cost function), kita dapat menemukan nilai-nilai parameter model yang menguranginya.

Memecahkan kuadrat terkecil biasa (Ordinary Least Square) untuk regresi linier sederhana
Pada bagian ini, kita akan bekerja melalui pemecahan kuadrat terkecil biasa untuk regresi linier sederhana. Ingat bahwa regresi linier sederhana diberikan oleh persamaan berikut:
Juga, ingat bahwa tujuan kita adalah untuk memecahkan nilai-nilai dari 𝞫 dan 𝞪 yang meminimalkan fungsi biaya. Kita akan memecahkan 𝞫 dulu. Untuk melakukannya, kita akan menghitung varians x dan covariance x dan y.

Varians adalah ukuran seberapa jauh satu set nilai tersebar. Jika semua angka dalam set sama, varians dari himpunan adalah nol. Sebuah varians kecil menunjukkan bahwa angka-angka mendekati mean dari set, sementara satu set yang mengandung angka yang jauh dari mean dan satu sama lain akan memiliki varians yang besar. Varians dapat dihitung menggunakan persamaan berikut:
Pada persamaan sebelumnya, x-mean (x ada garis di atasnya) adalah nilai rata-rata x, xi adalah nilai x untuk instance pelatihan ke-i, dan n adalah jumlah instance pelatihan. Mari menghitung varians diameter pizza di set pelatihan kita:
from __future__ import division
xbar = (6 + 8 + 10 + 14 + 18) / 5
variance = ((6 - xbar)**2 + (8 - xbar)**2 + (10 - xbar)**2 + (14 - xbar)**2 + (18 - xbar)**2) / 4
print variance
NumPy juga menyediakan metode var untuk menghitung varians. Parameter kata kunci ddof dapat digunakan untuk mengatur koreksi Bessel untuk menghitung varians sampel:
Kovarian adalah ukuran dari seberapa banyak dua variabel berubah bersama. Jika nilai dari variabel meningkat bersama-sama, kovarian mereka positif. Jika satu variabel cenderung meningkat sementara yang lain menurun, kovarian mereka negatif. Jika tidak ada hubungan linear antara dua variabel, maka kovariannya akan sama dengan nol; variabel tidak linier berkorelasi tetapi tidak selalu independen. Kovarian dapat dihitung menggunakan rumus berikut:
Seperti halnya varians, xi adalah diameter dari contoh pelatihan ke-i, x adalah mean dari diameter, y adalah mean dari harga, yi adalah harga dari instance pelatihan ke-i, dan n adalah jumlah instance pelatihan. Mari kita menghitung kovarians diameter dan harga pizza dalam set pelatihan:
xbar = (6 + 8 + 10 + 14 + 18) / 5
ybar = (7 + 9 + 13 + 17.5 + 18) / 5
cov = ((6 - xbar) * (7 - ybar) + (8 - xbar) * (9 - ybar) + (10 - xbar) * (13 - ybar) + (14 - xbar) * (17.5 - ybar) + (18 - xbar) * (18 - ybar)) / 4
print cov

import numpy as np
print np.cov([6, 8, 10, 14, 18], [7, 9, 13, 17.5, 18])[0][1]
Sekarang kita telah menghitung varians dari variabel explanatory dan kovarians dari variabel respon dan variabel explanatory, kita dapat memecahkan 𝛽 menggunakan rumus berikut:
Setelah 𝛽 dipecahkan, kita bisa menyelesaikan 𝞪 menggunakan rumus berikut:
Dalam rumus sebelumnya, y-mean (y di atasnya ada garis) adalah rata-rata y dan x-mean (x di atasnya ada garis) adalah rerata x.(x-mean, y-mean) adalah koordinat dari pusat massa, titik yang harus dilalui oleh model. Kita dapat menggunakan centroid dan nilai 𝛽 untuk memecahkan 𝞪 sebagai berikut:

yrerata = ybar = (7 + 9 + 13 + 17.5 + 18) / 5 = 12.9
𝛽  = 0.976293103448276
xrerata = xbar = (6 + 8 + 10 + 14 + 18) / 5 = 11.2

jadi:
Sekarang kita telah memecahkan nilai-nilai parameter model yang meminimalkan fungsi biaya, kita dapat menghubungkan diameter pizza dan memprediksi harganya. Misalnya, pizza 11 inci diperkirakan berharga sekitar $ 12,70, dan pizza 18 inci diperkirakan berharga sekitar $ 19,54. Selamat! Anda menggunakan regresi linier sederhana untuk memprediksi harga pizza.

Alpha Beta x (Diameter pizza) Harga Prediksi = Alpha + (Beta * x)
1.96551724137931 0.976293103448276 11 12.7047413793103
1.96551724137931 0.976293103448276 12 13.6810344827586
1.96551724137931 0.976293103448276 15 16.6099137931034
1.96551724137931 0.976293103448276 18 19.5387931034483
1.96551724137931 0.976293103448276 21 22.4676724137931

Mengevaluasi Model
Kami telah menggunakan algoritma pembelajaran untuk memperkirakan parameter model dari data pelatihan. Bagaimana kita bisa menilai apakah model kita mewakili dengan baik dari hubungan yang sebenarnya? Mari kita berasumsi bahwa Anda telah menemukan halaman lain dalam jurnal pizza Anda. Kami akan menggunakan entri di halaman ini sebagai tes yang ditetapkan untuk mengukur kinerja model:
Beberapa ukuran dapat digunakan untuk menilai kemampuan prediksi model kami. Kami akan mengevaluasi prediksi harga pizza menggunakan r-squared. R-Squared mengukur seberapa baik nilai-nilai yang diamati dari variabel respon diprediksi oleh model. Lebih konkret, r-squared adalah proporsi dari varians dalam variabel respon yang dijelaskan oleh model. Skor r-squared dari satu menunjukkan bahwa variabel respon dapat diprediksi tanpa kesalahan menggunakan model. Skor r-squared dari satu setengah menunjukkan bahwa setengah dari varians dalam variabel respon dapat diprediksi menggunakan model. Ada beberapa metode untuk menghitung r-squaed. Dalam kasus regresi linier sederhana, r-squared sama dengan kuadrat koefisien korelasi momen produk Pearson, atau Pearson's r

Dengan menggunakan metode ini, r-kuadrat harus berupa bilangan positif antara nol dan satu. Metode ini intuitif; jika r-squared menjelaskan proporsi varians dalam variabel respon yang dijelaskan oleh model, itu tidak boleh lebih besar dari satu atau kurang dari nol. Metode lain, termasuk metode yang digunakan oleh scikit-learn, tidak menghitung r-squared sebagai kuadrat r Pearson, dan dapat mengembalikan r-squared negatif jika model berkinerja sangat buruk. Kami akan mengikuti metode yang digunakan oleh scikit-learn untuk menghitung r-squared untuk prediksi harga pizza kami.

Pertama, kita harus mengukur jumlah total kuadrat. yi adalah nilai yang diamati dari variabel respon untuk instance pengujian ke-i, dan ymean (y diatasnya ada tanda garis) adalah mean dari nilai-nilai yang teramati dari variabel respon:

Selanjutnya, kita harus menemukan jumlah sisa kuadrat. Ingat bahwa ini juga cost function kita.
Akhirnya, kita dapat menemukan r-squared menggunakan rumus berikut:
Skor r-squared sebesar 0,6620 menunjukkan bahwa sebagian besar varians dalam harga contoh tes yang telah dijelaskan oleh model. Sekarang, mari kita konfirmasikan perhitungan kita menggunakan scikit-learn. Metode skor LinearRegression mengembalikan nilai r-squared model, seperti yang terlihat pada contoh berikut:

from sklearn.linear_model import LinearRegression
X = [[6], [8], [10], [14], [18]]
y = [[7], [9], [13], [17.5], [18]]
X_test = [[8], [9], [11], [16], [12]]
y_test = [[11], [8.5], [15], [18], [11]]
model = LinearRegression()
model.fit(X, y)
print 'R-squared: %.4f' % model.score(X_test, y_test)

---!!! SEMOGA BISA BERMANFAAT !!!----
Subscribe to: Posts (Atom)


Popular Posts

Contact Form

Name

Email *

Message *