吴恩达深度学习课后习题L1W2

一、

1.1math.exp()和np.exp()的区别

array其实是numpy中的数据类型，用np.exp()能处理array，但math.exp()无法处理。
在赋值过程中，用np.array()函数，否则容易报错。

def sigmoid_np(x):
    s=1./(1+np.exp(-x))
    return s
x=[1,2,3]
print(sigmoid_np(x))

error：bad operand type for unary -: ‘list’

def sigmoid_np(x):
    s=1./(1+np.exp(-x))
    return s
x=np.array([1,2,3])
print(sigmoid_np(x))

bingo

1.2求sigmoid（）对其输入的梯度函数

a=sigmoid（z）
da/dz=a（1-a）

import numpy as np
def sigmoid(x):
    s=1./(1+np.exp(-x))
    return s
def sigmoid_grad(x):
    s=sigmoid(x)
    ds=s*(1-s)
    return ds

1.3重塑数组

实现image2vector() ,该输入采用维度为(length, height, 3)的输入，并返回维度为(length×height×3, 1)的向量。

def image2vec(image):
    vec=image.reshape(image.shape[0]*image.shape[1]*image.shape[2],1)
    return vec
x=np.random.rand(1,2,3)
print(x,image2vec(x))

先开始image.shape()报错，出现TypeError: ‘tuple’ object is not callable,是因为tuple是一个数据类型，不是函数，应该用[]而不是()。

1.4行标准化

执行 normalizeRows（）来标准化矩阵的行。 将此函数应用于输入矩阵x之后，x的每一行应为单位长度（即长度为1）向量。

def nomalizeRows(a):
    b=np.multiply(a,a) #对应元素相乘
    c=b.sum(axis=1,keepdims=True) #每行元素相加，输出列向量
    d=a/(np.sqrt(c)) #用broadcasting，每个元素除以范数
    return d
a=np.array([[1,1,1],[3,4,5],[2,3,4]])
print(nomalizeRows(a))

注：直接用c=b.sum(axis=1)输出的是一个横向量，且无法用转置.T转换成列向量。这是因为用sum求和之后，直接把维度给消灭了。
解决方法：
1.c=b.sum(axis=1).reshape(-1,1)。
2.添加keepdims这个参数：c=b.sum(axis=1,keepdims=True)。

方法二：直接用np.linalg.norm()函数，其中lin是linear algebra的简写。

def nomalizeRows(a):
    b=np.linalg.norm(a,axis=1,ord=2,keepdims=True)
    return a/b
a=np.array([[1,1,1],[3,4,5],[2,3,4]])
print(nomalizeRows(a))

1.5广播和softmax函数

使用numpy实现softmax函数。 你可以将softmax理解为算法需要对两个或多个类进行分类时使用的标准化函数。

def softmax(a):
    a_exp=np.exp(a)
    a_sum=np.sum(a_exp,axis=1,keepdims=True)
    s=a_exp/a_sum
    return s
a=np.array([[1,1,1],[3,4,5],[2,3,4]])
print(softmax(a))

2.1实现L1和L2损失函数

实现L1损失函数的Numpy向量化版本。 我们会发现函数abs（x）（x的绝对值）很有用。

def L1(y,yhat):
    s=np.sum(np.abs(y-yhat))
    return s
y=np.array([1,0,1,0,1,1])
yhat=np.array([0.9,0.2,0.8,0,0.9,0.8])
print(L1(y,yhat))

实现L2损失函数的Numpy向量化版本。 有好几种方法可以实现L2损失函数，但是还是np.dot（）函数更好用。

def L2(y,yhat):
    s=np.dot((y-yhat),(y-yhat).T)
    return s
y=np.array([1,0,1,0,1,1])
yhat=np.array([0.9,0.2,0.8,0,0.9,0.8])
print(L2(y,yhat))

二、

运行from Ir_utils import load_dataset时报错，因为Ir_utils是自己写的py文件。将以下代码粘贴到Ir_utils.py，并放在同一目录下即可。

import numpy as np
import h5py
 
def load_dataset():
   train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")
   train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set features
   train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels

   test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
   test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
   test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels

   classes = np.array(test_dataset["list_classes"][:]) # the list of classes
   
   train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
   test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
   
   return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes

整个过程可以分解为如下几个步骤：
1、初始化w、b的值
2、计算预测输出
3、计算dw、db
4、更新w、b

分解为以下几个函数：
1、sigmoid函数：sigmoid()
输入wx+b的值，输出sigmoid函数的值

def sigmoid(x):
    s=1./(1+np.exp(-x))
    return s
a=np.array([0,2])
print("sigmoid([0,2])="+str(sigmoid(a)))

2、初始化参数w、b函数
输入w所需要的维度，输出矩阵w（m*1个0），和b（0）

def initialize_with_zeros(dim):
    w=np.zeros((dim,1))
    b=0
    assert(w.shape==(dim,1))
    assert(isinstance(b,int)or isinstance(b,float))
    return w,b
dim=2
print(initialize_with_zeros(dim))

3、传播函数
输入：X，Y，输出：cost，dw，db

def propagate(w,b,X,Y):
    m=X.shape[1]
    z=np.dot(w.T,X)+b
    A=sigmoid(z)
    cost=-1/m*(np.dot(Y,np.log(A).T)+np.dot((1-Y),np.log(1-A).T))
    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 cost,grads
w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])
print(propagate(w, b, X, Y))

4、迭代优化函数
输入：迭代次数，学习速率，w，b，X，Y
输出：costs，w，b，dw，db

def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):
    costs = []
    for i in range(num_iterations):
        cost,grads=propagate(w,b,X,Y)
        dw=grads["dw"]
        db=grads["db"]
        w=w-learning_rate*dw
        b=b-learning_rate*db
        if i%100==0:
            costs.append(cost)
        if i%100==0 and print_cost :
            print("cost after iteration %d: %f",i,cost)
    params={"w":w,
            "b":b}
    grads={"dw":dw,
           "db":db}
    return params,grads,costs
params, grads, costs = optimize(w, b, X, Y, num_iterations= 100, learning_rate = 0.009, print_cost = False)
print ("w = " + str(params["w"]))
print ("b = " + str(params["b"]))
print ("dw = " + str(grads["dw"]))
print ("db = " + str(grads["db"]))
print(costs)

5、预测函数

def predict(w, b, X):
    z=np.dot(w.T,X)+b
    A=sigmoid(z)
    m=A.shape[1]
    Y_prediction=np.zeros((1,m))
    for i in range(m):
        Y_prediction[0,i]=0 if A[0,i]<=0.5 else 1
    assert(Y_prediction.shape==(1,m)) 
    return Y_prediction