吴承恩深度学习第四周编程作业

import numpy as np
import h5py
import matplotlib.pyplot as plt
import testCases #参见资料包，或者在文章底部copy
from dnn_utils import sigmoid, sigmoid_backward, relu, relu_backward #参见资料包
import lr_utils #参见资料包，或者在文章底部copy
import scipy
import cv2
def chushihua(layers_dims):
    np.random.seed(3)
    L = len(layers_dims)
    parameters = {}
    for i in range(1,L):
        parameters["W"+str(i)] = np.random.randn(layers_dims[i],layers_dims[i-1])/np.sqrt(layers_dims[i-1])
        parameters["b"+str(i)] = np.zeros((layers_dims[i],1))
    return parameters
def qianxiang(A,W,b):
    Z = np.dot(W,A)+b
    cache = (A,W,b)
    return Z,cache
def activations_qian(A_prev,W,b,activations):
    if activations == "relu":
        Z,linear_cache = qianxiang(A_prev,W,b)
        A,cache_activations = relu(Z)
    elif activations == "sigmoid":
        Z,linear_cache = qianxiang(A_prev,W,b)
        A,cache_activations = sigmoid(Z)
    cache = (linear_cache,cache_activations)
    return A,cache
def L_qianxiang(X,parameters):
    L = len(parameters)//2
    caches = []
    A = X
    for i in range(1,L):
        A_prev = A
        A,cache = activations_qian(A_prev,parameters["W"+str(i)],parameters["b"+str(i)],"relu")
        caches.append(cache)
    A_prev = A
    AL,cache = activations_qian(A_prev,parameters["W"+str(L)],parameters["b"+str(L)],"sigmoid")
    caches.append(cache)
    return AL,caches
def compute_cost(AL,Y):
    m = Y.shape[1]
    cost = -np.sum(np.multiply(np.log(AL),Y) + np.multiply(np.log(1 - AL), 1 - Y)) / m
    cost = np.squeeze(cost)
    return cost
def linear_backward(dZ,cache):
    A_prev,W,b = cache
    m = A_prev.shape[1]
    dW = np.dot(dZ,A_prev.T)/m
    db = np.sum(dZ,axis=1, keepdims=True)/m
    dA_prev = np.dot(W.T,dZ)
    return dA_prev,dW,db
def linear_activation_backward(dA_prev,cache,activation = "relu"):
    linear_cache,activation_cache = cache
    if activation == "relu":
        dZ = relu_backward(dA_prev,activation_cache)
        dA_prev,dW,db = linear_backward(dZ,linear_cache)
    elif activation == "sigmoid":
        dZ = sigmoid_backward(dA_prev,activation_cache)
        dA_prev,dW,db = linear_backward(dZ,linear_cache)
    return dA_prev,dW,db
def L_model_backward(AL,Y,caches):
    grads = {}
    L = len(caches)
    m = AL.shape[1]
    dAL = -(np.divide(Y,AL)-np.divide(1-Y,1-AL))
    current_cache = caches[L-1]
    grads["dA"+str(L)],grads["dW"+str(L)],grads["db"+str(L)] = linear_activation_backward(dAL,current_cache,"sigmoid")
    for i in reversed(range(L-1)):
        current_cache = caches[i]
        dA_prev_temp,dW_prev_temp,db_prev_temp = linear_activation_backward(grads["dA"+str(i+2)],current_cache,"relu")
        grads["dA"+str(i+1)] = dA_prev_temp
        grads["dW"+str(i+1)] = dW_prev_temp
        grads["db"+str(i+1)] = db_prev_temp
    return grads
def update_parameters(parameters,grads,learning_rate):
    L = len(parameters)//2
    for i in range(L):
        parameters["W"+str(i+1)] = parameters["W"+str(i+1)]-learning_rate*grads["dW"+str(i+1)]
        parameters["b"+str(i+1)] = parameters["b"+str(i+1)]-learning_rate*grads["db"+str(i+1)]
    return parameters
def L_year_model(X,Y,layers_dims,learn_rate = 0.0075,num_iterations=3000,isplot=True,print_cost=True):
    np.random.seed(1)
    costs = []
    parameters = chushihua(layers_dims)
    for i in range(num_iterations):
        AL,caches = L_qianxiang(X,parameters)
        cost = compute_cost(AL,Y)
        grads = L_model_backward(AL,Y,caches)
        parameters = update_parameters(parameters,grads,learn_rate)
        if i%100==0:
            costs.append(cost)
            if print_cost:
                print("第"+str(i)+"次迭代，成本为",np.squeeze(cost))
    if isplot:
        plt.plot(np.squeeze(costs))
        plt.ylabel("cost")
        plt.xlabel("iterations(per tens)")
        plt.show()
    return parameters
def predict(X,y,parameters):
    m = X.shape[1]
    n = len(parameters)//2
    p = np.zeros((1,m))
    probas,caches = L_qianxiang(X,parameters)
    for i in range(0,probas.shape[1]):
        if probas[0,i]>0.5:
            p[0,i] = 1
        else:
            p[0,i] = 0
    print("准确度为"+str((np.sum((p==y))/m)))
    return p

train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = lr_utils.load_dataset()
train_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T 
test_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T
train_x = train_x_flatten / 255
train_y = train_set_y
test_x = test_x_flatten / 255
test_y = test_set_y
layers_dims = [12288, 20, 7, 5, 1] #  5-layer model
parameters = L_year_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = False,isplot=False)
pred_train = predict(train_x,train_y,parameters)
pred_test = predict(test_x,test_y,parameters)
def print_mislabeled_images(classes, X, y, p):
    """
	绘制预测和实际不同的图像。
	    X - 数据集
	    y - 实际的标签
	    p - 预测
    """
    a = p + y
    #np.asarray() : 将输入转化为数组
    #np.where有两种用法
# 1.np.where(condition,x,y) 当where内有三个参数时，第一个参数表示条件，当条件成立时where方法返回x，当条件不成立时where返回y
# 2.np.where(condition) 当where内只有一个参数时，那个参数表示条件，当条件成立时，where返回的是每个符合condition条件元素的坐标,返回的是以元组的形式

    mislabeled_indices = np.asarray(np.where(a == 1))
    plt.rcParams['figure.figsize'] = (40.0, 40.0)  # set default size of plots设置绘图的默认尺寸，default：默认的；违约（figure.figsize ： 图像显示大小）
    num_images = len(mislabeled_indices[0])
    for i in range(num_images):
        index = mislabeled_indices[1][i]
# plt.subplot(2,3,1)也可以简写plt.subplot(231)表示把显示界面分割成2*3的网格。其中，第一个参数是行数，第二个参数是列数，第三个参数表示图形的标号
        plt.subplot(2, num_images, i + 3)
        plt.imshow(X[:, index].reshape(64, 64, 3), interpolation='nearest')
        plt.axis('off')#plt.axis(‘off’) 关闭坐标轴 ；plt.axis(‘square’) 作图为正方形，并且x,y轴范围相同 ； plt.axis(‘equal’) x,y轴刻度等长
        plt.title(
            "Prediction: " + classes[int(p[0, index])].decode("utf-8") + " \n Class: " + classes[y[0, index]].decode(
                "utf-8"))
    plt.show()

需要注意的点在于

1.维度问题

图片，吴承恩给的图片的大小是644*64*3的，因此我们第一个w的初始化有要求，必须有12288列

2.数据处理

test_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T

-1是一个特殊的参数，告诉他自己计算图片的大小，最后得到的是一个行向量的一维数组，转置得到一个列向量

3.为什么总是看到了len(parameters)//2

因为对于每一层，都有两个数据w和b被存入parameters，因此要整除2

最重要的一点，在写函数的时候要想清楚我要输入什么，要返回什么，用什么东西存储我计算出来的值，很明显，字典是一个好的选择