深度学习基本概念

人工智能是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。人工智能的目的就是让计算机能够像人一样思考。
强人工智能：就是要使机器学习人的理解、学习和执行任务的能力。
弱人工智能：指用于自动化特定任务的软件。
机器学习的广义概念：是指从已知数据中获得规律，并利用规律对未知数据进行预测的方法。机器学习是一种统计学习方法，机器人和计算机等机器需要使用大量数据进行学习，从而提取出所需的信息。
深度学习 就是一种利用深度人工神经网络来进行自动分类、预测和学习的技术。
人工智能>机器学习>深度学习

TensorFlow

TensorFlow 是一款用于数值计算的强大的开源软件库，特别适用于大规模机器学习的微调。

MNIST数据读取、建模、编译、训练、测试

import tensorflow as tf
# 载入数据
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
# 建模
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)), # 将输入“压平”，即把多维的输入一维化，只有第一层有输入数据的形状
  tf.keras.layers.Dense(128, activation='relu'), # 该层的输出维度或神经元个数和激活函数
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='softmax')
])
# 编译（优化器、损失和评价）
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
# 训练（训练和验证数据不一样）
model.fit(x_train, y_train, epochs=5)
#  验证
model.evaluate(x_test, y_test, verbose=2)

优化器 tf.optimizers；
SGD 随机梯度下降优化器

tf.keras.optimizers.SGD( learning_rate=0.01, momentum=0.0,nesterov=False, name='SGD', **kwargs)
学习率、动量、是否使用nesterov震荡

Adam优化器
tf.keras.optimizers.Adam(learning_rate=0.001)

损失函数：均方根误差MSE（MeanSquaredError）、二值交叉熵（BinaryCrossentropy）;
metrics sparse_categorical_crossentropy（多分类损失函数）
metrics评价函数
“accuracy” :真实值(y_)和预测值(y) 都是数值;
“sparse_accuracy”:y_和y都是以独热码和概率分布表示;
“sparse_categorical_accuracy”:y_是以数值形式给出，y是以独热码给出
データ構造
1) ランク: 次元
2) 形状: 各次元のデータ数
3) データ型: bool、int、float、string、complex、Truncated float、Quantized int
4) 変数と定数: 変数と定数

共通機能

データ型変換

ここに画像の説明を挿入

import tensorflow as tf
import tensorflow.compat.v1 as tf1
string = '12.3'
n1 = tf1.string_to_number(string, out_type=None, name=None)  #字符串转为数字
x = 12.3
d1 = tf1.to_double(x, name='ToDouble')#转为64位浮点类型float64
f1 = tf1.to_float(x, name='ToFloat') #转为32位浮点类型float32
i1 = tf1.to_int32(x, name='ToInt32') #转为32位整型int32
i2 = tf1.to_int64(x, name='ToInt64')     #转为64位整型–int64
a = [1.8, 2.2]
i3 = tf.cast(a, tf.int32)  # 将a或者a.values转换为dtype

形状操作

t = [ [[1, 1, 1], [2, 2, 2]] ,  [[3, 3, 3], [4, 4, 4]] ]
tf.shape(t)    #返回维度中数据的个数
tf.size(t)      #返回数据的元素数量
tf.rank(t)      #返回数据维度
t = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(tf.shape(t))
t2 = tf.reshape(t, [3, 3])  #改变tensor的形状
print(tf.shape(t2))
t3 = tf.reshape(t, [3, -1])
print(t3)

ここに画像の説明を挿入

その他の操作機能

t = [2,3] #插⼊维度1进⼊⼀个tensor中
t1 = tf.shape(tf.expand_dims(t, 0)) [1,2]
t2 = tf.shape(tf.expand_dims(t, 1))  [2,1]
t3 = tf.shape(tf.expand_dims(t, -1)) [2,1]
t4 = tf.ones([2,3,5])   #用数字1填充所有维度
t6 = tf.shape(tf.expand_dims(t4, 2))  shape=【2，3，1，5】
t= [[[1, 1, 1], [2, 2, 2]],[[3, 3, 3], [4, 4, 4]],[[5, 5, 5], [6, 6, 6]]]
#对tensor进⾏切⽚操作
t1 = tf.slice(t, [1, 0, 0], [1, 1, 3])  
t2 = tf.slice(t, [1, 0, 0], [1, 2, 3])
t3 = tf.slice(t, [1, 0, 0], [2, 1, 3])

t = tf.ones([5,30]) 
t1, t2, t3 = tf.split(t,3,1)  #沿着某⼀维度将tensor分离
print(tf.shape(t1))
print(tf.shape(t2))
print(tf.shape(t3))

t1 = [[1, 2, 3], [4, 5, 6]]
t2 = [[7, 8, 9], [10, 11, 12]] 
t3 = tf.concat([t1, t2], 0)  #沿着某⼀维度连结tensor
t4 = tf.concat([t1, t2], 1)

x = [1, 4] y = [2, 5] z = [3, 6]
t1 =tf.stack([x, y, z]) #沿着第⼀维stack [[1 4] [2 5] [3 6]]
t2 = tf.stack([x, y, z], axis=1) #axis取0时表示按x轴叠加，取1时表示按y轴叠加#[[1 2 3] [4 5 6]]

t = [[  [[ 0, 1, 2, 3],[ 4, 5, 6, 7],[ 8, 9, 10, 11]], 
 [[12, 13, 14, 15],[16, 17, 18, 19],[20, 21, 22, 23]]  ]] # shape=(1,2,3,4),dims = [3]
t1 = tf.reverse(t, dims) #沿着某维度进⾏序列反转dims = [1] 
t2 = tf.reverse(t, dims) #dims = [2] 
t3 = tf.reverse(t, dims) [[  [[ 8 9 10 11] [ 4 5 6 7] [ 0 1 2 3]]  [[20 21 22 23] [16 17 18 19] [12 13 14 15]] ]]

t = [[1, 2, 3],[4, 5, 6]]
t1 = tf.transpose(t)  #调换tensor的维度顺序	
t2 = tf.transpose(t, perm=[1, 0])  # [[1 4] [2 5] [3 6]]

indices = [0, 1, 2]  depth = 3
t1 = tf.one_hot(indices, depth)  #
indices = [0, 2, -1, 1]   depth = 3
t2 = tf.one_hot(indices, depth,on_value=5.0, off_value=0.0,axis=-1) 
indices = [[0, 2], [1, -1]]  depth = 3
t3 = tf.one_hot(indices, depth,on_value=1.0, off_value=0.0,axis=-1) #    [ [[1. 0. 0.][0. 0. 1.]]
[[0. 1. 0.][0. 0. 0.]] ]
t = [1, 1, 2, 4, 4, 4, 7, 8, 8]
y, idx = tf.unique(t)  
print(y) #t的所有唯一元素
print(idx) #y中每个值的索引

tf.math.ceil([-1.7,-1.5,-0.2,0.2,1.5,1.7,2.0])  #向上取整函数
tf.gather(params,indices,axis=0 ) 从params的axis维根据indices的参数值获取切片

手術

tf.diag(diagonal) 根据主对角线元素生成矩阵
tf.trace(x, name=None)求二维tensor对角值之和
tf.matrix_determinant(input, name=None)求方阵行列式
tf.matrix_inverse(input, adjoint=None,name=None)求逆矩阵
tf.matmul(a,b,transpose_a=False,transpose_b=False,a_is_sparse=False,b_is_sparse=False,name=None)矩阵相乘
tf.complex(real, imag, name=None) 将两实数转换为复数形式
tf.complex_abs(x, name=None) 计算复数的绝对值，即⻓度。
tf.conj(input, name=None) 计算共轭复数
tf.imag(input, name=None)
tf.real(input, name=None)
tf.eye(num_rows,num_columns=None)生成单位阵
tf.fill(dims,value,name=None)   fill([2, 3], 9) ==> [[9, 9, 9][9, 9, 9]]
tf.ones(shape,dtype=tf.dtypes.float32,name=None)

データ生成

⽣成随机张量
tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None)
从“服从指定正态分布的序列”中随机取出指定个数的值，shape: 输出张量的形状，mean: 正态分布的均值，stddev: 正态分布的标准差，dtype: 输出的类型，seed: 随机数种子，是一个整数，当设置之后，每次生成的随机数都一样

tf.truncated_normal(shape, mean, stddev)
产生截断正态分布随机数，取值范围为 [ mean - 2 * stddev, mean + 2 * stddev ]

tf.random_uniform(shape，minval=0, maxval=None, dtype=tf.float32, seed=None)
生成的值在 [minval, maxval) 范围内遵循均匀分布.

tf.random_shuffle()  随机地将张量沿其第一维度打乱

变量：
biases = tf.Variable(tf.zeros([200]),name=“var") 生成一组变量（没有初始化）
const = tf.constant(1.0,name="constant") 创建常量

名称作用域
在TensorFlow 应用程序中，可能会有数以千计的计算节点。如此多节点汇集在一起，难以分析，甚至无法用标准的图表工具来展示。为解决这个问题，一个有效方法就是，为Op/Tensor 划定名称范围。在TensorFlow 中，这个机制叫名称作用域(name scope)

tf.variable_scope() 管理变量命名空间，可以创建同名变量。在tf.variable_scope 中创建的变量,名称. name 中名称前面会加入命名空间的名称，并通过“/” 来分隔命名空间名和变量名。

tf.get_variable(name="foo/bar", shape=[1]) ，可以通过带命名空间名称的变量名来获取其命名空间下的变量。如果变量存在，则使用以前创建的变量，如果不存在，则新创建一个变量。不能创建同名变量。

ピトーチ

コンセプト: Pytorch は Python に基づいた科学計算パッケージであり、主な目的は次のとおりです。

Numpy の代替として、GPU のパフォーマンスを使用して効率的な計算を行うことができます。
柔軟性が高く高速なディープラーニングプラットフォームとして

测试：
torch.cuda.is_available()
x = torch.rand(5,3) print(x)
print(x)

基本要素:テンソル (Tensor)、変数 (Variable)、ニューラルネットワークモジュール (nn.Module)

Tensor : Tensor は PyTorch の最も基本的な要素であり、numpy.ndarray に相当します。Tensor は、PyTorch の numpy.ndarray の代替品です。
変数: ニューラルネットワークを構築する場合、計算グラフを構築するために変数が必要です。
変数はテンソルをカプセル化したもので、変化する値(テンソル)を格納する物理的な場所です。
変数には 3 つのプロパティがあります。
- variable.data : 変数内のテンソルの値
- variable.grad : 変数内のテンソルの勾配。
- variable.gradfn : バックプロパゲーションの勾配計算に使用される Function オブジェクトを指します。

nn.モジュール

ニューラルネットワークモジュール nn.Module: ニューラルネットワークのインターフェイス。独自のニューラルネットワークを定義する場合は、nn.Module クラスを継承する必要があります。

(1) ライナーモジュール

torch.nn.Linear(in_features, out_features, bias=True)
⽹络中的全连接层，全连接层输⼊与输出都是⼆维张量，输⼊形状为[batch_size, size]。
in_features：指的是输入的二维张量的大小。
out_features：指的是输出的二维张量的大小，即输出的二维张量的形状为[batch_size，output_size]，也代表该全连接层的神经元个数。

(2) Conv2d模块

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)
kernel_size:卷积核的⼤⼩，⽤(H,W)表示HxW的输出，H表示H*H⼤⼩的输出。
stride：卷积步幅，卷积核每次挪动间距
padding:填充操作，控制padding_mode的数⽬。默认为Zero-padding。
dilation:扩张操作，控制kernel点（卷积核点）的间距，默认为1。
group:控制分组卷积，默认不分组。 (对输入feature map进行分组，然后每组分别卷积。)
bias:是否添加偏置，如为真，则在输出中添加⼀个可学习的偏差，默认为True。

ここに画像の説明を挿入

Linear和Conv2d连接，Conv2d的输出为四维张量，转换为⼆维张量之后，才能作为全连接层的输⼊。

ここに画像の説明を挿入

(3)⼆维批量归⼀化模块

torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True)
num_features：特征数C

ここに画像の説明を挿入

(4)最⼤池化模块

torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1)
输⼊: (N,C,H_in,W_in)
输出: (N,C,H_out,W_out)

ここに画像の説明を挿入

(5)平均池化模块：

torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False)
ceil_mode:如果为True，则在计算输出形状时使⽤ceil函数替代floor

ここに画像の説明を挿入

(6)⾃适应平均池化模块:

torch.nn.AdaptiveAvgPool2d(output_size) Output_size: 出力信号のサイズ
アダプティブプーリングの特徴は、出力テンソルのサイズが指定された output_size であることです。任意の入力サイズの入力の場合、出力サイズは H*W として指定できますが、入力フィーチャと出力フィーチャの数は変わりません。
ここに画像の説明を挿入

nn.関数

場所: torch.nn.function
例:torch.nn.functional.adaptive_avg_pool2d(input, output_size)
torch.nn.ReLU(inplace=False) inplace: インプレース操作、つまり x = x+1 を実行するかどうかを選択します。
シグモイド：

m = nn.Sigmoid() 
input = torch.randn(2) 
output = m(input) 
input, output 
(tensor([-0.8425, 0.7383]), tensor([0.3010, 0.6766]))

4. タン:

m = nn.Tanh() 
input = torch.randn(2) 
output = m(input) 
input, output 
(tensor([1.3372, 0.6170]), tensor([0.8710, 0.5490]))

RNN

関数：torch.nn.RNN(input_size, hidden_size, num_layers)

hidden_size: rnn 出力は各タイムステップでの隠れ状態であるため、隠れ層内のニューロンの数は出力の次元でもあります。
num_layers: 隠れ層の数。

RNN の出力は 2 つの部分で構成されます: 出力値 Y (つまり出力) と最後の瞬間の隠れ層の出力 $h_n$

前向き予測:
ここに画像の説明を挿入

x: [seq_len,batch,feature_len]、すべての特徴を一度に入力するためのものであり、現時点での xt を毎回入力する必要はありません。
h0 は、最初の初期瞬間におけるすべての層のメモリユニットのテンソルです (各層の各文の隠れた出力として理解されます)。

例：中国語を入力し、英語を出力します。各漢字は 100 次元のデータでエンコードされ、各隠れ層の次元は 20 で、隠れ層は 4 つあります。つまり、input_size = 100、hidden_size = 20、num_layers = 4 となります。モデルがトレーニングされており、入力として長さ 10 の文があると仮定すると、seq_len = 10、batch_size = 1 となります。


import torch 
import torch.nn as nn 
input_size = 100 # 输⼊数据编码的维度 
hidden_size = 20 # 隐含层维度 
num_layers = 4 # 隐含层层数 
rnn = nn.RNN(input_size=input_size,hidden_size=hidden_size,num_layers=num_layers) 
print("rnn:",rnn)
seq_len = 10 # 句⼦⻓度 
batch_size = 1 

x = torch.randn(seq_len,batch_size,input_size) # 输⼊数据x 
h0 = torch.zeros(num_layers,batch_size,hidden_size) # 输⼊数据h0 

out, h = rnn(x, h0) # 输出数据 

print("out.shape:",out.shape) 
print("h.shape:",h.shape)

RNNCell モジュール:
(1) 相違点: nn.RNN は、すべての時間の特徴を一度にネットワークに入力します。nn.RNNCell はシーケンス上の「各瞬間のデータ」を分離して処理します
(2) 前方予測: $h_t = forward(x_t, h_{t-1})$

例: 3 つの文を処理する場合、各文には 10 単語が含まれており、各単語はnn によって
渡されるテンソルの形状である 100 次元の埋め込みベクトルによって表されます。テンソルの形状は [3,100] です。
この演算器を 10 回実行する

LSTMモジュール
- 関数：torch.nn.LSTM(input_size, hidden_size, num_layers)
- 入力および出力形式:out, (h_t, c_t) = lstm(x, [h_t0, c_t0])
- LSTMCell モジュール:h_t, c_t = lstmcell(x_t, [h_t-1, c_t-1])
  - xt: [batch, feature_len] は時間 t での入力を示します
  - ht−1, ct−1: [batch, hidden_len]、時間 t−1 におけるこの層の隠れユニットとメモリユニット)

nn.LSTM は、すべての時間特徴を一度にネットワークに入力します。
nn.LSTMCell はシーケンス上の「各瞬間のデータ」を個別に処理します

CNN

フィードフォワードニューラルネットワークの学習は主にエラー修正方法 (BP アルゴリズムなど) を採用しており、計算プロセスは比較的遅く、収束速度も遅いです。
フィードバックニューラルネットワークは主にHebb学習則を採用しており、計算の収束速度が非常に速いです。

CNN は部分的に接続された層を使用し、局所性、同一性、不変性の 3 つの概念を使用します。

畳み込み層

ニューロンの最初の層は、入力画像内の知覚領域にあるピクセルのみを接続し、画像の低レベルの特徴に焦点を当てます。
ニューロンの 2 番目の層は、高レベルの機能の最初の層の知覚領域内にあるニューロンにのみ接続されます。

フィルタ（フィルタ、コンボリューションカーネル）コンボリューション演算設定パラメータ
1) フィルタの長さ、幅、高さ HWC
2) ステップサイズ (Stride)
3) 境界充填

ここに画像の説明を挿入

注: フィルターによって処理された画像は特徴マップと呼ばれ、特徴マップ内のすべてのニューロンは同じパラメーター (重み、バイアス) を共有します。

基本構造（入力層＋畳み込み層（特徴抽出）＋プーリング層（圧縮特徴）＋全結合層（非線形出力））

入力画像の表現: 3D テンソル[高さ、幅、チャネル];
ミニバッチ表現: 4D Tensor [ミニバッチ、高さ、幅、チャネル];

畳み込み層の重み表現: 4D tensor [fh,fw,fn,fn']

fh は現在のレイヤーフィルターの高さ、fw は現在のレイヤーフィルターの幅、fn は現在のレイヤーフィルターの数、fn' は前のレイヤーの特徴マップの数です。

畳み込み層のバイアス項目表現: 1D tensor [fn]

计算：一个具有5×5过滤器的卷积层，输出尺寸为150×100的200个特征图，带有步幅1和SAME填充。

参数数量：若输入是150×100 RGB图像（三通道），则参数的数量：（5×5×3+1）*200=15,200

200个特征图每一个都包含150×100个神经元，每个都需要计算其5×5×3=75个输入的加权和，总共有75*150*100*200=2.25亿次浮点乘法。

若用32位浮点数表示特征图，卷积层输出将占200×150×100×32=96百万位（约11.4 MB）内存

パディングについて

コードを記述するときは、パディングには「同じ」と「有効」という 2 つのモードがあることに注意してください。

padding='same'パディングを示します。パディングの値は、畳み込みカーネルのサイズに基づいてアルゴリズムによって計算されます。目的は、出力サイズを入力と等しくすることです。これは、パディングではない、つまり、padding=0、有効なウィンドウ位置のみを意味します
padding='valid'。が使用されます。これがデフォルトのオプションです。

塗りつぶされた値 = (b - 1) / 2
塗りつぶされた値、b の値はコンボリューションカーネルのサイズです。コンボリューションカーネルサイズが通常奇数に選択される理由は次のとおりです。

例:
質問 1.サイズ 5 5 の特徴マップは、ストライド = 1 で 3 3 の畳み込み層を通過します。出力サイズが入力サイズと等しい場合、パディング値はどうあるべきですか?
答え: 充填値 = (3 - 1)/2 = 1、つまり、各辺が 1 つのレイヤーで充填されます。

質問 2. サイズ 224 224 の特徴マップは、ストライド 2 で7 7 畳み込み層を通過します。出力サイズを入力サイズと等しくしたい場合、パディング値はどのようにすべきですか?
答え: 充填値 = (7 - 1)/2 = 3、つまり、各辺が 3 つのレイヤーで充填されます。

padding='same' の目的は、出力サイズを入力サイズと等しくすることですが、前提条件は stride=1 であり、stride が 1 でない場合、出力サイズは入力サイズと異なる必要があります。

同じ有効なパディングモードの 2 つの直接的な理解は、パディングなし、または出力サイズを入力サイズと等しくするためのパディングのいずれかです。パディングの値はランダムに取得されません。2 つのケースでは、padding
=0 または padding のいずれかです。 =(b - 1)/2。

プーリング層:

1) 目標: 入力画像をサブサンプル (つまり、ダウンスケール) して、計算量、メモリ使用量、パラメーターの数を削減します (オーバーフィッティングのリスクを軽減します) 2) 機能: 各プーリング層ニューロンはすべて
、前の層に配置され、小さな長方形の受容領域に位置します。ただし、プーリングニューロンには重みがありません。max_pool() や avg_pool() などの集計関数を使用して入力を集計します。
3) 機能: 特徴の次元削減、過学習の回避、空間不変性、パラメータの削減、トレーニングの困難さの軽減

4) コードは 2x2 カーネルプーリング層 (keras 実装) を実装します。

keras.layers.MaxPool2D( pool_size=(2,2),  strides=None, #默认值和pool_size相等
padding='valid', data_format=None)

keras.layers.AvgPool2D(pool_size=(2,2),strides= None, # 默认值和pool_size相等
padding='valid', data_format=None)

keras.layers.GlobalAveragePooling2D(data_format=None)

MNIST 処理用の CNN ネットワークを設計します。構造とパラメーターは次のとおりです。各 MaxPooling の後に係数 0.25 の Dropout を追加します。

ここに画像の説明を挿入

import os
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten, Conv2D, 
import numpy as np

(X_tarin, y_train), (X_test, y_test) = mnist.load_data()
X_train4D = X_tarin.reshape(X_tarin.shape[0], 28, 28, 1).astype('float32')
X_test4D = X_test.reshape(X_test.shape[0], 28, 28, 1).astype('float32')

 # 归⼀化
X_train4D_Normalize = X_train4D / 255
X_test4D_Normalize = X_test4D / 255
# 标签onehot编码
y_trainOnehot = to_categorical(y_train)
y_testOnehot = to_categorical(y_test)

# 建⽴模型
model = Sequential()
model.add(Conv2D(filters=16,kernel_size=(5, 5),padding='SAME', input_shape=(28, 28, 1),activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

# ⼆层卷积
model.add(Conv2D(filters=32,kernel_size=(5, 5), padding='SAME', activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

#三、四层卷积
model.add(Conv2D(filters=64, kernel_size=(5, 5), padding='same', activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(filters=128, kernel_size=(5, 5), padding='same', activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.25)) 
# 全连接层
model.add(Flatten()) 
model.add(Dense(128, activation='relu')) 
model.add(Dropout(0.25)) 

model.add(Dense(10, activation='softmax')) 
model.summary()
# 编译模型
model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])
#训练模型
train_history = model.fit(x=X_train4D_Normalize,y=y_trainOnehot,validation_split=0.2,batch_size=300,
 epochs=10,verbose=2)
#评估模型
model.evaluate(X_test4D_Normalize, y_testOnehot)[1] 
#预测
prediction = model.predict_classes(X_test4D_Normalize)

RNN

概念: シーケンスデータの処理に使用されるニューラルネットワークの一種。シーケンスの現在の出力は前の出力に関連します。具体的な表現は次のとおりです。ネットワークは以前の情報を記憶し、それを現在の出力の計算に適用します。つまり、隠れ層間のノードが接続され、隠れ層の入力には入力層だけでなく出力も含まれます。 of には、直前の隠れ層の出力も含まれます。

構造:
ここに画像の説明を挿入

パラメータ 3 の重みグループ:

U (入力xとノード間の計算)
W (経時的なノード変換計算)
V: (ノード x と出力ノード間の計算)
$s_t = f(U_{x_t} + W_{s_t−1}) における$ 隠れ層の状態です。 $s = f (U_{バツ} + W_{s -} ）$

インセンティブ機能: 一般的にはtanhまたはReLU
$o_t$ は時間 t での出力です。 $o_t = ソフトマックス(V_{s_t})$

分類：

入出力シーケンスの構造に応じて: One to One、One to Many (ベクトルからシーケンス)、Many to One (シーケンスからベクトル)、Many to Many、Encoder-Decoder モデル (Seq2Seq モデル)
内部構造によると: 従来の RNN、LSTM、Bi-LSTM、GRU、Bi-GRU

単純な RNN の欠点: 長いシーケンスの予測ではうまく機能せず、不安定な勾配の問題に直面し、勾配の消失または爆発が起こりやすくなります。RNN が長いシーケンスを処理すると、シーケンスの最初の入力が徐々に忘れられてしまいます。

単純な RNN

np.random.seed(42)
tf.random.set_seed(42)

model = keras.models.Sequential([
keras.layers.SimpleRNN(1, input_shape=[None, 1]) ])

optimizer = keras.optimizers.Adam(learning_rate=0.005)

model.compile(loss="mse", optimizer=optimizer)
history = model.fit(X_train, y_train, epochs=20,validation_data=(X_valid, y_valid))

model.evaluate(X_valid, y_valid)
y_pred = model.predict(X_valid)

ディープ RNN

np.random.seed(42)
tf.random.set_seed(42)
model = keras.models.Sequential([
 keras.layers.SimpleRNN(20, return_sequences=True,input_shape=[None, 1]),
 keras.layers.SimpleRNN(20, return_sequences=True),
 keras.layers.SimpleRNN(1)
])
model.compile(loss="mse", optimizer="adam")
history = model.fit(X_train, y_train, epochs=20,validation_data=(X_valid, y_valid))
model.evaluate(X_valid, y_valid)
y_pred = model.predict(X_valid)

np.random.seed(42)
tf.random.set_seed(42)

model = keras.models.Sequential([
keras.layers.SimpleRNN(20, return_sequences=True, input_shape=[None, 1])
keras.layers.BatchNormalization(),
keras.layers.SimpleRNN(20, return_sequences=True),
keras.layers.BatchNormalization(), 批量归一化
keras.layers.TimeDistributed(keras.layers.Dense(10)) 时间步
每⼀步都预测10个值，即在时刻0会预测1到10，时刻1预测2到11.
])
model.summary()
model.compile(loss="mse", optimizer="adam", metrics=[last_time_step_mse])
history = model.fit(X_train, Y_train, epochs=20, validation_data=(X_valid, Y_valid))
model.evaluate(X_valid, Y_valid)

LSTM

ここに画像の説明を挿入

LSTM セルの状態: h[t] (短期記憶状態)、c[t] (長期記憶状態)

c[t−1] は、まず忘却ドアを通過して丢弃いくつかの記憶を保存し、次にいくつかの記憶を追加および操作し增加(
入力ドアから一部を選択)、最後に変換せずに直接出力します。加算演算の後、長期状態は复制Tanh 活性化関数に通され、その結果が出力されて过滤短期状態 h[t] が得られます。h[t] は、このタイムステップのユニット出力 y[t] です。

短期記憶状態 $h [t - 1]$ と入力ベクトル $x [t]$ は 4 つの異なる全結合層を通過します: $g [t]$ 層はメイン層 (最も重要な部分を長期状態で保存、tanh は活性化関数)、他の 3 つの全結合層 (FC) は (活性化関数としてロジスティック) です⻔控制器。

权重计算
$W_{xi}，W_{xf} ，W_{xo}，W_{xg}$ 4 つの全結合層接続入力ベクトル x(t) の重みです;
$W_{hi}、 W_{hf} 、 W_{ho}、 W_{hg}$ 4 つの全結合層接続の重み h(t−1);
$b_i、 b_f 、 b_o、 b_g$ は全結合層の 4 つのバイアス項です。

ここに画像の説明を挿入
$W_{xi}、W_{xf} 、W_{xo}、W_{xg}$ 重みの数:
入力パラメータの数 × 隠れ層パラメータの数 + 隠れ層パラメータの数 × 隠れ層パラメータの
数バイアス数: 隠れ層パラメータの数

np.random.seed(42)
tf.random.set_seed(42)
model = keras.models.Sequential([
keras.layers.LSTM(20, return_sequences=True, input_shape=[None, 1]),
keras.layers.LSTM(20, return_sequences=True),
keras.layers.TimeDistributed(keras.layers.Dense(10))
])

model.summary()
model.compile(loss="mse", optimizer="adam", metrics=[last_time_step_mse])
history = model.fit(X_train, Y_train, epochs=20, validation_data=(X_valid, Y_valid))
model.evaluate(X_valid, Y_valid)

GRU

ここに画像の説明を挿入
長期状態と短期状態はベクトル h(t) に結合されます。ドアコントローラー z(t) (リセットドア) を使用して、忘れドアと入力ドアを制御します。

(ドアコントローラが 1 を出力した場合、忘れドアは開いており (= 1)、入力ドアは閉じています (1 - 1 = 0)。
出力が 0 の場合は、逆の操作を行い、出力ゲートをキャンセルし、各タイムステップで完全な状態ベクトルを出力します。

コントロールゲート r(t) (更新ゲート) を追加して、前の状態のどの部分をメイン層 g(t) に提示するかを制御します。

ここに画像の説明を挿入

注:単純な RNN よりも長いシーケンスを処理できますが、それでもある程度の短期記憶を持っています。

これに対処する 1 つの方法は、たとえば 1D 畳み込み層を使用して入力シーケンスを短縮することです。1D 畳み込み層はシーケンス上で複数のカーネルをスライドさせ、各カーネルは 1D 特徴マップを生成できます。各コアは非常に短いシーケンスパターン (コアのサイズ以下) を学習できます。

np.random.seed(42)
tf.random.set_seed(42)

model = keras.models.Sequential([
keras.layers.GRU(20, return_sequences=True, input_shape=[None, 1]),
keras.layers.GRU(20, return_sequences=True),
keras.layers.TimeDistributed(keras.layers.Dense(10))
])
model.summary()
model.compile(loss="mse", optimizer="adam", metrics=[last_time_step_mse])
history = model.fit(X_train, Y_train, epochs=20, validation_data=(X_valid, Y_valid))

データセットMNIST上でRNNの分類タスクを実現する

import torch
import torch.nn as nn
import torchvision.datasets as ds
import torchvision.transforms as transforms
from torch.autograd import Variable

sequence_length = 28 , input_size = 28 ,  hidden_size = 128 
num_layers = 2, num_classes = 10 ,  batch_size = 100  ,  num_epochs = 2      
learning_rate = 0.003

#加载MNIST数据集
train_dataset = ds.MNIST(root='.\data',train=True,transform=transforms.ToTensor(),download=True)
test_dataset = ds.MNIST(root='.\data',train=False,transform=transforms.ToTensor())
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,batch_size=batch_size,shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,batch_size=batch_size,shuffle=False)

#定义多对⼀双向RNN模型
class BiRNN(nn.Module):
   def __init__(self, input_size, hidden_size, num_layers, num_classes):
      super(BiRNN, self).__init__()
      self.hidden_size = hidden_size
      self.num_layers = num_layers
      self.lstm = nn.LSTM(input_size, hidden_size, num_layers,
      batch_first=True, bidirectional=True)
      self.fc = nn.Linear(hidden_size * 2, num_classes) 
      
   def forward(self, x):
      h0 = Variable(torch.zeros(self.num_layers * 2, x.size(0),self.hidden_size)) # 设置初始状态
      c0 = Variable(torch.zeros(self.num_layers * 2, x.size(0),self.hidden_size)) 
      out, _ = self.lstm(x, (h0, c0)) #前向传播
      out = self.fc(out[:, -1, :]) # 上一时间步隐藏状态输出
      return out

#定义模型
rnn = BiRNN(input_size, hidden_size, num_layers, num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(rnn.parameters(), lr=learning_rate)

#训练模型
for epoch in range(num_epochs):
   for i, (images, labels) in enumerate(train_loader):
     images = Variable(images.view(-1, sequence_length, input_size)) 
     labels = Variable(labels) 
     optimizer.zero_grad()#前向+后向+优化器
     outputs = rnn(images)
	 loss = criterion(outputs, labels)
	 loss.backward()
	 optimizer.step()
 if (i + 1) % 100 == 0:
 	print('Epoch [%d/%d], Step [%d/%d], Loss: %.4f'% (epoch+1,num_epochs,i + 1, len(train_dataset)
 // batch_size, loss.item()))
 
# 测试模型
correct = 0
total = 0
for images, labels in test_loader:
	 images = Variable(images.view(-1, sequence_length, input_size))
	 outputs = rnn(images)
	 _, predicted = torch.max(outputs.data, 1)
	 total += labels.size(0)
	 correct += (predicted.cpu() == labels).sum()
	 print('Test Accuracy of the model on test images: %d %%'  %  (100 * correct / total))

AE

特徴
オートエンコーダーは通常、入力データよりもはるかに次元が低いため、次元削減の目的に役立ちます。オートエンコーダは、ノイズ低減の
状況にも適用できます。オートエンコーダーは強力な特徴検出器としても機能し、ディープニューラルネットワークの教師なし事前トレーニングに使用できます。一部のオートエンコーダーは、トレーニングデータによく似た新しいデータをランダムに生成する生成モデルです。
オートエンコーダは 2 つの部分で構成されます。
認識ネットワーク: 入力を潜在表現に変換するエンコーダ
生成ネットワーク: 潜在表現を出力に変換するデコーダ
データの潜在空間表現には、元のデータポイントを表現するために必要なすべての重要な情報が含まれています。表現は元のデータの特徴を表す必要があります。つまり、モデルはデータの特性を学習し、その表現を簡素化し、分析を容易にします。
出力層のニューロンの数は入力の数と等しくなければなりません。オートエンコーダーは入力を再構築しようとするため、出力はしばしば再構築と呼ばれます。損失関数には、再構築が入力と異なる場合にモデルにペナルティを与える再構築損失が含まれます。

X_train = np.random.rand(100,3)
encoder = Sequential([Dense(2, input_shape=[3])])
decoder = Sequential([Dense(3)])

autoencoder = Sequential([encoder, decoder])
autoencoder.compile(loss="mse", optimizer=SGD(lr=0.1))

history = autoencoder.fit(X_train, X_train, epochs=20)
codings = encoder.predict(X_train)

オートエンコーダーは、入力データの最も重要な特徴を学習し、重要でない特徴を削除する必要があります。(PCA を使用) オートエンコーダーが線形アクティベーションのみを使用し、損失関数が平均二乗誤差 (MSE) である場合、最終的に主成分分析 (PCA) を行うことになります。
ここに画像の説明を挿入

ディープオートエンコーダー

オートエンコーダーは複数の隠れ層を持つことができ、ディープオートエンコーダーと呼ばれます。
レイヤーを追加すると、オートエンコーダーがより複雑なエンコーディングを学習するのに役立ちます。ただし、オートエンコーダーを強力にしすぎないようにしてください。
エンコーダーが強力すぎると、過剰適合の問題が発生します。このようなオートエンコーダーはトレーニングデータを完全に再構築しますが、その過程で有用なデータ表現を学習せず、新しいインスタンスにうまく一般化できない可能性があります。
ここに画像の説明を挿入

import utils.mnist_reader
X_train, y_train = utils.mnist_reader.load_mnist('./data/', kind='train')
X_valid, y_valid = utils.mnist_reader.load_mnist('./data/', kind='t10k')
X_train = X_train.reshape(X_train.shape[0],28,28).astype('float32')
X_valid = X_valid.reshape(X_valid.shape[0],28,28).astype('float32')

stacked_encoder = Sequential([
Flatten(input_shape=[28, 28]),
Dense(100, activation="selu"),
Dense(30, activation="selu"),
])

stacked_decoder = Sequential([
Dense(100, activation="selu", input_shape=[30]),
Dense(28 * 28, activation="sigmoid"),
Reshape([28, 28])
])

stacked_ae = Sequential([stacked_encoder, stacked_decoder])
stacked_ae.compile( loss="binary_crossentropy", optimizer=SGD(lr=1.5))
history = stacked_ae.fit(X_train,X_train,epochs=10,validation_data=[X_valid])

畳み込み自動エンコーディング

畳み込みオートエンコーダーは通常、入力の空間次元 (つまり、高さと幅) を削減する一方で、深さ (つまり、特徴マップの数) を増やします。デコーダは逆に動作し、画像を拡大し、奥行きを圧縮します。これは、畳み込み層を転置することで実現できます。アップサンプリング層と畳み込み層を組み合わせることも可能です。

conv_encoder = Sequential([
Reshape([28, 28, 1], input_shape=[28, 28]),
Conv2D(16, kernel_size=3, padding="same", activation="selu"),
MaxPool2D(pool_size=2),
Conv2D(32, kernel_size=3, padding="same", activation="selu"),
MaxPool2D(pool_size=2),
Conv2D(64, kernel_size=3, padding="same", activation="selu"),
MaxPool2D(pool_size=2)
])

conv_decoder = Sequential([
Conv2DTranspose(32, kernel_size=3, strides=2, padding="valid",
activation="selu", input_shape=[3, 3, 64]),
Conv2DTranspose(16, kernel_size=3, strides=2, padding="same",
activation="selu"),
Conv2DTranspose(1, kernel_size=3, strides=2, padding="same",
activation="sigmoid"),
Reshape([28, 28])
])

conv_ae = Sequential([conv_encoder, conv_decoder])

デコンボリューション:
デコンボリューションまたはデコンボリューションと呼ばれる、画像のサイズを拡大するために使用される手法。
例: 入力特徴マップ: 3 ∗ 3 入力畳み込みカーネル: kernel=3 ∗ 3、stride=2、padding=1
出力特徴マップ: 3 * 3 - 3 + 2 * 1 +1 = 5
再帰的オートエンコーダー
再帰的オートエンコーダーのエンコーダーはシーケンスからベクトルへの RNN であり、デコーダーはベクトルからシーケンスへの RNN です。

recurrent_encoder = Sequential([
	LSTM(100, return_sequences=True, input_shape=[None, 28]),
	LSTM(30)
])
recurrent_decoder = Sequential([
	RepeatVector(28, input_shape=[30]), 将输⼊重复28次
	LSTM(100, return_sequences=True),
	TimeDistributed(Dense(28, activation="sigmoid"))将Dense层应⽤于输⼊的每个时间⽚（对输入的每个向量进行一次Dense操作）。
])
recurrent_ae = Sequential([recurrent_encoder, recurrent_decoder])

VAE (変分オートエンコーダー)

損失関数:

再構成損失: オートエンコーダーをプッシュして入力を再現します。
潜在的な損失: オートエンコーダーをプッシュして、エンコードが単純なガウス分布からサンプリングされたように見せます。
ターゲット分布 (ガウス) とエンコードの実際の分布の間の KL 発散を使用します。

変分オートエンコーダは、指定された入力のエンコードを直接生成しません。エンコーダは平均エンコード μ と標準偏差 σ を生成し、平均 μ と標準偏差 σ のガウス分布からランダムにサンプリングしてエンコードを実現します。その後、デコーダは通常どおりサンプルのエンコードをデコードします。

ランダムサンプリングを通じて、以前は離散的だった潜在属性空間を、連続した滑らかな潜在空間に変換できます。

RL

エージェント: 知的体、つまりロボット、あなたのコードです。
環境: 環境、つまりゲーム自体。openai Gym はさまざまなゲームを提供します。つまり、複数のゲーム環境を提供します。
アクション: スーパーマリオをプレイしたり、上下に動かしたりするなどのアクション。
State : 状態。エージェントがアクションを実行するたびに、環境はそれに応じて応答し、状態と報酬を返します。
報酬: 報酬 : ゲームルールに従ってスコアを獲得します。エージェントは得点の仕方を知りません。継続的にゲームのルールを理解しようとします。たとえば、この状態で上向きの動きをして得点した場合、次にこの環境状態になると、エージェントは得点する傾向があります。上向きの動きをします。

強化学習では、エージェント（Agent）が環境（Environment）の状態（State）を観察（Observation）し、意思決定（Action）を行うことで報酬（Reward）を得ることができます。

エージェントの目標は、期待される報酬を最大化するために行動する方法を学ぶことです。

ジムのコアインターフェイスは統合環境 Env であり、次のコアメソッドが含まれています。

1. reset(self): 環境の状態をリセットし、観測値の観測値を返します。
2. step(self,action): タイムステップを進めて [観察、報酬、完了、情報] を返します。
3. render(self,mode='human', close=False): 環境のフレームを再描画します。通常、デフォルトモードは、ウィンドウをポップアップするなど、より使いやすいモードです。
4. info(dict): デバッグ用の診断情報。
5. observation(object): 環境の観察を記述する、特定の環境のオブジェクトを返します。たとえば、カメラのピクセルデータ、ロボットの関節角度や関節速度、ボードゲームの盤面の状態などです。
6. reward(float): 前のアクションによって取得された合計報酬値を返します。
7. done(boolean): 環境をリセットする必要があるかどうかを返します。ほとんどのゲームタスクは複数のステージ (エピソード) に分かれており、done=true の場合、このステージが終了したことを意味します。

CartPole 環境の場合、各観測値は 4 つの浮動小数点を含む 1D Numpy ベクトルです。
1. カートの水平位置 (0 を中心)
2. カートの速度
3. ポールの角度 (垂直)
4. ポールの角速度

CartPole-v0 の例

env = gym.make('CartPole-v0') # 初始化环境
for i_episode in range(20): # 外层循环
	obs = env.reset()  返回观察值
	for t in range(100): # 内层循环
		env.render()  重绘环境的一帧。
		action = env.action_space.sample()  随机选取动作
		obs, re, done, info = env.step(action)
		print(obs)
		if done:
			print("done == True : %d" % (t+1))
			break
env.close()

深層強化学習

戦略的探索

強化学習では、エージェントがその動作を変更するために使用するアルゴリズムをポリシーと呼びます。たとえば、ポリシーは、観測を入力として受け取り、アクションを出力として受け取るニューラルネットワークである可能性があります。

探索戦略方法:
1)ランダム戦略: この戦略は、思いつく限り任意のアルゴリズムを使用できます;
2)トライアル戦略: 試して探索することができ、つまり、多数の実験を通じてパラメータの最適な組み合わせを選択できます;
3)遺伝的戦略アルゴリズム: 最適なパラメータを検索するための遺伝的アルゴリズムによる
4)ポリシー勾配(PG) : 最適化技術を使用し、ポリシーパラメータに関する報酬の勾配を評価し、より高い報酬に向けて勾配に従ってこれらのパラメータを調整します (勾配) ascent); 5) ニューラル
ネットワークポリシー: ニューラルネットワークは観測値を入力として受け取り、実行するアクションを出力します。各アクションの確率を推定し、推定された確率に基づいてアクションをランダムに選択します。

Q: 最高スコアのアクションを選択するのではなく、ニューラルネットワークによって与えられる確率に基づいてランダムなアクションを選択するのはなぜですか? A
: この方法により、エージェントは新しい動作の探索と実行可能なアクションの選択の間のバランスを見つけることができます。

行動の評価: 単位割り当て問題

強化学習では、エージェントがガイダンスを得る唯一の方法は報酬を介することですが、報酬は通常、まばらで遅れます。

クレジットの割り当ての問題: エージェントが報酬を受け取るとき、エージェントはどのアクションを信頼すべきか (または非難すべきか) をどのようにして知るのでしょうか。

解決戦略は、アクション後のスコアの合計に基づいてアクションを評価することであり、通常は各ステップで減衰率 r を適用します。減衰率が 0 に近い場合、将来の報酬は当面の報酬に比べてあまり意味がありません。逆に、減衰率が 1 に近い場合、将来への報酬は当面の報酬とほぼ同じになります。

エージェントが 3 回連続で右に進むことを決定した場合、最初のステップ後に +10、2 番目のステップ後に 0、3 番目のステップ後に -50 の報酬を受け取ります。r=0.8 の減衰率で、最初のステップの後には -50 が与えられます。 $r^2 ×(−50) = 10+ を取得します$ 。 $+0.8^2 ×(−50)=−22$ 。

Qラーニング

マルコフ連鎖には
N 個の状態が含まれており、ある状態から別の状態への遷移確率 (Transition Probability) は決定されており、過去の状態には依存しません (システムにはメモリがありません)。将来の状態分布は現在のみに依存し、過去とは何の関係もありません。すべての状態間の遷移確率関係は、遷移行列 (Transition Matrix) と呼ばれる行列で表すことができます。
マルコフ決定プロセス (MDP):
1) 各ステップで、エージェントはいくつかの可能なアクションのうち 1 つを選択でき、遷移確率は選択されたアクションによって異なります。一部の状態遷移は何らかの報酬 (正または負) を返します。エージェントの目標は、時間の経過とともに報酬を最大化するポリシーを見つけることです。
2) 任意の状態 s の最良の状態値を推定する方法 (V*(s) として示されます):

T(s,a,s') は、エージェントがアクション a を選択したときの状態 s から状態 s' への遷移確率です。
R(s,a,s') は、エージェントが状態 s から状態 s' へのアクション a を選択したときに得られる報酬です。γは割引率です。

Q値反復アルゴリズム:

動的プログラミングの例。複雑な問題を、反復的に解決できる扱いやすい部分問題に分割します。

原則: 状態アクション値 (s, a) は Q 値と呼ばれ、Q(s, a) と表されます。これは、この状態でアクションを実行した場合の将来の報酬期待値を返します。状態アクション (s, a) の最良の Q 値。Q*(s, a) として表されます。

仕組み: まずすべての Q 値推定値をゼロに初期化し、次に Q 値反復アルゴリズムを使用して更新します。

Q ラーニングアルゴリズムは、遷移確率と報酬が不明な状況に適応する Q 値反復アルゴリズムです。

对于每个状态 - 动作对（s，a），算法跟踪agent 在离开状态s时采取动作a的奖励的运行平均值，以及预期稍后获得的奖励。ターゲットポリシーは最適なアクションを実行するため、次の状態の最大 Q 値推定値を取得します。

評価 Q ラーニング
Q ラーニングの主な問題は、多くの状態とアクションを含む大規模、中規模の MDP 問題にはうまく対応できないことです。管理可能な数のパラメーターを使用して Q 値を近似する関数を見つけることは、評価 Q ラーニングと呼ばれます。

Q 値の推定に使用される DNN は、Deep Q Network (DQN) と呼ばれます。DQN を使用した近似 Q 学習は、ディープ Q ラーニング (DQL) と呼ばれます。

Qラーニングの例

簡単な例を使用して、Q ラーニングアルゴリズムの実行プロセスを紹介します。建物には 6 つの部屋があり、部屋は 0 ～ 5 の番号で表され、部屋はドアでつながっています。5号室は建物の周辺空間であり、大部屋ともいえる。まずエージェントを建物内の任意の部屋に配置します。その 1 つの目標は、その部屋から部屋 5 まで歩くことです。

ここに画像の説明を挿入

初期化：Q、R、γの初期化
Qラーニングアルゴリズム

ここに画像の説明を挿入

Step 1 给定参数 和R矩阵，Q=0.
Step 2 循环执行Step3,4
Step 3 随机选择一个初始状态s
Step 4 循环执行：
	1.判断s是否是目标状态，如否则执行下列步骤,如是则结束Step 4.
	2.在当前状态s的所有可能行动中选取一个动作a
	3.利用选定的动作a，得到下一个状态s~
	4.利用公式计算Q(s,a)
	5.令s=s~

実装プロセス

 循环1
 	令初始状态为1。
 	状态不为5，则在R矩阵中选择状态1的可能动作：3或5。
 	选择状态5，得到下一个状态为5。
 	利用公式计算Q(1,5)
 	Q矩阵更新为：
 		当前状态为5，所以下次循环判断后即可结束

ここに画像の説明を挿入

	循环2
		回到Step 3, 重新选择一个初始状态。
		选择初始状态为3.
		找出状态3的可能动作：1,2,4
		选择状态1，对应2个可能的动作：3或5
		利用公式计算Q(3,1)
		Q矩阵更新为：
			现在的当前状态变成了状态1，因为状态1不是目标状态，因此从状态1 的可能动作选择一个：3或5。
		选择状态5，其动作有3个可能：1,4或5；
		利用公式计算Q(1,5)

ここに画像の説明を挿入

	继续循环，继续执行多次后，将得到矩阵Q：
	
	一旦Q接近收敛状态，就可以指导Agent进行最佳路径选择。
	如，假定Agent从状态2出发，可到到下列路径：
	1. Q矩阵中，状态2的最大元素值为320，选择状态3；
	2. 状态3的最大元素值为400， 状态为1或4，选择状态4；
	3. 状态4的最大元素值为500，即状态5，到达目标。
	因此最佳路径为：2-3-4-5

深度学习架构-Tensorflow

深度学习基本概念

TensorFlow

共通機能

ピトーチ

nn.モジュール

nn.関数

RNN

CNN

畳み込み層

パディングについて

プーリング層:

RNN

LSTM

GRU

AE

ディープオートエンコーダー

畳み込み自動エンコーディング

RL

深層強化学習

戦略的探索

行動の評価: 単位割り当て問題

Qラーニング

Qラーニングの例

おすすめ