|
MUHAMMAD AL-XORAZMIY NOMIDAGI
TOSHKENT AXBOROT TEXNOLOGIYALARI UNIVERSITETI
Robotexnikada sun’iy intellektga kirish
Amaliy ish - 6
Bajardi: Sirojiddinov Z.
Tekshirdi: Xasanov Umidjon
Toshkent 2023
Mavzu: Chuqur o’qitish (Deep Learning) algoritmlari asosida masala yechish
Chuqur o‘qitish algoritmlari ham neyron tarmog‘i ishlab chiqishda muhim rol o‘ynaydi. Bu algoritmlar kompyuter tizimlarini o‘qitib, ma’lumotlarni tushunish, tasavvurlash, va boshqa vazifalarni bajarishda foydalaniladi. Ular umumiy ravishda neyron tarmog‘ining strukturasi va uzluksizligini o‘rganish, ya'ni boshqa so‘z bilan aytganda, kompyuter tizimlarini biroz "o‘zini o‘rganish" orqali ma’lumotlarni tushunish va bajargan vazifalarni boshqarishni o‘rganishni o‘z ichiga oladi.
Bu algoritmlarning bir qismini endi faqatgina tushunishim mumkin, chunki men ham birorta bir mutaxassislik sohibi emasman. Lekin, bu sohadagi ilmiy literaturadan, onlayn kurslardan yoki ma’lumotlarni tarqatuvchi resurslardan foydalanib, shu sohani o‘rganishingiz mumkin. Chuqur o‘qitish algoritmlari ko‘p o‘rnatilgan tizimlarning yaratilishida, axborotni tushunish va baholashda, ta'limda va boshqa sohalar bilan bog‘liq vazifalarni bajarishda ishlatiladi.
Bu jarayon o‘rganish uchun sabrli va tizimli ishlashni talab qiladi, lekin natijaga erishish uchun qulay va foydali bo‘ladi. Bo‘lgan ma’lumotlarni amaliyotga o‘tish, tajribani olish, va so‘ngra xotirjamlikni o‘rganish, bu yo‘nalishda rivojlanish uchun muhimdir.
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
class KemalarDataset(Dataset):
def init(self, data_path):
self.data = torch.tensor(data_path, dtype=torch.float32)
def len(self):
return len(self.data)
def getitem(self, idx):
sample = self.data[idx, :-1]
label = int(self.data[idx, -1])
return sample, label
class KemalarModel(nn.Module):
def init(self, input_size, hidden_size, output_size):
super(KemalarModel, self).init()
self.fc1 = nn.Linear(input_size, hidden_size)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(hidden_size, output_size)
def forward(self, x):
x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
return x
def train(model, dataloader, criterion, optimizer, num_epochs=1000):
for epoch in range(num_epochs):
for inputs, labels in dataloader:
outputs = model(inputs)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (epoch + 1) % 100 == 0:
print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
data_path = [
[150, 130, 290, 0],
[150, 155, 340, 0],
[150, 166, 332, 0],
[111, 110, 60, 1],
[110, 96, 44, 1],
[92, 95, 41, 1],
[44, 36, 12, 2],
[38, 36, 8, 2],
[33, 23, 6, 2],
]
dataset =KemalarDataset(data_path)
dataloader = DataLoader(dataset, batch_size=8, shuffle=True)
input_size = 3 # Uzunlik, balandlik, og'irlik
hidden_size = 16
output_size = 3
model = KemalarModel(input_size, hidden_size, output_size)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
train(model, dataloader, criterion, optimizer, num_epochs=1000)
with torch.no_grad():
test_data = torch.tensor([[210,170,395]], dtype=torch.float32)
predicted_class = torch.argmax(model(test_data))
print(f'Bashoratli sinf: {predicted_class.item()}')
Sizning kodingizni ko'rib, siz ma'lumotlarni sinovdan o'tkazish uchun ikkita sinf tuzib olamiz.MashinaSet sinfi, datani o'z ichiga oladi va PyTorch Dataset protokoliga muvofiq bo'lgan metodlarni implement qiladi. Bu sinfning maqsadi, datani tugunlarga ajratib qo'yish va u haqida ma'lumotlarni berish.Mashinalar sinfi, bir necha liniyali qatlamli (fully connected) neyron tarmoqini (network) ifodalaydi. Bu tarmoqda ReLU aktivatsiya funktsiyasi ham ishlatilgan.Sizning train funktsiyangiz esa modelni o'qitish jarayonini (training loop) ifodalaydi. Uning orqali, har bir epoch uchun ma'lumotlarni o'qitib, modelni yangilaydi.
Endi, torch.no_grad() blokida test qilishni amalga oshirgan bo'lib, berilgan test ma'lumotini modelga sig'magan holda bajarishni ko'rish uchun.
|
