《TensorFlow深度学习》笔记

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import datasets
import numpy as np
import matplotlib 
import matplotlib.pyplot as plt
import sklearn# import datasets
from sklearn import model_selection
import seaborn as sns
from sklearn.datasets import make_moons

#数据集
N_SAMPLES = 2000 # 采样点数
TEST_SIZE = 0.3 # 测试数量比率
# 利用工具函数直接生成数据集
X, y =make_moons(n_samples = N_SAMPLES, noise=0.2, random_state=100)
# 将2000 个点按着7:3 分割为训练集和测试集
X_train, X_test, y_train, y_test =model_selection.train_test_split(
    X, y,test_size=TEST_SIZE, random_state=42)
print(X.shape, y.shape)
# 绘制数据集的分布，X 为2D 坐标，y 为数据点的标签
def make_plot(X,y,plot_name,file_name=None,XX=None,YY=None,preds=None,dark=False):
    if(dark):
        plt.style.use('dark_background')
    else:
        sns.set_style('white')
    plt.figure(figsize=(16,12))
    axes = plt.gca() # 设置坐标轴
    axes.set(xlabel="$x_1$",ylabel="$y_1$")
    plt.title(plot_name, fontsize=30)
    plt.subplots_adjust(left=0.2)  
    plt.subplots_adjust(right=0.8)
    if(XX is not None and YY is not None and preds is not None):
        #等高线填充
        plt.contourf(XX,YY,preds.reshape(XX.shape),25,alpha=1,cmap=plt.cm.Spectral)
        #等高线
        plt.contour(XX,YY,preds.reshape(XX.shape),levels=[.5],cmap="Grays",vmin=0,vmax=.6)
    plt.scatter(X[:,0], X[:,1], c=y.ravel(),s=40,cmap=plt.cm.Spectral,edgecolors='none')
# 调用make_plot 函数绘制数据的分布，其中X 为2D 坐标，y 为标签    
make_plot(X, y, 'plot_name')
plt.show()
    
#网络层
class Layer:
    #全连接网络层
    def __init__(self,n_input,n_neurons,activation=None,weights=None,bias=None):
        """
:param int n_input: 输入节点数
:param int n_neurons: 输出节点数
:param str activation: 激活函数类型
:param weights: 权值张量，默认类内部生成
:param bias: 偏置，默认类内部生成
"""
# 通过正态分布初始化网络权值，初始化非常重要，不合适的初始化将导致网络不收敛
        self.weights=weights if weights is not None else np.random.randn(
            n_input,n_neurons)*np.sqrt(1/n_neurons)
        self.bias=bias if bias is not None else np.random.rand(n_neurons)*0.1
        self.activation=activation# 激活函数类型，如sigmoid
        self.last_activation=None# 激活函数的输出值o
        self.error=None # 用于计算当前层的delta 变量的中间变量
        self.delta=None# 记录当前层的delta 变量，用于计算梯度
       # 网络层的前向传播函数实现如下，其中last_activation 变量用于保存当前层的输出值：
    def activate(self, x):   # 前向传播函数
        r = np.dot(x, self.weights) + self.bias # X@W+b
# 通过激活函数，得到全连接层的输出o
        self.last_activation = self._apply_activation(r)
        return self.last_activation
    def _apply_activation(self, r):
        # 计算激活函数的输出,实现不同类型的激活函数的前向计算过程，尽管此处只使用Sigmoid 激活函数一种
        if self.activation is None:
            return r # 无激活函数，直接返回
        # ReLU 激活函数
        elif self.activation == 'relu':
            return np.maximum(r, 0)
        # tanh 激活函数
        elif self.activation == 'tanh':
            return np.tanh(r)
        # sigmoid 激活函数
        elif self.activation == 'sigmoid':
            return 1 / (1 + np.exp(-r))
        return r
    #针对于不同类型的激活函数，它们的导数计算实现如下：
    def apply_activation_derivative(self, r):
    # 计算激活函数的导数
    # 无激活函数，导数为1
        if self.activation is None:
            return np.ones_like(r)
        # ReLU 函数的导数实现
        elif self.activation == 'relu':
            grad = np.array(r, copy=True)
            grad[r > 0] = 1.
            grad[r <= 0] = 0.
            return grad
        # tanh 函数的导数实现
        elif self.activation == 'tanh':
            return 1 - r ** 2
        # Sigmoid 函数的导数实现
        elif self.activation == 'sigmoid':
            return r * (1 - r)
        return r

#网络模型
#创建单层网络类后，我们实现网络模型的NeuralNetwork 类，它内部维护各层的网络层Layer 类对象
class NeuralNetwork:
# 神经网络模型大类
    def __init__(self):
        self._layers = [] # 网络层对象列表
    def add_layer(self, layer):
    # 追加网络层
        self._layers.append(layer)
#网络的前向传播只需要循环调各个网络层对象的前向计算函数即可，代码如下：
    def feed_forward(self, X):
    # 前向传播
        for layer in self._layers:
    # 依次通过各个网络层
            X = layer.activate(X)
        return X

    def backpropagation(self, X, y, learning_rate):
        # 反向传播算法实现
        # 前向计算，得到输出值
        output = self.feed_forward(X)
        for i in reversed(range(len(self._layers))): # 反向循环
            layer = self._layers[i] # 得到当前层对象
            # 如果是输出层
            if layer == self._layers[-1]: # 对于输出层
                layer.error = y - output # 计算2 分类任务的均方差的导数
                # 关键步骤：计算最后一层的delta，参考输出层的梯度公式
                layer.delta = layer.error *layer.apply_activation_derivative(output)
            else: # 如果是隐藏层
                next_layer = self._layers[i + 1] # 得到下一层对象
                layer.error = np.dot(next_layer.weights, next_layer.delta)
                # 关键步骤：计算隐藏层的delta，参考隐藏层的梯度公式
                layer.delta = layer.error *layer.apply_activation_derivative(
                    layer.last_activation)       
        # 循环更新权值
        for i in range(len(self._layers)):
            layer = self._layers[i]
            # o_i 为上一网络层的输出
            o_i = np.atleast_2d(X if i == 0 else self._layers[i -1].last_activation)
            # 梯度下降算法，delta 是公式中的负数，故这里用加号
            layer.weights += layer.delta * o_i.T * learning_rate
            
    #网络训练
    def train(self, X_train, X_test, y_train, y_test, learning_rate,max_epochs):
        # 网络训练函数
        # one-hot 编码
        y_onehot = np.zeros((y_train.shape[0], 2))
        y_onehot[np.arange(y_train.shape[0]), y_train] = 1
        #将One-hot 编码后的真实标签与网络的输出计算均方误差，并调用反向传播函数更新网络参数，循环迭代训练集1000 遍即可。代码如下：
        mses = []
        for i in range(max_epochs): # 训练1000 个epoch
            for j in range(len(X_train)): # 一次训练一个样本
                self.backpropagation(X_train[j], y_onehot[j], learning_rate)
                if i % 10 == 0:
                # 打印出MSE Loss
                    mse = np.mean(np.square(y_onehot - self.feed_forward(X_train)))
                    mses.append(mse)
                    print('Epoch: #%s, MSE: %f' % (i, float(mse)))
                    # 统计并打印准确率
                    print('Accuracy: %.2f%%' % (self.accuracy(
                        self.predict(X_test),y_test.flatten()) * 100))
        return mses