Experiência em código de reconhecimento de número manuscrito CV&NLP Foundation 6

Visualização geral do processo (ideias)

x é a imagem de entrada y é o rótulo correspondente à imagem

Uma nota sobre o conjunto de dados de treinamento

Construa a camada de rede de computação

这里输入x是[60000, 784]，输出的label y是10分类。像上一篇文章一样，写出各层的变化。
第一层: h1 = relu(x @ w1 + b1)
       其中，w1: [784, 512]，b1: [512]，h1: [784, 512]

第二层: h2 = relu(h1 @ w2 + b2)
       其中，w2: [512, 256]，b2: [256]，h2: [784, 256]

第三层: out = relu(h2 @ w3 + b3)
       其中，w3: [256, 10]，b3: [10]，out: [784, 10]

A versão clara do vídeo detalhado abaixo: Link: https://pan.baidu.com/s/1LibA6jI0bHylwo6qyGp4bA?pwd=njcw Código de extração: njcw

CVNLP Artigo Básico 6 Visão Geral da Construção de uma Camada de Rede Computacional

Calcule a perda de valor de perda

x.shape[0] é o número de fotos. O cálculo da perda aqui é a “perda média”, a perda total não é utilizada, ambas estão disponíveis, e o objetivo é reduzir o valor da perda

A versão clara do vídeo detalhado abaixo: Link: https://pan.baidu.com/s/1GVaP6S2sJ0qkeAL7MOUmcg?pwd=ffd4 Código de extração: ffd4

CVNLP Artigo Básico 6 Calcular a perda de valor de perda

Otimizar perda de valor de perda (minimizar perda)

A versão clara do vídeo detalhado abaixo: Link: https://pan.baidu.com/s/1IVt75gRfln_KnF0Yt4auyw?pwd=tyhc Código de extração: tyhc

Artigo básico 6 do CVNLP perda de valor de perda de otimização

Código de primeira experiência digital manuscrito

o código

Importe vários pacotes

import os # “os”是系统包
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # TensorFlow的最小打印日志的等级为2。
# TensorFlow集成了深度学习环境，每次运行都会显示一些电脑环境信息，设置了这个值，就可以隐藏一些不紧要的输出，更简洁。

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, optimizers, datasets

recuperar dados

(x, y), (x_val, y_val) = datasets.mnist.load_data() 
# (x,y)是训练集；(x_val, y_val)是验证集。
# 注: 这里写“(x_val, y_val)”只是为了更全一点，如果用不到验证集，用“_”代替便可

# 目前数据还是“数字类型”，需要将数据转换成深度学习里面的变量类型“tensor”
x = tf.convert_to_tensor(x, dtype=tf.float32) / 255 # x是图片数据，让矩阵元素是浮点数构成。除以255是处理图像的习惯，让矩阵中的值在0~1或者-1~0之间

y = tf.convert_to_tensor(y, dtype=tf.int32) # y是标签,此时y是0~9中的一个数,不会有小数点，是哪一类就是哪一类，用整数型就可以了

# 现在我们不想让“y”是单个数字形式。现在采用“独热编码one-hot”处理“label y”，关于独热编码见“CV&NLP基础文章5”。
y = tf.one_hot(y, depth=10) # depth就是标签y有几类，数字图片一共有10种。此时y从“一维单个数字”转换成了“十维向量”。
                            # 例: y是2的话，就用[0,0,1,0,0,0,0,0,0,0]表示。y是7的话，就用[0,0,0,0,0,0,1,0,0,0]表示。

print(f"6万张训练数据集的数据格式为: {x.shape}, {y.shape}")
print(tf.reduce_max(x), tf.reduce_min(x)) #上面除以255以后，“28*28维矩阵x”中最大的元素是1.0，最小的元素是0.0

Pré-processamento de dados (fatiamento)

train_dataset = tf.data.Dataset.from_tensor_slices((x, y)).batch(100) 
#以100个为一组对6万张训练集切片。此时一共有600组，每组各100张图片

Construir o modelo de cálculo (esta etapa é apenas para construir a estrutura, sem entrada e saída reais)

model = keras.Sequential([
    layers.Dense(512, activation='relu'),
    layers.Dense(256, activation='relu'),
    layers.Dense(10, activation='relu')
])
optimizer = optimizers.SGD(learning_rate=0.0001)
# 以上详情见本篇文章“搭建计算机网络层”视频

# 下面两行代码只是用来看看这个框架都有些什么参数
model.build(input_shape=(None, 784)) # None意思是没有输入图片, 仅是测试而已
model.summary() # 用来看框架内部结构的函数

# 下面输出解读:
# 第一列Layer层：这里是Dense函数产生的层
# 第二列就是每道工序的“输出维度”
# 第三列的参数就是 w、b的个数，以第一层工序举例: 第一层的输入是[None ,784]，
# 那么第一层的“W参数”就是[784, 512]，“b参数”就是[512]，所以784*512+512=401920个参数

comece a treinar

# 大循环，形参epoch是执行几轮“600次循环”的次数，多次训练数据集可以让计算机不断学习，降低loss值
# 每一轮大循环都是训练6万张图片极其标签，有“epoch”次大循环
def train_epoch(epoch): 
    
    # 小循环,只为训练6万张数据。根据切片,一共600次循环,每一次循环处理100张图片(x)和图片的标签(y)
    for step, (x, y) in enumerate(train_dataset): 
        
        # 计算loss
        with tf.GradientTape() as tape:
            # [b, 28, 28] => [b, 784]
            x = tf.reshape(x, (-1, 784))
            
            # [b, 784] => [b, 10]
            out = model(x) # 将输入x送入模型，得到out
            
            # x.shape[0]是输入的图片数，这里应为 100
            loss = tf.reduce_sum(tf.square(out-y)) / x.shape[0] 
            
        # 计算梯度，“model.trainable_variables”里面是各个w、b，更新w、b后也放入其中 
        # grads 里面是 w、b的梯度
        grads = tape.gradient(loss, model.trainable_variables)
        
        # 更新梯度 w' = w - learning rate * grad w      b' = b - learning rate * grad b
        optimizer.apply_gradients(zip(grads, model.trainable_variables))
        
        if step%50 == 0: # 小循环是600轮，每格50轮输出看看loss值，loss是tensor类型，需要转换成numpy类型来更好地查看
            print('epoch: {}, step: {}, loss: {}'.format(epoch, step, loss.numpy()))

def train():
    #每一轮大循环都换在训练6万张图片
    for epoch in range(10):
        print('当前是第 ', epoch, " 次 大循环")
        train_epoch(epoch)

train()

Captura de tela do JupyterLab em execução

Uso da função tf.convert_to_tensor

Descrição da função:
converta vários tipos de objetos python em objetos tensores

Converta o valor fornecido em Tensor.
Esta função converte vários tipos de objetos Python em objetos Tensor. Aceita objetos Tensor, matrizes numpy, listas Python e escalares Python.
Parâmetros:
valor: dtype a ser convertido
: tipo de elemento opcional do tensor retornado. Se estiver ausente, o tipo será inferido a partir do tipo de valor.
nome: nome opcional a ser usado se o Tensor criar um novo.
Retorno:
uma operação de saída baseada em valor (ops), produz um tensor (próprio entendimento)

convert_to_tensor(
    value,
    dtype=None,
    name=None,
    preferred_dtype=None
)

Exemplo:

a = np.array([1,2,3])
b = tf.convert_to_tensor(a)
print(type(a)) # <class 'numpy.ndarray'>
print(type(b)) # <class 'tensorflow.python.framework.ops.Tensor'>

Suplemento: operação de remodelação do tensorflow tf.reshape()

1. Ao processar dados de imagem, sempre haverá situações em que as dimensões da imagem de entrada não correspondem.Neste momento, reshape() no tensorflow resolve esse problema muito bem.

2. numpy.reshape() é semelhante ao tensorflow, reshape()

3. Formatar:tf.reshape(tensor,shape,name=None)

4. A função da função é transformar o tensor na forma do parâmetro shape, onde a forma está na forma de uma lista. A característica especial é que a lista pode ser percorrida na ordem inversa, ou seja, list(-1 ). -1所代表的含义是我们不用亲自去指定这一维的大小，函数会自动进行计算，但是列表中只能存在一个-1。(Se houver vários -1s, é uma equação com múltiplas soluções)

Na operação real, o efeito é o seguinte: criei um array unidimensional:

>>>import numpy as np
>>>a= np.array([1,2,3,4,5,6,7,8])
>>>a
array([1,2,3,4,5,6,7,8])

Use o método reshape() para alterar a forma do array, tornando-o um array bidimensional: (o número de elementos no array é 2×4=8)

>>>d = a.reshape((2,4))
>>>d
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

Melhorias adicionais, você pode obter uma matriz tridimensional f: (observe que o número de elementos na matriz é 2×2×2=8)

>>>f = a.reshape((2,2,2))
>>>f
array([[[1, 2],
        [3, 4]],
 
       [[5, 6],
        [7, 8]]])

Aplicação de -1: -1 表示不知道该填什么数字合适的情况下，可以选择，由python通过a和其他的值3推测出来, por exemplo, aqui a é um array bidimensional e há 6 elementos no array. Ao usar reshape(), 6/3=2, então um array bidimensional com 3 linhas e 2 colunas é formado. Pode-se ver que, ao usar reshape para converter a forma do array, ele deve satisfazer o número de x*y=arrays em (x,y).

>>>a = np.array([[1,2,3],[4,5,6]])
>>>np.reshape(a,(3,-1)) 
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> np.reshape(a,(1,-1))
array([[1, 2, 3, 4, 5, 6]])
>>> np.reshape(a,(6,-1))
array([[1],
       [2],
       [3],
       [4],
       [5],
       [6]])
>>> np.reshape(a,(-1,1))
array([[1],
       [2],
       [3],
       [4],
       [5],
       [6]])

Abaixo estão duas imagens 2×3 (não sei quantas imagens podem ser substituídas por -1), como converter todas as fotos bidimensionais em unidimensionais, consulte a seguinte matriz tridimensional:

>>>image = np.array([[[1,2,3], [4,5,6]], [[1,1,1], [1,1,1]]])
>>>image.shape
(2,2,3)
>>>image.reshape((-1,6))
array([[1, 2, 3, 4, 5, 6],
       [1, 1, 1, 1, 1, 1]])
>>> a = image.reshape((-1,6))
>>> a.reshape((-1,12))
array([[1, 2, 3, 4, 5, 6, 1, 1, 1, 1, 1, 1]])
a.reshape((12,-1))
array([[1],
       [2],
       [3],
       [4],
       [5],
       [6],
       [1],
       [1],
       [1],
       [1],
       [1],
       [1]])
>>> a.reshape([-1])
array([1, 2, 3, 4, 5, 6, 1, 1, 1, 1, 1, 1])

Por fim, vou mostrar o exemplo oficial:

# tensor 't' is [1, 2, 3, 4, 5, 6, 7, 8, 9]
# tensor 't' has shape [9]
reshape(t, [3, 3]) ==> [[1, 2, 3],
                        [4, 5, 6],
                        [7, 8, 9]]
 
# tensor 't' is [[[1, 1], [2, 2]],
#                [[3, 3], [4, 4]]]
# tensor 't' has shape [2, 2, 2]
reshape(t, [2, 4]) ==> [[1, 1, 2, 2],
                        [3, 3, 4, 4]]
 
# tensor 't' is [[[1, 1, 1],
#                 [2, 2, 2]],
#                [[3, 3, 3],
#                 [4, 4, 4]],
#                [[5, 5, 5],
#                 [6, 6, 6]]]
# tensor 't' has shape [3, 2, 3]
# pass '[-1]' to flatten 't'
reshape(t, [-1]) ==> [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]
 
# -1 can also be used to infer the shape
 
# -1 is inferred to be 9:
reshape(t, [2, -1]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
                         [4, 4, 4, 5, 5, 5, 6, 6, 6]]
# -1 is inferred to be 2:
reshape(t, [-1, 9]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
                         [4, 4, 4, 5, 5, 5, 6, 6, 6]]
# -1 is inferred to be 3:
reshape(t, [ 2, -1, 3]) ==> [[[1, 1, 1],
                              [2, 2, 2],
                              [3, 3, 3]],
                             [[4, 4, 4],
                              [5, 5, 5],
                              [6, 6, 6]]]
 
# tensor 't' is [7]
# shape `[]` reshapes to a scalar
reshape(t, []) ==> 7