Machine learning 感知器不能正确地学习

我试着做基本的ML。这是我的二元分类感知器类

class perceptron():
    def __init__(self, x, y, threshold=0.5, learning_rate=0.1, max_epochs=10):
        self.threshold = threshold
        self.learning_rate = learning_rate
        self.x = x
        self.y = y
        self.max_epochs = max_epochs
        
    def initialize(self):
        self.weights = np.random.rand(len(self.x[0]))
                
    def train(self):
        epoch = 0
        while True:
            error_count = 0
            epoch += 1
            for (x,y) in zip(self.x, self.y):
                error_count += self.train_observation(x, y, error_count)
            print('Epoch: {0} Error count: {1}'.format(epoch, error_count))
            if error_count == 0:
                print('Training successful')
                break
            if epoch >= self.max_epochs:
                print('Reached max epochs')
                break
                
    def train_observation(self, x, y, error_count):
        result = np.dot(x, self.weights) > self.threshold
        error = y - result
        if error != 0:
            error_count += 1
            for index, value in enumerate(x):
                self.weights[index] += self.learning_rate * error * value
        return error_count
        
    def predict(self, x):
        return int(np.dot(x, self.weights) > self.threshold)

如果列表值之和>=0（表示1）或不是（表示0），我想进行分类 所以我做了50个数组len 10，每个数组都有随机的int值[-3,3]：

def sum01(x):
    if sum(x) >= 0:
        return 1
    else:
        return 0
x = np.random.randint(low=-3, high=3, size=(50,10))
y = [sum01(z) for z in a]

然后我初始化并训练：

p = perceptron(x, y)
p.initialize()
p.train()

p = perceptron(x, y)
p.initialize()
p.train()

然后我检查，很多预测都不正确，我做错了什么

predics = [(p.predict(i), sumab(i)) for i in np.random.randint(low=-3, high=3, size=(10, 10))]
print(predics)

---

使用小错误修复程序重新运行代码，我看到损失减少到0，并且输出正确-

---

解决方案

您的代码中需要进行一些快速更改-

定义x和y时：

在获得预测时：

---

那就行了。您的完整代码变为-

class perceptron():
    def __init__(self, x, y, threshold=0.5, learning_rate=0.1, max_epochs=10):
        self.threshold = threshold
        self.learning_rate = learning_rate
        self.x = x
        self.y = y
        self.max_epochs = max_epochs
        
    def initialize(self):
        self.weights = np.random.rand(len(self.x[0]))
                
    def train(self):
        epoch = 0
        while True:
            error_count = 0
            epoch += 1
            for (x,y) in zip(self.x, self.y):
                error_count += self.train_observation(x, y, error_count)
            print('Epoch: {0} Error count: {1}'.format(epoch, error_count))
            if error_count == 0:
                print('Training successful')
                break
            if epoch >= self.max_epochs:
                print('Reached max epochs')
                break
                
    def train_observation(self, x, y, error_count):
        result = np.dot(x, self.weights) > self.threshold
        error = y - result
        if error != 0:
            error_count += 1
            for index, value in enumerate(x):
                self.weights[index] += self.learning_rate * error * value
        return error_count
        
    def predict(self, x):
        return int(np.dot(x, self.weights) > self.threshold)
    
    
def sum01(x):
    if sum(x) >= 0:
        return 1
    else:
        return 0
    
x = np.random.randint(low=-3, high=3, size=(50,10))
y = [sum01(z) for z in x]

p = perceptron(x, y)
p.initialize()
p.train()

predics = [(p.predict(i), sum01(i)) for i in np.random.randint(low=-3, high=3, size=(10, 10))]
print(predics)

predics = [(p.predict(i), sum01(i)) for i in np.random.randint(low=-3, high=3, size=(10, 10))]
print(predics)

[(1, 1), (0, 0), (0, 0), (0, 0), (1, 1), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0)]

x = np.random.randint(low=-3, high=3, size=(50,10))
y = [sum01(z) for z in x] #CHANGE THIS TO x INSTEAD OF a

#CHANGE sumab TO sum01
predics = [(p.predict(i), sum01(i)) for i in np.random.randint(low=-3, high=3, size=(10, 10))] 

class perceptron():
    def __init__(self, x, y, threshold=0.5, learning_rate=0.1, max_epochs=10):
        self.threshold = threshold
        self.learning_rate = learning_rate
        self.x = x
        self.y = y
        self.max_epochs = max_epochs
        
    def initialize(self):
        self.weights = np.random.rand(len(self.x[0]))
                
    def train(self):
        epoch = 0
        while True:
            error_count = 0
            epoch += 1
            for (x,y) in zip(self.x, self.y):
                error_count += self.train_observation(x, y, error_count)
            print('Epoch: {0} Error count: {1}'.format(epoch, error_count))
            if error_count == 0:
                print('Training successful')
                break
            if epoch >= self.max_epochs:
                print('Reached max epochs')
                break
                
    def train_observation(self, x, y, error_count):
        result = np.dot(x, self.weights) > self.threshold
        error = y - result
        if error != 0:
            error_count += 1
            for index, value in enumerate(x):
                self.weights[index] += self.learning_rate * error * value
        return error_count
        
    def predict(self, x):
        return int(np.dot(x, self.weights) > self.threshold)
    
    
def sum01(x):
    if sum(x) >= 0:
        return 1
    else:
        return 0
    
x = np.random.randint(low=-3, high=3, size=(50,10))
y = [sum01(z) for z in x]

p = perceptron(x, y)
p.initialize()
p.train()

predics = [(p.predict(i), sum01(i)) for i in np.random.randint(low=-3, high=3, size=(10, 10))]
print(predics)