作業目錄
- 作業一（Week2 ex1）
- 作業二（Week3 ex2）
- 作業三（Week4 ex3）
- 作業四（Week5 ex4）
- 作業五（Week6 ex5）
- 作業六（Week7 ex6）
- 作業七（Week8 ex7）
- 作業八（Week9 ex8）
作業結構：
作業一（Week2 ex1）
在本部分的練習中，您將使用一個變數實作線性回歸，以預測食品卡車的利潤，假設你是一家餐館的首席執行官，正在考慮不同的城市開設一個新的分店，該連鎖店已經在各個城市擁有卡車，而且你有來自城市的利潤和人口資料，
您希望使用這些資料來幫助您選擇將哪個城市擴展到下一個城市，
ex1data1.txt 是本次作業資料,我們列印出來如圖：
線性回歸的代價函式：
其中1/2m的1/2只是方便求導，求梯度（平方的導數是乘以2， 剛好和1/2約了），網上也有些公式是沒有1/2的， 都是正確的， 不影響后面的分析，
權重優化公式
紅線部分為梯度公式， 也就是代價函式的導數，
α 是學習率， 之所以之前1/2可以約去， 是因為1/2只是個常數， 后面可以用α 來兜底， 來控制梯度的大小，
下面用python實作本周編程作業：
ex1必做題：
warmUpExercise.py:
from numpy import *;
def warmUpExercise():
# % ============= YOUR CODE HERE ==============
# % Instructions: Return the 5x5 identity matrix
# % In octave, we return values by defining which variables
# % represent the return values (at the top of the file)
# % and then set them accordingly.
A = mat(random.rand(5, 5));
print(A)
if __name__ == '__main__':
warmUpExercise()
computeCost.py：
from numpy import *;
import numpy as np;
import math;
import pandas as pd
import matplotlib.pyplot as plt
def computeCost(X, y, theta):
#COMPUTECOST Compute cost for linear regression
# J = COMPUTECOST(X, y, theta) computes the cost of using theta as the
# parameter for linear regression to fit the data points in X and y
#
# Initialize some useful values
m = len(y); # number of training examples
# You need to return the following variables correctly
J = 0;
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the cost of a particular choice of theta
# You should set J to the cost.
J = np.sum( np.power((X.dot(theta.T)-y),2) )/(2 * m)
# =========================================================================
return J
if __name__ == '__main__':
path = 'ex1data1.txt'
data = pd.read_csv(path, header=None)
X = np.matrix(data[0])
y = np.matrix(data[1])
m = X.shape[1]
X = X.reshape(m,1)
y = y.reshape(m,1)
theta = np.zeros((1,1))
print('X.shape',X.shape)
print('theta.shape',theta.shape)
print('y.shape',y.shape)
J = computeCost(X, y, theta)
print('J',J)
輸出：
X.shape (97, 1)
theta.shape (1, 1)
y.shape (97, 1)
J 32.072733877455676
gradientDescent.py:
from numpy import *;
from computeCost import computeCost
import numpy as np;
import math;
import pandas as pd
import matplotlib.pyplot as plt
from plotData import plotData
def gradientDescent(X, y, theta, alpha, num_iters):
#GRADIENTDESCENT Performs gradient descent to learn theta
# theta = GRADIENTDESCENT(X, y, theta, alpha, num_iters) updates theta by
# taking num_iters gradient steps with learning rate alpha
# Initialize some useful values
m = X.shape[0] # number of training examples
J_history = np.zeros(num_iters);
for iter in range(num_iters):
# ====================== YOUR CODE HERE ======================
# theta.
#
# Hint: While debugging, it can be useful to print out the values
# of the cost function (computeCost) and gradient here.
#
theta = theta - alpha/m * (( X.dot(theta.T) - y ).T.dot(X))
J = computeCost(X, y, theta)
J_history[iter] = J
return theta, J_history
if __name__ == '__main__':
path = 'ex1data1.txt'
data = pd.read_csv(path, header=None)
cols = data.shape[1]
X = data.iloc[:,0:cols-1]
y = data.iloc[:,cols-1:cols]
X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.zeros((1,1))
alpha = 0.001
epoch = 20
theta, J_history = gradientDescent(X, y, theta, alpha, epoch)
print('theta',theta)
print('J_history',J_history)
plotData(np.arange(0,epoch,1), J_history)
輸出：
theta [[0.65565076]]
J_history [27.97858553 24.52386652 21.60870997 19.1488463 17.07316731 15.32167052
13.84372475 12.59660645 11.54426468 10.656279 9.90698007 9.2747076
8.74118426 8.29098728 7.91110265 7.59054888 7.32005961 7.0918157
6.89921922 6.73670271]
選擇題：
featureNormalize.py:
from numpy import *;
import numpy as np;
import math;
import pandas as pd
import matplotlib.pyplot as plt
def featureNormalize(X):
#FEATURENORMALIZE Normalizes the features in X
# FEATURENORMALIZE(X) returns a normalized version of X where
# the mean value of each feature is 0 and the standard deviation
# is 1. This is often a good preprocessing step to do when
# working with learning algorithms.
# You need to set these values correctly
# ====================== YOUR CODE HERE ======================
# Instructions: First, for each feature dimension, compute the mean
# of the feature and subtract it from the dataset,
# storing the mean value in mu. Next, compute the
# standard deviation of each feature and divide
# each feature by it's standard deviation, storing
# the standard deviation in sigma.
#
# Note that X is a matrix where each column is a
# feature and each row is an example. You need
# to perform the normalization separately for
# each feature.
#
# Hint: You might find the 'mean' and 'std' functions useful.
#
mu = X.mean()
sigma = X.std()
X_norm = (X - mu)/sigma
return X_norm, mu, sigma
if __name__ == '__main__':
path = 'ex1data2.txt'
data = pd.read_csv(path, header=None)
cols = data.shape[1] # 列數
X = data.iloc[:,0:cols-1] # 取前cols-1列，即輸入向量
y = data.iloc[:,cols-1:cols] # 取最后一列，即目標向量
X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.zeros((1,2))
X_norm, mu, sigma = featureNormalize(X)
# print('X_norm',X_norm)
print('mu',mu)
print('sigma',sigma)
輸出：
mu 1001.9255319148937
sigma 1143.0528202028345
computeCostMulti.py:
from numpy import *;
import numpy as np;
import math;
import pandas as pd
import matplotlib.pyplot as plt
path = 'ex1data2.txt'
data = pd.read_csv(path, header=None)
cols = data.shape[1] # 列數
X = data.iloc[:,0:cols-1] # 取前cols-1列，即輸入向量
y = data.iloc[:,cols-1:cols] # 取最后一列，即目標向量
X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.matrix([0,0])
def computeCostMulti(X, y, theta):
#COMPUTECOSTMULTI Compute cost for linear regression with multiple variables
# J = COMPUTECOSTMULTI(X, y, theta) computes the cost of using theta as the
# parameter for linear regression to fit the data points in X and y
# Initialize some useful values
m = len(y); # number of training examples
# You need to return the following variables correctly
J = 0;
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the cost of a particular choice of theta
# You should set J to the cost.
J = np.sum( np.power((X*theta.T-y),2) )/(2 * m)
# # =========================================================================
return J
if __name__ == '__main__':
print(X.shape)
print(theta.shape)
print(y.shape)
J = computeCostMulti(X, y, theta)
print(J)
輸出:
(47, 2)
(1, 2)
(47, 1)
65591548106.45744
normalEqn.py:
from numpy import *;
import numpy as np;
import math;
import pandas as pd
import matplotlib.pyplot as plt
def normalEqn(X, y):
#NORMALEQN Computes the closed-form solution to linear regression
# NORMALEQN(X,y) computes the closed-form solution to linear
# regression using the normal equations.
# ====================== YOUR CODE HERE ======================
# Instructions: Complete the code to compute the closed form solution
# to linear regression and put the result in theta.
#
# ---------------------- Sample Solution ----------------------
theta = np.linalg.inv(X.T * X) * X.T * y
# -------------------------------------------------------------
# ============================================================
return theta
if __name__ == '__main__':
path = 'ex1data2.txt'
data = pd.read_csv(path, header=None)
cols = data.shape[1] # 列數
X = data.iloc[:,0:cols-1] # 取前cols-1列，即輸入向量
y = data.iloc[:,cols-1:cols] # 取最后一列，即目標向量
X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.matrix([0,0])
theta = normalEqn(X, y)
print('theta',theta)
輸出：
theta [[ 140.86108621]
[16978.19105903]]
作業二（Week3 ex2）
在這部分的練習中，你將建立一個邏輯回歸模型來預測一個學生是否能進入大學，假設你是一所大學的行政管理人員，你想根據兩門考試的結果，來決定每個申請人是否被錄取，你有以前申請人的歷史資料，可以將其用作邏輯回歸訓練集，對于每一個訓練樣本，你有申請人兩次測評的分數以及錄取的結果，為了完成這個預測任務，我們準備構建一個可以基于兩次測驗評分來評估錄取可能性的分類模型，
下圖是ex2data1.txt資料模型圖：
邏輯回歸的假設函式：
其中的 g代表邏輯回歸的S形函式（Sigmoid function）：
大概長這樣：
y值在0到1之間，大于等于0.5歸一類，小于0.5歸一類，
邏輯回歸的代價函式：
和線性回歸的代價函式略有不同， 看似復雜，其實原理差不多，
下面用python實作本周編程作業：
sigmoid.py:
from numpy import *;
import numpy as np;
import math;
import pandas as pd
import matplotlib.pyplot as plt
def sigmoid(z):
#SIGMOID Compute sigmoid function
# g = SIGMOID(z) computes the sigmoid of z.
# You need to return the following variables correctly
# g = zeros(size(z));
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the sigmoid of each value of z (z can be a matrix,
# vector or scalar).
g = 1 / ( 1 + np.exp(-z))
# =============================================================
return g
if __name__ == '__main__':
x1 = np.arange(-10, 10, 0.1)
g = sigmoid(x1)
plt.plot(x1, sigmoid(x1), c='r')
plt.show()
輸出：
costFunction.py:
from numpy import *;
import numpy as np;
import math;
import pandas as pd
from sigmoid import sigmoid
import matplotlib.pyplot as plt
def costFunction(theta, X, y):
#COSTFUNCTION Compute cost and gradient for logistic regression
# J = COSTFUNCTION(theta, X, y) computes the cost of using theta as the
# parameter for logistic regression and the gradient of the cost
# w.r.t. to the parameters.
# Initialize some useful values
m = len(y); # number of training examples
# You need to return the following variables correctly
# J = 0;
# grad = zeros(size(theta));
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the cost of a particular choice of theta.
# You should set J to the cost.
# Compute the partial derivatives and set grad to the partial
# derivatives of the cost w.r.t. each parameter in theta
#
# Note: grad should have the same dimensions as theta
#
h = sigmoid(X.dot(theta.T))
J = 1/m * np.sum(-np.multiply(y,np.log(h)) - np.multiply((1-y),np.log(1-h)))
grad = (h -y).T * X/m
# =============================================================
return J, grad
if __name__ == '__main__':
path = 'ex2data1.txt'
data = pd.read_csv(path, header=None)
cols = data.shape[1] # 列數
X = data.iloc[:,0:cols-1] # 取前cols-1列，即輸入向量
y = data.iloc[:,cols-1:cols] # 取最后一列，即目標向量
X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.matrix([0,0])
# print('X.shape',X.shape)
# print('theta.shape',theta.shape)
# print('y.shape',y.shape)
J, grad = costFunction(theta, X, y)
print('J',J)
print('grad',grad)
輸出：
J 0.6931471805599453
grad [[-12.00921659 -11.26284221]]
costFunctionReg.py:
from numpy import *;
import numpy as np;
import math;
import pandas as pd
import costFunction as cf
import sigmoid as s
import matplotlib.pyplot as plt
def costFunctionReg(theta, X, y, lamb_da):
#COSTFUNCTIONREG Compute cost and gradient for logistic regression with regularization
# J = COSTFUNCTIONREG(theta, X, y, lambda) computes the cost of using
# theta as the parameter for regularized logistic regression and the
# gradient of the cost w.r.t. to the parameters.
# Initialize some useful values
m = len(y); # number of training examples
# You need to return the following variables correctly
# J = 0;
# grad = zeros(size(theta));
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the cost of a particular choice of theta.
# You should set J to the cost.
# Compute the partial derivatives and set grad to the partial
# derivatives of the cost w.r.t. each parameter in theta
J, grad= cf.costFunction(theta, X, y)
theta = theta[: 1]
J += lamb_da/2*m*(theta * theta.T)
grad += lamb_da/m*theta
# =============================================================
return J, grad
if __name__ == '__main__':
path = 'ex2data2.txt'
data = pd.read_csv(path, header=None)
cols = data.shape[1] # 列數
X = data.iloc[:,0:cols-1] # 取前cols-1列，即輸入向量
y = data.iloc[:,cols-1:cols] # 取最后一列，即目標向量
X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.matrix([0,0])
# print('X.shape',X.shape)
# print('theta.shape',theta.shape)
# print('y.shape',y.shape)
J, grad = costFunctionReg(theta, X, y, lamb_da=1)
print('J',J)
print('grad',grad)
輸出：
J [[0.69314718]]
grad [[1.87880932e-02 7.77711864e-05]]
predict.py:
from numpy import *;
import numpy as np;
import math;
import pandas as pd
import sigmoid as s
import costFunction as cf
import matplotlib.pyplot as plt
import scipy.optimize as opt
path = 'ex2data2.txt'
data = pd.read_csv(path, header=None)
cols = data.shape[1] # 列數
X = data.iloc[:,0:cols-1] # 取前cols-1列，即輸入向量
y = data.iloc[:,cols-1:cols] # 取最后一列，即目標向量
X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.matrix([0.20623159, 0.20147149])
def predict(theta, X):
#PREDICT Predict whether the label is 0 or 1 using learned logistic
#regression parameters theta
# p = PREDICT(theta, X) computes the predictions for X using a
# threshold at 0.5 (i.e., if sigmoid(theta'*x) >= 0.5, predict 1)
m = X.shape[0]; # Number of training examples
# You need to return the following variables correctly
# p = zeros(m, 1);
# ====================== YOUR CODE HERE ======================
# Instructions: Complete the following code to make predictions using
# your learned logistic regression parameters.
# You should set p to a vector of 0's and 1's
#
h = s.sigmoid(X*theta.T)
# p = np.matrix(data.iloc[:,cols-1:cols].values)
# for i in range(m):
# if h[i][0]>=0.5:
# p[i][0] = 1
# else:
# p[i][0] = 0
p = [1 if x >= 0.5 else 0 for x in h]
# =========================================================================
return p
if __name__ == '__main__':
print(X.shape)
print(theta.shape)
print(y.shape)
p = predict(theta, X)
print(p)
輸出：
(118, 2)
(1, 2)
(118, 1)
[1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1]
作業三（Week4 ex3）
我們將擴展我們在練習2中寫的logistic回歸的實作，并將其應用于一對多的分類（不止兩個類別），
下面用plot_100_image方法根據ex3data1.mat隨機畫100個數字：
def plot_100_image(X):
sample_idx = np.random.choice(np.arange(X.shape[0]), 100) # 隨機選100個樣本
sample_images = X[sample_idx, :] # (100,400)
fig, ax_array = plt.subplots(nrows=10, ncols=10, sharey=True, sharex=True, figsize=(8, 8))
for row in range(10):
for column in range(10):
ax_array[row, column].matshow(sample_images[10 * row + column].reshape((20, 20)),
cmap='gray_r')
plt.xticks([])
plt.yticks([])
plt.show()
正則化的logistic回歸的代價函式：
紅色部分就是正則化部分， 前面就是之前提到的邏輯回歸代價函式公式，
下面用python實作本周編程作業：
lrCostFunction.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
def lrCostFunction(theta, X, y, lamb_da):
# LRCOSTFUNCTION Compute cost and gradient for logistic regression with
# regularization
# J = LRCOSTFUNCTION(theta, X, y, lambda) computes the cost of using
# theta as the parameter for regularized logistic regression and the
# gradient of the cost w.r.t. to the parameters.
# Initialize some useful values
m = len(y); # number of training examples
# You need to return the following variables correctly
# J = 0;
# grad = zeros(size(theta));
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the cost of a particular choice of theta.
# You should set J to the cost.
# Compute the partial derivatives and set grad to the partial
# derivatives of the cost w.r.t. each parameter in theta
#
# Hint: The computation of the cost function and gradients can be
# efficiently vectorized. For example, consider the computation
#
# sigmoid(X * theta)
#
# Each row of the resulting matrix will contain the value of the
# prediction for that example. You can make use of this to vectorize
# the cost function and gradient computations.
#
# Hint: When computing the gradient of the regularized cost function,
# there're many possible vectorized solutions, but one solution
# looks like:
# grad = (unregularized gradient for logistic regression)
# temp = theta;
# temp(1) = 0; # because we don't add anything for j = 0
# grad = grad + YOUR_CODE_HERE (using the temp variable)
J = compute_J(theta, X, y, lamb_da, m)
grad = compute_grad(theta, X, y, lamb_da, m)
# =============================================================
return J, grad
def compute_J(theta, X, y, lamb_da, m):
y = y.reshape(y.size,1)
theta = theta.reshape(1,theta.size)
h = sigmoid(X.dot(theta.T))
# theta = theta[:,1:]
theta[0] = 1
J = 1 / m * np.sum(-np.multiply(y, np.log(h)) - np.multiply((1 - y), np.log(1 - h))) + lamb_da / (2 * m) * (
theta.dot(theta.T))
# J = 1 / m * np.sum(-np.multiply(y, np.log(h)) - np.multiply((1 - y), np.log(1 - h)))
return J
def compute_grad(theta, X, y, lamb_da, m):
y = y.reshape(y.size,1)
theta = theta.reshape(1,theta.size)
h = sigmoid(X.dot(theta.T))
# theta = theta[:,1:]
theta[0] = 1
grad = 1 / m * X.T.dot(h - y) + (lamb_da / m) * theta.T
# grad = 1 / m * X.T.dot(h - y)
return grad
def sigmoid(z):
g = 1 / (1 + np.exp(-z));
return g
def load_data(path):
data = loadmat(path)
X = data['X']
y = data['y']
return X, y
if __name__ == '__main__':
X, y = load_data('ex3data1.mat')
theta = np.zeros((1, X.shape[1]))
J, grad = lrCostFunction(theta, X, y, lamb_da=1)
print('J.shape',J.shape)
print('J',J)
print('grad.shape',grad.shape)
輸出：
J.shape (1, 1)
J [[160.43425758]]
grad.shape (400, 1)
oneVsAll.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
from scipy.optimize import minimize
from lrCostFunction import compute_J, compute_grad, sigmoid,load_data
def oneVsAll(X, y, num_labels, lamb_da):
# ONEVSALL trains multiple logistic regression classifiers and returns all
# the classifiers in a matrix all_theta, where the i-th row of all_theta
# corresponds to the classifier for label i
# [all_theta] = ONEVSALL(X, y, num_labels, lambda) trains num_labels
# logistic regression classifiers and returns each of these classifiers
# in a matrix all_theta, where the i-th row of all_theta corresponds
# to the classifier for label i
# Some useful variables
m, n = X.shape
# You need to return the following variables correctly
all_theta = np.zeros((num_labels, n))
# Add ones to the X data matrix
# X = [ones(m, 1) X];
# ====================== YOUR CODE HERE ======================
# Instructions: You should complete the following code to train num_labels
# logistic regression classifiers with regularization
# parameter lambda.
#
# Hint: theta(:) will return a column vector.
#
# Hint: You can use y == c to obtain a vector of 1's and 0's that tell you
# whether the ground truth is true/false for this class.
#
# Note: For this assignment, we recommend using fmincg to optimize the cost
# function. It is okay to use a for-loop (for c = 1:num_labels) to
# loop over the different classes.
#
# fmincg works similarly to fminunc, but is more efficient when we
# are dealing with large number of parameters.
#
# Example Code for fmincg:
#
# # Set Initial theta
# initial_theta = zeros(n + 1, 1);
#
# # Set options for fminunc
# options = optimset('GradObj', 'on', 'MaxIter', 50);
#
# # Run fmincg to obtain the optimal theta
# # This function will return theta and the cost
# [theta] = ...
# fmincg (@(t)(lrCostFunction(t, X, (y == c), lambda)), ...
# initial_theta, options);
for i in range(1, num_labels + 1):
theta = np.zeros((1, X.shape[1]))
y_i = np.array([1 if label == i else 0 for label in y])
ret = minimize(fun=compute_J, x0=theta, args=(X, y_i, lamb_da, m), method='TNC',
jac=compute_grad, options={'disp': True})
all_theta[i - 1, :] = ret.x
# =========================================================================
return all_theta
if __name__ == '__main__':
X, y = load_data('ex3data1.mat')
all_theta = oneVsAll(X, y, num_labels=10, lamb_da=1)
print(all_theta.shape)
輸出：
(10, 400)
predict.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
from scipy.optimize import minimize
from lrCostFunction import compute_J, compute_grad, sigmoid,load_data
from oneVsAll import oneVsAll
def predict(Theta1, Theta2, X):
#PREDICT Predict the label of an input given a trained neural network
# p = PREDICT(Theta1, Theta2, X) outputs the predicted label of X given the
# trained weights of a neural network (Theta1, Theta2)
# Useful values
m = X.shape[0]
# You need to return the following variables correctly
# p = zeros(size(X, 1), 1);
# ====================== YOUR CODE HERE ======================
# Instructions: Complete the following code to make predictions using
# your learned neural network. You should set p to a
# vector containing labels between 1 to num_labels.
#
# Hint: The max function might come in useful. In particular, the max
# function can also return the index of the max element, for more
# information see 'help max'. If your examples are in rows, then, you
# can use max(A, [], 2) to obtain the max for each row.
# Add ones to the X data matrix -jin
a2 = sigmoid(X.dot(Theta1.T))
a2 = np.insert(a2, 0, values=np.ones(a2.shape[0]), axis=1)
a3 = sigmoid(a2.dot(Theta2.T))
p = np.argmax(a3, axis=1) + 1
p = p.reshape(p.size,1)
# =========================================================================
return p
def load_weight(path):
data = loadmat(path)
return data['Theta1'], data['Theta2']
if __name__ == '__main__':
theta1, theta2 = load_weight('ex3weights.mat')
X, y = load_data('ex3data1.mat')
X = np.insert(X, 0, values=np.ones(X.shape[0]), axis=1)
p = predict(theta1, theta2, X)
accuracy = np.mean(p == y)
print ('accuracy = {0}%'.format(accuracy * 100))
輸出：
accuracy = 97.52%
predictOneVsAll.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
from scipy.optimize import minimize
from lrCostFunction import compute_J, compute_grad, sigmoid,load_data
from oneVsAll import oneVsAll
def predictOneVsAll(all_theta, X):
#PREDICT Predict the label for a trained one-vs-all classifier. The labels
#are in the range 1..K, where K = size(all_theta, 1).
# p = PREDICTONEVSALL(all_theta, X) will return a vector of predictions
# for each example in the matrix X. Note that X contains the examples in
# rows. all_theta is a matrix where the i-th row is a trained logistic
# regression theta vector for the i-th class. You should set p to a vector
# of values from 1..K (e.g., p = [1; 3; 1; 2] predicts classes 1, 3, 1, 2
# for 4 examples)
m = X.shape[0]
num_labels = all_theta.shape[0]
# You need to return the following variables correctly
# p = zeros(size(X, 1), 1);
# Add ones to the X data matrix
# X = [ones(m, 1) X];
# ====================== YOUR CODE HERE ======================
# Instructions: Complete the following code to make predictions using
# your learned logistic regression parameters (one-vs-all).
# You should set p to a vector of predictions (from 1 to
# num_labels).
#
# Hint: This code can be done all vectorized using the max function.
# In particular, the max function can also return the index of the
# max element, for more information see 'help max'. If your examples
# are in rows, then, you can use max(A, [], 2) to obtain the max
# for each row.
p = sigmoid(X.dot(all_theta.T))
p = np.argmax(p, axis=1)
p = p + 1
# =========================================================================
return p
if __name__ == '__main__':
X, y = load_data('ex3data1.mat')
all_theta = oneVsAll( X, y, num_labels=10, lamb_da=1)
y_pred = predictOneVsAll(all_theta,X)
y_pred = y_pred.reshape(y_pred.size,1)
accuracy = np.mean(y_pred == y)
print ('accuracy = {0}%'.format(accuracy * 100))
輸出：
accuracy = 97.39999999999999%
作業四（Week5 ex4）
這周被稱作“絕望第五周”，需要實作反向傳播演算法來學習神經網路的引數，依舊是上次預測手寫數數字的例子，
正向傳遞程序，其中 g 為sigmoid激活函式：
反向傳播程序：
先算誤差：
再算梯度：
最后網路的總梯度為：
這里的反向傳播有點繞，我另一篇文章有詳細手寫推導程序：
【用高中的知識點徒手推導邏輯回歸中的反向梯隊】
下面用python實作本周編程作業：
sigmoidGradient.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
def sigmoidGradient(z):
# SIGMOIDGRADIENT returns the gradient of the sigmoid function
# evaluated at z
# g = SIGMOIDGRADIENT(z) computes the gradient of the sigmoid function
# evaluated at z. This should work regardless if z is a matrix or a
# vector. In particular, if z is a vector or matrix, you should return
# the gradient for each element.
# g = zeros(size(z));
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the gradient of the sigmoid function evaluated at
# each value of z (z can be a matrix, vector or scalar).
h = sigmoid(z)
g = np.multiply(h, (1 - h))
# =============================================================
return g
def sigmoid(z):
g = 1 / (1 + np.exp(-z));
return g
def load_data(path):
data = loadmat(path)
X = data['X']
y = data['y']
return X, y
def load_weight(path):
data = loadmat(path)
return data['Theta1'], data['Theta2']
if __name__ == '__main__':
X, y = load_data('ex4data1.mat')
theta = np.zeros((1, X.shape[1]))
z = np.dot(X, theta.T)
g = sigmoidGradient(z)
print('g', g)
輸出：
g [[0.25]
[0.25]
[0.25]
...
[0.25]
[0.25]
[0.25]]
nnCostFunction.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
from sigmoidGradient import sigmoid, load_data, load_weight, sigmoidGradient
def nnCostFunction(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, lamb_da):
# NNCOSTFUNCTION Implements the neural network cost function for a two layer
# neural network which performs classification
# [J grad] = NNCOSTFUNCTON(nn_params, hidden_layer_size, num_labels, ...
# X, y, lambda) computes the cost and gradient of the neural network. The
# parameters for the neural network are "unrolled" into the vector
# nn_params and need to be converted back into the weight matrices.
#
# The returned parameter grad should be a "unrolled" vector of the
# partial derivatives of the neural network.
#
# Reshape nn_params back into the parameters Theta1 and Theta2, the weight matrices
# for our 2 layer neural network
# Theta1 = reshape(nn_params(1:hidden_layer_size * (input_layer_size + 1)), ...
# hidden_layer_size, (input_layer_size + 1));
#
# Theta2 = reshape(nn_params((1 + (hidden_layer_size * (input_layer_size + 1))):end), ...
# num_labels, (hidden_layer_size + 1));
# Theta1 = np.zeros(hidden_layer_size,input_layer_size+1)
# Theta2 = np.zeros(num_labels,hidden_layer_size+1)
# Setup some useful variables
m = X.shape[0]
# You need to return the following variables correctly
J = 0;
# Theta1_grad = zeros(size(Theta1));
# Theta2_grad = zeros(size(Theta2));
# ====================== YOUR CODE HERE ======================
# Instructions: You should complete the code by working through the
# following parts.
#
# Part 1: Feedforward the neural network and return the cost in the
# variable J. After implementing Part 1, you can verify that your
# cost function computation is correct by verifying the cost
# computed in ex4.m
#
# Part 2: Implement the backpropagation algorithm to compute the gradients
# Theta1_grad and Theta2_grad. You should return the partial derivatives of
# the cost function with respect to Theta1 and Theta2 in Theta1_grad and
# Theta2_grad, respectively. After implementing Part 2, you can check
# that your implementation is correct by running checkNNGradients
#
# Note: The vector y passed into the function is a vector of labels
# containing values from 1..K. You need to map this vector into a
# binary vector of 1's and 0's to be used with the neural network
# cost function.
#
# Hint: We recommend implementing backpropagation using a for-loop
# over the training examples if you are implementing it for the
# first time.
#
# Part 3: Implement regularization with the cost function and gradients.
#
# Hint: You can implement this around the code for
# backpropagation. That is, you can compute the gradients for
# the regularization separately and then add them to Theta1_grad
# and Theta2_grad from Part 2.
#
Theta1, Theta2 = load_weight('ex4weights.mat')
# Part 1
X = np.insert(X, 0, values=np.ones(X.shape[0]), axis=1)
a2 = sigmoid(X.dot(Theta1.T))
a2 = np.insert(a2, 0, values=np.ones(a2.shape[0]), axis=1)
a3 = sigmoid(a2.dot(Theta2.T))
cy = np.zeros((m, num_labels))
for i in range(m):
cy[i, y[i] - 1] = 1
Theta1 = Theta1[:, 1:]
Theta2 = Theta2[:, 1:]
J = compute_J(Theta1, Theta2, a3, m, cy, lamb_da)
grad = compute_grad(a2,a3, Theta2, cy, m)
# =========================================================================
return J, grad
def compute_J(Theta1, Theta2, a3, m, cy, lamb_da):
J = 1 / m * np.sum(-np.multiply(cy, np.log(a3)) - np.multiply((1 - cy), np.log(1 - a3)))
th1 = 0
th2 = 0
for i in range(Theta1.shape[0]):
t_tmp = Theta1[i, :]
th1 += np.sum(t_tmp.dot(t_tmp.T))
for i in range(Theta2.shape[0]):
t_tmp = Theta2[i, :]
th2 += np.sum(t_tmp.dot(t_tmp.T))
J += lamb_da / (2 * m) * (th1 + th2)
return J
def compute_grad(a2,a3, Theta2, cy, m):
delta3 = a3 - cy # (5000,10)
delta2 = np.multiply(delta3.dot(Theta2), sigmoidGradient(a2[:,1:])) # (5000,25)
Theta1_grad = delta2.T.dot(X) # (25,401)
Theta2_grad = delta3.T.dot(a2) # (10,26)
t1_t2 = np.r_[Theta1_grad.flatten(), Theta2_grad.flatten()] # np.r_是按列連接兩個矩陣，就是把兩矩陣上下相加，要求列數相等，
grad = (1 / m) * t1_t2 # (10285,)
return grad
if __name__ == '__main__':
X, y = load_data('ex4data1.mat')
J, grad = nnCostFunction(nn_params=1, input_layer_size=10, hidden_layer_size=25, num_labels=10, X=X, y=y, lamb_da=1)
print('J', J)
print('grad.shape', grad.shape)
輸出：
J 0.38376985909092365
grad.shape (10260,)
作業五（Week6 ex5）
在前半部分的練習中，你將實作正則化線性回歸，以預測水庫中的水位變化，從而預測大壩流出的水量，在下半部分中，您將通過一些除錯學習演算法的診斷，并檢查偏差 v.s. 方差的影響，
根據ex5data1.mat列印出這次資料的模樣：
線性回歸正則化代價函式：
和邏輯回歸正則化代價函式一樣， 前面都是正兒八經的線性回歸代價函式 ， 紅色部分就是正則化函式，
線性回歸正則化梯度：
下面用python實作本周編程作業：
learningCurve.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
from linearRegCostFunction import compute_grad, compute_J, linearRegCostFunction
def learningCurve(X, y, Xval, yval, lamb_da):
#LEARNINGCURVE Generates the train and cross validation set errors needed
#to plot a learning curve
# [error_train, error_val] = ...
# LEARNINGCURVE(X, y, Xval, yval, lambda) returns the train and
# cross validation set errors for a learning curve. In particular,
# it returns two vectors of the same length - error_train and
# error_val. Then, error_train(i) contains the training error for
# i examples (and similarly for error_val(i)).
#
# In this function, you will compute the train and test errors for
# dataset sizes from 1 up to m. In practice, when working with larger
# datasets, you might want to do this in larger intervals.
#
# Number of training examples
m = X.shape[0]
# You need to return these values correctly
# error_train = np.zeros((m, 1))
# error_val = np.zeros((m, 1))
error_train, error_val = [], []
# ====================== YOUR CODE HERE ======================
# Instructions: Fill in this function to return training errors in
# error_train and the cross validation errors in error_val.
# i.e., error_train(i) and
# error_val(i) should give you the errors
# obtained after training on i examples.
#
# Note: You should evaluate the training error on the first i training
# examples (i.e., X(1:i, :) and y(1:i)).
#
# For the cross-validation error, you should instead evaluate on
# the _entire_ cross validation set (Xval and yval).
#
# Note: If you are using your cost function (linearRegCostFunction)
# to compute the training and cross validation error, you should
# call the function with the lambda argument set to 0.
# Do note that you will still need to use lambda when running
# the training to obtain the theta parameters.
#
# Hint: You can loop over the examples with the following:
#
# for i = 1:m
# # Compute train/cross validation errors using training examples
# # X(1:i, :) and y(1:i), storing the result in
# # error_train(i) and error_val(i)
# ....
#
# end
#
# ---------------------- Sample Solution ----------------------
for i in range(1, m+1):
theta = trainLinearReg(X[:i], y[:i], lamb_da)
error_train.append(compute_J(theta, X[:i], y[:i], lamb_da, m))
error_val.append(compute_J(theta, Xval, yval, lamb_da, m))
# -------------------------------------------------------------
# =========================================================================
return error_train, error_val
def trainLinearReg(X, y, l):
theta = np.zeros(X.shape[1])
m = len(X)
res = opt.minimize(fun=compute_J,
x0=theta,
args=(X, y, l, m),
method='TNC',
jac=compute_grad)
return res.x
if __name__ == '__main__':
data = loadmat('ex5data1.mat')
X, y = data['X'], data['y']
Xval, yval = data['Xval'], data['yval']
X = np.insert(X, 0, 1, axis=1)
Xval = np.insert(Xval, 0, 1, axis=1)
theta = np.zeros((1, X.shape[1]))
error_train, error_val = learningCurve(X, y, Xval, yval,0)
print('error_train', error_train)
print('error_val', error_val)
輸出：
error_train [array([[0.18980339]]), array([[0.24715886]]), array([[49.43667484]]), array([[105.97979737]]), array([[106.30855924]]), array([[106.49601542]]), array([[115.51234849]]), array([[115.79709682]]), array([[116.379967]]), array([[116.960197]]), array([[119.38441281]]), array([[140.95412088]])]
error_val [array([[287.20263926]]), array([[287.20263926]]), array([[287.20263926]]), array([[287.20263926]]), array([[287.20263926]]), array([[287.20263926]]), array([[287.20263926]]), array([[287.20263926]]), array([[287.20263926]]), array([[287.20263926]]), array([[287.20263926]]), array([[287.20263926]])]
linearRegCostFunction.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
def linearRegCostFunction(X, y, theta, lamb_da):
# LINEARREGCOSTFUNCTION Compute cost and gradient for regularized linear
# regression with multiple variables
# [J, grad] = LINEARREGCOSTFUNCTION(X, y, theta, lambda) computes the
# cost of using theta as the parameter for linear regression to fit the
# data points in X and y. Returns the cost in J and the gradient in grad
# Initialize some useful values
m = len(y); # number of training examples
# You need to return the following variables correctly
# J = 0;
# grad = zeros(size(theta));
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the cost and gradient of regularized linear
# regression for a particular choice of theta.
#
# You should set J to the cost and grad to the gradient.
#
J = compute_J(theta, X, y, lamb_da, m)
grad = compute_grad(theta, X, y, lamb_da, m)
# =========================================================================
return J, grad
def compute_J(theta, X, y, lamb_da, m):
y = y.reshape(y.size, 1)
theta = theta.reshape(1, theta.size)
h = X.dot(theta.T)
# theta = theta[:,1:]
theta[0] = 0
J = (1 / (2 * m)) * np.sum(np.square(h - y)) + lamb_da / (2 * m) * (theta.dot(theta.T))
return J
def compute_grad(theta, X, y, lamb_da, m):
y = y.reshape(y.size, 1)
theta = theta.reshape(1, theta.size)
h = X.dot(theta.T)
# theta = theta[:,1:]
# grad = 1 / m * (h - y).T.dot(X) + np.concatenate((np.zeros((1, 1)), (lamb_da / m) * theta))
theta[0] = 0
grad = 1 / m * (h - y).T.dot(X) + (lamb_da / m) * theta
return grad
if __name__ == '__main__':
data = loadmat('ex5data1.mat')
X, y = data['X'], data['y']
X = np.insert(X, 0, 1, axis=1)
theta = np.ones((1, X.shape[1]))
J, grad = linearRegCostFunction(X, y, theta, lamb_da=1)
print('X={},y={}'.format(X.shape, y.shape))
print('theta={}'.format(theta.shape))
print('J', J)
print('grad.shape', grad.shape)
print('grad', grad)
輸出：
X=(12, 2),y=(12, 1)
theta=(1, 2)
J [[303.95152555]]
grad.shape (1, 2)
grad [[ -11.21758933 -245.65199649]]
polyFeatures.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
from linearRegCostFunction import compute_grad,compute_J, linearRegCostFunction
def polyFeatures(X, p):
#POLYFEATURES Maps X (1D vector) into the p-th power
# [X_poly] = POLYFEATURES(X, p) takes a data matrix X (size m x 1) and
# maps each example into its polynomial features where
# X_poly(i, :) = [X(i) X(i).^2 X(i).^3 ... X(i).^p];
#
# You need to return the following variables correctly.
# X_poly = []
X_poly = np.ones((len(X), p))
# ====================== YOUR CODE HERE ======================
# Instructions: Given a vector X, return a matrix X_poly where the p-th
# column of X contains the values of X to the p-th power.
#
#
for i in range(1, p):
X_poly[:,i] = np.power(X, i).flatten()
# =========================================================================
return X_poly
if __name__ == '__main__':
data = loadmat('ex5data1.mat')
X, y = data['X'], data['y']
X_poly = polyFeatures(X, 6)
print('X_poly',X_poly)
輸出：
X_poly [[ 1.00000000e+00 -1.59367581e+01 2.53980260e+02 -4.04762197e+03
6.45059724e+04 -1.02801608e+06]
[ 1.00000000e+00 -2.91529792e+01 8.49896197e+02 -2.47770062e+04
7.22323546e+05 -2.10578833e+07]
[ 1.00000000e+00 3.61895486e+01 1.30968343e+03 4.73968522e+04
1.71527069e+06 6.20748719e+07]
[ 1.00000000e+00 3.74921873e+01 1.40566411e+03 5.27014222e+04
1.97589159e+06 7.40804977e+07]
[ 1.00000000e+00 -4.80588295e+01 2.30965109e+03 -1.10999128e+05
5.33448815e+06 -2.56369256e+08]
[ 1.00000000e+00 -8.94145794e+00 7.99496701e+01 -7.14866612e+02
6.39194974e+03 -5.71533498e+04]
[ 1.00000000e+00 1.53077929e+01 2.34328523e+02 3.58705250e+03
5.49098568e+04 8.40548715e+05]
[ 1.00000000e+00 -3.47062658e+01 1.20452489e+03 -4.18045609e+04
1.45088020e+06 -5.03546340e+07]
[ 1.00000000e+00 1.38915437e+00 1.92974986e+00 2.68072045e+00
3.72393452e+00 5.17311991e+00]
[ 1.00000000e+00 -4.43837599e+01 1.96991814e+03 -8.74323736e+04
3.88057747e+06 -1.72234619e+08]
[ 1.00000000e+00 7.01350208e+00 4.91892115e+01 3.44988637e+02
2.41957852e+03 1.69697190e+04]
[ 1.00000000e+00 2.27627489e+01 5.18142738e+02 1.17943531e+04
2.68471897e+05 6.11115839e+06]]
validationCurve.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
from linearRegCostFunction import compute_grad, compute_J, linearRegCostFunction
def validationCurve(X, y, Xval, yval):
# VALIDATIONCURVE Generate the train and validation errors needed to
# plot a validation curve that we can use to select lambda
# [lambda_vec, error_train, error_val] = ...
# VALIDATIONCURVE(X, y, Xval, yval) returns the train
# and validation errors (in error_train, error_val)
# for different values of lambda. You are given the training set (X,
# y) and validation set (Xval, yval).
#
# Selected values of lambda (you should not change this)
lambda_vec = np.array([0, 0.001, 0.003, 0.01, 0.03, 0.1, 0.3, 1, 3, 10]).T
# You need to return these variables correctly.
# error_train = np.zeros((len(lambda_vec), 1))
# error_val = np.zeros((len(lambda_vec), 1))
error_train, error_val = [], []
# ====================== YOUR CODE HERE ======================
# Instructions: Fill in this function to return training errors in
# error_train and the validation errors in error_val. The
# vector lambda_vec contains the different lambda parameters
# to use for each calculation of the errors, i.e,
# error_train(i), and error_val(i) should give
# you the errors obtained after training with
# lambda = lambda_vec(i)
#
# Note: You can loop over lambda_vec with the following:
#
# for i = 1:length(lambda_vec)
# lambda = lambda_vec(i);
# # Compute train / val errors when training linear
# # regression with regularization parameter lambda
# # You should store the result in error_train(i)
# # and error_val(i)
# ....
#
# end
#
#
m = len(lambda_vec)
for i in range(m):
lamb_da = lambda_vec[i]
theta = trainLinearReg(X, y, lamb_da, m)
error_train.append(linearRegCostFunction(X, y, theta, 0))
error_val.append(linearRegCostFunction(Xval, yval, theta, 0))
# =========================================================================
return lambda_vec, error_train, error_val
def trainLinearReg(X, y, l, m):
theta = np.zeros(X.shape[1])
res = opt.minimize(fun=compute_J,
x0=theta,
args=(X, y, l, m),
method='TNC',
jac=compute_grad)
return res.x
if __name__ == '__main__':
data = loadmat('ex5data1.mat')
X, y = data['X'], data['y']
Xval, yval = data['Xval'], data['yval']
X = np.insert(X, 0, 1, axis=1)
Xval = np.insert(Xval, 0, 1, axis=1)
theta = np.zeros((1, X.shape[1]))
lambda_vec, error_train, error_val = validationCurve(X, y, Xval, yval)
print('error_train', error_train)
print('error_val', error_val)
作業六（Week7 ex6）
這部分，使用SVM做非線性分類，我們將使用高斯核函式，因為SVM在九十年代、資料量少的時代一直充當著主要分類函式， 所以本章有必要介紹一下，
為了用SVM找出一個非線性的決策邊界，我們首先要實作高斯核函式，我可以把高斯核函式想象成一個相似度函式，用來測量一對樣本的距離，
根據ex6data1.mat列印資料
根據ex6data2.mat列印資料
根據ex6data3.mat列印資料
高斯核函式：
這里公式十分復雜， 可以不用記住，sklearn自帶的svm中的核函式，用即可，
下面用python實作本周編程作業：
dataset3Params.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
from sklearn import svm
def dataset3Params(X, y, Xval, yval):
#DATASET3PARAMS returns your choice of C and sigma for Part 3 of the exercise
#where you select the optimal (C, sigma) learning parameters to use for SVM
#with RBF kernel
# [C, sigma] = DATASET3PARAMS(X, y, Xval, yval) returns your choice of C and
# sigma. You should complete this function to return the optimal C and
# sigma based on a cross-validation set.
#
# You need to return the following variables correctly.
C = 1;
sigma = 0.3;
# ====================== YOUR CODE HERE ======================
# Instructions: Fill in this function to return the optimal C and sigma
# learning parameters found using the cross validation set.
# You can use svmPredict to predict the labels on the cross
# validation set. For example,
# predictions = svmPredict(model, Xval);
# will return the predictions on the cross validation set.
#
# Note: You can compute the prediction error using
# mean(double(predictions ~= yval))
#
Cvalues = (0.01, 0.03, 0.1, 0.3, 1., 3., 10., 30.)
sigmavalues = Cvalues
best_pair, best_score = (0, 0), 0
for C in Cvalues:
for sigma in sigmavalues:
gamma = np.power(sigma,-2.)/2
model = svm.SVC(C=C,kernel='rbf',gamma=gamma)
model.fit(X, y.flatten())
this_score = model.score(Xval, yval)
if this_score > best_score:
best_score = this_score
best_pair = (C, sigma)
print('best_pair={}, best_score={}'.format(best_pair, best_score))
C = best_pair[0]
sigma = best_pair[1]
# =========================================================================
return C, sigma
if __name__ == '__main__':
data = loadmat('ex6data3.mat')
X, y = data['X'], data['y']
Xval, yval = data['Xval'], data['yval']
C, sigma= dataset3Params(X, y, Xval, yval)
print('C', C)
print('sigma', sigma)
輸出：
best_pair=(1.0, 0.1), best_score=0.965
C 1.0
sigma 0.1
emailFeatures.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
import re
import nltk, nltk.stem.porter
from processEmail import processEmail
def emailFeatures(word_indices):
#EMAILFEATURES takes in a word_indices vector and produces a feature vector
#from the word indices
# x = EMAILFEATURES(word_indices) takes in a word_indices vector and
# produces a feature vector from the word indices.
# Total number of words in the dictionary
n = 1899;
# You need to return the following variables correctly.
x = np.zeros((n, 1))
# ====================== YOUR CODE HERE ======================
# Instructions: Fill in this function to return a feature vector for the
# given email (word_indices). To help make it easier to
# process the emails, we have have already pre-processed each
# email and converted each word in the email into an index in
# a fixed dictionary (of 1899 words). The variable
# word_indices contains the list of indices of the words
# which occur in one email.
#
# Concretely, if an email has the text:
#
# The quick brown fox jumped over the lazy dog.
#
# Then, the word_indices vector for this text might look
# like:
#
# 60 100 33 44 10 53 60 58 5
#
# where, we have mapped each word onto a number, for example:
#
# the -- 60
# quick -- 100
# ...
#
# (note: the above numbers are just an example and are not the
# actual mappings).
#
# Your task is take one such word_indices vector and construct
# a binary feature vector that indicates whether a particular
# word occurs in the email. That is, x(i) = 1 when word i
# is present in the email. Concretely, if the word 'the' (say,
# index 60) appears in the email, then x(60) = 1. The feature
# vector should look like:
#
# x = [ 0 0 0 0 1 0 0 0 ... 0 0 0 0 1 ... 0 0 0 1 0 ..];
#
#
for i in range(len(word_indices)):
x[word_indices[i],0] = 1
# =========================================================================
return x
if __name__ == '__main__':
with open('emailSample1.txt', 'r') as f:
email_contents = f.read()
print(email_contents)
word_indices = processEmail(email_contents)
x = emailFeatures(word_indices)
print('x', x)
輸出：
x [[0.]
[0.]
[0.]
...
[0.]
[0.]
[0.]]
learningCurve.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
def learningCurve(x1, x2, sigma):
#RBFKERNEL returns a radial basis function kernel between x1 and x2
# sim = gaussianKernel(x1, x2) returns a gaussian kernel between x1 and x2
# and returns the value in sim
# Ensure that x1 and x2 are column vectors
# x1 = x1(:); x2 = x2(:);
# You need to return the following variables correctly.
# sim = 0;
# ====================== YOUR CODE HERE ======================
# Instructions: Fill in this function to return the similarity between x1
# and x2 computed using a Gaussian kernel with bandwidth
# sigma
#
#
sim = np.exp( - np.sum(np.square(x1 - x2))/(2*np.square(sigma)))
# =============================================================
return sim
if __name__ == '__main__':
data = loadmat('ex6data1.mat')
x1, y1 = data['X'], data['y']
x1 = x1[:,1:]
sim= learningCurve(x1,y1, 1)
print('sim', sim)
輸出：
sim 2.0846210945302472e-85
processEmail.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
import re
import nltk, nltk.stem.porter
def processEmail(email_contents):
#PROCESSEMAIL preprocesses a the body of an email and
#returns a list of word_indices
# word_indices = PROCESSEMAIL(email_contents) preprocesses
# the body of an email and returns a list of indices of the
# words contained in the email.
#
# Load Vocabulary
vocabList = getVocabList();
# Init return value
word_indices = [];
# ========================== Preprocess Email ===========================
# Find the Headers ( \n\n and remove )
# Uncomment the following lines if you are working with raw emails with the
# full headers
# hdrstart = strfind(email_contents, ([char(10) char(10)]));
# email_contents = email_contents(hdrstart(1):end);
# Lower case
email_contents = email_contents.lower()
# Strip all HTML
# Looks for any expression that starts with < and ends with > and replace
# and does not have any < or > in the tag it with a space
email_contents = re.sub('<[^<>]+>', ' ',email_contents)
# Handle Numbers
# Look for one or more characters between 0-9
email_contents = re.sub('[0-9]+', 'number',email_contents)
# Handle URLS
# Look for strings starting with http:// or https://
email_contents = re.sub('(http|https)://[^\s]*', 'httpaddr',email_contents)
# Handle Email Addresses
# Look for strings with @ in the middle
email_contents = re.sub('[^\s]+@[^\s]+', 'emailaddr', email_contents)
# Handle $ sign
email_contents = re.sub('[$]+', 'dollar', email_contents)
# ========================== Tokenize Email ===========================
# Output the email to screen as well
print('\n==== Processed Email ====\n\n');
# Process file
l = 0;
# I'll use the NLTK stemmer because it more accurately duplicates the
# performance of the OCTAVE implementation in the assignment
stemmer = nltk.stem.porter.PorterStemmer()
tokens = re.split('[ \@\$\/\#\.\-\:\&\*\+\=\[\]\?\!\(\)\{\}\,\'\"\>\_\<\;\%]', email_contents)
tokenlist = []
for str in tokens:
# Remove any non alphanumeric characters
str = re.sub('[^a-zA-Z0-9]', '', str)
# Stem the word
# (the porterStemmer sometimes has issues, so we use a try catch block)
# stemmed = stemmer.stem(str)
# Skip the word if it is too short
if len(str) < 1:
continue
# tokenlist.append(stemmed)
# Look up the word in the dictionary and add to word_indices if
# found
# ====================== YOUR CODE HERE ======================
# Instructions: Fill in this function to add the index of str to
# word_indices if it is in the vocabulary. At this point
# of the code, you have a stemmed word from the email in
# the variable str. You should look up str in the
# vocabulary list (vocabList). If a match exists, you
# should add the index of the word to the word_indices
# vector. Concretely, if str = 'action', then you should
# look up the vocabulary list to find where in vocabList
# 'action' appears. For example, if vocabList{18} =
# 'action', then, you should add 18 to the word_indices
# vector (e.g., word_indices = [word_indices ; 18]; ).
#
# Note: vocabList{idx} returns a the word with index idx in the
# vocabulary list.
#
# Note: You can use strcmp(str1, str2) to compare two strings (str1 and
# str2). It will return 1 only if the two strings are equivalent.
#
for i in range(len(vocabList)):
if vocabList[i,0] == str :
word_indices.append(i)
# =============================================================
# # Print to screen, ensuring that the output lines are not too long
# if (l + len(str) + 1) > 78:
# print('\n');
# l = 0;
# print('#s ', str);
# l = l + len(str) + 1;
# Print footer
print('\n\n=========================\n');
return word_indices
def getVocabList():
#GETVOCABLIST reads the fixed vocabulary list in vocab.txt and returns a
#cell array of the words
# vocabList = GETVOCABLIST() reads the fixed vocabulary list in vocab.txt
# and returns a cell array of the words in vocabList.
## Read the fixed vocabulary list
df = pd.read_table('vocab.txt',names=['words'])
vocab = df.values
# Store all dictionary words in cell array vocab{}
# n = 1899; # Total number of words in the dictionary
#
# # For ease of implementation, we use a struct to map the strings => integers
# # In practice, you'll want to use some form of hashmap
# vocabList = np.zeros(len(vocab))
# for i in range(1, n) :
# # # Word Index (can ignore since it will be = i)
# # fscanf(fid, '#d', 1);
# # # Actual Word
# # vocabList{i} = fscanf(fid, '#s', 1);
# vocabList[i] = 1
return vocab
if __name__ == '__main__':
with open('emailSample1.txt', 'r') as f:
email_contents = f.read()
print(email_contents)
word_indices= processEmail(email_contents)
print('word_indices', word_indices)
輸出：
word_indices [793, 1076, 882, 1698, 789, 1821, 1830, 882, 1170, 793, 1892, 1363, 237, 161, 687, 944, 1662, 1119, 1061, 1698, 1161, 1892, 1509, 798, 1181, 809, 180, 1698, 1895, 687, 960, 1476, 70, 529, 1698, 530]
作業七（Week8 ex7）
在這個練習中，您將實作K-means演算法并將其用于影像壓縮，通過減少影像中出現的顏色的數量，只剩下那些在影像中最常見的顏色，
根據ex7data2.mat列印出本次作業的資料：
K-means演算法：
1.先隨機分配三個點（這里用三舉例，也可以隨意用大于1的正整數）
2.然后計算測驗資料分布屬于哪三個點（離哪三個點近）
3.重新計算三個簇中心，為這個簇里面所有點位置的平均值，
4.當有測驗資料進來， 會計算歸類到新的中心點（離哪三個新的中心點近）
PCA由兩部分組成：
1.計算資料的方差矩陣
2.用SVD計算特征向量
在PCA之前，記得標準化資料，
然后計算方差矩陣，如果你的每條樣本資料是以行的形式表示，那么計算公式如下：
接著就可以用SVD計算主成分
U包含了主成分，每一列就是我們資料要映射的向量，S為對角矩陣，為奇異值，
下面用python實作本周編程作業：
computeCentroids.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
from findClosestCentroids import findClosestCentroids
def computeCentroids(X, idx, K):
#COMPUTECENTROIDS returns the new centroids by computing the means of the
#data points assigned to each centroid.
# centroids = COMPUTECENTROIDS(X, idx, K) returns the new centroids by
# computing the means of the data points assigned to each centroid. It is
# given a dataset X where each row is a single data point, a vector
# idx of centroid assignments (i.e. each entry in range [1..K]) for each
# example, and K, the number of centroids. You should return a matrix
# centroids, where each row of centroids is the mean of the data points
# assigned to it.
#
# Useful variables
m, n = X.shape;
# You need to return the following variables correctly.
centroids = np.zeros((K, n))
# ====================== YOUR CODE HERE ======================
# Instructions: Go over every centroid and compute mean of all points that
# belong to it. Concretely, the row vector centroids(i, :)
# should contain the mean of the data points assigned to
# centroid i.
#
# Note: You can use a for-loop over the centroids to compute this.
#
centroids = []
for i in range(K):
temp = []
for j in range(len(idx)):
if idx[j,0] ==i:
temp.append(X[j])
centroids.append(np.array(temp).mean(axis=0))
# =============================================================
return np.array(centroids)
if __name__ == '__main__':
data = loadmat('ex7data2.mat')
X = data['X']
centroids = np.array([[3, 3], [6, 2], [8, 5]])
idx = findClosestCentroids(X,centroids)
centroids = computeCentroids(X, idx, K=3)
print('centroids', centroids)
輸出：
centroids [[2.42830111 3.15792418]
[5.81350331 2.63365645]
[7.11938687 3.6166844 ]]
findClosestCentroids.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
def findClosestCentroids(X, centroids):
#FINDCLOSESTCENTROIDS computes the centroid memberships for every example
# idx = FINDCLOSESTCENTROIDS (X, centroids) returns the closest centroids
# in idx for a dataset X where each row is a single example. idx = m x 1
# vector of centroid assignments (i.e. each entry in range [1..K])
#
# Set K
K = centroids.shape[0]
# You need to return the following variables correctly.
idx = np.zeros((X.shape[0], 1))
# ====================== YOUR CODE HERE ======================
# Instructions: Go over every example, find its closest centroid, and store
# the index inside idx at the appropriate location.
# Concretely, idx(i) should contain the index of the centroid
# closest to example i. Hence, it should be a value in the
# range 1..K
#
# Note: You can use a for-loop over the examples to compute this.
#
m = X.shape[0]
for i in range(1,m):
tdis = X[i,:]-centroids[0,:]
bestdis = np.sum(np.square(tdis))
idx[i]=0
for j in range(1,K):
tdis = X[i,:]-centroids[j,:]
dis = np.sum(np.square(tdis))
if(bestdis>dis):
bestdis=dis
idx[i]=j
# =============================================================
return idx
if __name__ == '__main__':
data = loadmat('ex7data2.mat')
X = data['X']
centroids = np.array([[3, 3], [6, 2], [8, 5]])
idx= findClosestCentroids(X,centroids)
print('idx', idx[0:5])
輸出：
idx [[0.]
[2.]
[1.]
[0.]
[0.]]
kMeansInitCentroids.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
def kMeansInitCentroids(X, K):
# KMEANSINITCENTROIDS This function initializes K centroids that are to be
# used in K-Means on the dataset X
# centroids = KMEANSINITCENTROIDS(X, K) returns K initial centroids to be
# used with the K-Means on the dataset X
#
# You should return this values correctly
# centroids = zeros(K, size(X, 2));
# ====================== YOUR CODE HERE ======================
# Instructions: You should set centroids to randomly chosen examples from
# the dataset X
#
m, n = X.shape
idx = np.random.choice(m, K)
centroids = X[idx]
# =============================================================
return centroids
if __name__ == '__main__':
data = loadmat('ex7data2.mat')
X = data['X']
centroids = kMeansInitCentroids(X, K=3)
print('centroids', centroids)
輸出：
centroids [[2.15653404 0.40358861]
[3.54010186 0.86446135]
[1.95538864 1.32156857]]
pca.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
def pca(X):
#PCA Run principal component analysis on the dataset X
# [U, S, X] = pca(X) computes eigenvectors of the covariance matrix of X
# Returns the eigenvectors U, the eigenvalues (on diagonal) in S
#
# Useful values
m, n = X.shape
# You need to return the following variables correctly.
U = np.zeros(n);
S = np.zeros(n);
# ====================== YOUR CODE HERE ======================
# Instructions: You should first compute the covariance matrix. Then, you
# should use the "svd" function to compute the eigenvectors
# and eigenvalues of the covariance matrix.
#
# Note: When computing the covariance matrix, remember to divide by m (the
# number of examples).
#
sigma = (1 / m)*(X.T.dot(X))
U, S ,V = np.linalg.svd(sigma)
# =========================================================================
return U, S
if __name__ == '__main__':
data = loadmat('ex7data1.mat')
X = data['X']
U, S = pca(X)
print('U', U)
print('S', S)
輸出：
U [[-0.6298592 -0.77670934]
[-0.77670934 0.6298592 ]]
S [42.94043399 0.37681126]
projectData.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
from pca import pca
def projectData(X, U, K):
#PROJECTDATA Computes the reduced data representation when projecting only
#on to the top k eigenvectors
# Z = projectData(X, U, K) computes the projection of
# the normalized inputs X into the reduced dimensional space spanned by
# the first K columns of U. It returns the projected examples in Z.
#
# You need to return the following variables correctly.
Z = np.zeros((X.shape[0], K))
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the projection of the data using only the top K
# eigenvectors in U (first K columns).
# For the i-th example X(i,:), the projection on to the k-th
# eigenvector is given as follows:
# x = X(i, :)';
# projection_k = x' * U(:, k);
#
Z = X.dot(U[:,:K])
# =============================================================
return Z
if __name__ == '__main__':
data = loadmat('ex7data1.mat')
X = data['X']
U, S = pca(X)
Z = projectData(X, U, K=1)
print('Z', Z)
輸出：
Z [[-4.76226381]
[-7.39891873]
...
[-7.9499247 ]]
recoverData.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
from pca import pca
from projectData import projectData
def recoverData(X, U, K):
#RECOVERDATA Recovers an approximation of the original data when using the
#projected data
# X_rec = RECOVERDATA(Z, U, K) recovers an approximation the
# original data that has been reduced to K dimensions. It returns the
# approximate reconstruction in X_rec.
#
# You need to return the following variables correctly.
X_rec = np.zeros((Z.shape[0], U.shape[0]))
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the approximation of the data by projecting back
# onto the original space using the top K eigenvectors in U.
#
# For the i-th example Z(i,:), the (approximate)
# recovered data for dimension j is given as follows:
# v = Z(i, :)';
# recovered_j = v' * U(j, 1:K)';
#
# Notice that U(j, 1:K) is a row vector.
#
X_rec = Z.dot(U[:,:K].T)
# =============================================================
return X_rec
if __name__ == '__main__':
data = loadmat('ex7data1.mat')
X = data['X']
U, S = pca(X)
Z = projectData(X, U, K=6)
X_rec = recoverData(Z, U, K=6)
print('X_rec', X_rec)
輸出：
X_rec [[3.38156267 3.38911268]
[4.52787538 5.8541781 ]
...
[5.11795499 6.08507386]]
作業八（Week9 ex8）
這部分，您將實作一個例外檢測演算法來檢測服務器計算機中的例外行為，他的特征是測量每個服務器的回應速度(mb/s)和延遲(ms)，當你的服務器運行時，你收集到了m=307的樣本，是無標簽的，你相信其中絕大多數樣本是正常的，但還是有一小部分的樣本是例外的，
我們將使用高斯分布模型來檢測資料集中的例外樣本，
根據ex8data1.mat 列印出本周作業資料：
下面用python實作本周編程作業：
cofiCostFunc.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
def cofiCostFunc(params, Y, R, num_users, num_movies, num_features, lamb_da):
#COFICOSTFUNC Collaborative filtering cost function
# [J, grad] = COFICOSTFUNC(params, Y, R, num_users, num_movies, ...
# num_features, lambda) returns the cost and gradient for the
# collaborative filtering problem.
#
# Unfold the U and W matrices from params
# X = reshape(params(1:num_movies*num_features), num_movies, num_features)
# Theta = reshape(params(num_movies*num_features+1:end),c num_users, num_features)
# You need to return the following values correctly
# J = 0;
# X_grad = zeros(size(X));
# Theta_grad = zeros(size(Theta));
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the cost function and gradient for collaborative
# filtering. Concretely, you should first implement the cost
# function (without regularization) and make sure it is
# matches our costs. After that, you should implement the
# gradient and use the checkCostFunction routine to check
# that the gradient is correct. Finally, you should implement
# regularization.
#
# Notes: X - num_movies x num_features matrix of movie features
# Theta - num_users x num_features matrix of user features
# Y - num_movies x num_users matrix of user ratings of movies
# R - num_movies x num_users matrix, where R(i, j) = 1 if the
# i-th movie was rated by the j-th user
#
# You should set the following variables correctly:
#
# X_grad - num_movies x num_features matrix, containing the
# partial derivatives w.r.t. to each element of X
# Theta_grad - num_users x num_features matrix, containing the
# partial derivatives w.r.t. to each element of Theta
#
X, theta = deserialize(params, num_users, num_movies, num_features)
part1 = np.sum(((X.dot(theta.T) - Y) ** 2) * R) / 2
part2 = lamb_da * np.sum(theta ** 2) / 2
part3 = lamb_da * np.sum(X ** 2) / 2
J = part1 + part2 + part3
X_grad = ((X.dot(theta.T)-Y)*R).dot(theta) + lamb_da*X
Theta_grad = ((X.dot(theta.T)-Y)*R).T.dot(X) + lamb_da*theta
# =============================================================
grad = serialize(X_grad, Theta_grad)
return J, grad
def serialize(X, theta):
return np.concatenate((X.flatten(), theta.flatten()), axis=0)
def deserialize(seq, nm, nu, nf):
return seq[:nm*nf].reshape(nm, nf), seq[nm*nf:].reshape(nu, nf)
if __name__ == '__main__':
data1 = loadmat("ex8_movies.mat")
Y = data1["Y"] # (1682,943)
R = data1["R"] # (1682,943)
data2 = loadmat("ex8_movieParams.mat")
X = data2["X"] # (1682,10)
theta = data2["Theta"] # (943,10)
nu = data2["num_users"][0][0] # (1,1) 943
nm = data2["num_movies"][0][0] # (1,1) 1682
nf = data2["num_features"][0][0] # (1,1) 10
# 題目中計算資料不是全部資料，取nm=5,nu=4,nf=3,值為22.224603725685675
nu = 4
nm = 5
nf = 3
X = X[:nm, :nf]
theta = theta[:nu, :nf]
Y = Y[:nm, :nu]
R = R[:nm, :nu]
J, grad = cofiCostFunc(serialize(X, theta), Y, R, nm, nu, nf, lamb_da=0)
print('J', J)
print('grad', grad)
輸出：
J 22.224603725685675
grad [ -2.52899165 7.57570308 -1.89979026 -0.56819597 3.35265031
-0.52339845 -0.83240713 4.91163297 -0.76677878 -0.38358278
2.26333698 -0.35334048 -0.80378006 4.74271842 -0.74040871
-10.5680202 4.62776019 -7.16004443 -3.05099006 1.16441367
-3.47410789 0. 0. 0. 0.
0. 0. ]
estimateGaussian.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
def estimateGaussian(X):
#ESTIMATEGAUSSIAN This function estimates the parameters of a
#Gaussian distribution using the data in X
# [mu sigma2] = estimateGaussian(X),
# The input X is the dataset with each n-dimensional data point in one row
# The output is an n-dimensional vector mu, the mean of the data set
# and the variances sigma^2, an n x 1 vector
#
# Useful variables
m, n = X.shape
# You should return these values correctly
mu = np.zeros((n, 1))
sigma2 = np.zeros((n, 1))
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the mean of the data and the variances
# In particular, mu(i) should contain the mean of
# the data for the i-th feature and sigma2(i)
# should contain variance of the i-th feature.
#
mu = np.sum(X,axis=0) / m
sigma2 = ((X-mu).T .dot(X-mu)) / m
# =============================================================
return mu,sigma2
if __name__ == '__main__':
data = loadmat('ex8data1.mat')
X = data['X']
mu,sigma2 = estimateGaussian(X)
print('mu', mu)
print('sigma2', sigma2)
輸出：
mu [14.11222578 14.99771051]
sigma2 [[ 1.83263141 -0.22712233]
[-0.22712233 1.70974533]]
gaussian.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
from estimateGaussian import estimateGaussian
def gaussian(X, mu, sigma2):
if np.ndim(sigma2)==1:
sigma2=np.diag(sigma2) # Extract a diagonal or construct a diagonal array
norm=1/(np.power(2*np.pi,X.shape[1]/2)*np.power(np.linalg.det(sigma2),0.5))
p=np.exp(-1/2*(X-mu).dot(np.linalg.inv(sigma2)).dot((X-mu).T))
return norm*np.diag(p)
if __name__ == '__main__':
data = loadmat('ex8data1.mat')
X = data['X']
mu, sigma2 = estimateGaussian(X)
ypred = gaussian(X,mu,sigma2)
print('ypred ', ypred )
輸出：
ypred [6.35952245e-02 4.71175698e-02 7.24075654e-02 4.68671935e-02
6.14847658e-02 4.13471164e-02
...
8.12920163e-21]
selectThreshold.py:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat
import scipy.optimize as opt
from gaussian import gaussian
from estimateGaussian import estimateGaussian
def selectThreshold(yval, pval):
#SELECTTHRESHOLD Find the best threshold (epsilon) to use for selecting
#outliers
# [bestEpsilon bestF1] = SELECTTHRESHOLD(yval, pval) finds the best
# threshold to use for selecting outliers based on the results from a
# validation set (pval) and the ground truth (yval).
#
bestEpsilon = 0;
bestF1 = 0;
F1 = 0;
# stepsize = (np.max(pval) - np.min(pval)) / 1000
epsilons=np.linspace(np.min(pval),np.max(pval),1000)
for epsilon in epsilons:
# ====================== YOUR CODE HERE ======================
# Instructions: Compute the F1 score of choosing epsilon as the
# threshold and place the value in F1. The code at the
# end of the loop will compare the F1 score for this
# choice of epsilon and set it to be the best epsilon if
# it is better than the current choice of epsilon.
#
# Note: You can use predictions = (pval < epsilon) to get a binary vector
# of 0's and 1's of the outlier predictions
pval_tmp=pval<epsilon # True or False vector
Tp=np.sum(pval_tmp&yval) # correctly classified
Fp=np.sum(pval_tmp&(yval^1)) # incorrectly classified
Fn=np.sum((pval_tmp^1)&yval) # incorrectly classified
prec=Tp/(Tp+Fp) if Tp+Fp else 0
rec=Tp/(Tp+Fn) if Tp+Fn else 0
F1=2*prec*rec/(prec+rec) if prec+rec else 0
# =============================================================
if F1 > bestF1:
bestF1 = F1
bestEpsilon = epsilon
return bestEpsilon, bestF1
if __name__ == '__main__':
data = loadmat('ex8data2.mat')
X = data['X']
yval = data['yval']
mu,sigma2 = estimateGaussian(X)
ypred = gaussian(X, mu, sigma2)
bestEpsilon, bestF1 = selectThreshold(yval, ypred)
print('bestEpsilon', bestEpsilon)
print('bestF1', bestF1)
輸出：
bestEpsilon 3.0794215337381673e-15
bestF1 0.18180163785259326
總結：
作業第一到第五需要熟練掌握，最后可以用張紙上推導一下，記憶更深，作業第六到第八需要大概的理解即可，
Referrence:
https://blog.csdn.net/Cowry5/article/details/83302646
https://blog.csdn.net/buchidanhuang/article/details/83958947
https://blog.csdn.net/chosen1hyj/article/details/93176560
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/295325.html
標籤：AI