一起深度学习

题目：

对提供的数据集进行训练，得到某种判断标准（如预测概率，若大于0.5则为猫，小于0,5则不是猫）。
对于输入的图片，判断是否为猫，是则输入1，否则输入0。

数据集合：

1、train_catvnoncat.h5：
训练集，维度为：（209，64，64，3），即209张6464的彩色图片。
2、test_catvnoncat.h5：
测试集，维度为：（50，64，64，3），即50张6464的彩色图片。

深度学习课程地址：
https://mooc.study.163.com/university/deeplearning_ai#/c
笔记地址：
http://www.ai-start.com/dl2017/
课后作业地址：
https://blog.csdn.net/u013733326/article/details/79827273

代码编写：

1、加载数据集：

train_data = h5py.File('E:/Deep_Learning/Resource/datasets/train_catvnoncat.h5',"r")
test_data = h5py.File('E:/Deep_Learning/Resource/datasets/test_catvnoncat.h5',"r")

h5的格式与字典相似，通过key可取得对应的value值。通过for key in train_data 打印可知：train_data中有三个key，分别是list_classes（类别）、train_set_x（图片集合）、train_set_y（输出标签）。

2、取出训练集，测试集

train_data_org = train_data['train_set_x'][:] #取出所有行和所有列
train_label_org = train_data['train_set_y'][:] #取出输出标签
test_data_org = test_data['test_set_x'][:]   #同理，测试集
test_label_org = test_data['test_set_y'][:]

通过 pit.imshow(train_data_org[178]) pit.show()可查看对应的照片

3、进行数据的处理

m_train = train_data_org.shape[0] #训练集样本的数量
m_test =test_data_org.shape[0] #测试样本的数量
train_data_tran = train_data_org.reshape(m_train,-1).T #重新塑形
test_data_tran = test_data_org.reshape(m_test,-1).T #重新塑形
# print(train_data_tran.shape,test_data_tran.shape) #(12288,209) (12288,50)
import numpy as np
train_label_tran = train_label_org[np.newaxis,:]
test_label_tran = test_label_org[np.newaxis,:]
# print(train_label_org.reshape(1,209).shape)  #同上一句，将输出标签转变为 1行209列，实现向量化
# print(train_label_tran.shape)

4、数据标准化

#数据标准化
train_data_sta =train_data_tran / 255
test_data_sta = test_data_tran / 255

5、定义sigmoid函数

def sigmoid(z):
    a = 1 / (1+np.exp(-z))
    return a

#初始化参数
n_dim = train_data_sta.shape[0] #取出行数，维度
#print(n_dim)
w = np.zeros((n_dim,1)) #定义一个n行1列的零矩阵
b = 0.0

6、定义向前传播函数、代价函数以及梯度下降

def propagate(w,b,X,y):
    #1、前向传播函数
    z = np.dot(w.T,X) + b
    A = sigmoid(z)

    #2、代价函数
    m =X.shape[1]#获取样本个数
   # print(m)
    J = -1/m *( np.sum(y* np.log(A) + (1-y) * np.log(1-A)))

    #3、梯度下降
    dw = 1/m * np.dot(X,(A-y).T)
    db = 1/m * np.sum(A-y)

    grands = {'dw':dw, 'db':db}

    return grands,J

7、优化部分

def optimize(w,b,X,y,alpha,n_itern,print_cost):
    """
    :param w: 权重
    :param b: 偏置值
    :param X: 训练集
    :param y: 输出标签
    :param alpha: 学习率
    :param n_itern:  迭代次数
    :return:
    """
    costs = []
    for i in range(n_itern):
        grands ,J = propagate(w,b,X,y)
        dw = grands['dw']
        db = grands['db']
        w = w - alpha * dw
        b = b - alpha * db
        if (i % 100 == 0):
            costs.append(J)
            if print_cost:
                print("代价函数的值为：",J)
    grands = {'dw': dw, 'db': db}
    params = {'w': w, 'b': b}
    return grands,params,costs

8、预测部分

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

9、模型整合

def model(w,b,x_train,y_train,X_test,y_test,alpha,n_iters,print_cost):
    grands, params, costs = optimize(w,b,x_train,y_train,alpha,n_iters,print_cost)
    w = params['w']
    b = params['b']
    y_pred_train = predict(w,b,x_train)
    y_pred_test = predict(w,b,X_test)

    print("the train acc is",np.mean(y_pred_train == y_train)*100,'%') #mean 是取均值
    print("the test acc is",np.mean(y_pred_test == y_test)*100,'%') #mean 是取均值
    result = {'w':w,
              'b':b,
              'y_pred_train':y_pred_train,
              'y_pred_test':y_pred_test,
              'costs':costs,
              'alpha':alpha
              }
    return result

10、运行测试

（1）进行训练

result = model(w,b,train_data_sta,train_label_tran,test_data_sta,test_label_tran,alpha=0.05,n_iters=2000)
pit.plot(result['costs'])
pit.xlabel('per hundred iters')
pit.ylabel('cost')
pit.show()

（2）进行新图测试

index = 12
#print('y is ',test_label_tran[0,index])
print("y_prediction is ",int(result["y_pred_test"][0,index]))
pit.imshow(test_data_org[index])
pit.show()

11、修改不同的学习率，查看预测概率大小。

alphas = [0.01,0.001,0.0001]
for i in alphas:
    print('alpha = ',i)
    result = model(w, b, train_data_sta, train_label_tran, test_data_sta, test_label_tran, alpha=i, n_iters=2000,print_cost=False)
    print('-----------')
    pit.plot(result['costs'],label = str(i))
pit.xlabel("per hundred iters")
pit.ylabel('cost')
pit.legend()
pit.show()

12、自定义图片进行预测

result = model(w,b,train_data_sta,train_label_tran,test_data_sta,test_label_tran,alpha=0.01,n_iters=2000,print_cost=False)
fname = 'xxxxxxxxxxxx/d56426d444554c5d68457cb18c6df3c.jpg'
image = pit.imread(fname)  #根据路径读取图片
from skimage import transform 
image_tran = transform.resize(image,(64,64,3)).reshape(64*64*3,1)#由于导入的照片不符合之前的训练集（规格为64*64*3），进行修改。
y = predict(result['w'],result['b'],image_tran)
if y == 1:
    print("我是猫")
else:
    print("不是猫")

总结：附上两张草稿，以免丢失。

学习视频：1、吴恩达的Deep learning 系列。
2、b站手把手讲解吴恩达老师作业的up。
感谢！