Mạng thần kinh chuyển đổi – Triển khai PyTorch trên Bộ dữ liệu CIFAR-10

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

Giới thiệu

Mạng nơ-ron chuyển đổi, còn được gọi là ConvNets, được giới thiệu lần đầu tiên vào những năm 1980 bởi Yann LeCun, một nhà nghiên cứu khoa học máy tính làm việc ở chế độ nền. LeCun được xây dựng dựa trên công trình của Kunihiko Fukushima, một nhà khoa học Nhật Bản, một mạng cơ bản để nhận dạng hình ảnh.

Phiên bản cũ của CNN, được gọi là LeNet (sau LeCun), có thể nhìn thấy các chữ số viết tay. CNN giúp tìm mã pin từ bưu điện. Nhưng bất chấp chuyên môn của họ, ConvNets vẫn tiến gần đến thị giác máy tính và trí tuệ nhân tạo vì họ phải đối mặt với một vấn đề lớn: Họ không thể mở rộng quy mô. CNN yêu cầu rất nhiều dữ liệu và tích hợp tài nguyên để hoạt động tốt cho hình ảnh lớn.

Vào thời điểm đó, phương pháp này chỉ được áp dụng cho những hình ảnh có độ phân giải thấp. Pytorch là một thư viện có thể thực hiện các hoạt động học sâu. Chúng ta có thể sử dụng điều này để thực hiện các mạng nơ-ron liên kết. Mạng nơ-ron chuyển đổi chứa nhiều lớp nơ-ron nhân tạo. Tế bào thần kinh tổng hợp, mô phỏng phức tạp của các đối chứng sinh học, là các hàm toán học tính toán khối lượng có trọng số của nhiều đầu vào và kích hoạt giá trị sản phẩm.

Hình ảnh trên cho chúng ta thấy một mô hình CNN lấy một hình ảnh giống như chữ số là 2 và cho chúng ta kết quả là chữ số nào được hiển thị trong hình ảnh dưới dạng một số. Chúng tôi sẽ thảo luận chi tiết về cách chúng tôi có được điều này trong bài viết này.

CIFAR-10 là một bộ dữ liệu có một bộ sưu tập các hình ảnh của 10 lớp khác nhau. Bộ dữ liệu này được sử dụng rộng rãi cho mục đích nghiên cứu để kiểm tra các mô hình học máy khác nhau và đặc biệt là cho các vấn đề về thị giác máy tính. Trong bài viết này, chúng tôi sẽ cố gắng xây dựng mô hình mạng Neural bằng Pytorch và kiểm tra nó trên tập dữ liệu CIFAR-10 để kiểm tra độ chính xác của dự đoán có thể đạt được.

Nhập thư viện PyTorch 

nhập numpy dưới dạng np nhập gấu trúc dưới dạng pd

import torch import torch.nn.chức năng như F từ tập dữ liệu nhập torchvision, chuyển đổi từ torch import nn import matplotlib.pyplot dưới dạng plt import numpy as np import seaborn as sns #from tqdm.notebook import tqdm from tqdm import tqdm

Trong bước này, chúng tôi nhập các thư viện cần thiết. Có thể thấy chúng tôi sử dụng NumPy cho các phép toán số và gấu trúc cho các phép toán khung dữ liệu. Thư viện ngọn đuốc được sử dụng để nhập Pytorch.

Pytorch có một thành phần nn được sử dụng để trừu tượng hóa các hoạt động và chức năng học máy. Điều này được nhập dưới dạng F. Thư viện torchvision được sử dụng để chúng tôi có thể nhập tập dữ liệu CIFAR-10. Thư viện này có nhiều bộ dữ liệu hình ảnh và được sử dụng rộng rãi cho nghiên cứu. Các biến đổi có thể được nhập để chúng tôi có thể thay đổi kích thước hình ảnh thành kích thước bằng nhau cho tất cả các hình ảnh. Tqdm được sử dụng để chúng tôi có thể theo dõi sự tiến bộ trong quá trình đào tạo và được sử dụng để hình dung.

Đọc tập dữ liệu bắt buộc

trainData = pd.read_csv ('cifar-10 / trainLabels.csv') trainData.head ()

Khi chúng ta đọc tập dữ liệu, chúng ta có thể thấy nhiều nhãn khác nhau như ếch, xe tải, hươu, ô tô, v.v.

Phân tích dữ liệu với PyTorch

print ("Số điểm:", trainData.shape [0]) print ("Số lượng tính năng:", trainData.shape [1]) print ("Tính năng:", trainData.columns.values) print ("Số lượng Giá trị duy nhất ") cho col trong trainData: print (col,": ", len (trainData [col] .unique ())) plt.figure (figsize = (12,8))

Đầu ra:

Số điểm: 50000 Số tính năng: 2 Tính năng: ['id' 'label'] Số giá trị duy nhất id: 50000 label: 10

Trong bước này, chúng tôi phân tích tập dữ liệu và thấy rằng dữ liệu tàu của chúng tôi có khoảng 50000 hàng với id và nhãn được liên kết của chúng. Có tổng cộng 10 lớp như trong tên CIFAR-10.

Nhận bộ xác thực bằng PyTorch

từ torch.utils.data import random_split val_size = 5000 train_size = len (dataset) - val_size train_ds, val_ds = random_split (dataset, [train_size, val_size]) len (train_ds), len (val_ds)

Bước này giống như bước huấn luyện, nhưng chúng ta muốn chia dữ liệu thành các tập hợp lệ và huấn luyện.

(45000, 5000)

from torch.utils.data.dataloader import DataLoader batch_size = 64 train_dl = DataLoader (train_ds, batch_size, shuffle = True, num_workers = 4, pin_memory = True) val_dl = DataLoader (val_ds, batch_size, num_workers = 4, pin_memory = True)

Torch.utils có một trình tải dữ liệu có thể giúp chúng tôi tải dữ liệu được yêu cầu bằng cách bỏ qua các thông số khác nhau như số công nhân hoặc kích thước lô.

Xác định các chức năng cần thiết

@ torch.no_grad () độ chính xác def (đầu ra, nhãn): _, preds = torch.max (đầu ra, dim = 1) trả về torch.tensor (torch.sum (preds == nhãn) .item () / len (preds )) class ImageClassificationBase (nn. , các nhãn) trả về mất mát, xác thực xác nhận acquy def_step (tự, hàng loạt): hình ảnh, nhãn = kết xuất hàng loạt = bản thân (hình ảnh) # Tạo dự đoán mất mát = F.cross_entropy (hết, nhãn) # Tính toán tổn thất acc = độ chính xác (hết, nhãn) # Tính toán độ chính xác trả về {'Loss': loss.detach (), 'Accuracy': acc} def validation_epoch_end (self, outputs): batch_losses = [x ['Loss'] for x in outputs] epoch_loss = torch.stack (batch_losses ) .mean () # Kết hợp các tổn thất batch_accs = [x ['Độ chính xác'] cho x ở đầu ra] epoch_acc = torch.stack (batch_accs) .mean () # Kết hợp độ chính xác trả về {'Loss': epoch_loss.item (), ' Độ chính xác ': epoch_acc.item ()} def epoch_end (self, epoch, result): pr int ("Epoch:", epoch + 1) print (f'Train Accuracy: {result ["train_accuracy"] * 100: .2f}% Validation Accuracy: {result ["Accuracy"] * 100: .2f}% ' ) print (f'Train Loss: {result ["train_loss"]:. 4f} Mất xác thực: {result ["Loss"]:. 4f} ')

Như chúng ta thấy ở đây, chúng ta đã sử dụng việc triển khai lớp ImageClassification và nó nhận một tham số là nn.Module. Trong lớp này, chúng ta có thể triển khai các chức năng khác nhau hoặc các bước khác nhau như huấn luyện, xác thực, v.v. Các chức năng ở đây là triển khai python đơn giản.

Bước đào tạo lấy hình ảnh và nhãn theo lô. chúng tôi sử dụng cross-entropy cho hàm tổn thất và tính toán tổn thất và trả lại tổn thất. Điều này tương tự như bước xác nhận như chúng ta có thể thấy trong hàm. Kết thúc kỷ nguyên kết hợp tổn thất và độ chính xác và cuối cùng, chúng tôi in ra độ chính xác và tổn thất.

Triển khai mô-đun mạng nơ-ron tích hợp

class Cifar10CnnModel (ImageClassificationBase): def __init __ (self): super () .__ init __ () self.network = nn.Sequential (nn.Conv2d (3, 32, kernel_size = 3, padding = 1), nn.ReLU (), nn.Conv2d (32, 64, kernel_size = 3, stride = 1, padding = 1), nn.ReLU (), nn.MaxPool2d (2, 2), # output: 64 x 16 x 16 nn.BatchNorm2d (64) , nn.Conv2d (64, 128, kernel_size = 3, stride = 1, padding = 1), nn.ReLU (), nn.Conv2d (128, 128, kernel_size = 3, stride = 1, padding = 1), nn .ReLU (), nn.MaxPool2d (2, 2), # đầu ra: 128 x 8 x 8 nn.BatchNorm2d (128), nn.Conv2d (128, 256, kernel_size = 3, stride = 1, padding = 1), nn.ReLU (), nn.Conv2d (256, 256, kernel_size = 3, stride = 1, padding = 1), nn.ReLU (), nn.MaxPool2d (2, 2), # đầu ra: 256 x 4 x 4 nn.BatchNorm2d (256), nn.Flatten (), nn.Linear (256 * 4 * 4, 1024), nn.ReLU (), nn.Linear (1024, 512), nn.ReLU (), nn.Linear (512, 10)) def forward (self, xb): return self.network (xb)

Đây là phần quan trọng nhất của việc triển khai mạng nơ-ron. Trong suốt, chúng tôi sử dụng mô-đun nn mà chúng tôi đã nhập từ torch. Như chúng ta có thể thấy trong dòng đầu tiên, Conv2d là một mô-đun giúp triển khai mạng nơ-ron tích hợp. Tham số đầu tiên 3 ở đây thể hiện rằng hình ảnh có màu và ở định dạng RGB. Nếu đó là một hình ảnh thang độ xám, chúng tôi đã chọn 1.

32 là kích thước của kênh đầu ra ban đầu và khi chúng ta chuyển sang lớp chuyển đổi tiếp theo, chúng ta sẽ có 2 này là kênh đầu vào và 32 là kênh đầu ra.

Tham số thứ 3 trong dòng đầu tiên được gọi là kích thước hạt nhân và nó giúp chúng ta quản lý các bộ lọc được sử dụng. Thao tác đệm là tham số cuối cùng.

Hoạt động tích chập được kết nối với một lớp kích hoạt và Relu ở đây. Sau hai lớp Conv2d, chúng tôi có hoạt động tổng hợp tối đa có kích thước 2 * 2. Giá trị xuất phát từ đây được chuẩn hóa hàng loạt để ổn định và tránh sự thay đổi hiệp biến bên trong. Các hoạt động này được lặp lại với nhiều lớp hơn để mạng sâu hơn và giảm kích thước. Cuối cùng, chúng ta làm phẳng lớp để chúng ta có thể xây dựng một lớp tuyến tính để ánh xạ các giá trị thành 10 giá trị. Xác suất của mỗi nơ-ron trong số 10 nơ-ron này sẽ xác định một hình ảnh cụ thể thuộc lớp nào dựa trên xác suất tối đa.

Đào tạo mô hình

@ torch.no_grad () def eval (model, data_loader): model.eval () outputs = [model.validation_step (batch) for batch in data_loader] return model.validation_epoch_end (outputs) def fit (model, train_loader, val_loader, epochs = 10, learning_rate = 0.001): best_valid = Không có lịch sử = [] Optimizer = torch.optim.Adam (model.parameters (), learning_rate, weight_decay = 0.0005) cho kỷ nguyên trong phạm vi (epochs): # Giai đoạn đào tạo model.train ( ) train_losses = [] train_accuracy = [] cho lô trong tqdm (train_loader): mất mát, acquy = model.training_step (lô) train_losses.append (mất) train_accuracy.append (acquy) loss.backward () Optimizer.step () trình tối ưu hóa .zero_grad () # Kết quả giai đoạn xác thực = eval (model, val_loader) result ['train_loss'] = torch.stack (train_losses) .mean (). item () result ['train_accuracy'] = torch.stack (train_accuracy). mean (). item () model.epoch_end (epoch, result) if (best_valid == Không có hoặc best_valid

history = fit (model, train_dl, val_dl)

Đây là bước cơ bản để đào tạo mô hình của chúng tôi để có được kết quả cần thiết. chức năng phù hợp ở đây sẽ phù hợp với dữ liệu tàu và Val với mô hình chúng tôi đã tạo. Hàm phù hợp ban đầu nhận một danh sách được gọi là lịch sử quản lý dữ liệu lặp lại của mọi kỷ nguyên. Chúng tôi chạy một vòng lặp for để chúng tôi có thể lặp lại qua từng kỷ nguyên. Đối với mỗi đợt, chúng tôi đảm bảo rằng chúng tôi hiển thị tiến trình bằng tqdm. Chúng tôi gọi là bước đào tạo mà chúng tôi đã thực hiện trước đó và tính toán chính xác và mất mát. Bắt đầu truyền ngược và chạy trình tối ưu hóa mà chúng tôi đã xác định trước đó. Khi chúng tôi làm điều này, chúng tôi sẽ theo dõi danh sách của mình và các chức năng giúp chúng tôi in chi tiết và tiến độ.

Mặt khác, hàm đánh giá sử dụng hàm eval và đối với mỗi bước, chúng tôi lấy lô được tải từ bộ tải dữ liệu và kết quả đầu ra được tính toán. Sau đó, giá trị được chuyển đến phần cuối của kỷ nguyên xác thực mà chúng tôi đã xác định trước đó và giá trị tương ứng được trả về.

Lập biểu đồ kết quả

Trong bước này, chúng ta sẽ hình dung độ chính xác so với từng kỷ nguyên. Chúng ta có thể quan sát thấy rằng khi kỷ nguyên tăng độ chính xác của hệ thống tiếp tục tăng và tương tự như vậy, tổn thất tiếp tục giảm. Dòng màu đỏ ở đây cho biết tiến trình dữ liệu đào tạo và màu xanh lam để xác nhận. Chúng ta có thể thấy rằng kết quả của chúng tôi đã được trang bị quá nhiều vì dữ liệu đào tạo khá tốt hơn kết quả xác nhận và tương tự trong trường hợp bị mất. Sau 10 kỷ, dữ liệu về chuyến tàu dường như vượt qua độ chính xác 90% nhưng bị mất khoảng 0.5. Dữ liệu thử nghiệm là khoảng 81% và tổn thất là gần 0.2.

def plot_accuracies (history): Validation_accuracies = [x ['Accuracy'] for x in history] Training_Accuracies = [x ['train_accuracy'] for x in history] plt.plot (Training_Accuracies, '-rx') plt.plot (Validation_accuracies , '-bx') plt.xlabel ('kỷ nguyên') plt.ylabel ('độ chính xác') plt.legend (['Đào tạo', 'Xác thực']) plt.title ('Độ chính xác so với Số kỷ nguyên') ; plot_accuracies (lịch sử)

def plot_losses (history): train_losses = [x.get ('train_loss') for x in history] val_losses = [x ['Loss'] for x in history] plt.plot (train_losses, '-bx') plt.plot (val_losses, '-rx') plt.xlabel ('kỷ nguyên') plt.ylabel ('mất mát') plt.legend (['Đào tạo', 'Xác thực']) plt.title ('Mất mát so với số kỷ nguyên '); plot_losses (lịch sử)

test_dataset = ImageFolder (data_dir + '/ test', biến đổi = ToTensor ()) test_loader = DeviceDataLoader (DataLoader (test_dataset, batch_size), device) result = eval (final_model, test_loader) print (f'Test Accuracy: {result ["Accuracy" ] * 100: .2f}% ')

Độ chính xác của bài kiểm tra: 81.07%

Chúng tôi có thể thấy rằng chúng tôi kết thúc với độ chính xác là 81.07%.

Kết luận:

Hình ảnh: https: //unsplash.com/photos/5L0R8ZqPZHk

Về tôi: Tôi là một Sinh viên nghiên cứu quan tâm đến lĩnh vực Học sâu và Xử lý ngôn ngữ tự nhiên và hiện đang theo đuổi ngành Trí tuệ nhân tạo sau tốt nghiệp.

Nguồn hình ảnh

1. Image 1: https://becominghuman.ai/cifar-10-image-classification-fd2ace47c5e8
2. Hình ảnh 2: https://www.analyticsvidhya.com/blog/2021/05/convolutions-neural-networks-cnn/

Vui lòng kết nối với tôi trên:

1.  Liên kết: https://www.linkedin.com/in/siddharth-m-426a9614a/
2.  Github: https://github.com/Siddharth1698

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/09/convolutions-neural-network-pytorch-implementation-on-cifar10-dataset/