吴恩达神经网络学习编程作业L1W2作业1

import math
import numpy as np


#构建一个返回实数x的sigmoid的函数。将math.exp（x）用于指数函数
def sigmoid(x):
    y=1/(1+math.exp(-x))
    return y
print(sigmoid(6))

#使用numpy实现sigmoid函数
def sigmoid(x):
    y=1/(1+np.exp(-x))
    return y
x=np.array([1,2,3])
# print(x)
print(sigmoid(x))

#创建函数sigmoid_grad（）计算sigmoid函数相对于其输入x的梯度。
# x=np.random.randn(1,5)
x=np.array([1,2,3])

def sigmoid(x):
    s = 1 / (1 + np.exp(-x))
    return s

def sigmoid_grad(x):
    grad=sigmoid(x)*(1-sigmoid(x))
    return grad

print("sigmoid_derivative(x) =",sigmoid_grad(x))


#重塑数组 实现image2vector() ,该输入采用维度为(length, height, 3)的输入，并返回维度为(length*height*3, 1)的向量。
# This is a 3 by 3 by 2 array, typically images will be (num_px_x, num_px_y,3) where 3 represents the RGB values
image = np.array([[[ 0.67826139,  0.29380381],
        [ 0.90714982,  0.52835647],
        [ 0.4215251 ,  0.45017551]],

       [[ 0.92814219,  0.96677647],
        [ 0.85304703,  0.52351845],
        [ 0.19981397,  0.27417313]],

       [[ 0.60659855,  0.00533165],
        [ 0.10820313,  0.49978937],
        [ 0.34144279,  0.94630077]]])

def image2vector(image):
    v=image.reshape(image.shape[0]*image.shape[1]*image.shape[2],1) #image.shape[0]=图片的高，shape[1]=图片的长，shape[2]=图片的通道数
    return v
print("image2vector=",image2vector(image))


#行标准化 执行 normalizeRows（）来标准化矩阵的行。 将此函数应用于输入矩阵x之后，x的每一行应为单位长度（即长度为1）向量。
x = np.array([[0,3,4],
             [2,6,4]])
# print(x)
def normalizeRows(x):
    x_norm=np.linalg.norm(x,axis=1,keepdims=True) #x_norm为x的范数, axis=0表示对列的操作, axis=1表示对行的操作
    x_normalized=x/x_norm #归一化后的矩阵
    return x_normalized
print("normalizeRows(x) = ",normalizeRows(x))


#广播和softmax函数 使用numpy实现softmax函数。 你可以将softmax理解为算法需要对两个或多个类进行分类时使用的标准化函数。
  #如果你在上方输出 x_exp，x_sum和s的维度并重新运行练习单元，则会看到x_sum的纬度为（2,1），
  # 而x_exp和s的维度为（2,5）。 x_exp/x_sum 可以使用python广播。
x = np.array([
    [9, 2, 5, 0, 0],
    [7, 5, 0, 0 ,0]])

def softmax(x):
    x_exp=np.exp(x)
    cal=np.sum(x_exp,axis=1,keepdims=True)
    s=x_exp/cal
    return s

print("softmax(x) = " + str(softmax(x)))


#实现L1损失函数的Numpy向量化版本
y_hat = np.array([.9, 0.2, 0.1, .4, .9])
y = np.array([1, 0, 0, 1, 1])

def L1(y_hat,y):
    loss=np.sum(np.abs(y_hat-y))
    return loss

print("L1 = " + str(L1(y_hat,y)))


#实现L2损失函数的Numpy向量化版本
y_hat = np.array([.9, 0.2, 0.1, .4, .9])
y = np.array([1, 0, 0, 1, 1])

def L2(y_hat,y):
    loss=np.sum(np.dot(y-y_hat,(y-y_hat).T))
    return loss

print("L2 = " + str(L2(y_hat,y)))