人工智能实战2019

项目	内容
课程	人工智能实战2019
作业要求	第5次作业
课程目标	学习人工智能基础知识
本次作业对我的帮助	学习并练习应用线性二分类的知识
理论课程	二分类原理

一、作业要求

---

训练一个逻辑或门和逻辑与门

二、样本数据

---

1. 逻辑或门的样本数据

样本序号	1	2	3	4
x1	0	0	1	1
x2	0	1	0	1
Y	0	1	1	1

2. 逻辑与门的样本数据

样本序号	1	2	3	4
x1	0	0	1	1
x2	0	1	0	1
Y	0	0	0	1

三、关键公式

---

1. 分类函数

[A(z)=Sigmoid(z)=frac{1}{1+e^{-z}} ]

2. 二分类交叉熵损失函数

[J=-[Y ln A+(1-Y) ln (1-A)] ]

3. 使用方式

训练时，一个样本x经过神经网络的最后一层的矩阵运算结果作为输入z，经过Sigmoid函数后，输出一个[0,1]之间的预测值。对于标签值为1的样本数据，预测值越接近0，惩罚越大，反向传播的力度越大；反之同理

四、程序实现

---

import numpy as np
import matplotlib.pyplot as plt
import math


# 读取样本数据
def ReadData(logic):
    if logic == "OR":
        X = np.array([0, 0, 1, 1, 0, 1, 0, 1]).reshape(2, 4)
        Y = np.array([0, 1, 1, 1]).reshape(1, 4)
    elif logic == "AND":
        X = np.array([0, 0, 1, 1, 0, 1, 0, 1]).reshape(2, 4)
        Y = np.array([0, 0, 0, 1]).reshape(1, 4)
    return X, Y


# 分类函数
def Sigmoid(x):
    s = 1 / (1 + np.exp(-x))
    return s


# 前向计算
def ForwardCalculationBatch(W, B, batch_X):
    Z = np.dot(W, batch_X) + B
    A = Sigmoid(Z)
    return A


# 计算损失函数值，二分类交叉熵损失函数
def CheckLoss(W, B, X, Y):
    m = X.shape[1]
    A = ForwardCalculationBatch(W, B, X)

    p1 = 1 - Y
    p2 = np.log(1 - A)
    p3 = np.log(A)

    p4 = np.multiply(p1, p2)
    p5 = np.multiply(Y, p3)

    LOSS = np.sum(-(p4 + p5))
    loss = LOSS / m
    return loss


# 反向计算
def BackPropagationBatch(X, Y, A):
    m = X.shape[1]
    dZ = A - Y
    dB = dZ.sum(axis=1, keepdims=True) / m
    dW = np.dot(dZ, X.T) / m
    return dW, dB


# 更新权重参数
def UpdateWeights(W, B, dW, dB, eta):
    W = W - eta * dW
    B = B - eta * dB
    return W, B


# 训练
def train(X, Y):

    num_example = X.shape[1]
    num_feature = X.shape[0]
    num_category = Y.shape[0]
    eta = 0.5
    max_epoch = 10000
    loss = 5  # initialize loss (larger than 0)
    error = 1e-3  # stop condition
    w = np.zeros((num_category, num_feature))
    b = np.zeros((num_category, 1))

    for epoch in range(max_epoch):
        print("epoch=%d" % epoch)
        for i in range(num_example):
            x = X[:, i].reshape(2, 1)
            y = Y[:, i].reshape(1, 1)
            z = ForwardCalculationBatch(w, b, x)
            dW, dB = BackPropagationBatch(x, y, z)
            w, b = UpdateWeights(w, b, dW, dB, eta)
        # end for
        loss = CheckLoss(w, b, X, Y)
        #print(epoch, i, loss, w, b)
        if math.isnan(loss):
            break
        if loss < error:
            break
    return w, b
    # end for


# 显示结果
def ShowResult(W, B, X, Y, title):
    # 根据w,b值画出分割线
    w = -W[0, 0] / W[0, 1]
    b = -B[0, 0] / W[0, 1]
    x = np.array([0, 1])
    y = w * x + b
    plt.plot(x, y)

    # 画出原始样本值
    for i in range(X.shape[1]):
        if Y[0, i] == 0:
            plt.scatter(X[0, i], X[1, i], marker="o", c='b', s=64)
        else:
            plt.scatter(X[0, i], X[1, i], marker="^", c='r', s=64)
    plt.axis([-0.1, 1.1, -0.1, 1.1])
    plt.title(title)
    plt.show()


# 测试
def Test(W, B, logic):
    n1 = input("input number one:")
    x1 = float(n1)
    n2 = input("input number two:")
    x2 = float(n2)
    a = ForwardCalculationBatch(W, B, np.array([x1, x2]).reshape(2, 1))
    print(a)
    if (logic == "OR"):
        y = x1 or x2
    if (logic == "AND"):
        y = x1 and x2
    if np.abs(a - y) < 1e-2:
        print("True")
    else:
        print("False")


# 主程序
if __name__ == '__main__':

    logic = "OR"
    X, Y = ReadData(logic)
    w, b = train(X, Y)

    print("w=", w)
    print("b=", b)
    ShowResult(w, b, X, Y, logic)
    while True:
        Test(w, b, logic)

五、运行结果

---

epoch=4520
w= [[13.13318012 13.13406338]]
b= [[-6.10742937]]
Qt: Untested Windows version 10.0 detected!
input number one:0
input number two:1
[[0.99911287]]
True
input number one:1
input number two:0
[[0.99911209]]
True
input number one:0
input number two:0
[[0.00222132]]
True
input number one:1
input number two:1
[[1.]]
True

epoch=8504
w= [[13.15361034 13.15287496]]
b= [[-19.89698044]]
Qt: Untested Windows version 10.0 detected!
input number one:0
input number two:1
[[0.00117642]]
True
input number one:1
input number two:0
[[0.00117728]]
True
input number one:0
input number two:0
[[2.28481577e-09]]
True
input number one:1
input number two:1
[[0.99835687]]
True