import numpy as np


class BPNetWork(object):
    """
    全連線神經網路，採用BP演算法訓練。
    """

    def __init__(self, layers, act_func='tanh'):
        """
        :param layers: 神經網路的結構
        :param act_func: 激勵函式
        輸入樣例：
        ann = BPNN((2, 3, 1))
        表示一個輸入層，一個隱含層，一個輸出層，輸入層有2個結點，
        隱含層有3個結點，輸出層有1個結點
        ann = BPNN((2, 3, 3, 1))
        表示一個輸入層，二個隱含層，一個輸出層，輸入層有2個結點，
        第一層隱含層有3個結點，第二層隱含層有3個結點，輸出層有1個結點
        """
 


        # 初始化神經元的值
        self.networks = []

        # 初始化神經元權重
        self.weights = []
        for i in range(len(layers) - 1):
            weight = 2 * np.random.random((layers[i], layers[i + 1])) - 1
            network = [1.0] * layers[i]
            self.networks.append(network)
            self.weights.append(weight)
        self.networks.append([1.0
 
] * layers[-1])
        self.networks = np.array(self.networks)

        # 初始化神經元閾值
        self.thresholds = []
        for i in range(1, len(layers)):
            threshold = 2 * np.random.random(layers[i]) - 1
            self.thresholds.append(threshold)

        # 選擇激勵函式和它的導函式
        if act_func == 'tanh'
 
:

            self.act_func = self.tanh
            self.dact_func = self.dthanh
        else:
            self.act_func = self.sigmoid
            self.dact_func = self.dsigmoid

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def dsigmoid(self, x):
        return self.sigmoid(x) * (1 - self.sigmoid(x))

    def tanh(self, x):
        return np.tanh(x)

    def dthanh(self, x):
        return 1.0 - np.tanh(x) ** 2

    def fit(self, train_x, train_y, epochs, learn_rate):
        '''
        :param train_x: 訓練集X
        :param train_y: 訓練集Y
        :param epochs: 迭代次數
        :param learn_rate: 學習率，步長
        :return: None
        擬合神經網路
        '''

        for i in range(epochs):
            i = np.random.randint(train_x.shape[0], high=None)
            self.update(train_x[i])
            self.back_propagate(train_y[i], learn_rate)

    def predict(self, test_x):
        '''
        :param test_x: 測試集合
        :return: 預測值
        '''
        self.update(test_x)
        return self.networks[-1].copy()

    def update(self, inputs):
        '''
        :param inputs: X的輸入值
        :return: None
        更新一次神經元的值
        '''
        self.networks[0] = inputs.copy()
        for i in range(len(self.weights)):
            count = np.dot(self.networks[i], self.weights[i]) - self.thresholds[i]
            self.networks[i + 1] = self.act_func(count)

    def back_propagate(self, y, rate):
        '''
        :param y: target
        :param rate: 學習率
        :return: None
        BP演算法，對神經網路的權值和閾值進行更新
        '''
        errors = y - self.networks[-1]
        gradients = [self.dact_func(self.networks[-1]) * errors]

        self.thresholds[-1] += (-1) * rate * gradients[-1]
        for i in range(len(self.weights) - 1, 0, -1):
            gradients.append(gradients[-1].dot(self.weights[i].T) * self.dact_func(self.networks[i]))
            self.thresholds[i - 1] += (-1) * rate * gradients[-1]

        gradients.reverse()
        for i in range(len(self.weights)):
            self.weights[i] += rate * self.networks[i].reshape((-1, 1)) * gradients[i]