tf#单层感知器实现(1.np实现，2.tf实现)

1.基础概念

1.建模之前，我们把数据集分成3部分

• 训练集：用来训练构建模型
• 测试集：等模型训练好之后，用来测试模型的好坏
• 验证集：在模型训练阶段，测试模型好坏

2. 回归/分类/聚类总结
   回归：预测数据为连续类型
   分类：预测数据为类别型数据，并且类别已知
   聚类：预测数据为类别型数据，但类别未知

2.模型收敛条件

1.误差小于，某个预先设定的较小的值
2.2次迭代之间的权值，很小
3.设定最大迭代次数，当迭代超过最大次数就停止

第一个次，不用tf的感知器描述

import numpy as np
import matplotlib.pyplot as plt

# 定义输入的数据
X = np.array([[1, 3, 3],
              [1, 4, 3],
              [1, 1, 1],
              [1, 2, 1]])

# 定义标签
T = np.array([[1],
              [1],
              [-1],
              [-1]])

# 权值初始化
W = np.random.random([3,1])
# 设置学习率（）
lr = 0.1
# 神经网络输出
Y = 0

# 跟新权值的函数
def train():
    global X,Y,T,W,lr
    # 同时计算4个数据的预测值，Y(4,1)
    Y = np.sign(np.dot(X, W))
    # T-Y得到4个标签与预测值的误差E（4，1）
    E = T - Y
    # 计算权值的变化
    d_w = lr*(X.T.dot(E))/X.shape[0]
    # 跟新权值
    W = W +d_w


for i in range(100):
    train()
    # 当前训练次数
    print('当前训练次数：',i+1)
    print('当前权值',W)
    # 计算当前输出
    Y = np.sign(np.dot(X,W))
    if (Y==T).all():
        print('finish')
        break

使用tf的单层感知器

import tensorflow as tf
import os
from tensorflow.examples.tutorials.mnist import input_data
# mnist = input_data.read_data_sets('./data/mnist/input_data',one_hot=True)

def full():
    # 获取真实的数据
    mnist = input_data.read_data_sets('./data/mnist/input_data', one_hot=True)
    # 1.建立数据的占位符，x [None，784]，y_true [None,10]
    with tf.variable_scope('data'):
        x = tf.placeholder(tf.float32,[None, 784])
        y_true = tf.placeholder(tf.int32,[None, 10])

    # 2.建立一个全连接层的神经网络 权重w[784,10],b[10]
    with tf.variable_scope('fc_model'):
        # 创建一个变量
        weight = tf.Variable(tf.random.normal([784, 10],mean=0.0,stddev=1.0),name='w')
        # tf.constant()：常量
        bias = tf.Variable(tf.constant(0.0,shape=[10]))

        # 预测一个输出结果 [none,784] * [784,10] + [10] = [none,10]
        y_predict = tf.matmul(x,weight) + bias

    # 3. 求出所有样本的损失，然后求平均值
    # 交叉熵损失
    with tf.variable_scope('fc_model'):
        # 求平均交叉熵损失
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true,  # 真实值
            logits=y_predict,  # 样本加权之后的值
            name=None))

    # 4.梯度下降求出损失
    with tf.variable_scope('optimizer'):
        # 0.1 学习率 minimize(loss) 最小化损失
        train_op=tf.train.GradientDescentOptimizer(0.1).minimize(loss)

    # 5 计算准确率
    with tf.variable_scope('acc'):
        # 比较准确率，测试值，和实际值是否相等，相等为1不能为0 返回一个【1，0，0，1，0，1】
        equal_list = tf.equal(tf.argmax(y_true,1),tf.argmax(y_predict,1))
        accuracy = tf.reduce_mean(tf.cast(equal_list, tf.float32))


    # 定义一个初始化的op
    init_op = tf.global_variables_initializer()
    # 开启绘画训练
    with tf.Session() as sess:
        # 初始化op
        sess.run(init_op)

        # 迭代
        for i in range(2000):
            # 取出真实存在的特征值，目标值
            mnist_x, mnist_y = mnist.train.next_batch(50)  # 每次获取50个数据
            # 运行op训练

            sess.run(train_op, feed_dict={x: mnist_x, y_true: mnist_y})

            # 打印准确率
            print('训练%d次，准确率%f'%(i, sess.run(accuracy, feed_dict={x: mnist_x, y_true: mnist_y})))


    return None

if __name__ == "__main__":
    full()