Amaliy ish 6 Bajardi: Obidov Xojiakbar

MUHAMMAD AL-XORAZMIY NOMIDAGI

TOSHKENT AXBOROT TEXNOLOGIYALARI UNIVERSITETI
KOMPYUTER INJINIRINGGI 222-21 GURUH TALABASI



FAN: Robotexnikada sun’iy intellekt
Amaliy ish - 6
Bajardi: Obidov Xojiakbar
Tekshirdi: Xasanov Umidjon
Toshkent 2023

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 = [
[220, 130, 290, 0],
[215, 155, 340, 0],
[222, 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 oldingiz. Birinchisi KemalarDataset va ikkinchisi KemalarModel.

KemalarDataset 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.

KemalarModel 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.