Technologieaustausch

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. nn.Modul

Torch.nn ist ein Modul, das speziell für Deep Learning entwickelt wurde. Die Kerndatenstruktur von Torch.nn ist das Modul, ein abstraktes Konzept, das entweder eine bestimmte Schicht in einem neuronalen Netzwerk oder ein neuronales Netzwerk mit vielen Schichten darstellen kann. In der Praxis besteht der häufigste Ansatz darin, nn.Module zu erben und Ihr eigenes Netzwerk/Ihre eigene Schicht zu schreiben. Schauen wir uns zunächst an, wie Sie mit nn.Module Ihre eigene vollständig verbundene Schicht implementieren.Y = AX + B.

import torch as t
import torch.nn as nn

class network(nn.Module):
    def __init__(self, input, output):
        super().__init__()
        # 定义权重矩阵a，它是一个可训练的参数，形状为(input, output)
        self.a = nn.Parameter(t.randn(input, output))
        # 定义偏置向量b，它也是一个可训练的参数，形状为(output,)
        # 注意：偏置向量的长度应与输出特征的维度相匹配
        self.b = nn.Parameter(t.randn(output))

    def forward(self, x):
        """
        定义前向传播过程

        参数:
            x (torch.Tensor): 输入数据，形状应为(batch_size, input)

        返回:
            torch.Tensor: 输出数据，形状为(batch_size, output)
        """
        # 首先，使用权重矩阵a对输入x进行线性变换
        # [email protected]执行矩阵乘法，x的每一行与a相乘，结果形状为(batch_size, output)
        x = x @ self.a
        # 然后，将偏置向量b扩展（通过broadcasting）到与x相同的形状，并加到x上
        # self.b.expand_as(x)将b的形状从(output,)扩展到(batch_size, output)
        # x + self.b.expand_as(x)将偏置加到每个样本的输出上
        x = x + self.b.expand_as(x)
        # 返回变换后的输出
        return x


a = network(4, 3)
# 创建输入数据，形状为(6, 4)，表示有6个样本，每个样本有4个特征
input = t.rand(6, 4)
# 通过网络前向传播得到输出
output = a(input)
# 打印输出，形状应为(6, 3)，表示有6个样本，每个样本的输出特征维度为3
print(output)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

• Das benutzerdefinierte Layer-Netzwerk muss nn.Module erben, und der Konstruktor von nn.Module muss in seinem Konstruktor aufgerufen werden, dh super ().drin() oder nn.Module.drin(selbst), die erste Verwendung wird empfohlen;
• Im Konstruktor __init__ müssen Sie die lernbaren Parameter selbst definieren und in Parameter kapseln. In diesem Beispiel kapseln wir beispielsweise w und b in Parameter. Parameter ist ein spezieller Tensor, der jedoch standardmäßig Ableitungen erfordert (requires_grad
  = Wahr）
• Die Vorwärtsfunktion implementiert den Vorwärtsausbreitungsprozess und ihre Eingabe kann ein oder mehrere Tensoren sein.
• Es ist nicht erforderlich, eine Backpropagation-Funktion zu schreiben. Das Modul kann Autograd verwenden, um die Backpropagation automatisch zu implementieren. Dies ist viel einfacher als die Funktion.
• Lernbare Parameter im Modul können einen Iterator über „named_parameters()“ oder „parameters()“ zurückgeben. Ersteres fügt jedem Parameter einen Namen hinzu, um ihn besser identifizierbar zu machen.

2. Häufig verwendete neuronale Netzwerkschichten

2.1 Bildbezogene Ebene

Zu den bildbezogenen Schichten gehören hauptsächlich Faltungsschichten (Conv), Pooling-Schichten (Pool) usw. Bei der tatsächlichen Verwendung können diese Schichten in eindimensionale (1D), zweidimensionale (2D) und dreidimensionale (3D) unterteilt werden. Die Pooling-Methode ist auch in durchschnittliches Pooling (AvgPool), maximales Pooling (MaxPool), adaptives Pooling (AdaptiveAvgPool) usw. unterteilt. Zusätzlich zur häufig verwendeten Vorwärtsfaltung verfügt die Faltungsschicht auch über eine umgekehrte Faltung (TransposeConv) usw. Nachfolgend wird ein Beispiel gegeben.

• Merkmalsextraktion
• Behalten Sie die Datenraumstruktur bei
• Einführung einer nichtlinearen Transformation Nach der Faltungsoperation wird normalerweise eine Aktivierungsfunktion (wie ReLU, Sigmoid oder Tanh) angewendet, um eine nichtlineare Transformation einzuführen. Diese Aktivierungsfunktionen können die Ausdruckskraft von CNN erhöhen und es ihm ermöglichen, komplexere nichtlineare Beziehungen zu lernen.
• Verbessern Sie die Recheneffizienz. Durch die kombinierte Verwendung von Faltungsoperationen und Pooling-Schichten kann die Faltungsschicht die räumliche Dimension der Feature-Map reduzieren, wodurch der Rechenaufwand reduziert und die Recheneffizienz des Modells verbessert wird. Gleichzeitig kann die Pooling-Schicht auch die Übersetzungsinvarianz von Merkmalen verbessern und das Modell robuster gegenüber kleinen Änderungen in den Eingabedaten machen.

Faltungsschicht

Beim Deep Learning ist die Faltungsschicht (Conv) die wichtigste Netzwerkstruktur im Zusammenhang mit der Bildverarbeitung. Das Wesentliche eines Faltungs-Neuronalen Netzwerks ist die Überlagerung von Faltungsschichten, Pooling-Schichten, Aktivierungsschichten und anderen Schichten. Daher ist es äußerst wichtig, das Funktionsprinzip der Faltungsschicht zu verstehen Faltungsoperation.

# 导入PyTorch库  
import torch  
import torch.nn as nn  
  
# 从torchvision.transforms导入ToTensor和ToPILImage，用于图像张量和PIL图像之间的转换  
from torchvision.transforms import ToTensor, ToPILImage  
  
# 从PIL（Python Imaging Library，Pillow是其一个分支）导入Image模块，用于处理图像文件  
from PIL import Image  
  
# 使用PIL的Image.open函数打开指定路径的图片文件，并通过.convert("L")将其转换为灰度图像（单通道）  
img = Image.open("H:\PYTHON_Proj\handlearnpytorch\OIP-C.jpg").convert("L")  
  
# 实例化ToTensor转换对象，用于将PIL图像转换为PyTorch张量  
to_tensor = ToTensor()  
  
# 实例化ToPILImage转换对象，用于将PyTorch张量转换回PIL图像  
to_PIL = ToPILImage()  
  
# 使用to_tensor将PIL图像转换为PyTorch张量，并通过.unsqueeze(0)在批次大小维度上增加一个维度，使其形状变为(1, 1, H, W)  
img = to_tensor(img).unsqueeze(0)  
  
# 创建一个3x3的卷积核（滤波器），初始时所有元素都被设置为-1/9，然后将中心元素设置为1  
kernel = torch.ones(3, 3) / (-9.0)  
kernel[1][1] = 1  
  
# 创建一个Conv2d层，指定输入通道数为1（因为是灰度图像），输出通道数也为1，卷积核大小为3x3，步长为1，填充为1（保持输出尺寸与输入相同），且不使用偏置项  
conv = nn.Conv2d(1, 1, 3, 1, 1, bias=False)  
  
# 将之前定义的卷积核赋值给Conv2d层的权重，注意要调整形状以匹配Conv2d层的期望（out_channels, in_channels, kernel_size[0], kernel_size[1]）  
conv.weight.data = kernel.reshape(1, 1, 3, 3)  
  
# 对图像应用卷积操作，此时img是一个四维张量，Conv2d层会处理它并返回一个新的四维张量  
img = conv(img)  
  
# 使用to_PIL将卷积后的PyTorch张量转换回PIL图像，并通过.squeeze(0)移除批次大小维度  
img = to_PIL(img.squeeze(0))  
  
# 使用PIL的.show()方法显示图像  
img.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

Pooling-Schicht

Die Pooling-Schicht kann als spezielle Faltungsschicht betrachtet werden, die hauptsächlich zum Downsampling verwendet wird. Durch Hinzufügen einer Pooling-Schicht kann die Anzahl der Parameter reduziert und gleichzeitig die Hauptmerkmale beibehalten werden, wodurch eine Überanpassung bis zu einem gewissen Grad verhindert wird. Die Pooling-Schicht hat keine lernbaren Parameter und ihr Gewicht ist fest. In der Torch.nn-Toolbox sind verschiedene Pooling-Schichten enthalten, darunter Max Pooling (MaxPool) und Average Pooling (AvgPool). Die Pooling-Schicht spielt eine sehr wichtige Rolle. Seine Hauptanwendungen lassen sich wie folgt zusammenfassen:

• Dimensionsreduzierung (Verringerung des Rechenaufwands): Die Pooling-Schicht reduziert den Rechenaufwand und die Anzahl der Parameter nachfolgender Schichten, indem sie die räumliche Größe der Daten (d. h. Höhe und Breite) reduziert. Dies ist sehr nützlich, um eine Überanpassung zu verhindern und die Berechnungen zu beschleunigen.
• Merkmalsinvarianz: Die Pooling-Schicht kann es dem Modell ermöglichen, eine robustere Merkmalsdarstellung zu erlernen, die gegenüber kleinen Änderungen in den Eingabedaten (z. B. Translation, Rotation usw.) invariant ist. Dies liegt daran, dass Pooling-Vorgänge (z. B. maximales Pooling, durchschnittliches Pooling usw.) repräsentative Merkmale innerhalb des Gebiets auswählen, anstatt sich auf bestimmte Standortinformationen zu verlassen.
• Hauptmerkmale extrahieren: Durch den Pooling-Vorgang können die wichtigsten Merkmale im Bild extrahiert werden, während einige unwichtige Details ignoriert werden. Dies ist für nachfolgende Faltungsschichten hilfreich, um Merkmale auf hoher Ebene weiter zu extrahieren.
• Erweiterung des Empfangsfelds: Mit zunehmender Anzahl der Netzwerkschichten kann die Pooling-Schicht den Eingabebereich (dh das Empfangsfeld) für jedes Neuron in nachfolgenden Schichten schrittweise erweitern. Dies hilft dem Netzwerk, mehr globale Funktionsinformationen zu erfahren.
• Überanpassung reduzieren: Da die Pooling-Schicht die Anzahl der Parameter durch Reduzierung der räumlichen Dimension der Daten reduziert, kann dies die Komplexität des Modells bis zu einem gewissen Grad reduzieren und so dazu beitragen, eine Überanpassung zu verhindern.

Zu den gängigen Pooling-Vorgängen gehören:

• Max Pooling: Wählen Sie den Maximalwert innerhalb des Pooling-Fensters als Ausgabe aus. Dieser Ansatz trägt dazu bei, die Kanten- und Texturinformationen des Bildes zu bewahren.
• Durchschnittliches Pooling: Berechnen Sie den Durchschnitt aller Werte innerhalb des Pooling-Fensters als Ausgabe. Dieser Ansatz trägt dazu bei, die Hintergrundinformationen des Bildes zu bewahren.
• Stochastisches Pooling: Basierend auf dem Wert jedes Elements im Pooling-Fenster werden Elemente nach Wahrscheinlichkeit zufällig als Ausgabe ausgewählt. Diese Methode kombiniert die Vorteile von Max-Pooling und Average-Pooling, weist jedoch eine höhere Rechenkomplexität auf.

Kurz gesagt, die Pooling-Schicht ist ein unverzichtbarer Bestandteil des Faltungs-Neuronalen Netzwerks. Sie stellt die Lernfähigkeit und Leistung des gesamten Netzwerks bereit, indem sie die räumliche Dimension der Daten reduziert, Hauptmerkmale extrahiert, das Empfangsfeld erweitert und eine Überanpassung verhindert Unterstützung.

# 导入PyTorch库  
import torch  
  
# 导入PyTorch的神经网络模块，用于构建和训练神经网络  
import torch.nn as nn  
  
# 从torchvision.transforms模块导入ToTensor和ToPILImage，这两个转换工具用于图像数据的预处理和后处理  
from torchvision.transforms import ToTensor, ToPILImage  
  
# 从PIL库导入Image模块，用于图像的打开、显示等操作  
from PIL import Image  
  
# 创建一个ToTensor的实例，用于将PIL图像或numpy.ndarray转换为FloatTensor，并归一化到[0.0, 1.0]  
to_tensor = ToTensor()  
  
# 创建一个ToPILImage的实例，用于将Tensor或ndarray转换为PIL图像  
to_pil = ToPILImage()  
  
# 使用PIL的Image.open方法打开指定路径的图像文件，并将其转换为灰度图像（'L'模式）  
img = Image.open("H:\PYTHON_Proj\handlearnpytorch\OIP-C.jpg").convert('L')  
  
# 使用PIL的show方法显示图像  
img.show()  
  
# 使用ToTensor转换将PIL图像转换为Tensor，并增加一个维度使其成为[1, H, W]形状，即增加一个批次维度  
img = to_tensor(img).unsqueeze(0)  
  
# 创建一个平均池化层实例，使用2x2的窗口大小和步长为2进行池化  
pool = nn.AvgPool2d(2, 2)  
  
# 对图像Tensor应用平均池化层，然后移除批次维度（squeeze(0)），使其变回[H', W']形状  
img = pool(img).squeeze(0)  
  
# 将Tensor转换回PIL图像以便显示  
img = to_pil(img)  
  
# 再次使用PIL的show方法显示经过池化处理的图像  
img.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

andere Schichten

Neben Faltungsschichten und Pooling-Schichten werden beim Deep Learning häufig auch die folgenden Schichten verwendet:

• Linear: vollständig verbundene Schicht;
• BatchNorm: Batch-Normalisierungsebene, unterteilt in 1D, 2D und 3D. Zusätzlich zur Standard-BatchNorm gibt es auch die InstanceNorm-Ebene, die häufig bei der Stilmigration verwendet wird.
• Dropout: Die Dropout-Ebene wird zur Verhinderung einer Überanpassung verwendet und ist ebenfalls in 1D, 2D und 3D unterteilt.

3. Initialisierungsstrategie

Die Initialisierung von Parametern ist beim Deep Learning sehr wichtig. Eine gute Initialisierung kann dazu führen, dass das Modell schneller konvergiert und ein höheres Niveau erreicht, während eine schlechte Initialisierung dazu führen kann, dass das Modell schnell zusammenbricht. Die Modulparameter von nn.Module in PyTorch verwenden eine vernünftigere Initialisierungsstrategie, sodass wir sie im Allgemeinen nicht berücksichtigen müssen. Natürlich können wir auch eine benutzerdefinierte Initialisierung verwenden, um die Standardinitialisierung des Systems zu ersetzen. Wenn wir Parameter verwenden, ist die benutzerdefinierte Initialisierung besonders wichtig, da Torch.Tensor () eine Zufallszahl im Speicher zurückgibt, die wahrscheinlich einen Maximalwert hat, was zu einem Überlauf oder zum Verschwinden des Gradienten führt . Das nn.init-Modul in PyTorch ist ein speziell für die Initialisierung entwickeltes Modul, das häufig verwendete Initialisierungsstrategien implementiert. Wenn eine bestimmte Initialisierungsstrategie nn.init nicht bereitstellt, können Benutzer diese auch direkt selbst initialisieren.

import torch  
from torch.nn import init  
from torch import nn  
  
# 创建一个线性层，其权重和偏置会被随机初始化（与torch.manual_seed无关，因为这是在调用torch.manual_seed之前发生的）  
linear = nn.Linear(3, 4)  
  
# 打印层创建时默认初始化的权重  
print("默认初始化的权重:")  
print(linear.weight)  
  
# 设置随机数生成的种子，以确保接下来的随机数生成是可重复的  
torch.manual_seed(2021)  
  
# 使用Xavier正态分布重新初始化权重  
# 这个初始化是受torch.manual_seed(2021)影响的  
init.xavier_normal_(linear.weight)  
  
# 打印重新初始化后的权重  
print("Xavier正态分布初始化后的权重:")  
print(linear.weight)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21