Полносвязный слой PyTorch в Python

Линейный слой также называют полносвязным слоем. Этот слой помогает преобразовать размерность вывода предыдущего слоя.

В следующем коде мы импортируем модуль torch, из которого мы сможем преобразовать размерность вывода предыдущего слоя:

• inp = torch.randn(15, 9) используется в качестве входного значения.
• вес = torch.randn(7,9) используется для генерации веса.
• torch.mm(inp,weght.t()) используется как умножение матриц.
• lay=nn.Linear(in_features=9,out_features=7,bias=False) используется для создания сети прямой связи.
• lay.weght=nn.Parameter(weght) используется для определения веса.

import torch
import torch.nn as nn
 
inp = torch.randn(15, 9)
weght = torch.randn(7,9)
 
torch.mm(inp,weght.t())
lay=nn.Linear(in_features=9,out_features=7,bias=False)
lay.weght=nn.Parameter(weght)
lay.weght
lay(inp)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что на экране отображается полносвязный слой PyTorch.

• Инициализация полносвязного слоя
• Входные данные
• Полносвязный слой CNN
• Полносвязный слой 2d
• Слой со 128 нейронами
• Отсев полносвязного слоя
• Relu

Инициализация полносвязного слоя

Линейный слой используется на последнем этапе нейронной сети. Линейный слой также называют полносвязным слоем.

Линейный слой инициализируется и помогает преобразовать размерность выходных данных предыдущего слоя.

Для этого модель может легко объяснить взаимосвязь между значениями данных.

В следующем коде мы импортируем модуль факела, из которого мы сможем инициализировать полносвязный слой:

• nn.Conv2d() используется для применения 2d-свертки к входным данным.
• nn.Dropout2d() используется для обеспечения независимости между картами объектов.
• self.fc = nn.Linear(9218, 130) используется как первый полносвязный слой.
• self.fc1 = nn.Linear(130, 12) используется как второй полносвязный слой.
• print(nnmodel) используется для печати модели.

import torch as tor
import torch.nn as nn
import torch.nn.functional as fun
class model(nn.Module):
    def __init__(self):
      super(model, self).__init__()

      self.conv = nn.Conv2d(3, 34, 5, 3)
      self.conv1 = nn.Conv2d(34, 66, 5, 3)

      self.dropout = nn.Dropout2d(0.27)
      self.dropout1 = nn.Dropout2d(0.7)
      self.fc = nn.Linear(9218, 130)
      # Second fully connected layer that outputs our 10 labels
      self.fc1 = nn.Linear(130, 12)

nnmodel = model()
print(nnmodel)

Выход:

В следующем выводе мы видим, что полностью подключенный уровень успешно инициализируется.

Входные данные

«Полносвязный слой» умножает входные данные на матрицу весов и добавляет бай по весу. Входные данные нейронной сети представляют собой тип Batch_size*channel_number*Height*Weight.

В следующем коде мы импортируем модуль torch, из которого мы сможем получить входной размер:

• nn.Conv2d() ожидает, что входные данные будут иметь форму pack_size, input_channels, input_height, input_width.
• nn.Linear() используется в качестве нейронной сети прямого распространения.
• print(fc) используется для печати полностью связанной нейронной сети.

import torch
import torch.nn as nn
import torch.nn.functional as fun
class fcmodel(nn.Module):
    def __init__(self):
        super(fcmodel, self).__init__()
        self.conv = nn.Conv2d(5, 8, 7)
        self.pool  = nn.MaxPool2d(2,2)
        self.conv1 = nn.Conv2d(8, 18, 7)
        self.fc  = nn.Linear(16*5*5, 120)
        self.fc1   = nn.Linear(140, 86)
        self.fc2  = nn.Linear(86, 12)

    def forward(self, y):
        y = self.pool(fun.relu(self.conv(y)))
        y = self.pool(fun.relu(self.conv1(y)))
        y = y.view(-1, 16*5*5)
        y = fun.relu(self.fc(y))
        y = fun.relu(self.fc1(y))
        y = self.fc2(y)
        return y

fc = fcmodel()
print(fc)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что входной размер полностью связанного слоя печатается на экране.

Полносвязный слой CNN

CNN — самый популярный метод решения задач компьютерного зрения, например, обнаружения объектов. CNN ищет закономерности на изображении.

Линейный слой используется на последнем этапе сверточной нейронной сети. Линейный слой также называют полносвязным слоем.

В следующем коде мы импортируем модуль torch, из которого мы сможем создать полносвязный слой cnn:

• def вперед(self, y) здесь y представляет наши данные.
• y = self.conv(y) используется для передачи данных через conv.
• y = func.relu(y) используется выпрямленная линейная функция активации по y.
• y = func.max_pool2d(y, 2) используется для запуска максимального пула по y.
• y = self.dropout(y) используется для передачи данных через исключение.
• y = torch.flatten(y, 1) используется как сглаживание y с start_dim 1.
• y = self.fc(y) используется для передачи данных через fc.
• print(cnn) используется для печати слоя cnn.

import torch
import torch.nn as nn
import torch.nn.functional as func
class cnnfc(nn.Module):
    def __init__(self):
      super(cnnfc, self).__init__()
      self.conv = nn.Conv2d(3, 34, 5, 3)
      self.conv1 = nn.Conv2d(34, 66, 5, 3)
      self.dropout = nn.Dropout2d(0.30)
      self.dropout1 = nn.Dropout2d(0.10)
      self.fc = nn.Linear(9218, 130)
      self.fc1 = nn.Linear(130, 15)


    def forward(self, y):

      y = self.conv(y)
      y = func.relu(y)

      y = self.conv1(y)
      y = func.relu(y)

      y = func.max_pool2d(y, 2)

      y = self.dropout(y)

      y = torch.flatten(y, 1)

      y = self.fc(y)
      y = func.relu(y)
      y = self.dropout1(y)
      y = self.fc1(y)
 

cnn = cnnfc()
print(cnn)

Выход:

В следующем выводе мы видим, что полностью подключенный слой PyTorch cnn печатается на экране.

Полносвязный слой 2d

2-мерный полносвязный слой помогает изменить размерность вывода предыдущего слоя. Модель может легко определить взаимосвязь между значением данных.

В следующем коде мы импортируем модуль torch, из которого мы сможем инициализировать 2D полносвязный слой:

• nn.Conv2d() используется для выполнения свертки 2D-данных.
• nn.Linear() используется для создания нейронной сети прямого распространения.
• modl = model() используется для запуска модели.
• print(modl) используется для печати модели.

import torch
import torch.nn as nn
import torchvision
import torch.nn.functional as func
import torchvision.transforms as transforms
class model(nn.Module):
    def __init__(self):
        super(model, self).__init__()
        self.conv = nn.Conv2d(in_channels=3, out_channels=34, kernel_size= 7,stride = 3)
        self.conv1 = nn.Conv2d(34, 66, 7, 2)
        self.fc = nn.Linear(66*22*22, 49)
 
    def forward(self, y):
        y = func.relu(self.conv(y))
        y = func.relu(self.conv1(y))
        y = func.max_pool2d(y, 1)
        y = torch.flatten(y, 1)
        y = self.fc(y)
        out = func.log_softmax(y, dim=1)
        return out
# initiating the model
modl = model()
print(modl)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что полносвязный слой PyTorch 2d печатается на экране.

Слой со 128 нейронами

Полностью подключенный уровень определяется как уровень, на котором все входы одного уровня подключены к каждому блоку активации следующего уровня.

В следующем коде мы импортируем модуль torch, из которого сможем создать полносвязный слой со 128 нейронами.

• self.conv = nn.Conv2d(1, 35,(7, 7), дополнение = 0) используется в качестве свертки с 35 картами функций размером 7 x 7 с активацией ReLU.
• self.fc = nn.Linear(20 * 7**4, 128) используется как полносвязный слой со 128 нейронами.
• z = self.conv(y) используется для передачи данных через conv.
• z = func.relu(z) используется как выпрямленно-линейная функция активации по z.
• z = func.max_pool2d(z, 2) выполнить максимальное объединение по z.
• z = self.dropout(z) данные могут передаваться через отсев.
• z = torch.flatten(z, 1) сгладить z с start_dim = 1.
• cnn = cnnwithneurons() используется для запуска модели.

import torch 
import torch.nn.functional as func
from torch import nn


class cnnwithneurons(nn.Module):
    def __init__(self):
        super(cnnwithneurons, self).__init__()
        self.conv = nn.Conv2d(1, 35,(7, 7), padding=0)
        self.conv1 = nn.Conv2d(35, 20,(5, 5), padding=0)
        self.fc = nn.Linear(20 * 7**4, 128)
        self.fc1 = nn.Linear(128, 52)
        self.fc2 = nn.Linear(52, 12)

    def forward(self, z):

      z = self.conv(y)

      z = func.relu(z)

      z = self.conv1(z)
      z = func.relu(z)


      z = func.max_pool2d(z, 2)

      z = self.dropout(z)

      z = torch.flatten(z, 1)

      z = self.fc(z)
      z = func.relu(z)
      z = self.dropout1(z)
      z = self.fc1(z)
cnn = cnnwithneurons()
print(cnn)

Выход:

В следующем выводе мы видим, что на экране напечатан полносвязный слой со 128 нейронами.

Отсев полносвязного слоя

Техника отсева используется для удаления нейронной сети для имитации одновременного обучения большого количества архитектур.

В следующем коде мы импортируем модуль torch, из которого мы сможем получить полностью связанный слой с выпадением.

• self.conv = nn.Conv2d(5, 34, 5) ожидает ввода в форме pack_size, input_channels, input_height, input_width.
• nn.Linear() используется для создания нейронной сети прямого распространения.
• self.dropout = nn.Dropout(0,27) используется для определения доли выпадающих нейронов.
• model =dropoutmodel() используется для запуска модели.
• print(model) используется для печати модели.

import torch
from torch import nn
import torch.nn.functional as func
from torch import nn
class dropoutmodel(nn.Module):
  def __init__(self, input_shape=(3,32,32)):
    super(dropoutmodel, self).__init__()
    
    self.conv = nn.Conv2d(5, 34, 5)
    self.conv1 = nn.Conv2d(34, 66, 5)
    self.conv2 = nn.Conv2d(66, 130, 5)
    
    self.pool = nn.MaxPool2d(2,2)

    
    self.fc = nn.Linear(20 * 9**4, 218)
    self.fc1 = nn.Linear(218, 10)

    # Define proportion or neurons to dropout
    self.dropout = nn.Dropout(0.27)
      
  def forward(self, z):
    z = self._forward_features(z)
    z = z.view(z.size(0), -1)
    z = self.dropout(z)
    z = func.relu(self.fc1(z))
    # Apply dropout
    z = self.dropout(z)
    z = self.fc2(z)
    return z
model =dropoutmodel()
print(model)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором мы видим, что полносвязный отсев PyTorch печатается на экране.

Relu

Прежде чем двигаться дальше, нам нужно иметь некоторые знания о relu. ReLu означает выпрямленную линейную функцию активации. Она также известна как нелинейная функция активации, которая используется в многолинейной нейронной сети.

В следующем коде мы импортируем модуль факела, из которого мы сможем создать полносвязный слой relu.

• class fcrmodel(nn.Module) используется для определения класса сети.
• super().__init__() используется для вызова конструктора из суперкласса.
• nn.Linear() используется для создания нейронной сети прямого распространения.
• func.relu(self.fc1(z)) используется для определения прямого прохода.
• rmodl = fcrmodel() используется для запуска модели.
• print(rmodl) используется для печати архитектуры модели.

import torch
import torch.nn.functional as func
from torch import nn


class fcrmodel(nn.Module):
    def __init__(self):

        super().__init__()
        

        self.fc = nn.Linear(18, 14)
        self.fc1 = nn.Linear(14, 12)
        self.fc2 = nn.Linear(12, 3)
        
    def forward(self, z):

        z = func.relu(self.fc1(z))
        z = func.relu(self.fc2(z))
        z = torch.sigmoid(self.fc3(z))
        return z

rmodl = fcrmodel()

print(rmodl)

Выход:

В следующем выводе мы видим, что активация relu полностью подключенного слоя PyTorch печатается на экране.