python 감지 기 알고리즘 구현(일괄 처리)
먼저 감지 기 클래스 만 들 기:2 분류 에 사용
# -*- coding: utf-8 -*-
import numpy as np
class Perceptron(object):
"""
:
https://blog.csdn.net/simple_the_best/article/details/54619495
:
w0:
w:
learning_rate:
threshold:
"""
def __init__(self,learning_rate=0.01,threshold=0.001):
self.learning_rate=learning_rate
self.threshold=threshold
def train(self,x,y):
"""
:
x: , n*m( m ,x m ), n
y: , n*1, 1 -1( )
:
self:object
"""
self.w0=0.0
self.w=np.full(x.shape[1],0.0)
k=0
while(True):
k+=1
dJw0=0.0
dJw=np.zeros(x.shape[1])
err=0.0
for i in range(0,x.shape[0]):
if not (y[i]==1 or y[i]==-1):
print(" 1 -1! !")
break
update=self.learning_rate*0.5*(y[i]-self.predict(x[i]))
dJw0+=update
dJw+=update*x[i]
err+=np.abs(0.5*(y[i]-self.predict(x[i])))
self.w0 += dJw0
self.w += dJw
if np.abs(np.sum(self.learning_rate*dJw))<self.threshold or k>500:
print(" :",k," :",err)
break
return self
def predict(self,x):
"""
:
x: ,1*m ,1 ,m
:
yhat: ,1 -1,1 ,-1
"""
if np.matmul(self.w,x.T)+self.w0>0:
yhat=1
else:
yhat=-1
return yhat
def predict_value(self,x):
"""
:
x: ,1*m ,1 ,m
:
y:
"""
y=np.matmul(self.w,x.T)+self.w0
return y
그 다음 에 Iris 데이터 세트 에 Iris 류 를 만 들 고 50%의 검증 에 필요 한 데 이 터 를 만 들 며 서로 다른 견본 수량의 데이터 세트 를 만 들 수 있 습 니 다.
# -*- coding: utf-8 -*-
"""
Author:CommissarMa
2018 5 23 16 52
"""
import numpy as np
import scipy.io as sio
class Iris(object):
"""Iris
:
data: size iris
size:
way:one against the rest || one against one
:
5 (5-cv), 5
:one against the rest
"""
def __init__(self,size=50,way="one against the rest"):
"""
size:
"""
data=sio.loadmat("C:\\Users\\CommissarMa\\Desktop\\ \\ ppt\\PR \\iris_data.mat")
iris_data=data['iris_data']#iris_data: ,shape:150*4,1-50 ,51-100 ,101-150
self.size=size
self.way=way
self.data=np.zeros((size*3,4))
for r in range(0,size*3):
self.data[r]=iris_data[int(r/size)*50+r%size]
def generate_train_data(self,index_fold,index_class,neg_class=None):
"""
index_fold:5 , :0,1,2,3,4
index_class: , : -1, 1
"""
if self.way=="one against the rest":
fold_size=int(self.size/5)# 5
train_data=np.zeros((fold_size*4*3,4))
label_data=np.full((fold_size*4*3),-1)
for r in range(0,fold_size*4*3):
n_class=int(r/(fold_size*4))#
n_fold=int((r%(fold_size*4))/fold_size)#
n=(r%(fold_size*4))%fold_size#
if n_fold<index_fold:
train_data[r]=self.data[n_class*self.size+n_fold*fold_size+n]
else:
train_data[r]=self.data[n_class*self.size+(n_fold+1)*fold_size+n]
label_data[fold_size*4*index_class:fold_size*4*(index_class+1)]=1
elif self.way=="one against one":
if neg_class==None:
print("one against one !")
return
else:
fold_size=int(self.size/5)# 5
train_data=np.zeros((fold_size*4*2,4))
label_data=np.full((fold_size*4*2),-1)
for r in range(0,fold_size*4*2):
n_class=int(r/(fold_size*4))#
n_fold=int((r%(fold_size*4))/fold_size)#
n=(r%(fold_size*4))%fold_size#
if n_class==0:#
if n_fold<index_fold:
train_data[r]=self.data[index_class*self.size+n_fold*fold_size+n]
else:
train_data[r]=self.data[index_class*self.size+(n_fold+1)*fold_size+n]
if n_class==1:#
if n_fold<index_fold:
train_data[r]=self.data[neg_class*self.size+n_fold*fold_size+n]
else:
train_data[r]=self.data[neg_class*self.size+(n_fold+1)*fold_size+n]
label_data[0:fold_size*4]=1
else:
print(" ! one against one one against the rest!")
return
return train_data,label_data
def generate_test_data(self,index_fold):
"""
index_fold:5 , :0,1,2,3,4
:
test_data: index_fold
label_data: 0,1,2
"""
fold_size=int(self.size/5)# 5
test_data=np.zeros((fold_size*3,4))
label_data=np.zeros(fold_size*3)
for r in range(0,fold_size*3):
test_data[r]=self.data[int(int(r/fold_size)*self.size)+int(index_fold*fold_size)+r%fold_size]
label_data[0:fold_size]=0
label_data[fold_size:fold_size*2]=1
label_data[fold_size*2:fold_size*3]=2
return test_data,label_data
그리고 우 리 는 훈련 테스트 를 진행 합 니 다.먼저 one against the rest 전략 을 사용 합 니 다.
# -*- coding: utf-8 -*-
from perceptron import Perceptron
from iris_data import Iris
import numpy as np
if __name__=="__main__":
iris=Iris(size=50,way="one against the rest")
correct_all=0
for n_fold in range(0,5):
p=[Perceptron(),Perceptron(),Perceptron()]
for c in range(0,3):
x,y=iris.generate_train_data(index_fold=n_fold,index_class=c)
p[c].train(x,y)
# ,
correct=0
x_test,y_test=iris.generate_test_data(index_fold=n_fold)
num=len(x_test)
for i in range(0,num):
maxvalue=max(p[0].predict_value(x_test[i]),p[1].predict_value(x_test[i]),
p[2].predict_value(x_test[i]))
if maxvalue==p[int(y_test[i])].predict_value(x_test[i]):
correct+=1
print(" :",num-correct," :",(num-correct)/num)
correct_all+=correct
print(" :",(num*5-correct_all)/(num*5))
그리고 one against one 전략 을 사용 하여 테스트 를 훈련 합 니 다:
# -*- coding: utf-8 -*-
from perceptron import Perceptron
from iris_data import Iris
import numpy as np
if __name__=="__main__":
iris=Iris(size=10,way="one against one")
correct_all=0
for n_fold in range(0,5):
#
p01=Perceptron()#0 1
p02=Perceptron()
p12=Perceptron()
x,y=iris.generate_train_data(index_fold=n_fold,index_class=0,neg_class=1)
p01.train(x,y)
x,y=iris.generate_train_data(index_fold=n_fold,index_class=0,neg_class=2)
p02.train(x,y)
x,y=iris.generate_train_data(index_fold=n_fold,index_class=1,neg_class=2)
p12.train(x,y)
#
correct=0
x_test,y_test=iris.generate_test_data(index_fold=n_fold)
num=len(x_test)
for i in range(0,num):
vote0=0
vote1=0
vote2=0
if p01.predict_value(x_test[i])>0:
vote0+=1
else:
vote1+=1
if p02.predict_value(x_test[i])>0:
vote0+=1
else:
vote2+=1
if p12.predict_value(x_test[i])>0:
vote1+=1
else:
vote2+=1
if vote0==max(vote0,vote1,vote2) and int(vote0)==int(y_test[i]):
correct+=1
elif vote1==max(vote0,vote1,vote2) and int(vote1)==int(y_test[i]):
correct+=1
elif vote2==max(vote0,vote1,vote2) and int(vote2)==int(y_test[i]):
correct+=1
print(" :",num-correct," :",(num-correct)/num)
correct_all+=correct
print(" :",(num*5-correct_all)/(num*5))
실험 결 과 는 그림 과 같다.이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
로마 숫자를 정수로 또는 그 반대로 변환그 중 하나는 로마 숫자를 정수로 변환하는 함수를 만드는 것이었고 두 번째는 그 반대를 수행하는 함수를 만드는 것이었습니다. 문자만 포함합니다'I', 'V', 'X', 'L', 'C', 'D', 'M' ; 문자열이 ...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.