【深度学习】 第二周课程作业实践

【导入数据集】

# 导入数据 数据集的h5文件
import h5py
# 训练集
train_data = h5py.File('E:\pycharmTest\datasets/train_catvnoncat.h5','r')
# 测试集
test_data = h5py.File('E:\pycharmTest\datasets/test_catvnoncat.h5','r')

【查看数据格式】

# 查看数据
for key in train_data.keys():#遍历key
print(key)
# classes  1/0
# train_set_x key
# train_set_y value 1/0 标签
print(train_data['train_set_x'].shape)#该key的数据
# [(209, 64, 64, 3)] 209张图片 64 64 3 3个通道 RGB
print(train_data['train_set_x'][:1])
print(train_data['train_set_y'].shape)

【取出训练集、测试集】

train_data_org = train_data['train_set_x'][:]#org 训练集原始数据 [209,64,64,3]
train_labels_org = train_data['train_set_y'][:]
test_data_org = test_data['test_set_x'][:]
test_labels_org = test_data['test_set_y'][:]
#添加查看功能
# 查看图片
import  matplotlib.pyplot as plt
#plt.imshow(train_data_org[148])#图片
#plt.show()

【数据处理】

# 数据维度的处理
import numpy as np
m_train = train_labels_org.shape[0]
m_test = test_labels_org.shape[0]
#print(m_test)
#print(m_train)

train_data_tran = train_data_org.reshape(m_train,-1).T #转换[209,64,64,3]->[209,12288]->[12288,209] _tran转换后的矩阵
test_data_tran = test_data_org.reshape(m_test,-1).T

train_labels_tran = train_labels_org[np.newaxis,:] # 1/0 [209,]->[1,209]
test_labels_tran = test_labels_org[np.newaxis,:]

# 数据标准化 0~255 影响梯度下降性能 标准化0~1
#print(test_data_tran)
train_data_sta = train_data_tran / 255 # _sta标准化
test_data_sta = test_data_tran / 255
#print(test_data_sta)

【函数】

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

# 初始化参数
n_dim = train_data_sta.shape[0] #n的维度
w = np.zeros((n_dim,1))
b = 0

# 前向传播函数、代价函数、梯度下降
# Z=W.T*X+B
# A=sigmoid(Z)
def profun(w,X,b,Y):
#w 权重 X特征 b偏差 Y实际标签(1/0)
#1.前向传播
z = np.dot(w.T,X) + b
A = sigmoid(z)

#2.代价函数
m = X.shape[1]

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} ##字典，保存dw,db。
return grands,J

# 优化
def optimize(w,b,X,y,alpha,n_iters,print_cost):
'''
w  - 权重
b  - 偏差
X  - 维度为（num_px * num_px * 3，训练数据的数量）的数组。
Y  - 实际标签(1/0)
n_iters  - 迭代次数
alpha  - 学习率
print_cost  - bool型 是否打印
'''
costs = [] #J的列表 用于绘图

for i in range(n_iters):
grands,J = profun(w,X,b,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('n_iters is',i,' cost is ',J)
grands = {'dw':dw,'db':db}
params = {'w':w,'b':b}
return grands,params,costs

# 预测
def predict(w,b,X_test):
#最优参数w,b 进行前向传播
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

【模型整合】

#逻辑回归模型
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, '%')
#预测是否等于实际 标签 是否是1/0

End = {#返回集合
'w' : w,
'b' : b,
'costs':costs,
'y_pred_train' : y_pred_train,
'y_pred_test' : y_pred_test,
'alpha' : alpha
}

return End

【调用】

End = model(w,b,train_data_sta,train_labels_tran,test_data_sta,test_labels_tran,alpha=0.001,n_iters = 3000,print_cost = True)

#绘制costs变化图
plt.plot(End['costs']) #取COSTS
plt.xlabel(['per hunred iters'])
plt.ylabel(['cost'])
plt.show()

'''
# 取图片查看验证
# index = 46
# print('y is ',test_labels_tran[0,index])
# print('y_pred is ',End['y_pred_test'][0,index])
# plt.imshow(test_data_org[index])
# plt.show()
'''

'''
# alpha 不同的准确率 绘制
alphas = [0.01,0.001,0.0001]
for i in alphas:
print('alpha = ',i)
End = model(w, b, train_data_sta, train_labels_tran, test_data_sta, test_labels_tran, alpha=i, n_iters=2000,print_cost = False)
print('==================')
plt.plot(End['costs'],label=str(i))
plt.xlabel('per hundred iters')
plt.ylabel('costs')
plt.legend()#显示标签
plt.show()
'''

'''
#单个测试图片
fname = 'C:\\Users\\Wwwww\\Pictures\\1.png'
image = plt.imread(fname)
#plt.imshow(image)
#plt.show()
#print(image.shape)
from skimage import transform
image_tran = transform.resize(image,(64,64,3)).reshape(64*64*3,1)
#print(image_tran.shape)
pre = predict(End['w'],End['b'],image_tran)
if pre == 1:
print('It\'s a cat')
else:
print('It\'s not a cat')
'''