import numpy as np
import matplotlib.pyplot as plt
import h5py
import scipy
from PIL import Image
from scipy import ndimage
from m1_uits import load_dataset
%matplotlib inline
train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes=load_dataset()
index =5
plt.imshow(train_set_x_orig[index])print("y = "+str(train_set_y[:, index])+", it is a '"+ classes[np.squeeze(train_set_y[:, index])].decode("utf-8")+"' picture.")
#查看数据集大小
m_train = train_set_x_orig.shape[0]
m_test = test_set_x_orig.shape[0]
num_px = train_set_x_orig.shape[1]print("Number of training examples: m_train = "+str(m_train))print("Number of testing examples: m_test = "+str(m_test))print("Height/Width of each image: num_px = "+str(num_px))print("Each image is of size: ("+str(num_px)+", "+str(num_px)+", 3)")print("train_set_x shape: "+str(train_set_x_orig.shape))print("train_set_y shape: "+str(train_set_y.shape))print("test_set_x shape: "+str(test_set_x_orig.shape))print("test_set_y shape: "+str(test_set_y.shape))
#Reshape the training and test examples
train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T
test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T
print("train_set_x_flatten shape: "+str(train_set_x_flatten.shape))print("train_set_y shape: "+str(train_set_y.shape))print("test_set_x_flatten shape: "+str(test_set_x_flatten.shape))print("test_set_y shape: "+str(test_set_y.shape))print("sanity check after reshaping: "+str(train_set_x_flatten[0:5,0]))
#GRADED FUNCTION: sigmoid
def sigmoid(z):"""
Compute the sigmoid of z
Arguments:
z -- A scalar or numpy array of any size.
Return:
s --sigmoid(z)"""
s =1/(1+ np.exp(-z))return s
print("sigmoid([0, 2]) = "+str(sigmoid(np.array([0,2]))))
#初始化参数
#GRADED FUNCTION: initialize_with_zeros
def initialize_with_zeros(dim):
w = np.zeros((dim,1))
b =0assert(w.shape ==(dim,1))assert(isinstance(b,float) or isinstance(b,int))return w, b
dim =2
w, b =initialize_with_zeros(dim)print("w = "+str(w))print("b = "+str(b))
#GRADED FUNCTION: 前向传播
def propagate(w, b, X, Y):
m = X.shape[1]#FORWARD PROPAGATION(FROM X TO COST)
A =sigmoid(np.dot(w.T, X)+ b) # compute activation
cost =-1/ m * np.sum(Y * np.log(A)+(1- Y)* np.log(1- A)) # compute cost
#BACKWARD PROPAGATION(TO FIND GRAD)
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 grads, cost
w, b, X, Y = np.array([[1],[2]]),2, np.array([[1,2],[3,4]]), np.array([[1,0]])
grads, cost =propagate(w, b, X, Y)print("dw = "+str(grads["dw"]))print("db = "+str(grads["db"]))print("cost = "+str(cost))
#GRADED FUNCTION: optimize
def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):
costs =[]for i in range(num_iterations):#Cost and gradient calculation(≈ 1-4 lines of code)
grads, cost =propagate(w, b, X, Y)#Retrieve derivatives from grads
dw = grads["dw"]
db = grads["db"]
w = w - learning_rate * dw
b = b - learning_rate * db
#Record the costsif i %100==0:
costs.append(cost)#Print the cost every 100 training examplesif print_cost and i %100==0:print("Cost after iteration %i: %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)
#GRADED FUNCTION: predict
def predict(w, b, X):
m = X.shape[1]
Y_prediction = np.zeros((1,m))
w = w.reshape(X.shape[0],1)#Compute vector "A"predicting the probabilities of a cat being present in the picture
A =sigmoid(np.dot(w.T, X)+ b)for i in range(A.shape[1]):#Convert probabilities A[0,i] to actual predictions p[0,i]if A[0, i]<=0.5:
Y_prediction[0, i]=0else:
Y_prediction[0, i]=1assert(Y_prediction.shape ==(1, m))return Y_prediction
print("predictions = "+str(predict(w, b, X)))
#GRADED FUNCTION: model
def model(X_train, Y_train, X_test, Y_test, num_iterations =2000, learning_rate =0.5, print_cost = False):#initializeparameters with zeros
w, b =initialize_with_zeros(X_train.shape[0])#Gradient descent
parameters, grads, costs =optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)#Retrieve parameters w and b from dictionary "parameters"
w = parameters["w"]
b = parameters["b"]#Predict test/train set examples
Y_prediction_test =predict(w, b, X_test)
Y_prediction_train =predict(w, b, X_train)#Print train/test Errorsprint("train accuracy: {} %".format(100- np.mean(np.abs(Y_prediction_train - Y_train))*100))print("test accuracy: {} %".format(100- np.mean(np.abs(Y_prediction_test - Y_test))*100))
d ={"costs": costs,"Y_prediction_test": Y_prediction_test,"Y_prediction_train": Y_prediction_train,"w": w,"b": b,"learning_rate": learning_rate,"num_iterations": num_iterations}#plotthe cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate ="+str(learning_rate))
plt.show()return d
d =model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations =2000, learning_rate =0.005, print_cost = True)
#Example of a picture that was wrongly classified.
index =1
plt.imshow(test_set_x[:,index].reshape((num_px, num_px,3)))print("y = "+str(test_set_y[0,index])+", you predicted that it is a \""+ classes[int(d["Y_prediction_test"][0,index])].decode("utf-8")+"\" picture.")