Mạng thần kinh để phân loại với Tensorflow

Bài báo này đã được xuất bản như một phần của Blogathon Khoa học Dữ liệu

Trong bài viết này, tôi sẽ xây dựng mô hình mạng nơ-ron với TensorFlow để giải quyết vấn đề phân loại. Chúng ta hãy cùng nhau khám phá cách chúng ta có thể tiếp cận một vấn đề phân loại trong Tensorflow. Nhưng trước tiên, tôi muốn đảm bảo rằng chúng tôi có thể trả lời những câu hỏi sau:

Neural Network là gì?

Mục đích chính của mạng nơ-ron là cố gắng tìm ra mối quan hệ giữa các đặc điểm trong một tập dữ liệu, và nó bao gồm một tập hợp các thuật toán bắt chước hoạt động của bộ não con người. Một "nơ-ron" trong mạng nơ-ron là một hàm toán học thu thập và phân loại thông tin theo một kiến ​​trúc cụ thể.

Phân loại là gì?

Vấn đề phân loại liên quan đến việc dự đoán nếu một cái gì đó thuộc về một lớp hay không. Nói cách khác, trong khi làm việc đó, chúng ta cố gắng xem điều gì đó là điều này hay điều khác.

Các loại phân loại

• Giả sử rằng bạn muốn dự đoán xem một người có mắc bệnh tiểu đường hay không. Nếu bạn đang đối mặt với tình huống này, có hai khả năng, phải không? Cái đó được gọi là Phân loại nhị phân.
• Giả sử rằng bạn muốn xác định xem ảnh là đồ chơi, người hay mèo, phải không? cái này được gọi là Phân loại nhiều lớp bởi vì có nhiều hơn hai lựa chọn.
• Giả sử bạn muốn quyết định rằng những danh mục nào nên được chỉ định cho một bài báo. Nếu vậy, nó được gọi là Phân loại nhiều nhãn, bởi vì một bài báo có thể có nhiều hơn một danh mục được chỉ định. Hãy cùng chúng tôi lý giải qua bài viết này. Chúng tôi có thể chỉ định các danh mục như “Học sâu, TensorFlow, Phân loại”, v.v. cho bài viết này

Bây giờ chúng ta có thể tiến lên phía trước vì chúng ta có sự hiểu biết chung về vấn đề mà chúng ta sẽ giải quyết. Vì vậy, đã đến lúc viết mã. Tôi hy vọng bạn đang viết chúng ra với tôi bởi vì cách duy nhất để trở nên tốt hơn, ít mắc lỗi hơn là viết nhiều mã hơn.

Chúng tôi đang bắt đầu với việc nhập các thư viện mà chúng tôi sẽ sử dụng:

import numpy as np import pandas as pd import matplotlib.pyplot as plt import tensorflow as tf print (tf .__ version__)

Tạo tập dữ liệu

Đã đến lúc tạo tập dữ liệu để làm việc trên:

từ sklearn.datasets nhập mẫu make_circles = 1000 X, y = make_circles (mẫu, nhiễu = 0.03, random_state = 42)

print (X >> [[0.75424625 0.23148074] [-0.75615888 0.15325888] [-0.81539193 0.17328203] ... [-0.13690036 -0.81001183] [0.67036156 -0.76750154] [0.28105665 0.96382443]]

print (y) >> [1 1 1 1 0 1 1 1 1 0]

Được rồi, chúng ta đã xem tập dữ liệu của mình chi tiết hơn, nhưng chúng ta vẫn chưa biết gì về nó, phải không? Đó là lý do tại sao ở đây, một bước quan trọng là trở thành một với dữ liệu và trực quan hóa là cách tốt nhất để làm điều này.

circle = pd.DataFrame ({'X0': X [:, 0], 'X1': X [:, 1], 'label': y}) circle.head ()

Ở đây một câu hỏi được đặt ra, chúng ta đang xử lý loại nhãn nào?

circle.label.value_counts () >> 1 500 0 500 Tên: label, dtype: int64

Có vẻ như chúng tôi đang giải quyết một vấn đề phân loại nhị phân, bởi vì chúng ta có 2 nhãn (0 và 1).

plt.scatter (X [:, 0], X [:, 1], c = y, cmap = plt.cm.RdYlBu)

Như tôi đã đề cập ở trên, cách tốt nhất để có được một dữ liệu là trực quan hóa. Bây giờ, cốt truyện tự nói rằng chúng ta cần xây dựng loại mô hình nào. Chúng tôi sẽ xây dựng một mô hình có thể phân biệt các chấm xanh và các chấm đỏ.

Trước khi xây dựng bất kỳ mô hình mạng nơron nào, chúng ta phải kiểm tra hình dạng của các tính năng đầu vào và đầu ra của mình. chúng phải giống nhau!

print (X.shape, y.shape) print (len (X), len (y)) >> (1000, 2) (1000,) 1000 1000

Chúng ta có cùng một lượng giá trị cho mỗi đối tượng địa lý, nhưng hình dạng của X thì khác nhau? Tại sao? Hãy cùng kiểm tra nào.

X [0], y [0] >> (mảng ([0.75424625, 0.23148074]), 1)

Được rồi, chúng tôi có 2 tính năng X cho 1 y. Vì vậy, chúng tôi có thể tiến về phía trước mà không gặp bất kỳ vấn đề gì.

Các bước trong mô hình hóa mạng thần kinh để phân loại với Tensorflow

Trong TensorFlow có các giai đoạn cố định để tạo một mô hình:

• Tạo mô hình - ghép các lớp của Mạng thần kinh lại với nhau bằng cách sử dụng API tuần tự hoặc chức năng
• Biên dịch một mô hình - xác định cách đo lường hiệu suất của một mô hình và cải thiện nó như thế nào (chức năng mất mát và trình tối ưu hóa)
• Phù hợp với một chế độl - cho phép một mô hình tìm thấy các mẫu trong dữ liệu

Chúng tôi sẽ sử dụng API tuần tự. Vậy hãy bắt đầu

tf.random.set_seed (42)

model_1 = tf.keras.Sequential ([tf.keras.layers.Dense (1)])

 Optimizer = tf.keras.optimizers.SGD (), #SGD là viết tắt của Stochastic Gradient Descent metrics = ['precision']) model_1.fit (X, y, epochs = 5)

>> Epoch 1/5 32/32 [==============================] - 1 giây 1ms / bước - mất: 2.8544 - độ chính xác: 0.4600 Epoch 2/5 32/32 [=================================] - 0 giây 2ms / bước - mất : 0.7131 - độ chính xác: 0.5430 Epoch 3/5 32/32 [=================================] - 0 giây 2ms / bước - mất mát: 0.6973 - độ chính xác: 0.5090 Epoch 4/5 32/32 [=================================] - 0 giây 2ms / bước - mất: 0.6950 - độ chính xác: 0.5010 Epoch 5/5 32/32 [=================================] - 0s 1ms / bước - mất: 0.6942 - độ chính xác: 0.4830

Độ chính xác của mô hình xấp xỉ 50%, về cơ bản có nghĩa là mô hình chỉ là phỏng đoán, chúng ta hãy cố gắng đào tạo nó lâu hơn

model_1.fit (X, y, epochs = 200, verbose = 0) # chúng tôi đặt verbose = 0 để xóa quy trình đào tạo) model_1.evaluate (X, y)

>> 32/32 [==============================] - 0 giây 1ms / bước - mất: 0.6935 - độ chính xác: 0.5000 [0.6934829950332642, 0.5]

Ngay cả sau 200 kỷ nguyên, nó vẫn hoạt động như đoán. Bước tiếp theo là thêm nhiều lớp hơn và đào tạo lâu hơn.

tf.random.set_seed (42)

model_2 = tf.keras.Sequential ([tf.keras.layers.Dense (1), tf.keras.layers.Dense (1)]) model_2.compile (mất = tf.keras.losses.BinaryCrossentropy (), trình tối ưu hóa = tf.keras.optimizers.SGD (), metrics = ['precision']) model_2.fit (X, y, epochs = 100, verbose = 0)

 mô hình_2. đánh giá (X, y)

>> 32/32 [==============================] - 0 giây 1ms / bước - mất: 0.6933 - độ chính xác: 0.5000 [0.6933314800262451, 0.5]

Tuy nhiên, thậm chí không có một chút thay đổi, dường như có điều gì đó không ổn.

Cải thiện mô hình phân loại mạng thần kinh với Tensorflow

Có nhiều cách khác nhau để cải thiện một mô hình ở các giai đoạn khác nhau:

• Tạo mô hình - thêm nhiều lớp hơn, tăng số lượng các đơn vị ẩn (tế bào thần kinh), thay đổi chức năng kích hoạt của mỗi lớp
• Biên dịch một mô hình - thử các hàm tối ưu hóa khác nhau, ví dụ sử dụng Adam () thay vì SGD ().
• Phù hợp với một mô hình - chúng tôi có thể tăng số lượng kỷ nguyên

Chúng ta hãy cố gắng thêm nhiều tế bào thần kinh và cố gắng Adam tối ưu hóa

tf.random.set_seed (42)

model_3 = tf.keras.Sequential ([tf.keras.layers.Dense (100), # thêm 100 tế bào thần kinh dày đặc tf.keras.layers.Dense (10), # thêm một lớp khác với 10 tế bào thần kinh tf.keras.layers.Dense (1)]) model_3.compile (loss = tf.keras.losses.BinaryCrossentropy (), Optimizer = tf.keras.optimizers.Adam (), metrics = ['precision']) model_3.fit (X, y, kỷ nguyên = 100, verbose = 0)

model_3.evaluate (X, y) >> 32/32 [==============================] - 0 giây 1ms / bước - mất mát: 0.6980 - độ chính xác: 0.5080 [0.6980254650115967, 0.5080000162124634]

Vẫn không khá hơn! Hãy hình dung dữ liệu để xem điều gì đang xảy ra.

Hình dung mô hình Mạng thần kinh

Để hình dung các dự đoán của mô hình, chúng ta sẽ tạo một hàm plot_decision_boundary () mà:

• Sử dụng mô hình, tính năng và nhãn được đào tạo
• Tạo một lưới lưới gồm các giá trị X khác nhau.
• Đưa ra dự đoán trên lưới lưới.
• Lập đồ thị các dự đoán với dòng.

Lưu ý:  Chức năng này đã được điều chỉnh từ hai tài nguyên:

CS231n Được thực hiện với những kiến ​​thức cơ bản về ML 

def plot_decision_boundary (model, X, y): # Xác định ranh giới trục của biểu đồ và tạo một lưới lưới x_min, x_max = X [:, 0] .min () - 0.1, X [:, 0] .max () + 0.1 y_min, y_max = X [:, 1] .min () - 0.1, X [:, 1] .max () + 0.1 xx, yy = np.meshgrid (np.linspace (x_min, x_max, 100), np .linspace (y_min, y_max, 100)) # Tạo giá trị X (chúng tôi sẽ dự đoán trên tất cả các giá trị này) x_in = np.c_ [xx.ravel (), yy.ravel ()] # Đưa ra dự đoán bằng cách sử dụng model y_pred = model.posystem (x_in) # Kiểm tra nhiều lớp

 if len (y_pred [0])> 1: print ("đang phân loại nhiều lớp ...") # Chúng ta phải định hình lại các dự đoán của mình để chúng sẵn sàng cho việc vẽ biểu đồ y_pred = np.argmax (y_pred, axis = 1) .reshape ( xx.shape) else: print ("doing binary classifcation ...") y_pred = np.round (y_pred) .reshape (xx.shape) # Plot quyết định ranh giới plt.contourf (xx, yy, y_pred, cmap = plt. cm.RdYlBu, alpha = 0.7) plt.scatter (X [:, 0], X [:, 1], c = y, s = 40, cmap = plt.cm.RdYlBu) plt.xlim (xx.min ( ), xx.max ()) plt.ylim (yy.min (), yy.max ()) plot_decision_boundary (model_3, X, y)

Đây rồi! Một lần nữa hình dung lại cho chúng ta thấy điều gì sai và phải làm gì? Mô hình của chúng tôi đang cố gắng vẽ một đường thẳng xuyên qua dữ liệu, nhưng dữ liệu của chúng tôi không thể phân tách bằng một đường thẳng. Có điều gì đó bị thiếu trong vấn đề phân loại của chúng tôi? Nó là gì?

Đây là phi tuyến tính! Chúng ta cần một số đường phi tuyến tính. Bạn có thể bối rối ngay bây giờ, nếu bạn đang nghĩ rằng bạn không nhìn thấy loại chức năng đó trước đây, thì bạn đã nhầm, bởi vì bạn có. Hãy xem chúng một cách trực quan. Hình dung luôn hoạt động tốt hơn!

Có một số chức năng kích hoạt trong Mạng thần kinh mà chúng ta có thể sử dụng, như tái lu, sigmoid. Hãy tạo ra một chút đồ chơi căng và kiểm tra các chức năng đó trên đó.

Chức năng kích hoạt cho mạng thần kinh

A = tf.cast (tf.range (-12,12), tf.float32) print (A) >> tf.Tensor ([-12. -11. -10. -9. -8. -7. - 6. -5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.], shape = (24,), dtype = float32)

Chúng ta hãy xem tensor đồ chơi của chúng ta trông như thế nào?

plt.plot (A)

Nó trông như thế này, một đường thẳng! 

Bây giờ chúng ta hãy tạo lại các hàm kích hoạt để xem chúng làm gì với tensor của chúng ta?

sigma:

def sigmoid (x): return 1 / (1 + tf.exp (-x)) sigmoid (A) plt.plot (sigmoid (A))

Một đường không thẳng!

ReLu:

def relu (x): trả về tf.maximum (0, x) plt.plot (relu (A))

Một đường không thẳng!

Bây giờ bạn đã thấy các hàm kích hoạt phi tuyến tính và đây là những gì sẽ hoạt động với chúng ta, mô hình không thể học bất cứ điều gì trên tập dữ liệu phi tuyến tính với các hàm kích hoạt tuyến tính! Nếu bạn đã học được điều này, đã đến lúc phân chia dữ liệu của chúng ta thành các tập huấn luyện và kiểm tra, đồng thời xây dựng các mô hình mạnh mẽ.

X_train, y_train = X [: 800], y [: 800] X_test, y_test = X [800:], y [800:] X_train.shape, X_test.shape >> ((800, 2), (200, 2 ))

tf.random.set_seed (42)

model_4 = tf.keras.Sequential ([tf.keras.layers.Dense (4, activation = 'relu'), # chúng tôi cũng có thể sửa nó "tf.keras.activations.relu" tf.keras.layers.Dense (4 , kích hoạt = 'relu'), tf.keras.layers.Dense (1, kích hoạt = 'sigmoid')]) model_4.compile (mất = tf.keras.losses.binary_crossentropy, trình tối ưu hóa = tf.keras.optimizers.Adam ( lr = 0.01), metrics = ['precision']) model_4.fit (X_train, y_train, epochs = 25, verbose = 0)

Đánh giá mô hình

mất, độ chính xác = model_4.evaluate (X_test, y_test) print (f 'Mất mô hình trên tập thử nghiệm: {loss}') print (f 'Độ chính xác của mô hình trên tập thử nghiệm: {100 * precision}')

>> 7/7 [==============================] - 0 giây 2ms / bước - mất: 0.1247 - độ chính xác: 1.0000 Mất mô hình trên bộ thử nghiệm: 0.1246885135769844 Độ chính xác của mô hình trên bộ thử nghiệm: 100.0

plt.figure (figsize = (12, 6)) plt.subplot (1, 2, 1) plt.title ("Train") plot_decision_boundary (model_4, X = X_train, y = y_train) plt.subplot (1, 2, 2) plt.title ("Thử nghiệm") plot_decision_boundary (model_4, X = X_test, y = y_test) plt.show ()

Chúng ta hãy xem xét ngắn gọn những gì chúng ta đang nói về trong bài viết này. Chúng ta cùng nhau xem xét cách tiếp cận một nhiệm vụ phân loại trong Mạng thần kinh với TensorFlow. Chúng tôi đã tạo ra 3 mô hình theo cách đầu tiên nghĩ ra và với sự trợ giúp của hình dung, chúng tôi nhận ra mình đã sai ở đâu, chúng tôi khám phá tính tuyến tính, phi tuyến tính và cuối cùng, chúng tôi đã xây dựng được một mô hình tổng quát. Những gì tôi đang cố gắng thể hiện với tất cả các mã này và các bước tôi đang làm theo là không có gì là chính xác hoặc cố định 100 phần trăm, mọi thứ tiếp tục thay đổi hàng ngày. Để đoán xem bạn có khả năng gặp phải vấn đề nào trong loại dữ liệu nào và để xem cách kết hợp nào dẫn đến kết quả tốt hơn, tất cả những gì bạn cần là viết nhiều mã hơn và tích lũy kinh nghiệm.

Tôi hy vọng bài viết hữu ích một chút cho bạn và có một số đóng góp.

Phương tiện hiển thị trong bài viết này không thuộc sở hữu của Analytics Vidhya và được sử dụng theo quyết định của Tác giả

Sản phẩm liên quan

Nguồn: https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/