Guruh talabasi omonov islomjon 14-Amaliy mashg’ulot

640-20 GURUH TALABASI
OMONOV ISLOMJON


14-Amaliy mashg’ulot:

Nazorat savollari.

1. 
   PyTorch yordamida oddiy neyron tarmog'ini yaratish qanday?
   
2. 
   Chuqurlashtirib o’qitish uchun qanday ommalashgan freymwork lar mavjud?
   
3. 
   Bugungi kunda chuqurlashtirib o'qitish qanday muammolarni hal qilmoqda?
   
4. 
   Amaliy ish № ning asosiy vazifasini tushuntiring?
   

JAVOBLAR
1) PyTorch yordamida kichik neyron tarmog’i yaratish

PyTorch yordamida oddiy neyron tarmog'ini yaratishni boshlashimiz mumkin. Ushbu misolda biz 32 atribut (ustun) va 6000 naqsh (satr) bilan tasniflash ssenariyini simulyatsiya qiladigan ma'lumotlar to'plamini yaratamiz. Ma'lumotlar to'plami PyTorch-dagi randn funktsiyasi yordamida qayta ishlanadi.

3) Ishni bajarish:

Ushbu kodni Githubdan topishingiz mumkin.
#kerakli kutubxonalarni import qilish
import torch as tch
import torch.nn as nn
import numpy as np
from sklearn.metrics import confusion_matrix


#randn yordamida 500 natijani yaratish | tegni o’zlashtiramiz 0
X1 = tch.randn(3000, 32)
# Randn bilan X1 dan 500 ta biroz farqli natijalarni yaratish | tegni o’zlashtiramiz 0
X2 = tch.randn(3000, 32) + 0.5
#X1 va X2 kombinatsiyalash
X = tch.cat([X1, X2], dim=0)


# 50% 0 va 50% 1 ni birlashtirib 1000 Y hosil qiling
Y1 = tch.zeros(3000, 1)
Y2 = tch.ones(3000, 1)
Y = tch.cat([Y1, Y2], dim=0)


# o’qitish uchun ma’lumot indekslari va tasdiqlash uchun bo’linishlarni yaratish:
batch_size = 16
validation_split = 0.2 # 20%
random_seed= 2019


#indekslarni aralashtirish
dataset_size = X.shape[0]
indices = list(range(dataset_size))
split = int(np.floor(validation_split * dataset_size))
np.random.seed(random_seed)
np.random.shuffle(indices)


#o’qitish va tasdiqlash uchun indekslarni yaratish
train_indices, val_indices = indices[split:], indices[:split]
# o’qitish va tasdiqlash uchun ma’lumotlar to’plamini yaratish
X_train, x_test = X[train_indices], X[val_indices]
Y_train, y_test = Y[train_indices], Y[val_indices]


# Har bir ma'lumotlar to'plamining shaklini ko'rsatish
print("X_train.shape:",X_train.shape)
print("x_test.shape:",x_test.shape)
print("Y_train.shape:",Y_train.shape)
print("y_test.shape:",y_test.shape)


# 2 ta yashirin qatlam va 1 ta chiqish qatlami bilan neyron tarmoq yarating
# Yashirin qatlamlarda 64 va 256 neyron mavjud
# Chiqish qatlamlarida 1 neyron mavjud


class NeuralNetwork(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(32, 64)
self.relu1 = nn.ReLU()
self.fc2 = nn.Linear(64, 256)
self.relu2 = nn.ReLU()
self.out = nn.Linear(256, 1)
self.final = nn.Sigmoid()

def forward(self, x):
op = self.fc1(x)
op = self.relu1(op)
op = self.fc2(op)
op = self.relu2(op)
op = self.out(op)
y = self.final(op)
return y

model = NeuralNetwork()
loss_function = nn.BCELoss() # Ikkilik o'zaro entropiyaning yo'qolishi
optimizer = tch.optim.Adam(model.parameters(),lr= 0.001)


num_epochs = 10
batch_size=16


for epoch in range(num_epochs):
train_loss= 0.0


# Namunaviy o'qitishni boshlash
model.train()

for i in range(0,X_train.shape[0],batch_size):


# X va Y dan o'quv to'plamini chiqarib olish
input_data = X_train[i:min(X_train.shape[0],i+batch_size)]
labels = Y_train[i:min(X_train.shape[0],i+batch_size)]

# Teskari tarqalishni qo'llashdan oldin gradiyentlarni 0 ga o'rnatish
optimizer.zero_grad()

# Ma'lumotlarni uzatish
output_data = model(input_data)

#Yo’qotishlarni hisoblash
loss = loss_function(output_data, labels)

#Hatoliklarni teskari tarqatish algoritmini qo’llash
loss.backward()

#Og’irliklarni yangilash
optimizer.step()
train_loss += loss.item() * batch_size
print("Epoch: {} - Loss:{:.4f}".format(epoch+1,train_loss/X_train.shape[0] ))


#Prognozlash
y_test_pred = model(x_test)
a =np.where(y_test_pred>0.5,1,0)
confusion_matrix(y_test,a)
2) Chuqurlashtirib o’qitish uchun qanday ommalashgan freymwork lar mavjud?
Ushbu chuqurlashtirib o’qitish tizimlari yuqorida tavsiflangan mantiqiy bloklarni qurish uchun ishlatilishi, qayta ishlatilishi mumkin bo'lgan kod bloklarini hamda chuqurlashtirib o’qitish modelini yaratish uchun bir nechta qulay qo'shimcha modullarni taqdim etadi.

Barcha chuqurlashtirib o’qitishga mo’ljallangan freymworklarni quyi darajali va yuqori darajali turlarga ajratish mumkin. Bunday atama ushbu sohada qabul qilinmagan bo’lsada, freywork atamasini yaxshiroq tushunish uchun ulardan foydalanishimiz mumkin. Quyi darajali freymworklar abstraktlash uchun nisbatan asos bo’lgan funksionalni va shu bilan birga, kastomlashtirish va transformatsiya uchun ko’plab imkoniyatlarni taklif etadi. Yuqori darajali freymworklar nisbatan rivojlangan abstraktlash orqali ishimizni ancha osonlashtiradi, biroq o’zgarishlar kiritishimizda cheklovlar qo’yadi. Quyida chuqurlashtirib o’qitishda ommalasjgan freymworklar keltirilgan.