import numpy as np  # 导入包

###
# .前向传播函数
###
# 前向传播函数
# - x：包含输入数据的numpy数组，形状为（N，d_1，...，d_k）
# - w：形状为（D，M）的一系列权重
# - b：偏置，形状为（M，）
def affine_forward(x, w, b):   
    out = None                       # 初始化返回值为None
    N = x.shape[0]                   # 重置输入参数X的形状
    # shape输出他的形状，比如是3行4列，那么shape[0]==3
    x_row = x.reshape(N, -1)         # (N,D)
    # reshape的意思是把他进行重新形状规整，为N行-1列（-1代表自动计算）。
    # 因为很有可能x不止两个维度，比如输入的是(4,20,20)的东西，因此，我们需要将其拍扁为(4,20*20)
    out = np.dot(x_row, w) + b       # (N,M) wx+b
    ### (N,D)*（D，M）=(N,M)+(M,)=(N,M) 【b就是一个长度==M的一维数组，WX相乘后加上本行的b】
    cache = (x, w, b)                # 缓存值，反向传播时使用
    return out,cache           


# 反向传播函数
# - x：包含输入数据的numpy数组，形状为（N，d_1，...，d_k）
# - w：形状（D，M）的一系列权重
# - b：偏置，形状为（M，）
def affine_backward(dout, cache):   
    x, w, b = cache                              # 读取缓存
    dx, dw, db = None, None, None                # 返回值初始化
    ### 因为y=wx+b,那么x=yw^T-b,dx=dout*w^T(dout 代表的是在当前层（即上一层）的输出对损失函数的梯度)
    dx = np.dot(dout, w.T)                       # (N,D)
        ### (N,M)*(M,D) 
    dx = np.reshape(dx, x.shape)                 # (N,d1,...,d_k)   
    ### 规整为多维数组
    x_row = x.reshape(x.shape[0], -1)            # (N,D)    
    ### 规整为二维数组 
    dw = np.dot(x_row.T, dout)                   # (D,N)*(N,M)=(D,M)    
     ### 因为y=wx+b,那么w=yx^T-b,dx=dout*x^T(dout 代表的是在当前层（即上一层）的输出对损失函数的梯度)
    db = np.sum(dout, axis=0, keepdims=True)     # (1,M)    
    ### 沿着第0维度求和。 keepdims是保持维度恒定！
    ## 例如：[[1, 2, 3, 4],
    #          [5, 6, 7, 8],
    #          [9, 10, 11, 12]]
    ## keepdims==false ：[ 10,26,42]
    ##keepdims==true ：[ [10],  [26],  [42]]
    return dx, dw, db


### 初始化

X = np.array([[2,1],  
            [-1,1],  
            [-1,-1],  
            [1,-1]])      # 用于训练的坐标，对应的是I、II、III、IV象限
t = np.array([0,1,2,3])   # 标签，对应的是I、II、III、IV象限
np.random.seed(1)         # 有这行语句，你们生成的随机数就和我一样了

# 一些初始化参数  
input_dim = X.shape[1]     # 输入参数的维度，此处为2，即每个坐标用两个数表示
num_classes = t.shape[0]   # 输出参数的维度，此处为4，即最终分为四个象限
hidden_dim = 50            # 隐藏层维度，为可调参数
reg = 0.001                # 正则化强度，为可调参数
epsilon = 0.001            # 梯度下降的学习率，为可调参数
# 初始化W1，W2，b1，b2
W1 = np.random.randn(input_dim, hidden_dim)     # (2,50)
W2 = np.random.randn(hidden_dim, num_classes)   # (50,4)
b1 = np.zeros((1, hidden_dim))                  # (1,50)
b2 = np.zeros((1, num_classes))                 # (1,4)



for j in range(10000):   #这里设置了训练的循环次数为10000
 # ①前向传播
    H,fc_cache = affine_forward(X,W1,b1)                 # 第一层前向传播
    # H就是第一个值
    H = np.maximum(0, H)                                 # 激活
    relu_cache = H                                       # 缓存第一层激活后的结果
    Y,cachey = affine_forward(H,W2,b2)                   # 第二层前向传播        
 # ②Softmax层计算
    probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))    
    ### 对 Y 的每个行向量（代表一个样本的所有特征）减去该行向量的最大值，然后将结果传递给指数函数。这样做可以确保输出值会被压缩到负无穷大到正无穷大的范围内，而减去最大值可以防止数值过大导致计算不稳定。 
    probs /= np.sum(probs, axis=1, keepdims=True)        # Softmax算法实现
 # ③计算loss值
    N = Y.shape[0]                                       # 值为4
    print(probs[np.arange(N), t])                        # 打印各个数据的正确解标签对应的神经网络的输出
    loss = -np.sum(np.log(probs[np.arange(N), t])) / N   # 计算loss
    print(loss)                                          # 打印loss
 # ④反向传播
    dx = probs.copy()                                    # 以Softmax输出结果作为反向输出的起点,不从loss开始，因为loss无关乎结果，请看下面Softmax-with-Loss的图
    dx[np.arange(N), t] -= 1                             # 即实现y-t(Softmax-with-Loss)
    dx /= N                                               # 到这里是反向传播到softmax前
    dh1, dW2, db2 = affine_backward(dx, cachey)          # 反向传播至第二层前
    dh1[relu_cache <= 0] = 0                             # 反向传播至激活层前
    dX, dW1, db1 = affine_backward(dh1, fc_cache)        # 反向传播至第一层前
# ⑤参数更新
    dW2 += reg * W2
    dW1 += reg * W1
    W2 += -epsilon * dW2
    b2 += -epsilon * db2
    W1 += -epsilon * dW1
    b1 += -epsilon * db1


### 做一个验证
test = np.array([[2,2],[-2,2],[-2,-2],[2,-2]])
H,fc_cache = affine_forward(test,W1,b1)               #仿射
H = np.maximum(0, H)                                  #激活
relu_cache = H
Y,cachey = affine_forward(H,W2,b2)  #仿射
 # Softmax
probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))    
probs /= np.sum(probs, axis=1, keepdims=True)  # Softmax
print(probs)
for k in range(4):
    print(test[k,:],"所在的象限为",np.argmax(probs[k,:])+1)