1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
# -*- coding: utf-8 -*-
"""Day 14_multiclass_Perceptron.ipynb
Automatically generated by Colaboratory.
Original file is located at
"""
 
from google.colab import drive
drive.mount('/gdrive')
 
PATH = "/gdrive/My Drive/Colab Notebooks/resources/"
 
# %matplotlib inline
 
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
import pandas as pd
import seaborn as sns
import time
 
 
from scipy.stats import norm, multivariate_normal
# installing packages for interactive graphs
import ipywidgets as widgets
from IPython.display import display
from ipywidgets import interact, interactive, fixed, interact_manual, IntSlider
 
## j개의 클래스에 대해서 각각의 Score를 메기고 그중 가장 높은 스코어를 기록한 클래스의
## 인덱스를 리턴.
 
def evaluate_classifier(w,b,x):
    k = len(b)
    scores = np.zeros(k)
 
    for j in range(k):
        scores[j] = np.dot(w[j,:],x) + b[j]
    
    return int( np.argmax(scores) )
 
def train_multiclass_perceptron(x,y,k,n_iters=100):
    ## x => n개의 관측치와 d개의 피처가 있는 n행 d열 매트릭스 x
    n,d = x.shape
    
    ## 0으로 초기화
    w = np.zeros((k,d))
    b = np.zeros(k)
    done = False
    converged = True
    iters = 0
    np.random.seed(None)
    
    while not(done):
        done = True
        
        ## 전체 n개의 관측치를 셔플해서 I에 할당.
        I = np.random.permutation(n)
        
        for j in I:
            
            ## 하나의 관측치 x[j,:] 에 대해서 모든 클래스의 w와 b로 계산했을때 가장 유력한 클래스를 받는다.
            pred_y = evaluate_classifier(w,b,x[j,:])
            true_y = int(y[j])
            
            ## 예측값이 실제 y 라벨과 다를경우.
            if pred_y != true_y:
                
                ##실제 추측되었어야 될 클래스의 w와 b를 업데이트 한다.
                w[true_y,:] = w[true_y,:] + x[j,:]
                b[true_y] = b[true_y] + 1.0
                
                ## 방금 추측된 클래스의 w와 b를 업데이트 한다.
                w[pred_y,:] = w[pred_y,:] - x[j,:]
                b[pred_y] = b[pred_y] - 1.0
                
                done = False
        iters = iters + 1
        if iters > n_iters:
            done = True
            converged = False
            
    if converged:
        print("Perceptron algorithm: iterations until convergence: ", iters) 
    else:
        print("Perceptron algorithm: did not converge within the specified number of iterations"
    return w, b, converged
 
def display_data_and_boundary(x,y,pred_fn):
    # Determine the x1- and x2- limits of the plot
    x1min = min(x[:,0]) - 1
    x1max = max(x[:,0]) + 1
    x2min = min(x[:,1]) - 1
    x2max = max(x[:,1]) + 1
    
    
    plt.xlim(x1min,x1max)
    plt.ylim(x2min,x2max)
    # Plot the data points
    k = int(max(y)) + 1
    cols = ['ro''k^''b*','gx']
    for label in range(k):
        plt.plot(x[(y==label),0], x[(y==label),1], cols[label%4], markersize=8)
    # Construct a grid of points at which to evaluate the classifier
    grid_spacing = 0.05
    
    ## 가로 0~10 세로 0~10까지 0.05를 기준으로 모든 x 좌표값 , y 좌표값 생성
    ## xx1 은 200 x 200 매트릭스에서 x1 변수의 자리수. 즉 x좌표, 
    ## xx2 는 200 x 200 매트릭스에서 x2 변수의 자리수, 즉 y좌표 만을 가지고 있다
    
    xx1, xx2 = np.meshgrid(np.arange(x1min, x1max, grid_spacing), np.arange(x2min, x2max, grid_spacing))
    
    ## 그리드 내의 0.05 간격 모든 좌표값 200 x 200 요소를 가진 매트릭스의 각 좌표값을 가지고 있는 리스트가 된다.
    grid = np.c_[xx1.ravel(), xx2.ravel()]
    
    ## 각 좌표에서 내가 구분한 값의 클래스를 담는 변수 Z
    Z = np.array([pred_fn(pt) for pt in grid])
    # Show the classifier's boundary using a color plot
    Z = Z.reshape(xx1.shape)
    
    plt.pcolormesh(xx1, xx2, Z, cmap=plt.cm.Pastel1, vmin=0, vmax=k)
    plt.show()
 
def run_multiclass_perceptron(datafile):
    data = np.loadtxt(datafile)
    n,d = data.shape
    # Create training set x and labels y
    x = data[:,0:2]
    y = data[:,2]
    k = int(max(y)) + 1
    print ("Number of classes: ", k)
    # Run the Perceptron algorithm for at most 1000 iterations
    w,b,converged = train_multiclass_perceptron(x,y,k,1000)
    # Show the data and boundary
    pred_fn = lambda p: evaluate_classifier(w,b,p)
    display_data_and_boundary(x,y,pred_fn)
 
run_multiclass_perceptron(PATH+'multiclassSVM/data_3.txt')
 
 
 
cs



출처 및 참고자료 : edx -  Machine Learning Fundamentals_week_6 Programming Assignment.2

'Python Library > Machine Learning' 카테고리의 다른 글

Day 10_PCA_MNIST  (0) 2019.07.21
Day 09_Multiclass_SVM( Sklean )  (0) 2019.07.20
Day 09_SVM_Sentiment_Analysis  (0) 2019.07.19
Day 08. Perceptron_Classification_Algorithm  (0) 2019.07.18
Day 07_ridge-regression_gradient_descent  (0) 2019.07.17

+ Recent posts