<jupyter_start><jupyter_text>Logistic Regression with a Neural Network mindsetChào mừng bạn đến với bài tập lập trình (bắt buộc) đầu tiên của bạn! Bạn sẽ xây dựng một bộ phân loại hồi quy logistic để nhận dạng mèo. Bài tập này sẽ hướng dẫn bạn cách thực hiện điều này với tư duy Mạng thần kinh, và do đó cũng sẽ trau dồi trực giác của bạn về học sâu.**Hướng dẫn:**- Không sử dụng các vòng lặp (for / while) trong mã của bạn, trừ khi các hướng dẫn yêu cầu bạn làm như vậy một cách rõ ràng.**Bạn sẽ học cách:**   - Xây dựng kiến trúc chung của một thuật toán học, bao gồm:        - Khởi tạo các thông số        - Tính toán hàm chi phí và gradient của nó        - Sử dụng một thuật toán tối ưu hóa (gradient descent)   - Gộp cả 3 chức năng trên thành một chức năng mô hình chính, đúng thứ tự.   Cập nhậtSổ tay này đã được cập nhật trong vài tháng qua. Phiên bản trước được đặt tên là "v5" và phiên bản hiện tại được đặt tên là'6a'  Nếu bạn đang làm việc trên phiên bản trước:* Bạn có thể tìm thấy tác phẩm trước của mình bằng cách tìm trong thư mục tệp để tìm các tệp cũ hơn (được đặt tên theo tên phiên bản).* Để xem thư mục tập tin, hãy nhấp vào biểu tượng "Coursera" ở góc trên cùng bên trái của sổ ghi chép này.* Vui lòng sao chép tác phẩm của bạn từ phiên bản cũ sang phiên bản mới để gửi tác phẩm của bạn để chấm điểm. Danh sách cập nhật* Công thức truyền tiến, lập chỉ mục bây giờ bắt đầu từ 1 thay vì 0.* Nhận xét chức năng tối ưu hóa hiện cho biết "chi phí in mỗi 100 lần lặp lại đào tạo" thay vì "ví dụ".* Sửa lỗi ngữ pháp trong phần bình luận.* Tên biến Y_prediction_test được sử dụng nhất quán.* Nhãn trục của Plot hiện cho biết "số lần lặp (hàng trăm)" thay vì "số lần lặp".* Khi kiểm tra mô hình, hình ảnh kiểm tra được chuẩn hóa bằng cách chia cho 255.  1 - Thư Viện Đầu tiên, hãy chạy ô bên dưới để nhập tất cả các gói mà bạn sẽ cần trong quá trình gán này.* [numpy](www.numpy.org)là gói cơ bản cho tính toán khoa học với Python.* [h5py](http://www.h5py.org) là một gói phổ biến để tương tác với tập dữ liệu được lưu trữ trên tệp H5.* [matplotlib](http://matplotlib.org) là một thư viện nổi tiếng để vẽ đồ thị bằng Python.* [PIL](http://www.pythonware.com/products/pil/) và [scipy](https://www.scipy.org/) được sử dụng ở đây để kiểm tra mô hình của bạn với hình ảnh của chính bạn ở cuối .<jupyter_code>import numpy as np
import matplotlib.pyplot as plt
import h5py
import scipy
from PIL import Image
from scipy import ndimage
from lr_utils import load_dataset

%matplotlib inline<jupyter_output><empty_output><jupyter_text>2 - Overview of the Problem set **Tuyên bố sự cố**: Bạn được cung cấp một tập dữ liệu ("data.h5") chứa:    - tập hợp các hình ảnh m_train đào tạo được gắn nhãn là mèo (y = 1) hoặc không phải mèo (y = 0)    - một tập hợp các hình ảnh m_test thử nghiệm được gắn nhãn là mèo hoặc không phải mèo    - mỗi hình ảnh có hình dạng (num_px, num_px, 3) trong đó 3 là 3 kênh (RGB). Vì vậy, mỗi hình ảnh là hình vuông (chiều cao = num_px) và (chiều rộng = num_px). Bạn sẽ xây dựng một thuật toán nhận dạng hình ảnh đơn giản có thể phân loại chính xác các bức ảnh là mèo hay không phải mèo.Hãy làm quen với tập dữ liệu. Tải dữ liệu bằng cách chạy mã sau.<jupyter_code># Loading the data (cat/non-cat)
train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()<jupyter_output><empty_output><jupyter_text>Chúng tôi đã thêm "_orig" vào cuối tập dữ liệu hình ảnh (đào tạo và kiểm tra) vì chúng tôi sẽ xử lý trước chúng. Sau khi xử lý trước, chúng ta sẽ kết thúc với train_set_x và test_set_x (các nhãn train_set_y và test_set_y không cần xử lý trước).Mỗi dòng của train_set_x_orig và test_set_x_orig của bạn là một mảng đại diện cho một hình ảnh. Bạn có thể hình dung một ví dụ bằng cách chạy đoạn mã sau. Cũng thoải mái thay đổi giá trị `index` và chạy lại để xem các hình ảnh khác.<jupyter_code># Example of a picture
index = 25
plt.imshow(train_set_x_orig[index])
print ("y = " + str(train_set_y[:, index]) + ", it's a '" + classes[np.squeeze(train_set_y[:, index])].decode("utf-8") +  "' picture.")<jupyter_output>y = [1], it's a 'cat' picture.<jupyter_text>Nhiều lỗi phần mềm trong học sâu đến từ việc có kích thước ma trận / vectơ không phù hợp. Nếu bạn có thể giữ cho kích thước ma trận / vectơ của mình thẳng hàng, bạn sẽ đi một chặng đường dài hướng tới việc loại bỏ nhiều lỗi.**Bài tập:** Tìm các giá trị của:     - m_train (số lượng ví dụ đào tạo)     - m_test (số lượng ví dụ thử nghiệm)     - num_px (= height = width của hình ảnh đào tạo) Hãy nhớ rằng `train_set_x_orig` là một mảng nhiều hình dạng (m_train, num_px, num_px, 3). Ví dụ: bạn có thể truy cập `m_train` bằng cách viết` train_set_x_orig.shape [0] `.<jupyter_code>### START CODE HERE ### (≈ 3 lines of code)
m_train = train_set_x_orig.shape[0]
m_test =  test_set_x_orig.shape[0]
num_px = train_set_x_orig.shape[1] 
### END CODE HERE ###

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))<jupyter_output>Number of training examples: m_train = 209
Number of testing examples: m_test = 50
Height/Width of each image: num_px = 64
Each image is of size: (64, 64, 3)
train_set_x shape: (209, 64, 64, 3)
train_set_y shape: (1, 209)
test_set_x shape: (50, 64, 64, 3)
test_set_y shape: (1, 50)<jupyter_text>**Đầu ra mong đợi cho m_train, m_test và num_px**:       m_train     209            m_test     50            num_px     64       Để thuận tiện, bây giờ bạn nên định hình lại hình ảnh của hình dạng (num_px, num_px, 3) trong một mảng hình dạng phức tạp (num_px $ * $ num_px $ * $ 3, 1). Sau đó, tập dữ liệu huấn luyện (và thử nghiệm) của chúng tôi là một mảng numpy trong đó mỗi cột đại diện cho một hình ảnh phẳng. Phải có m_train (tương ứng là m_test) cột.**Bài tập:** Định hình lại các tập dữ liệu huấn luyện và kiểm tra để các hình ảnh có kích thước (num_px, num_px, 3) được làm phẳng thành các vectơ duy nhất có hình dạng (num\_px $*$ num\_px $*$ 3, 1).Một mẹo khi bạn muốn làm phẳng ma trận X có hình dạng (a, b, c, d) thành ma trận X_flatten có hình dạng (b $ * $ c $ * $ d, a) là sử dụng:`` pythonX_flatten = X.reshape (X.shape [0], -1) .T  X.T là chuyển vị của X``<jupyter_code># Reshape the training and test examples

### START CODE HERE ### (≈ 2 lines of code)
train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[1]*train_set_x_orig.shape[2]*train_set_x_orig.shape[3],-1)
test_set_x_flatten =  test_set_x_orig.reshape(test_set_x_orig.shape[1]*test_set_x_orig.shape[2]*test_set_x_orig.shape[3],-1)
### END CODE HERE ###

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]))<jupyter_output>train_set_x_flatten shape: (12288, 209)
train_set_y shape: (1, 209)
test_set_x_flatten shape: (12288, 50)
test_set_y shape: (1, 50)
sanity check after reshaping: [17 71 49 38 70]<jupyter_text>**Kết quả mong đợi**:       train_set_x_flatten shape     (12288, 209)         train_set_y shape    (1, 209)         test_set_x_flatten shape    (12288, 50)         test_set_y shape    (1, 50)       sanity check after reshaping  [17 31 56 22 33]    Để biểu diễn hình ảnh màu, các kênh màu đỏ, xanh lục và xanh lam (RGB) phải được chỉ định cho mỗi pixel và do đó giá trị pixel thực sự là một vectơ gồm ba số từ 0 đến 255.Một bước tiền xử lý phổ biến trong học máy là căn giữa và chuẩn hóa tập dữ liệu của bạn, nghĩa là bạn lấy giá trị trung bình của toàn bộ mảng numpy từ mỗi ví dụ, sau đó chia mỗi ví dụ cho độ lệch chuẩn của toàn bộ mảng numpy. Nhưng đối với tập dữ liệu hình ảnh, nó đơn giản và thuận tiện hơn và hoạt động gần như tốt khi chỉ cần chia mỗi hàng của tập dữ liệu cho 255 (giá trị tối đa của một kênh pixel).Hãy chuẩn hóa tập dữ liệu của chúng tôi.<jupyter_code>train_set_x = train_set_x_flatten/255.
test_set_x = test_set_x_flatten/255.<jupyter_output><empty_output><jupyter_text>Những điều bạn cần nhớ:    Các bước phổ biến để xử lý trước một tập dữ liệu mới là:- Tìm ra các kích thước và hình dạng của vấn đề (m_train, m_test, num_px, ...)- Định hình lại các tập dữ liệu để mỗi ví dụ bây giờ là một vectơ có kích thước (num_px  * num_px  * 3, 1)- "Chuẩn hóa" dữ liệu  3 - General Architecture of the learning algorithm Đã đến lúc thiết kế một thuật toán đơn giản để phân biệt hình ảnh con mèo với hình ảnh không phải con mèo.Bạn sẽ xây dựng Hồi quy logistic, sử dụng tư duy Mạng thần kinh. Hình sau giải thích lý do tại sao **Logistic Regression thực sự là một mạng nơ-ron rất đơn giản!** **Biểu thức toán học của thuật toán**:Cho 1 ví dụ $x^{(i)}$:$$z^{(i)} = w^T x^{(i)} + b \tag{1}$$$$\hat{y}^{(i)} = a^{(i)} = sigmoid(z^{(i)})\tag{2}$$ $$ \mathcal{L}(a^{(i)}, y^{(i)}) =  - y^{(i)}  \log(a^{(i)}) - (1-y^{(i)} )  \log(1-a^{(i)})\tag{3}$$Sau đó, chi phí được tính bằng cách tổng hợp tất cả các ví dụ đào tạo:$$ J = \frac{1}{m} \sum_{i=1}^m \mathcal{L}(a^{(i)}, y^{(i)})\tag{6}$$**Các bước chính**:Trong bài tập này, bạn sẽ thực hiện các bước sau:     - Khởi tạo các thông số của mô hình     - Tìm hiểu các thông số cho mô hình bằng cách giảm thiểu chi phí     - Sử dụng các tham số đã học để đưa ra dự đoán (trên bộ kiểm tra)     - Phân tích kết quả và kết luận  4 - Building the parts of our algorithm  Các bước chính để xây dựng Mạng thần kinh là:1. Xác định cấu trúc mô hình (chẳng hạn như số lượng các tính năng đầu vào)2. Khởi tạo các thông số của mô hình3. Vòng lặp:     - Tính toán tổn thất hiện tại (lan truyền thuận)     - Tính toán gradient hiện tại (lan truyền ngược)     - Cập nhật các thông số (gradient descent)Bạn thường xây dựng 1-3 riêng biệt và tích hợp chúng vào một chức năng mà chúng tôi gọi là `mô hình () '.  4.1 - Helper functions**Bài tập**: Sử dụng mã của bạn từ "Kiến thức cơ bản về Python", triển khai `sigmoid ()`. Như bạn đã thấy trong hình trên, bạn cần tính $ sigmoid (w ^ T x + b) = \ frac {1} {1 + e ^ {- (w ^ T x + b)}} $ để tạo dự đoán. Dùng np.exp().<jupyter_code># 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)
    """

    ### START CODE HERE ### (≈ 1 line of code)
    s = 1/(1+np.exp(-z))
    ### END CODE HERE ###
    
    return s
print ("sigmoid([0, 2]) = " + str(sigmoid(np.array([0,2]))))<jupyter_output>sigmoid([0, 2]) = [0.5        0.88079708]<jupyter_text>**Kết quả mong đợi**:       sigmoid([0, 2])     [ 0.5         0.88079708]     4.2 - Initializing parameters**Bài tập:** Thực hiện khởi tạo tham số trong ô bên dưới. Bạn phải khởi tạo w dưới dạng vectơ gồm các số không. Nếu bạn không biết sử dụng hàm numpy nào, hãy tra cứu np.zeros () trong tài liệu của thư viện Numpy.<jupyter_code># GRADED FUNCTION: initialize_with_zeros

def initialize_with_zeros(dim):
    """
    This function creates a vector of zeros of shape (dim, 1) for w and initializes b to 0.
    
    Argument:
    dim -- size of the w vector we want (or number of parameters in this case)
    
    Returns:
    w -- initialized vector of shape (dim, 1)
    b -- initialized scalar (corresponds to the bias)
    """
    
    ### START CODE HERE ### (≈ 1 line of code)
    w = np.zeros((dim,1))
    b = 0
    ### END CODE HERE ###

    assert(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))<jupyter_output>w = [[0.]
 [0.]]
b = 0<jupyter_text>**Kết quả mong đợi**:              w            [[ 0.] [ 0.]]                    b            0     Đối với đầu vào hình ảnh, w sẽ có hình dạng (num_px $\times$ num_px $\times$ 3, 1).  4.3 - Forward and Backward propagationBây giờ các tham số của bạn đã được khởi tạo, bạn có thể thực hiện các bước truyền "forward" và "backward" để học các tham số.** Bài tập: ** Thực hiện một hàm `propagate()` để tính toán hàm chi phí và độ dốc của nó.**Gợi ý**:Lan truyền thuận:- Bạn nhận được X- Bạn tính toán $A = \sigma(w^T X + b) = (a^{(1)}, a^{(2)}, ..., a^{(m-1)}, a^{(m)})$- Bạn tính toán hàm chi phí: $J = -\frac{1}{m}\sum_{i=1}^{m}y^{(i)}\log(a^{(i)})+(1-y^{(i)})\log(1-a^{(i)})$Đây là hai công thức bạn sẽ sử dụng:$$ \frac{\partial J}{\partial w} = \frac{1}{m}X(A-Y)^T\tag{7}$$$$ \frac{\partial J}{\partial b} = \frac{1}{m} \sum_{i=1}^m (a^{(i)}-y^{(i)})\tag{8}$$<jupyter_code># GRADED FUNCTION: propagate

def propagate(w, b, X, Y):
    """
    Implement the cost function and its gradient for the propagation explained above

    Arguments:
    w -- weights, a numpy array of size (num_px * num_px * 3, 1)
    b -- bias, a scalar
    X -- data of size (num_px * num_px * 3, number of examples)
    Y -- true "label" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)

    Return:
    cost -- negative log-likelihood cost for logistic regression
    dw -- gradient of the loss with respect to w, thus same shape as w
    db -- gradient of the loss with respect to b, thus same shape as b
    
    Tips:
    - Write your code step by step for the propagation. np.log(), np.dot()
    """
    
    m = X.shape[1]
    
    # FORWARD PROPAGATION (FROM X TO COST)
    ### START CODE HERE ### (≈ 2 lines of code)
    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
    ### END CODE HERE ###
    
    # BACKWARD PROPAGATION (TO FIND GRAD)
    ### START CODE HERE ### (≈ 2 lines of code)
    dw = 1/m * np.dot(X,(A-Y).T)
    db = 1/m * np.sum(A-Y)
    ### END CODE HERE ###

    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.,-1.],[3.,4.,-3.2]]), np.array([[1,0,1]])
grads, cost = propagate(w, b, X, Y)
print ("dw = " + str(grads["dw"]))
print ("db = " + str(grads["db"]))
print ("cost = " + str(cost))<jupyter_output>dw = [[0.99845601]
 [2.39507239]]
db = 0.001455578136784208
cost = 5.801545319394553<jupyter_text>**Kết quả mong đợi**:               dw          [[ 0.99845601]     [ 2.39507239]]                   db            0.00145557813678                    cost            5.801545319394553       4.4 - Optimization- Bạn đã khởi tạo các thông số của mình.- Bạn cũng có thể tính toán hàm chi phí và độ dốc của nó.- Bây giờ, bạn muốn cập nhật các thông số bằng cách sử dụng gradient descent.**Gợi ý:** Viết ra chức năng tối ưu hóa. Mục tiêu là tìm hiểu $ w $ và $ b $ bằng cách tối thiểu hóa hàm chi phí $ J $. Đối với tham số $\theta$, quy tắc cập nhật là $\theta =\theta - \alpha \text {} d \theta$, trong đó $ \alpha $ là tốc độ học tập.<jupyter_code># GRADED FUNCTION: optimize

def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):
    """
    This function optimizes w and b by running a gradient descent algorithm
    
    Arguments:
    w -- weights, a numpy array of size (num_px * num_px * 3, 1)
    b -- bias, a scalar
    X -- data of shape (num_px * num_px * 3, number of examples)
    Y -- true "label" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)
    num_iterations -- number of iterations of the optimization loop
    learning_rate -- learning rate of the gradient descent update rule
    print_cost -- True to print the loss every 100 steps
    
    Returns:
    params -- dictionary containing the weights w and bias b
    grads -- dictionary containing the gradients of the weights and bias with respect to the cost function
    costs -- list of all the costs computed during the optimization, this will be used to plot the learning curve.
    
    Tips:
    You basically need to write down two steps and iterate through them:
        1) Calculate the cost and the gradient for the current parameters. Use propagate().
        2) Update the parameters using gradient descent rule for w and b.
    """
    
    costs = []
    
    for i in range(num_iterations):
        
        
        # Cost and gradient calculation (≈ 1-4 lines of code)
        ### START CODE HERE ### 
        grads, cost = propagate(w, b, X, Y)
        ### END CODE HERE ###
        
        # Retrieve derivatives from grads
        dw = grads["dw"]
        db = grads["db"]
        
        # update rule (≈ 2 lines of code)
        ### START CODE HERE ###
        w = w - learning_rate*dw
        b = b - learning_rate*db
        ### END CODE HERE ###
        
        # Record the costs
        if i % 100 == 0:
            costs.append(cost)
        
        # Print the cost every 100 training iterations
        if 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"]))<jupyter_output>w = [[0.19033591]
 [0.12259159]]
b = 1.9253598300845747
dw = [[0.67752042]
 [1.41625495]]
db = 0.21919450454067657<jupyter_text>**Kết quả đầu ra**:             w        [[ 0.19033591] [ 0.12259159]]                 b         1.92535983008                 dw         [[ 0.67752042] [ 1.41625495]]                 db         0.219194504541      **Gợi ý:** hàm trước đó sẽ xuất ra w và b đã học. Chúng tôi có thể sử dụng w và b để dự đoán các nhãn cho tập dữ liệu X. Triển khai `predict()`Hàm. Có hai bước để tính toán các dự đoán:1. Tính $\hat{Y} = A = \sigma(w^T X + b)$2. Chuyển đổi các mục nhập của a thành 0 (if activation  0.5), lưu trữ các dự đoán trong một vectơ`Y_prediction`. Nếu bạn muốn, bạn có thể sử dụng một`if`/`else` tuyên bố trong một `for` vòng lặp (mặc dù cũng có một cách để vectơ hóa điều này).<jupyter_code># GRADED FUNCTION: predict

def predict(w, b, X):
    '''
    Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b)
    
    Arguments:
    w -- weights, a numpy array of size (num_px * num_px * 3, 1)
    b -- bias, a scalar
    X -- data of size (num_px * num_px * 3, number of examples)
    
    Returns:
    Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in 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
    ### START CODE HERE ### (≈ 1 line of code)
    A = sigmoid(np.dot(w.T,X)+b)
    ### END CODE HERE ###
    
    for i in range(A.shape[1]):
        
        # Convert probabilities A[0,i] to actual predictions p[0,i]
        ### START CODE HERE ### (≈ 4 lines of code)
        if A[0][i]> 0.5 or A[0][i] == 0.5:
            Y_prediction[0][i]= 1
        else:
            Y_prediction[0][i] = 0
            
        ### END CODE HERE ###
    
    assert(Y_prediction.shape == (1, m))
    
    return Y_prediction
w = np.array([[0.1124579],[0.23106775]])
b = -0.3
X = np.array([[1.,-1.1,-3.2],[1.2,2.,0.1]])
print ("predictions = " + str(predict(w, b, X)))<jupyter_output>predictions = [[1. 1. 0.]]<jupyter_text>**Kết quả mong đợi:**                          predictions                               [[ 1.  1.  0.]]               Những điều cần nhớ:    Bạn đã triển khai một số chức năng:- Khởi tạo (w, b)- Tối ưu hóa sự mất mát lặp đi lặp lại để tìm hiểu các tham số (w, b):     - tính toán chi phí và độ dốc của nó     - cập nhật các thông số bằng cách sử dụng gradient descent- Sử dụng (w, b) đã học để dự đoán các nhãn cho một bộ ví dụ nhất định  5 - Merge all functions into a model Bây giờ bạn sẽ thấy mô hình tổng thể được cấu trúc như thế nào bằng cách tập hợp tất cả các khối xây dựng (các chức năng được triển khai trong các phần trước) lại với nhau, theo đúng thứ tự.**Bài tập:** Thực hiện chức năng model. Sử dụng ký hiệu sau:     - Y_prediction_test cho các dự đoán của bạn trong bộ thử nghiệm     - Y_prediction_train cho những dự đoán của bạn về bộ huấn luyện     - w,cost, grads  cho các kết quả đầu ra của tối ưu hóa ()<jupyter_code># GRADED FUNCTION: model

def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):
    """
    Builds the logistic regression model by calling the function you've implemented previously
    
    Arguments:
    X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)
    Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)
    X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)
    Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)
    num_iterations -- hyperparameter representing the number of iterations to optimize the parameters
    learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()
    print_cost -- Set to true to print the cost every 100 iterations
    
    Returns:
    d -- dictionary containing information about the model.
    """
    
    ### START CODE HERE ###
    
    # initialize parameters with zeros (≈ 1 line of code)
    w, b = np.zeros((X_train.shape[0], 1)),0

    # Gradient descent (≈ 1 line of code)
    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 (≈ 2 lines of code)
    Y_prediction_test = predict(w,b,X_test)
    Y_prediction_train = predict(w,b,X_train)
    ### END CODE HERE ###

    # Print train/test Errors
    print("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}
    
    return d<jupyter_output><empty_output><jupyter_text>Chạy ô sau để đào tạo mô hình của bạn.<jupyter_code>d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)<jupyter_output>Cost after iteration 0: 0.693147
Cost after iteration 100: 0.709726
Cost after iteration 200: 0.657712
Cost after iteration 300: 0.614611
Cost after iteration 400: 0.578001
Cost after iteration 500: 0.546372
Cost after iteration 600: 0.518331
Cost after iteration 700: 0.492852
Cost after iteration 800: 0.469259
Cost after iteration 900: 0.447139
Cost after iteration 1000: 0.426262
Cost after iteration 1100: 0.406617
Cost after iteration 1200: 0.388723
Cost after iteration 1300: 0.374678
Cost after iteration 1400: 0.365826
Cost after iteration 1500: 0.358532
Cost after iteration 1600: 0.351612
Cost after iteration 1700: 0.345012
Cost after iteration 1800: 0.338704
Cost after iteration 1900: 0.332664
train accuracy: 91.38755980861244 %
test accuracy: 34.0 %<jupyter_text>**Expected Output**:               Cost after iteration 0             0.693147                     $\vdots$             $\vdots$                      Train Accuracy            99.04306220095694 %                 Test Accuracy           70.0 %       **Nhận xét**: Độ chính xác của việc huấn luyện là gần 100%. Đây là một kiểm tra tỉnh táo tốt: mô hình của bạn đang hoạt động và có dung lượng đủ cao để phù hợp với dữ liệu đào tạo. Độ chính xác của bài kiểm tra là 68%. Nó thực sự không tệ đối với mô hình đơn giản này, với tập dữ liệu nhỏ mà chúng tôi đã sử dụng và hồi quy logistic là một bộ phân loại tuyến tính. Nhưng đừng lo lắng, bạn sẽ xây dựng một bộ phân loại thậm chí còn tốt hơn vào tuần tới!Ngoài ra, bạn thấy rằng mô hình rõ ràng đang trang bị quá nhiều dữ liệu đào tạo. Sau đó trong chuyên ngành này, bạn sẽ học cách giảm thiểu việc trang bị quá nhiều, chẳng hạn như bằng cách sử dụng chính quy hóa. Sử dụng đoạn mã dưới đây (và thay đổi biến `chỉ số`), bạn có thể xem các dự đoán trên hình ảnh của bộ thử nghiệm.<jupyter_code># 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 \"" + str(classes[int(d["Y_prediction_test"][0,index])]) +  "\" picture.")<jupyter_output>y = 1, you predicted that it is a "b'non-cat'" picture.<jupyter_text>Hãy cũng vẽ biểu đồ của hàm chi phí và độ dốc.<jupyter_code># Plot learning curve (with costs)
costs = np.squeeze(d['costs'])
plt.plot(costs)
plt.ylabel('cost')
plt.xlabel('iterations (per hundreds)')
plt.title("Learning rate =" + str(d["learning_rate"]))
plt.show()<jupyter_output><empty_output><jupyter_text>**Diễn dịch**:Bạn có thể thấy chi phí giảm dần. Nó cho thấy rằng các tham số đang được học. Tuy nhiên, bạn thấy rằng bạn có thể đào tạo người mẫu nhiều hơn nữa trên bộ đào tạo. Cố gắng tăng số lần lặp lại trong ô ở trên và chạy lại các ô. Bạn có thể thấy rằng độ chính xác của bộ đào tạo tăng lên, nhưng độ chính xác của bộ kiểm tra sẽ giảm xuống. Điều này được gọi là trang phục quá mức.  6 - Further analysis (optional/ungraded exercise) Chúc mừng bạn đã xây dựng mô hình phân loại hình ảnh đầu tiên. Hãy phân tích sâu hơn và kiểm tra các lựa chọn khả thi cho tốc độ học tập $\alpha$.<jupyter_code>learning_rates = [0.01, 0.001, 0.0001]
models = {}
for i in learning_rates:
    print ("learning rate is: " + str(i))
    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)
    print ('\n' + "-------------------------------------------------------" + '\n')

for i in learning_rates:
    plt.plot(np.squeeze(models[str(i)]["costs"]), label= str(models[str(i)]["learning_rate"]))

plt.ylabel('cost')
plt.xlabel('iterations (hundreds)')

legend = plt.legend(loc='upper center', shadow=True)
frame = legend.get_frame()
frame.set_facecolor('0.90')
plt.show()<jupyter_output>learning rate is: 0.01
train accuracy: 71.29186602870814 %
test accuracy: 34.0 %

-------------------------------------------------------

learning rate is: 0.001
train accuracy: 74.16267942583733 %
test accuracy: 34.0 %

-------------------------------------------------------

learning rate is: 0.0001
train accuracy: 66.02870813397129 %
test accuracy: 34.0 %

-------------------------------------------------------<jupyter_text>**Diễn dịch**:- Tỷ lệ học tập khác nhau cho chi phí khác nhau và do đó kết quả dự đoán khác nhau.- Nếu tỷ lệ học tập quá lớn (0,01), chi phí có thể dao động lên xuống. Nó thậm chí có thể khác nhau (mặc dù trong ví dụ này, sử dụng 0,01 cuối cùng vẫn có giá trị tốt cho chi phí).- Chi phí thấp hơn không có nghĩa là một mô hình tốt hơn. Bạn phải kiểm tra xem có khả năng trang bị quá mức hay không. Nó xảy ra khi độ chính xác huấn luyện cao hơn rất nhiều so với độ chính xác của bài kiểm tra.- Trong học tập sâu, chúng tôi thường khuyên bạn:     - Chọn tỷ lệ học tập tốt hơn để giảm thiểu hàm chi phí.     - Nếu mô hình của bạn quá trang phục, hãy sử dụng các kỹ thuật khác để giảm trang bị quá mức. (Chúng ta sẽ nói về vấn đề này trong các video sau.)  7 - Test with your own image (optional/ungraded exercise) Chúc mừng bạn đã hoàn thành nhiệm vụ này. Bạn có thể sử dụng hình ảnh của riêng mình và xem đầu ra của mô hình của bạn. Để làm việc đó:     1. Nhấp vào "Tệp" ở thanh trên của sổ ghi chép này, sau đó nhấp vào "Mở" để truy cập Coursera Hub của bạn.     2. Thêm hình ảnh của bạn vào thư mục của Máy tính xách tay Jupyter này, trong thư mục "hình ảnh"     3. Thay đổi tên hình ảnh của bạn trong mã sau     4. Chạy mã và kiểm tra xem thuật toán có đúng không (1 = cat, 0 = non-cat)!<jupyter_code>## START CODE HERE ## (PUT YOUR IMAGE NAME)
import matplotlib.pyplot
from skimage.transform import resize

my_image = "cat1.jpeg"   # change this to the name of your image file 
## END CODE HERE ##

# We preprocess the image to fit your algorithm.
fname = "images/" + my_image

image = matplotlib.pyplot.imread(fname)
image = image/255.
print(image)
my_image = resize(image, output_shape=(num_px,num_px)).reshape((1, num_px*num_px*3)).T
my_predicted_image = predict(d["w"], d["b"], my_image)

plt.imshow(image)
print("y = " + str(np.squeeze(my_predicted_image)) + ", your algorithm predicts a \"" + classes[int(np.squeeze(my_predicted_image)),].decode("utf-8") +  "\" picture.")
!pip install pillow

import scipy
print(scipy.__version__)<jupyter_output>1.4.1
StarcoderdataJupyterStructuredCleanDedup