import matplotlib.pyplot as plt
import seaborn as sns #要注意的是一旦導(dǎo)入了seaborn，matplotlib的默認(rèn)作圖風(fēng)格就會(huì)被覆蓋成seaborn的格式
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
N_SAMPLES = 2000 # 采樣點(diǎn)數(shù)
TEST_SIZE = 0.3 # 測(cè)試數(shù)量比率
# 利用工具函數(shù)直接生成數(shù)據(jù)集
X, y = make_moons(n_samples = N_SAMPLES, noise=0.2, random_state=100)
# 將2000 個(gè)點(diǎn)按著7:3 分割為訓(xùn)練集和測(cè)試集
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=TEST_SIZE, random_state=42)
print(X.shape, y.shape)
# 繪制數(shù)據(jù)集的分布，X 為2D 坐標(biāo)，y 為數(shù)據(jù)點(diǎn)的標(biāo)簽
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("whitegrid")
  plt.figure(figsize=(16,12))
  axes = plt.gca()
  axes.set(xlabel="$x_1$", ylabel="$x_2$")
  plt.title(plot_name, fontsize=30)
  plt.subplots_adjust(left=0.20)
  plt.subplots_adjust(right=0.80)
  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="Greys", vmin=0, vmax=.6)
  # 繪制散點(diǎn)圖，根據(jù)標(biāo)簽區(qū)分顏色
  plt.scatter(X[:, 0], X[:, 1], c=y.ravel(), s=40, cmap=plt.cm.Spectral,edgecolors='none')
  plt.savefig('dataset.svg')
  plt.close()
# 調(diào)用make_plot 函數(shù)繪制數(shù)據(jù)的分布，其中X 為2D 坐標(biāo)，y 為標(biāo)簽
make_plot(X, y, "Classification Dataset Visualization ")
plt.show()

class Layer:
  # 全連接網(wǎng)絡(luò)層
  def __init__(self, n_input, n_neurons, activation=None, weights=None,
         bias=None):
    """
    :param int n_input: 輸入節(jié)點(diǎn)數(shù)
    :param int n_neurons: 輸出節(jié)點(diǎn)數(shù)
    :param str activation: 激活函數(shù)類(lèi)型
    :param weights: 權(quán)值張量，默認(rèn)類(lèi)內(nèi)部生成
    :param bias: 偏置，默認(rèn)類(lèi)內(nèi)部生成
    """
 
    # 通過(guò)正態(tài)分布初始化網(wǎng)絡(luò)權(quán)值，初始化非常重要，不合適的初始化將導(dǎo)致網(wǎng)絡(luò)不收斂
    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 # 激活函數(shù)類(lèi)型，如'sigmoid'
    self.last_activation = None # 激活函數(shù)的輸出值o
    self.error = None # 用于計(jì)算當(dāng)前層的delta 變量的中間變量
    self.delta = None # 記錄當(dāng)前層的delta 變量，用于計(jì)算梯度
 
  def activate(self, x):
    # 前向傳播
    r = np.dot(x, self.weights) + self.bias # X@W+b
    # 通過(guò)激活函數(shù)，得到全連接層的輸出o
    self.last_activation = self._apply_activation(r)
    return self.last_activation
  # 其中self._apply_activation 實(shí)現(xiàn)了不同的激活函數(shù)的前向計(jì)算過(guò)程：
  def _apply_activation(self, r):
 
    # 計(jì)算激活函數(shù)的輸出
    if self.activation is None:
      return r # 無(wú)激活函數(shù)，直接返回
    # ReLU 激活函數(shù)
    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
 
  # 針對(duì)于不同的激活函數(shù)，它們的導(dǎo)數(shù)計(jì)算實(shí)現(xiàn)如下：
  def apply_activation_derivative(self, r):
 
    # 計(jì)算激活函數(shù)的導(dǎo)數(shù)
    # 無(wú)激活函數(shù)，導(dǎo)數(shù)為1
    if self.activation is None:
      return np.ones_like(r)
    # ReLU 函數(shù)的導(dǎo)數(shù)實(shí)現(xiàn)
    elif self.activation == 'relu':
      grad = np.array(r, copy=True)
      grad[r > 0] = 1.
      grad[r <= 0] = 0.
      return grad
    # tanh 函數(shù)的導(dǎo)數(shù)實(shí)現(xiàn)
    elif self.activation == 'tanh':
      return 1 - r ** 2
    # Sigmoid 函數(shù)的導(dǎo)數(shù)實(shí)現(xiàn)
    elif self.activation == 'sigmoid':
      return r * (1 - r)
    return r

class NeuralNetwork:
  # 神經(jīng)網(wǎng)絡(luò)大類(lèi)
  def __init__(self):
    self._layers = [] # 網(wǎng)絡(luò)層對(duì)象列表
  def add_layer(self, layer):
    # 追加網(wǎng)絡(luò)層
    self._layers.append(layer)
  # 網(wǎng)絡(luò)的前向傳播只需要循環(huán)調(diào)用個(gè)網(wǎng)絡(luò)層對(duì)象的前向計(jì)算函數(shù)即可
  def feed_forward(self, X):
    # 前向傳播
    for layer in self._layers:
      # 依次通過(guò)各個(gè)網(wǎng)絡(luò)層
      X = layer.activate(X)
    return X
 
  #網(wǎng)絡(luò)模型的反向傳播實(shí)現(xiàn)稍復(fù)雜，需要從最末層開(kāi)始，計(jì)算每層的𝛿變量，根據(jù)我們
  #推導(dǎo)的梯度公式，將計(jì)算出的𝛿變量存儲(chǔ)在Layer類(lèi)的delta變量中
  # 因此，在backpropagation 函數(shù)中，反向計(jì)算每層的𝛿變量，并根據(jù)梯度公式計(jì)算每層參數(shù)的梯度值，
  # 按著梯度下降算法完成一次參數(shù)的更新。
  def backpropagation(self, X, y, learning_rate):
 
    # 反向傳播算法實(shí)現(xiàn)
    # 前向計(jì)算，得到輸出值
    output = self.feed_forward(X)
    for i in reversed(range(len(self._layers))): # 反向循環(huán)
      layer = self._layers[i] # 得到當(dāng)前層對(duì)象
      # 如果是輸出層
      if layer == self._layers[-1]: # 對(duì)于輸出層
        layer.error = y - output # 計(jì)算2 分類(lèi)任務(wù)的均方差的導(dǎo)數(shù)
      # 關(guān)鍵步驟：計(jì)算最后一層的delta，參考輸出層的梯度公式
        layer.delta = layer.error * layer.apply_activation_derivative(output)
 
      else: # 如果是隱藏層
        next_layer = self._layers[i + 1] # 得到下一層對(duì)象
        layer.error = np.dot(next_layer.weights, next_layer.delta)
        # 關(guān)鍵步驟：計(jì)算隱藏層的delta，參考隱藏層的梯度公式
        layer.delta = layer.error * layer.apply_activation_derivative(layer.last_activation)
 
 
  # 在反向計(jì)算完每層的𝛿變量后，只需要按著式計(jì)算每層的梯度，并更新網(wǎng)絡(luò)參數(shù)即可。
  # 由于代碼中的delta 計(jì)算的是−𝛿，因此更新時(shí)使用了加號(hào)。
        # 循環(huán)更新權(quán)值
    for i in range(len(self._layers)):
      layer = self._layers[i]
    # o_i 為上一網(wǎng)絡(luò)層的輸出
      o_i = np.atleast_2d(X if i == 0 else self._layers[i-1].last_activation)
      # 梯度下降算法，delta 是公式中的負(fù)數(shù)，故這里用加號(hào)
      layer.weights += layer.delta * o_i.T * learning_rate
 
 
 
 
  def train(self, X_train, X_test, y_train, y_test, learning_rate,max_epochs):
    # 網(wǎng)絡(luò)訓(xùn)練函數(shù)
    # one-hot 編碼
    y_onehot = np.zeros((y_train.shape[0], 2))
    y_onehot[np.arange(y_train.shape[0]), y_train] = 1
    mses = []
    for i in range(max_epochs): # 訓(xùn)練1000 個(gè)epoch
      for j in range(len(X_train)): # 一次訓(xùn)練一個(gè)樣本
        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)))
        # 統(tǒng)計(jì)并打印準(zhǔn)確率
        print('Accuracy: %.2f%%' % (self.accuracy(self.predict(X_test),y_test.flatten()) * 100))
    return mses
 
  def accuracy(self,y_pre,y_true):
    return np.mean((np.argmax(y_pre, axis=1) == y_true))
 
  def predict(self,X_test):
    return self.feed_forward(X_test)

nn = NeuralNetwork() # 實(shí)例化網(wǎng)絡(luò)類(lèi)
nn.add_layer(Layer(2, 25, 'sigmoid')) # 隱藏層1, 2=>25
nn.add_layer(Layer(25, 50, 'sigmoid')) # 隱藏層2, 25=>50
nn.add_layer(Layer(50, 25, 'sigmoid')) # 隱藏層3, 50=>25
nn.add_layer(Layer(25, 2, 'sigmoid')) # 輸出層, 25=>2
learning_rate = 0.01
max_epochs = 1000
nn.train(X_train, X_test, y_train, y_test, learning_rate,max_epochs)