まとめ2 - 深層学習ネットワークの構築と学習

PyTorch 医用画像セグメンテーションオープンソースライブラリを共有する
実用的な観点から見ると、少しのメリットがあります。ビデオ:CNN は、PyTorch と TensorFlow を 0 から 1 まですぐに使い始めるのに役立ちます。 github ウェブページ:畳み込みニューラルネットワーク
よく使われる活性化関数（励起関数）の理解と概要

----------Pytorch の学習--------------

深層学習フレームワークと pytorch の書籍、紹介と実践:第 4 章 Neural Network Toolboxnn
「PyTorch の nn.Linear() の詳しい説明」、公式サイト「torch.nn.Linear」
1) 特定のパラメータを学習する、

class：torch.nn.Linear(in_features、 ) a> 2) リニア)dtype= なし、 デバイス= なし 、 bias=True、 out_featuresサイズ計算: in_features は、入力 2 次元テンソル、つまり入力 [batch_size, Output_size]< /span> 3) 完全に接続された層: の出力テンソルに変換されます。 [batch_size, out_features][batch_size, in_features] 入力テンソルと出力テンソルの形状の観点から見ると、これはは、もちろん、全結合層内のニューロンの数も表します。 out_features は出力 2 次元テンソルのサイズを指します。つまり、出力 2 次元テンソルの形状は )。 [batch_size, size]

全結合層 (FC) は、畳み込みニューラルネットワーク全体で「分類器」の役割を果たします。畳み込み層、プーリング層、活性化関数層などの演算が元のデータを隠れ層特徴空間にマッピングする場合、< a i= 3>全結合層は、学習した「分散特徴表現」をサンプルラベル空間にマッピングする役割を果たします。 実際の使用では、全結合層は畳み込み演算によって実装できます。フロント層は完全に結合された全結合層です。1x1 コンボリューションとしてコンボリューションカーネルに変換でき、フロント層は畳み込み層の全結合層であり、畳み込みカーネルが hxw注 1)。参考記事「CNN入門：全結合層（Fully Connected Layer）とは？」、「完全接続」接続されているレイヤーの役割は何ですか? 》

コンピュータービジョンでは、全結合層と畳み込み層の間に大きな違いはありません。畳み込み層は実際には空間的に部分的に接続され、チャネル上で完全に接続された構造です。したがって、空間上の部分的な接続を放棄し、コンボリューションカーネルを 1x1 に置き換えると、チャネル上でのみ完全に接続されます。このとき、畳み込み層＝全結合層となります。これが、imagenet 分類の最後の層がプーリング + fc である理由です。プール後の機能は 1x1xC になります。このとき、fc はチャネルを完全に接続し、機能をラベルにマッピングします。注意深い人は、多くの特徴融合畳み込みが 1x1 カーネルを使用していることに気づくでしょう。これは完全接続層の関数でもあります。
```
# 例子1
# in_features指的是输入的二维张量的大小，即输入的[batch_size, size]中的size。
input = torch.randn(128, 20) # input(batch_size, size) 
m = nn.Linear(20, 30)# Linear(in_features, out_features)等同于Linear(size, out_features)
output = m(input) # output二维张量输出形状为[batch_size，out_features]，
print(output.size())# torch.Size([128, 30])

#例子2
import torch as t
from torch import nn

# in_features由输入张量的形状决定，out_features则决定了输出张量的形状 
connected_layer = nn.Linear(in_features = 64*64*3, out_features = 1)

# 假定输入的图像形状为[64,64,3]
input = t.randn(1,64,64,3)

# 将四维张量转换为二维张量之后，才能作为全连接层的输入
input = input.view(1,64*64*3)
print(input.shape) # torch.Size([1, 12288])
output = connected_layer(input) # 调用全连接层
print(output.shape) # torch.Size([1, 1])

# 例子3
def __init__(self):
    super(LeNet, self).__init__()
    # Conv2d的第一个参数是输入的channel数量，
    # 第二个是输出的channel数量，第三个是kernel size
    self.conv1 = nn.Conv2d(3, 6, 5)
    self.conv2 = nn.Conv2d(6, 16, 5)
    # 由于上一层有16个channel输出，
    # 每个feature map大小为5*5，
    # 所以linear的输入样本大小是16*5*5
    self.fc1 = nn.Linear(16*5*5, 120)
    self.fc2 = nn.Linear(120, 84)
    # 最终有10类，所以最后一个Linear输出样本大小是10
    self.fc3 = nn.Linear(84, 10)
    self.pool = nn.MaxPool2d(2, 2)
```
《Conv2d関数数详解（Pytorch）》，官网《torch.nn.Conv2d》
学习具体的なパラメータは、推算プロセスを理解します。
定义：torch.nn.Conv2d(in_channels, out_channels、< /span> [)dtype=None 、 device=None、 padding_mode= 39;zeros'、 bias=True、 groups=1、 dilation=1、 padding=0stride=1、 kernel_size、
```
# With square kernels and equal stride
m = nn.Conv2d(16, 33, 3, stride=2) #nn.Conv2d(Cin, Cout, kernel_size, stride=1)
input = torch.randn(20, 16, 50, 100) # torch.Size([20, 16, 50, 100])
output = m(input) # torch.Size([20, 33, 24, 49])

# input和output对比，Conv2d只改变通道数和图像大小
```
形：
《pytorch avg_pool2d》、公式ウェブサイト《torch.nn.AvgPool2d》。この例を見て、平均プーリングの特定のパラメーターについて理解してください。
定義: 平均プーリング、サンプリング操作は、 kernel_size 、stride と padding 3 つのパラメータで十分です。 つまり、N と C は変更されず、画像サイズ H と W の変更のみが考慮されます。
torch.nn.AvgPool2d(kernel_size, stride=None、 padding=0、 ceil_mode=False、 count_include_pad=True、 divisor_override=None)
形状:

コード例:
```
# pool of square window of size=3, stride=2
m = nn.AvgPool2d(3, stride=2)
input = torch.randn(20, 16, 50, 32) # torch.Size([20, 16, 50, 32])
output = m(input) # torch.Size([20, 16, 24, 15])

# input和output之间，N和C不变，只关心图像大小变化H、W。
```
《torch.nn.MaxPool2d の詳しい説明》、公式ウェブサイト《torch.nn.MaxPool2d a>》。
機能:近傍の特徴点を最大化し、畳み込み層パラメータ誤差を削減します結果は平均値の偏差が得られ、より多くのテクスチャ情報が保持されます。。
定義: torch.nn.MaxPool2d( kernel_size , stride = None , padding = 0 , dilation = 1 , return_indices = False , ceil_mode = False ) コード例: 形状: - True に等しい場合、出力信号のサイズを計算する場合、デフォルトの丸め演算ではなく、up が使用されます。ceil_mode- True に等しい場合、最大出力値のシーケンス番号を返します。これはアップサンプリング操作に役立ちます。return_indices – ウィンドウ内の要素のストライドを制御するパラメータ dilation(int または tuple、オプション) です。各入力エッジには 0 のレイヤー数が追加されます。padding(int または tuple、オプション)- 最大プーリングウィンドウ移動のステップサイズ。デフォルト値は kernel_sizestride( intまたはタプル、オプション) - 最大プーリングウィンドウサイズkernel_size(int または tuple)
パラメータ:
```
# pool of square window of size=3, stride=2
m = nn.MaxPool2d(3, stride=2)
# pool of non-square window
m = nn.MaxPool2d((3, 2), stride=(2, 1))
input = torch.randn(20, 16, 50, 32)
output = m(input)


input.shape
# Out[33]: torch.Size([20, 16, 50, 32])
output.shape
# Out[34]: torch.Size([20, 16, 24, 31])
```
バッチ正規化。
機械学習では、モデルをトレーニングする前に、分布の一貫性を保つためにデータを正規化する必要があります。ディープニューラルネットワークトレーニングのプロセスでは、通常、1 つのトレーニングはすべてのデータではなくバッチになります。各バッチの分布は異なるため、内部共変量シフト問題が発生します。トレーニングプロセス中にデータ分布が変化し、ネットワークの次の層の学習が困難になります。

バッチ正規化は、データを平均 0、分散 1 の正規分布に戻します (正規化)。一方ではデータ分布の一貫性が保たれ、他方では、グラデーションの消失やグラデーションの爆発を回避します。バッチ正規化とは入力を同じ分布を満たすようにすることですが、同じ分布を満たすためには入力のどのような特徴を持たせる必要があるでしょうか?つまり、各画像内の同じチャネルのすべてのピクセル値の平均と分散は同じです。たとえば、2 つのピクチャ (両方とも 3 チャネル) があり、ここでは R チャネルについてのみ説明します。最初のピクチャの R チャネルの平均値が、最初のピクチャの R チャネルの平均値と同じであることを望みます。 2番目の写真、差異は同じです。

内部共変量シフトを減らすには、ニューラルネットワークの各層を正規化するだけで十分です。各層の出力データが 0 平均、1 に正規化されていると仮定します。分散は正規分布を満たします。分布。ただしこのとき問題があり、各層のデータ分布は標準正規分布となっており、入力データの特徴を全く学習することができません、せっかく学習した特徴分布が正規化されているため、各層を正規化するのは明らかに無理があります。 ただし、これを少し変更して正規化用のトレーニング可能なパラメータを追加すると、それが Batch Norm で実装されます。

この記事ではプロセス全体について説明します。「Pytorch: nn.BatchNorm2d() 関数」
それぞれについて説明します。 pytorch——nn.BatchNorm1d()》《
《pytorch の BatchNorm1d、BatchNorm2d、BatchNorm3d》《nn > BatchNorm1d》;

代码验证批处理的过程参考《【PyTorch】详解pytorch中nn模块的BatchNorm2d()函数》；
定义：
torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None)
```
>>> # With Learnable Parameters
>>> m = nn.BatchNorm2d(100)
>>> input = torch.randn(20, 100, 35, 45)
>>> output = m(input)
```
アドバンテージ：

① トレーニング速度が大幅に向上するだけでなく、収束プロセスも大幅に高速化されます。

② 分類効果も高めることができる 1 つの説明として、これは過剰適合を防ぐための Dropout に似た正規表現であるため、Dropout なしでも同等の結果を得ることができます。

③さらに、パラメータ調整プロセスは非常に簡単で、初期化要件はそれほど高くなく、大きな学習率を使用できます。
nn.dropout:
順伝播中に、ニューロンの活性化値が特定の確率 p で動作を停止するようにし、モデルをより一般化できるようにします。特定のローカル機能にあまり依存しないでください。ネットワークは過剰適合を防ぎます。
テストコードについては、こちらの記事を参照してください。「torch.nn.dropout と torch.nn.dropout2d の違い」、インターネット上実際の使用については、この記事を参照してください。「Dropout of pytorch」
定義:
torch.nn.Dropout( p =0.5、 inplace=False)
```
>>> m = nn.Dropout(p=0.2)
>>> input = torch.randn(20, 16)
>>> output = m(input)
```
アクティベーション関数:
1) 原理:アクティベーション関数は、人工ニューラルネットワークモデルが学習し、非常に複雑な非線形関数の役割を理解するために使用されます。とても重要な役割。それらは私たちのネットワークに非線形特性を導入します。ニューロンでは、入力は重み付けされて合計され、それらに関数が適用されます。この関数は活性化関数です。 活性化関数は、ニューラルネットワークモデルの非線形性を高めるために導入されました。 活性化関数のない各層は行列の乗算と同等です。いくつかのレイヤーを重ねたとしても、それは単なる行列の掛け算にすぎません。 ”
励起関数を使用しない場合 (実際には励起関数と同等の関数は f(x) = x です)、この場合、ノードの各層の入力は線形です。ニューラルネットワークの層が何層であっても、出力は入力の線形結合であることを確認するのは簡単で、これは隠れ層がないのと同じです。は最も原始的なパーセプトロン (パーセプトロン) であるため、ネットワークの近似能力は非常に限られています。右上記の理由により、励起関数として非線形関数を導入することにしました。ディープニューラルネットワークの表現能力はより強力になります (入力の線形結合ではなくなりましたが、ほぼすべての関数を近似できます)。
2) パラメーターの説明、公式 Web サイトを参照してください。「nn.ReLU」。
参考例: "nn.ReLU 関数について" .
3) トーチ .nn.ReLU: relu が呼び出されます線形整流関数 (修正線形単位)、tf.nn.relu( ) は 0 未満の入力値を 0 に増加するために使用され、入力0 より大きい値は変更されません。

4) torch.nn.sigmoid(): 値は 0 ～ 1 にマッピングされます。< a i=20>5) torch.nn.Tanh:実数値入力を [-1, 1] の範囲にマッピングします6) 要約区別については、 を参照してください。活性化関数の詳細な説明 (Sigmoid/Tanh/ReLU/Leaky ReLu など) >》。

活性化関数はニューラルネットワークに非線形要素を導入し、活性化関数ニューラルネットワークを通じてさまざまな曲線をフィッティングすることができます。活性化関数は主に、飽和活性化関数 (飽和ニューロン) と非飽和関数 (片側飽和) に分類されます。 Sigmoid と Tanh は飽和活性化関数ですが、ReLU とそのバリアントは非飽和活性化関数です。非飽和活性化関数の主な利点は次のとおりです。
1. 非飽和活性化関数は勾配消失問題を解決できます。
2. 非飽和活性化関数により、収束を高速化できます。

1. シグモイドは勾配消失問題を容易に引き起こす可能性があります。ニューロンが飽和すると、勾配消失の問題がさらに悪化します。ニューロンの入力シグモイドの値が特に大きいか小さく、対応する勾配がほぼ 0 に等しいと仮定します。前のステップが大きいと、ニューロンの重み (w) とバイアス (bias) の勾配も 0 に近づき、パラメーターを効果的に更新できなくなります。
2. 時間のかかる計算。ニューラルネットワークのトレーニングでは、電力計算のために Sigmid の値を計算する必要があることがよくあり、消費時間が増加します。
3. シグモイド関数は原点を中心としたゼロ中心ではありません。
4.Tanh 活性化関数は原点中心対称性の問題を解決します。

5. ReLU 活性化関数は、勾配消失問題を解決するために提案されました。 ReLU の勾配は、0 または 1 の 2 つの値のみを取ることができます。入力が 0 より小さい場合、勾配は 0 になり、入力が 0 より大きい場合、勾配は 1 になります。利点は、ReLU 勾配の連続乗算が 0 に収束せず、連続乗算の結果が 0 または 1 の 2 つの値のみを取ることができることです。値が 1 の場合、勾配は変更されずに順方向に伝播します。値が 0 の場合、勾配はこの位置から順方向の伝播を停止します。
6. ReLU のような一方的な飽和は、ニューロンをノイズ干渉に対してより堅牢にすることもできます。 7.ReLU アクティベーション関数は計算効率も優れています。シグモイド関数の勾配の計算と比較すると、ReLU 関数の勾配値は 0 または 1 のみです。そして、ReLU は負の値を 0 に切り捨て、ネットワークにスパース性を導入し、計算効率をさらに向上させます。 8. ReLU スパース性は計算効率を向上させることができますが、トレーニングプロセスを妨げる可能性もあります。通常、活性化関数の入力値にはバイアス項(バイアス)があり、そのバイアスが小さくなりすぎて入力活性化関数の値が常に負になると、逆伝播過程の勾配は常に0になります。現時点では、重みとバイアスのパラメーターに対応するものを更新できません。活性化関数への入力がすべてのサンプル入力に対して負である場合、ニューロンは学習できなくなります。これはニューロンの「死」問題と呼ばれます。 9. Leaky ReLU はニューロンの「死」の問題を解決できる

Leaky ReLU はニューロンの「死」の問題を解決するために提案されました. Leaky ReLU は ReLU とよく似ています. 唯一の違いは入力が 0 未満の部分です. ReLU の入力が 0 未満の部分は値を持ちますLeakyReLUの入力が0未満の部分はマイナスの値となり、若干の傾きを持っています。関数グラフは(d)です。

Leaky ReLU を使用する利点は、逆伝播プロセス中に、(ReLU のように値が 0 になる代わりに) Leaky ReLU 活性化関数の入力が 0 未満である部分の勾配も計算できることです。グラデーション方向のエイリアシング問題を回避します。

10. 勾配誤差は、ニューラルネットワークのトレーニング中に計算された方向と勾配であり、ネットワークの重みを正しい方向と値で更新します。ディープネットワークまたはリカレントニューラルネットワークでは、更新中に勾配エラーが蓄積し、非常に大きな勾配が発生する可能性があります。これにより、ネットワークの重みが大規模に更新され、ネットワークが不安定になる可能性があります。極端な場合には、ウェイト値が大きくなりすぎてオーバーフローし、NaN 値が発生する勾配爆発現象が発生する可能性があります。

勾配爆発は、ネットワーク層 (値が 1.0 より大きい) で勾配を繰り返し乗算することによる指数関数的な増加によって発生します。
11.勾配爆発現象

明らかな現象:
1. モデルはトレーニングデータを「結合」できません。たとえば、損失関数が非常に貧弱です。
2. モデルが不安定で、更新のたびに損失が大きく変化します。
3. トレーニングプロセス中にモデル損失が NaN になります

あまり明白ではない現象もいくつかあります。
1. モデルの重みはトレーニング中に急速に大きく変化します。
2. トレーニングプロセス中にモデルの重みが NaN になります。
3. トレーニング中の各ノードとレイヤーの勾配誤差は常に 1.0 より大きくなります。
12.勾配爆発を解決する方法

1. ニューラルネットワークを再設計する
ネットワーク層の数を減らし、バッチサイズを減らし、切り詰めます。
2. LSTM を使用する
3. グラデーションクリッピングを使用する
Clipnorm=1.0 Clipvalue=0.5
4. 重み正則化
L1 および L2 を使用する

13. 活性化関数の選び方

1. 二項分類問題を除き、シグモイド関数は注意して使用してください。
2. Tanh を試すこともできますが、ほとんどの場合、その効果は ReLU や Maxout ほど良くありません。
3. どのアクティベーション関数を使用すればよいかわからない場合は、まず ReLU を選択してください。
4. ReLU を使用する場合は、Dead ReLU 問題に注意する必要があります。このとき、ニューロンの数が多すぎる大きな勾配を避けるために、学習率を慎重に選択する必要があります。死んだ"。
5. Dead ReLU 問題が発生した場合は、Leaky ReLU、ELU、およびその他の ReLU バリアントを試すと、良い結果が得られる可能性があります。
torch.nn.Sequential: ネットワークモジュールは順番に初期化され、forword 関数が自動的に実装されます。前のモジュールの出力サイズが以下と一致していることを確認する必要があります。次のモジュールの入力サイズ。詳細な説明については、「pytorch シリーズ 7 -----nn.順次説明」を参照してください。
```
from collections import OrderedDict
net3= nn.Sequential(OrderedDict([
          ('conv1', nn.Conv2d(3, 3, 3)),
          ('bn1', nn.BatchNorm2d(3)),
          ('relu1', nn.ReLU())
        ]))
print('net3:', net3)
```
出力：
net3: Sequential(
(conv1): Conv2d(3, 3, kernel_size=(3, 3), stride=( 1, 1))
(bn1): BatchNorm2d(3, eps=1e-05、momentum=0.1、affine=True、track_running_stats=True)
( relu1): ReLU()
)
nn.ModuleList は、Sequential と比較して、Modulelist には内部フォワード関数がなく、シーケンシャル要件もありません。、カスケード要件はありません。 ModuleList は Module のサブクラスであり、Module 内で使用すると自動的にサブモジュールとして認識されます。

損失関数
1. さまざまな損失関数の比較。記事「損失の概要」を参照してください。関数 (pytorch )》。通常、分類問題の損失関数としてクロスエントロピーを使用します。
クロスエントロピー:主に、実際の出力 (確率) と期待される出力 (確率) の間の距離を表します。つまり、クロスの値が小さいほど、エントロピーが小さいほど、クロスエントロピーの値が小さくなり、確率分布が近くなります。確率分布 p が期待される出力、確率分布 q が実際の出力、H(p,q) がクロスエントロピーであると仮定すると、Pytorch の CrossEntropyLoss() 関数には次の計算式があります。

2)nn .CrossEntropyLoss() の計算方法:
最後のステップは、複数の出力セットの損失を見つけることです:
リダクションの場合='mean'、平均値を見つけることです。
duction='mean' の場合、それは合計です。

import torch
import torch.nn as nn
import math
criterion = nn.CrossEntropyLoss()
output = torch.randn(3, 5, requires_grad=True)
label = torch.empty(3, dtype=torch.long).random_(5)
loss = criterion(output, label)
print("网络输出为3个5类:")
print(output)
print("要计算loss的类别:")
print(label)
print("计算loss的结果:")
print(loss)
first = [0, 0, 0]
for i in range(3):
    first[i] = -output[i][label[i]]
second = [0, 0, 0]
for i in range(3):
    for j in range(5):
        second[i] += math.exp(output[i][j])
res = 0
for i in range(3):
    res += (first[i] + math.log(second[i]))
print("自己的计算结果：")
print(res/3)

##########################
网络输出为3个5类:
tensor([[ 1.1499, -0.2208, -0.8943, -1.5002,  0.3065],
        [-0.0155,  0.7495,  0.4617,  0.5376,  1.2006],
        [-0.3464,  0.7741, -1.9237,  0.0350,  0.5038]], requires_grad=True)
要计算loss的类别:
tensor([1, 0, 4])
计算loss的结果:
tensor(1.8443, grad_fn=<NllLossBackward0>)
自己的计算结果：
tensor(1.8443, grad_fn=<DivBackward0>)

nn.CrossEntropyLoss例子:

# Example of target with class probabilities
loss = nn.CrossEntropyLoss()
input = t.randn(3, 5, requires_grad=True)
target = t.randn(3, 5).softmax(dim=1)
output = loss(input, target)
output.backward()

# batch_size=3，计算对应每个类别的分数（只有两个类别）
score = t.randn(3, 2)
# 三个样本分别属于1，0，1类，label必须是LongTensor
label = t.Tensor([1, 0, 1]).long()

# loss与普通的layer无差异
criterion = nn.CrossEntropyLoss()
loss = criterion(score, label)
loss

オプティマイザー torch.optim: 使用方法については、チュートリアル「オプティマイザー: torch.optim」を参照してください。
1) 一般的に使用される 4 つのオプティマイザーの比較については、「Pytorch で一般的に使用される 4 つのオプティマイザー: SGD、Momentum、RMSProp、および Adam」を参照してください。 >< a i=5>》
著者は次のように推奨しています:
a) RMSProp アルゴリズムは、効果的かつ実用的なディープニューラルネットワーク最適化アルゴリズムであることが経験的に証明されています。これは現在、深層学習の実践者によってよく採用される最適化手法の 1 つです。
b) SGD は最も一般的なオプティマイザですが、これには加速効果がないとも言えますが、Momentum は SGD の改良版であり、運動量の原則が追加されています。次の RMSprop はアップグレードされたものです。 Momentum のバージョン、そして Adam は RMSprop のアップグレードされたバージョンです。
c) 実際の操作では、Adam がデフォルトのアルゴリズムとして推奨されます。これは一般に RMSProp よりも優れています。
4 つのアルゴリズムのパフォーマンスを検証するために、同じネットワークが pytorch で最適化され、4 つのアルゴリズムの損失関数の経時的変化が比較されました。コードは次のとおりです。
```
opt_SGD=torch.optim.SGD(net_SGD.parameters(),lr=LR)
opt_Momentum=torch.optim.SGD(net_Momentum.parameters(),lr=LR,momentum=0.8)
opt_RMSprop=torch.optim.RMSprop(net_RMSprop.parameters(),lr=LR,alpha=0.9)
opt_Adam=torch.optim.Adam(net_Adam.parameters(),lr=LR,betas=(0.9,0.99))
```
2) 学習率を適応的に調整する方法については、「PyTorch ノート (18) - torch.optim オプティマイザーの使用」を参照してください。 /span> a>torch.optim の PyTorch ソースコード解釈: 詳細最適化アルゴリズムインターフェイスの説明》; PyTorch: torch.optim の 6 オプティマイザーと最適化アルゴリズムの概要《4) 異なるオプティマイザーの区別》;
3) ソースコードによる torch.optim の解釈《;
初期化戦略 torch.nn.init: PyTorch の nn.Module のモジュールパラメーターは、より合理的な初期化戦略を採用しているため、通常はそれを考慮する必要はありません。 Parameter を使用する場合、カスタム初期化は特に重要です。t.Tensor() はメモリ内の乱数を返しますが、これは最大値を持つ可能性が高く、実際のトレーニングネットワークでオーバーフローや勾配の消失を引き起こす可能性があります。 PyTorch のnn.init モジュールは、初期化用に特別に設計されています。
Tensor ディストリビューションを初期化します。この記事「torch.nn.init 公式ユーザーマニュアル「概要」」を参照してください。公式ウェブサイト「torch.nn.init」
があります。例:
```
import torch 
import torch.nn as nn

w = torch.empty(3,5)

#1.均匀分布 - u(a,b)
#torch.nn.init.uniform_(tensor, a=0.0, b=1.0)
print(nn.init.uniform_(w))
# =======================================================
# tensor([[0.9160, 0.1832, 0.5278, 0.5480, 0.6754],
#         [0.9509, 0.8325, 0.9149, 0.8192, 0.9950],
#         [0.4847, 0.4148, 0.8161, 0.0948, 0.3787]])
# =======================================================
```
nn.Module の詳細な分析:
nn.Module をさらに深く理解したい場合は、その原理を学ぶ必要があります。まず、nn.Module 基本クラスのコンストラクターを見てみましょう。
```
def __init__(self):
    self._parameters = OrderedDict()
    self._modules = OrderedDict()
    self._buffers = OrderedDict()
    self._backward_hooks = OrderedDict()
    self._forward_hooks = OrderedDict()
    self.training = True
```
各属性の説明は次のとおりです。
_parameters: ユーザーが直接設定したパラメータを保存する辞書、self.param1 = nn.Parameter( t.randn(3, 3)) が検出され、辞書に「param」としてキーが追加され、値がパラメータに対応する項目となります。 self.submodule = nn.Linear(3, 4) のパラメーターはここには存在しません。
_modules: サブモジュール、self.submodel = nn.Linear(3, 4) で指定されたサブモジュールがここに保存されます。
_buffers: キャッシュ。バッチノルムが運動量メカニズムを使用する場合、各順伝播では前の順伝播の結果を使用する必要があります。
_backward_hooks および _forward_hooks: フックテクノロジー。変数フックと同様、中間変数を抽出するために使用されます。
トレーニング:BatchNorm 層と Dropout 層は、トレーニングフェーズとテストフェーズで異なる戦略を採用します。順伝播戦略は、トレーニング値を判断することによって決定されます。
上記の属性のうち、_parameters、_modules、_buffers の 3 つの辞書のキー値は self.key を通じて取得でき、その効果は self._parameters[' ;キー']。
「Pytorch - 勾配計算」講義は良いです
DD

まとめ2 - 深層学習ネットワークの構築と学習

深層学習フレームワークと pytorch の書籍、紹介と実践:第 4 章 Neural Network Toolboxnn

代码验证批处理的过程参考《【PyTorch】详解pytorch中nn模块的BatchNorm2d()函数》；
定义：
**`torch.nn.BatchNorm2d`(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None)**

アドバンテージ：

おすすめ

まとめ2 - 深層学習ネットワークの構築と学習

深層学習フレームワークと pytorch の書籍、紹介と実践:第 4 章 Neural Network Toolboxnn

代码验证批处理的过程参考《【PyTorch】详解pytorch中nn模块的BatchNorm2d()函数》； 定义：torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None)

アドバンテージ：

おすすめ

代码验证批处理的过程参考《【PyTorch】详解pytorch中nn模块的BatchNorm2d()函数》；
定义：
**`torch.nn.BatchNorm2d`(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None)**