In [1]:

    

import numpy as np
#线性可分数据
#AND data
AND_inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]
AND_outputs = [0, 0, 0, 1]

#OR data
OR_inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]
OR_outputs = [0, 1, 1, 1]

#NOT data
NOT_inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]
NOT_outputs = [1, 0, 1, 0]

#NOT2 data
NOT2_inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]
NOT2_outputs = [0, 1, 0, 1]

#线性不可分数据
#XOR data
XOR_inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]
XOR_outputs = [0, 1, 1, 0]

#NOT XOR data
XOR2_inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]
XOR2_outputs = [1, 0, 0,1]


    

In [2]:

    

class NeuralNetwork:
    def __init__(self):
        #np.random.seed(1)
        self.w1=np.random.random(1)
        self.w2=np.random.random(1)
        self.b=np.random.random(1)
    
    def predict(self,inputs):
        linear_combination = self.w1 * inputs[0] + self.w2 * inputs[1] + self.b
        return int(linear_combination >= 0)
    
    def train(self,train_set_input,train_set_outputs,train_num=10000,train_lr=0.1):
        for i in range(train_num):
            num = i%4
            output = self.predict(train_set_input[num])
            error = output - train_set_outputs[num]
            self.w1 -= train_lr * (train_set_input[num][0]) * error
            self.w2 -= train_lr * (train_set_input[num][1]) * error
            self.b -= train_lr * error
            
    def test(self,train_set_input,train_set_outputs):
        right = 0
        for i in range(len(train_set_input)):
            #print('in1:{},in2:{},{}=={}'.format(train_set_input[i][0],train_set_input[i][1],self.predict(train_set_input[i]),train_set_outputs[i]))
            if(self.predict(train_set_input[i])==train_set_outputs[i]):
                right += 1                
        return right/float(len(train_set_input))*100
            
    
    def print_w_b(self):
        print('w1:{},w2:{},b:{}'.format(self.w1,self.w2,self.b))


    

In [3]:

    

NN = NeuralNetwork()
print('before train')
NN.print_w_b()
print(NN.test(XOR_inputs,XOR_outputs))
NN.train(NOT_inputs,NOT_outputs)
print('after train')
NN.print_w_b()
print(NN.test(XOR_inputs,XOR_outputs))


    

    




before train
w1:[ 0.57667911],w2:[ 0.99037969],b:[ 0.79751145]
50.0
after train
w1:[-0.02332089],w2:[-0.20962031],b:[ 0.09751145]
50.0

In [4]:

    

AND_NN = NeuralNetwork()
AND_NN.train(AND_inputs,AND_outputs)
print(AND_NN.test(AND_inputs,AND_outputs))


OR_NN = NeuralNetwork()
OR_NN.train(OR_inputs,OR_outputs)
print(OR_NN.test(OR_inputs,OR_outputs))


NOT_NN = NeuralNetwork()
NOT_NN.train(NOT_inputs,NOT_outputs)
print(NOT_NN.test(NOT_inputs,NOT_outputs))

NOT2_NN = NeuralNetwork()
NOT2_NN.train(NOT2_inputs,NOT2_outputs)
print(NOT2_NN.test(NOT2_inputs,NOT2_outputs))

print('不可线性分割所以训练不到100')
XOR_NN = NeuralNetwork()
XOR_NN.train(XOR_inputs,XOR_outputs)
print(XOR_NN.test(XOR_inputs,XOR_outputs))

XOR2_NN = NeuralNetwork()
XOR2_NN.train(XOR2_inputs,XOR2_outputs)
print(XOR2_NN.test(XOR2_inputs,XOR2_outputs))


    

    




100.0
100.0
100.0
100.0
不可线性分割所以训练不到100
25.0
50.0