import numpy as np
import matplotlib.pyplot as plt
import h5py
import scipy
from PIL import Image
from scipy import ndimage
from lr_utils import load_dataset


##第二周的课后编程训练
# 1- 介绍了项目中需要的一些库，并导入 numpy，matplotlib.pyplot，h5py, scipy, Image
# 2- 加载项目的 数据(训练集，测试集)
# 3- 运行模型，判断图片是否是猫
# 阶段2
# 1- 介绍项目中的数据集的结构， 让我们使用 .shape[]来取数据集中的某一部
#    例如1.1- array.shape[] ， 取数组中指定的索引下标的值
#       1.2- array。shape（），matrix.shape(），是获取集合的结构。例如数组的长度，矩阵的 维度
# 2- 使用 reshape方法， 将数组 转换为 向量。 即如何向量化
#    实践： X_flatten = X.reshape(X.shape[0], -1).T   ， X是一个数组，取值后，使用 -1，确保是专为 图片像素的矩阵
#    >>> X.shape
#       (209, 64, 64, 3)
#      x.reshape(x.shape(0),-1) = (209, 64*64*3)
#                                                      .T是向量转置，将行向量，转化为 列向量
# 3- 将 训练值标准化，这样可以加快 梯度下降的运行
#      标准化方法1 - x/ ||X||,  || X || = np.linalg.norm(x, axis=1 , keepdims=True), x是一个矩阵。 矩阵是向量构成的
#      标准化方法2 - 针对图片的矩阵， 由于图片的像素值是0-255，所以可以是 矩阵X 直接除以 255，即 x/255
# 4- 构建算法模型，
#    4.1- 构建激活函数， 本例使用 sigmoid
#    4.2- 初始化权重参数 w和b， 本例子使用 np.zeros， 将矩阵W 全部初始化 为 0
#    4.3- 计算图的实现， 包括 前向传播 和 后向传播。 返回 代价函数和 梯度
#    4.4- 参数的优化，及 梯度下降更新 权重参数 w和b的值， 返回 迭代梯度下降 优化后的 权重参数 w和b
#    4.5- 计算预测值， 根据得到的 权重参数 w和b ，计算得到预测值，再根据判断逻辑， 将预测值 转化为分类值
#    4.6- 在上诉的步骤 结合起来运算得到 模型d ， 模型d 包含的信息 有 代价函数， w和b，预测值，迭代次数，学习因子等等
# #

##
# 定义一个激活函数， sigmoid函数
# #
def sigmoid(z):
    """
    Arguments:
    z -- A scalar or numpy array of any size.
    """
    s = 1 / ( 1 + np.exp(-z))

    return s

"""
这个函数是用于创建一个 列向量(dim, 1) ，用来将 权重参数 w和b 初始化为 0 
Argument:
dim -- 我们想要的 w 的大小， 输入特征 X 一样

Returns:
w -- initialized vector of shape (dim, 1)
b -- initialized scalar (corresponds to the bias)
"""

def initialize_with_zeros(dim):
    w = np.zeros([dim,1])
    b = 0

    assert(w.shape == (dim, 1))
    assert(isinstance(b, float) or isinstance(b, int))

    return w, b

"""
   Arguments:
   w -- weights, a numpy array of size (num_px * num_px * 3, 1)
   b -- bias, a scalar
   X -- data of size (num_px * num_px * 3, number of examples)
   Y -- true "label" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)

   Return:
   cost -- negative log-likelihood cost for logistic regression
   dw -- gradient of the loss with respect to w, thus same shape as w
   db -- gradient of the loss with respect to b, thus same shape as b

   """
def propagate(w, b, X, Y):
    m = X.shape[0]
    # 前向传播， 将输入X 转化为 输出 代价函数 cost#
    # np.dot（） 矩阵相乘，或者 点积 #
    A = sigmoid(np.dot(w.T,X) + b)  ## 权重参数 矩阵 乘以 输入参数 矩阵 z = w.x + b
    cost = (-1/m) * (np.dot(Y,np.log(A).T) + np.dot((1-Y),np.log(1-A).T))  ## J = -1/m * sum(y*logy^ + （1-y）* log(1-y^))

    ## 反向传播 实现
    # 将 输入 Y， 转化为 输出 dw， db
    # dw = dJ/dA * dz/dw =
    dw = -1/m * np.dot(X,(A-Y).T)
    db = -1/m * np.sum((A-Y))

    assert(dw.shape == w.shape)
    assert(db.dtype == float)
    cost = np.squeeze(cost)
    assert(cost.shape == ())

    grads = {"dw": dw,
             "db": db}

    return grads, cost

"""
更新优化参数w，b
  在progapate()计算得到了梯度 dw，db， 那么使用 梯度下降的方法 更新 w,b
  Arguments:
    w -- weights, a numpy array of size (num_px * num_px * 3, 1)
    b -- bias, a scalar
    X -- data of shape (num_px * num_px * 3, number of examples)
    Y -- true "label" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)
    num_iterations -- number of iterations of the optimization loop， 梯度下降的次数
    learning_rate -- learning rate of the gradient descent update rule， 学习因子a
    print_cost -- True to print the loss every 100 steps
    
    Returns:
    params -- 包含优化后的 权重值 w 和 b 的字典
    grads -- 包含优化后的 梯度值 dw 和 db 的字典
    costs -- 在优化过程中产生的 代价函数值 的 集合list， 它用于绘制学习曲线
    
"""
def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):

    costs = []

    for i in range(num_iterations):
        # Cost and gradient calculation (≈ 1-4 lines of code)
        grads, cost = propagate(w, b, X, Y)

        # Retrieve derivatives from grads
        dw = grads["dw"]
        db = grads["db"]

        # update rule (≈ 2 lines of code)
        w = w - learning_rate * dw
        b = b - learning_rate * db

        # Record the costs
        if i % 100 == 0:
            costs.append(cost)

        # Print the cost every 100 training examples
        if print_cost and i % 100 == 0:
            print ("Cost after iteration %i: %f" %(i, cost))

    params = {"w": w,
              "b": b}

    grads = {"dw": dw,
             "db": db}

    return params, grads, costs
"""
预测函数，optimize()优化计算后 得到的w，b 带入 测试集进行验证
    Arguments:
    w -- weights, a numpy array of size (num_px * num_px * 3, 1)
    b -- bias, a scalar
    X -- data of size (num_px * num_px * 3, number of examples)
    
    Returns:
    Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X
"""
def predict(w,b,X):
    ## 步骤1 - 计算 预测值 Y^ = sigmoid(Z) = sigmoid(w.X + b)
    m = X.shape[1]  # 获取 测试集的 测试样本个数
    Y_prediction = np.zeros((1,m)) # 构建 预测值 的向量， 1行m列
    w = w.reshape(w.shape[0],1)  # 重组后的 数组 w 只有 一行， 但是 shape的值相乘 还是等于 从前的 shape值相乘。

    A = sigmoid(np.dot(w.T,X) + b) # 获取预测值
    # 步骤2 - 将预测值 带入 逻辑， 得到 判断值， 是不是 猫
    for i in range(A.shape[1]):
        if A[i] > 0.5:
            Y_prediction[0,i] = 1
        else:
            Y_prediction[0,i] = 0
    assert(Y_prediction.shape == (1, m))

    return Y_prediction

"""
将所有的步骤都结合起来， 运行得到 算法模型 model
    Arguments:
    X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)
    Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)
    X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)
    Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)
    num_iterations -- 超参数， 梯度下降的迭代次数
    learning_rate -- 学习因子
    print_cost -- 是否100行，打印一次代价函数 cost function
    
    Returns:
    d -- 包含模型的所有信息， 预测的分类值，训练集和测试集的准确率
"""
def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):
    # 初始化 w ， b
    w,b = initialize_with_zeros(X_train.shape[0])

    # 计算最优的 w，b ，  使用 梯度下降方法
    params, grads, costs = optimize(w,b,X_train,Y_train,learning_rate, print_cost)
    w = params["w"]
    b = params["b"]

    # 计算预测值 , 包括 训练集和 测试集
    Y_train_pre = predict(w,b,X_train)
    Y_test_pre = predict(w,b,X_test)

    # 计算并打印错误率， 包括 训练集 和 测试集
    print("train set error rate is %" + format(100 - np.mean(np.abs(Y_train_pre - Y_train)) * 100 ))
    print("test set error rate is %" + format(100 - np.mean(np.abs(Y_test_pre - Y_test)) * 100 ))

    # 构建并返回 模型信息， 迭代过程的代价函数， 预测值， 权重参数 w和b ， 学习因子， 梯度下降迭代的次数
    d = {"costs": costs,
         "Y_prediction_test": Y_train_pre,
         "Y_prediction_train" : Y_test_pre,
         "w" : w,
         "b" : b,
         "learning_rate" : learning_rate,
         "num_iterations": num_iterations}

    return d

import numpy as np
import matplotlib.pyplot as plt
import h5py
import scipy
from PIL import Image
from scipy import ndimage
from lr_utils import load_dataset


##第二周的课后编程训练
# 1- 介绍了项目中需要的一些库，并导入 numpy，matplotlib.pyplot，h5py, scipy, Image
# 2- 加载项目的 数据(训练集，测试集)
# 3- 运行模型，判断图片是否是猫
# 阶段2
# 1- 介绍项目中的数据集的结构， 让我们使用 .shape[]来取数据集中的某一部
#    例如1.1- array.shape[] ， 取数组中指定的索引下标的值
#       1.2- array。shape（），matrix.shape(），是获取集合的结构。例如数组的长度，矩阵的 维度
# 2- 使用 reshape方法， 将数组 转换为 向量。 即如何向量化
#    实践： X_flatten = X.reshape(X.shape[0], -1).T   ， X是一个数组，取值后，使用 -1，确保是专为 图片像素的矩阵
#    >>> X.shape
#       (209, 64, 64, 3)
#      x.reshape(x.shape(0),-1) = (209, 64*64*3)
#                                                      .T是向量转置，将行向量，转化为 列向量
# 3- 将 训练值标准化，这样可以加快 梯度下降的运行
#      标准化方法1 - x/ ||X||,  || X || = np.linalg.norm(x, axis=1 , keepdims=True), x是一个矩阵。 矩阵是向量构成的
#      标准化方法2 - 针对图片的矩阵， 由于图片的像素值是0-255，所以可以是 矩阵X 直接除以 255，即 x/255
# 4- 构建算法模型，
#    4.1- 构建激活函数， 本例使用 sigmoid
#    4.2- 初始化权重参数 w和b， 本例子使用 np.zeros， 将矩阵W 全部初始化 为 0
#    4.3- 计算图的实现， 包括 前向传播 和 后向传播。 返回 代价函数和 梯度
#    4.4- 参数的优化，及 梯度下降更新 权重参数 w和b的值， 返回 迭代梯度下降 优化后的 权重参数 w和b
#    4.5- 计算预测值， 根据得到的 权重参数 w和b ，计算得到预测值，再根据判断逻辑， 将预测值 转化为分类值
#    4.6- 在上诉的步骤 结合起来运算得到 模型d ， 模型d 包含的信息 有 代价函数， w和b，预测值，迭代次数，学习因子等等
# #

##
# 定义一个激活函数， sigmoid函数
# #
def sigmoid(z):
    """
    Arguments:
    z -- A scalar or numpy array of any size.
    """
    s = 1 / ( 1 + np.exp(-z))

    return s

"""
这个函数是用于创建一个 列向量(dim, 1) ，用来将 权重参数 w和b 初始化为 0 
Argument:
dim -- 我们想要的 w 的大小， 输入特征 X 一样

Returns:
w -- initialized vector of shape (dim, 1)
b -- initialized scalar (corresponds to the bias)
"""

def initialize_with_zeros(dim):
    w = np.zeros([dim,1])
    b = 0

    assert(w.shape == (dim, 1))
    assert(isinstance(b, float) or isinstance(b, int))

    return w, b

"""
   Arguments:
   w -- weights, a numpy array of size (num_px * num_px * 3, 1)
   b -- bias, a scalar
   X -- data of size (num_px * num_px * 3, number of examples)
   Y -- true "label" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)

   Return:
   cost -- negative log-likelihood cost for logistic regression
   dw -- gradient of the loss with respect to w, thus same shape as w
   db -- gradient of the loss with respect to b, thus same shape as b

   """
def propagate(w, b, X, Y):
    m = X.shape[0]
    # 前向传播， 将输入X 转化为 输出 代价函数 cost#
    # np.dot（） 矩阵相乘，或者 点积 #
    A = sigmoid(np.dot(w.T,X) + b)  ## 权重参数 矩阵 乘以 输入参数 矩阵 z = w.x + b
    cost = (-1/m) * (np.dot(Y,np.log(A).T) + np.dot((1-Y),np.log(1-A).T))  ## J = -1/m * sum(y*logy^ + （1-y）* log(1-y^))

    ## 反向传播 实现
    # 将 输入 Y， 转化为 输出 dw， db
    # dw = dJ/dA * dz/dw =
    dw = -1/m * np.dot(X,(A-Y).T)
    db = -1/m * np.sum((A-Y))

    assert(dw.shape == w.shape)
    assert(db.dtype == float)
    cost = np.squeeze(cost)
    assert(cost.shape == ())

    grads = {"dw": dw,
             "db": db}

    return grads, cost

"""
更新优化参数w，b
  在progapate()计算得到了梯度 dw，db， 那么使用 梯度下降的方法 更新 w,b
  Arguments:
    w -- weights, a numpy array of size (num_px * num_px * 3, 1)
    b -- bias, a scalar
    X -- data of shape (num_px * num_px * 3, number of examples)
    Y -- true "label" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)
    num_iterations -- number of iterations of the optimization loop， 梯度下降的次数
    learning_rate -- learning rate of the gradient descent update rule， 学习因子a
    print_cost -- True to print the loss every 100 steps
    
    Returns:
    params -- 包含优化后的 权重值 w 和 b 的字典
    grads -- 包含优化后的 梯度值 dw 和 db 的字典
    costs -- 在优化过程中产生的 代价函数值 的 集合list， 它用于绘制学习曲线
    
"""
def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):

    costs = []

    for i in range(num_iterations):
        # Cost and gradient calculation (≈ 1-4 lines of code)
        grads, cost = propagate(w, b, X, Y)

        # Retrieve derivatives from grads
        dw = grads["dw"]
        db = grads["db"]

        # update rule (≈ 2 lines of code)
        w = w - learning_rate * dw
        b = b - learning_rate * db

        # Record the costs
        if i % 100 == 0:
            costs.append(cost)

        # Print the cost every 100 training examples
        if print_cost and i % 100 == 0:
            print ("Cost after iteration %i: %f" %(i, cost))

    params = {"w": w,
              "b": b}

    grads = {"dw": dw,
             "db": db}

    return params, grads, costs
"""
预测函数，optimize()优化计算后 得到的w，b 带入 测试集进行验证
    Arguments:
    w -- weights, a numpy array of size (num_px * num_px * 3, 1)
    b -- bias, a scalar
    X -- data of size (num_px * num_px * 3, number of examples)
    
    Returns:
    Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X
"""
def predict(w,b,X):
    ## 步骤1 - 计算 预测值 Y^ = sigmoid(Z) = sigmoid(w.X + b)
    m = X.shape[1]  # 获取 测试集的 测试样本个数
    Y_prediction = np.zeros((1,m)) # 构建 预测值 的向量， 1行m列
    w = w.reshape(w.shape[0],1)  # 重组后的 数组 w 只有 一行， 但是 shape的值相乘 还是等于 从前的 shape值相乘。

    A = sigmoid(np.dot(w.T,X) + b) # 获取预测值
    # 步骤2 - 将预测值 带入 逻辑， 得到 判断值， 是不是 猫
    for i in range(A.shape[1]):
        if A[i] > 0.5:
            Y_prediction[0,i] = 1
        else:
            Y_prediction[0,i] = 0
    assert(Y_prediction.shape == (1, m))

    return Y_prediction

"""
将所有的步骤都结合起来， 运行得到 算法模型 model
    Arguments:
    X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)
    Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)
    X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)
    Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)
    num_iterations -- 超参数， 梯度下降的迭代次数
    learning_rate -- 学习因子
    print_cost -- 是否100行，打印一次代价函数 cost function
    
    Returns:
    d -- 包含模型的所有信息， 预测的分类值，训练集和测试集的准确率
"""
def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):
    # 初始化 w ， b
    w,b = initialize_with_zeros(X_train.shape[0])

    # 计算最优的 w，b ，  使用 梯度下降方法
    params, grads, costs = optimize(w,b,X_train,Y_train,learning_rate, print_cost)
    w = params["w"]
    b = params["b"]

    # 计算预测值 , 包括 训练集和 测试集
    Y_train_pre = predict(w,b,X_train)
    Y_test_pre = predict(w,b,X_test)

    # 计算并打印错误率， 包括 训练集 和 测试集
    print("train set error rate is %" + format(100 - np.mean(np.abs(Y_train_pre - Y_train)) * 100 ))
    print("test set error rate is %" + format(100 - np.mean(np.abs(Y_test_pre - Y_test)) * 100 ))

    # 构建并返回 模型信息， 迭代过程的代价函数， 预测值， 权重参数 w和b ， 学习因子， 梯度下降迭代的次数
    d = {"costs": costs,
         "Y_prediction_test": Y_train_pre,
         "Y_prediction_train" : Y_test_pre,
         "w" : w,
         "b" : b,
         "learning_rate" : learning_rate,
         "num_iterations": num_iterations}

    return d