2021A立方冬令营 三 . test3 我也不知道2是啥

常规开局定义一堆

from captcha.image import ImageCaptcha
import matplotlib.pyplot as plt
import numpy as np
import random
import string
characters = string.digits + string.ascii_uppercase 
# 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
print(characters)
from tensorflow.keras.utils import Sequence

请横屏观看

class CaptchaSequence(Sequence):
    def __init__(self,characters,batch_size,steps,n_len=4,width=128,height=64):
        self.characters = characters
        self.batch_size = batch_size
        self.steps = steps
        self.n_len = n_len
        self.width = width
        self.height = height
        self.n_class = len(characters)
        self.generator = ImageCaptcha(width = width,height =height)

    def __len__(self):                                                                      #使用len(CaptchaSequence)时返回值时
        return self.steps

    def __getitem__(self, idx):                                                             #使用CaptchaSequence[]时返回值时
        x = np.zeros((self.batch_size,self.height,self.width,3),dtype=np.float32)
        #建立一个数组，初始每一项为0，[一次训练所选取的样本数][高度][宽度][通道数]
        y = [np.zeros((self.batch_size,self.n_class),dtype=np.uint8) for i in range(self.n_len)]
        #[array([batch_size]*[n_class], dtype=uint8)*n_lenth个]
        for i in range(self.batch_size):
            random_str = ''.join([random.choice(self.characters)for j in range(self.n_len)])#随机拼接长度为n的字符串
            x[i] = np.array(self.generator.generate_image(random_str))/255.0                #随机图片/255（归一化）
            for j,ch in enumerate(random_str):                                              #（enumerate（迭代数组））j=1,2,3,4的迭代次数，ch是被迭代的值循环随机数个数次，长度=self.n_len
                y[j][i,:] = 0                                                               #y[self.n_len][batch_size][随机数中存在的数字所对应的onehot位]（无就0，有就1)
                y[j][i,self.characters.find(ch)] = 1
        return x,y

常规decode

def decode(y):
    y = np.argmax(np.array(y), axis=2)[:, 0]
    #np.argmax(np.array(y), axis=2)[:, 0]==>返回值应该是[4，1]的数组，每一项对应的是36个数中的最大的序号，然后也给他正过来变成[4]数组（每个数组中的数字代表着该行中数字最大的项（onehot编码中代表取该数））
    return ''.join([characters[x] for x in y])                  #输出概率最大的字符串（''.join([characters[x] for x in y])为onehot解码手段）

一个栗子

if __name__ == '__main__':
    data = CaptchaSequence(characters, batch_size=1, steps=1)   #一个栗子，显示一张图和他对应的字符
    X, y = data[0]
    plt.imshow(X[0])
    plt.title(decode(y))
    plt.show()

定义mode

from tensorflow.keras.models import *
from tensorflow.keras.layers import *
import string
width=128
height=64
n_len = 4
characters =string.digits + string.ascii_uppercase
n_class = len(characters)

input_tensor = Input((height,width,3))                  #这是输入的shape
x = input_tensor
for i,n_cnn in enumerate([2,2,2,2,2]):                  #(enumerate([2,2,2,2,2])返回值（第几个数）（2（被遍历到的东西））)
    for j in range(n_cnn):
        x = Conv2D(32*2**min(i,3),kernel_size=3,padding='same',kernel_initializer='he_uniform')(x)
        x = BatchNormalization()(x)                     #批量规范化（Batch Normalization）方法，能大幅加速模型训练，同时保持预测准确率不降，因而被一些优秀模型采纳为标准模型层。
        x = Activation('relu')(x)                       #relu作为激活函数
    x = MaxPooling2D(2)(x)                              #池化都是默认参数，2好像也是默认的

x = Flatten()(x)                                        #啪，拍平
x = [Dense(n_class,activation='softmax',name='c%d'%(i+1))(x) for i in range(n_len)]     #再加四个全连接层
model = Model(inputs=input_tensor,outputs=x)            #模型输入=输入，输出=输出（x）

花里胡哨

from tensorflow.keras .callbacks import EarlyStopping,CSVLogger,ModelCheckpoint
from tensorflow.keras.optimizers import *

train_data = CaptchaSequence(characters,batch_size=128,steps=1000)
valid_data = CaptchaSequence(characters,batch_size=128,steps=100)
#两个训练集
callbacks = [EarlyStopping(patience=3),CSVLogger('cnn.csv'),ModelCheckpoint('cnn_best.h5',save_best_only=True)]
#EarlyStopping:Callbacks的一种，callbacks用于指定在每个epoch开始和结束的时候进行哪种特定操作。
#CSVLogger:Callbacks的一种，将epoch（迭代次数）结果流式传输到csv文件的回调。
#ModelCheckpoint:该回调函数将在每个epoch后保存模型到filepath
model.compile(loss='categorical_crossentropy',optimizer=Adam(1e-3,amsgrad=True),metrics=['accuracy'])
#分别配置优化器，损失函数，准确率

model.fit_generator(train_data,epochs=10,validation_data=valid_data,workers=4,callbacks=callbacks)
#利用Python的生成器，逐个生成数据的batch并进行训练。生成器与模型将并行执行以提高效率。

EarlyStopping:
monitor: 监控的数据接口，有’acc’,’val_acc’,’loss’,’val_loss’等等。正常情况下如果有验证集，就用’val_acc’或者’val_loss’。但是因为笔者用的是5折交叉验证，没有单设验证集，所以只能用’acc’了。
min_delta：增大或减小的阈值，只有大于这个部分才算作improvement。这个值的大小取决于monitor，也反映了你的容忍程度。例如笔者的monitor是’acc’，同时其变化范围在70%-90%之间，所以对于小于0.01%的变化不关心。加上观察到训练过程中存在抖动的情况（即先下降后上升），所以适当增大容忍程度，最终设为0.003%。
patience：能够容忍多少个epoch内都没有improvement。这个设置其实是在抖动和真正的准确率下降之间做tradeoff。如果patience设的大，那么最终得到的准确率要略低于模型可以达到的最高准确率。如果patience设的小，那么模型很可能在前期抖动，还在全图搜索的阶段就停止了，准确率一般很差。patience的大小和learning rate直接相关。在learning rate设定的情况下，前期先训练几次观察抖动的epoch number，比其稍大些设置patience。在learning rate变化的情况下，建议要略小于最大的抖动epoch number。笔者在引入EarlyStopping之前就已经得到可以接受的结果了，EarlyStopping算是锦上添花，所以patience设的比较高，设为抖动epoch number的最大值。
mode: 就’auto’, ‘min’, ‘,max’三个可能。如果知道是要上升还是下降，建议设置一下。笔者的monitor是’acc’，所以mode=’max’。

https://blog.csdn.net/qq_28949847/article/details/109067395
ModelCheckpoint:
filename：字符串，保存模型的路径，filepath可以是格式化的字符串，里面的占位符将会被epoch值和传入on_epoch_end的logs关键字所填入。
例如：
filepath = “weights_{epoch:03d}-{val_loss:.4f}.h5”
则会生成对应epoch和验证集loss的多个文件。
monitor：需要监视的值，通常为：val_acc 或 val_loss 或 acc 或 loss
verbose：信息展示模式，0或1。为1表示输出epoch模型保存信息，默认为0表示不输出该信息，信息形如：
Epoch 00001: val_acc improved from -inf to 0.49240, saving model to /xxx/checkpoint/model_001-0.3902.h5
save_best_only：当设置为True时，将只保存在验证集上性能最好的模型
mode：‘auto’，‘min’，‘max’之一，在save_best_only=True时决定性能最佳模型的评判准则，例如，当监测值为val_acc时，模式应为max，当检测值为val_loss时，模式应为min。在auto模式下，评价准则由被监测值的名字自动推断。
save_weights_only：若设置为True，则只保存模型权重，否则将保存整个模型（包括模型结构，配置信息等）
period：CheckPoint之间的间隔的epoch数



model.compile(optimizer = 优化器，

                       loss = 损失函数，

                       metrics = ["准确率”])



https://blog.csdn.net/qq_32951799/article/details/82918098
model.fit_generator()
利用Python的生成器，逐个生成数据的batch并进行训练。生成器与模型将并行执行以提高效率。例如，该函数允许我们在CPU上进行实时的数据提升，同时在GPU上进行模型训练
函数的参数是：
generator：生成器函数，生成器的输出应该为：
一个形如（inputs，targets）的tuple
一个形如（inputs, targets,sample_weight）的tuple。所有的返回值都应该包含相同数目的样本。生成器将无限在数据集上循环。每个epoch以经过模型的样本数达到samples_per_epoch时，记一个epoch结束
steps_per_epoch：整数，当生成器返回steps_per_epoch次数据时计一个epoch结束，执行下一个epoch
epochs：整数，数据迭代的轮数
verbose：日志显示，0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录
validation_data：具有以下三种形式之一
生成验证集的生成器
一个形如（inputs,targets）的tuple
一个形如（inputs,targets，sample_weights）的tuple
validation_steps: 当validation_data为生成器时，本参数指定验证集的生成器返回次数
class_weight：规定类别权重的字典，将类别映射为权重，常用于处理样本不均衡问题。
sample_weight：权值的numpy array，用于在训练时调整损失函数（仅用于训练）。可以传递一个1D的与样本等长的向量用于对样本进行1对1的加权，或者在面对时序数据时，传递一个的形式为（samples，sequence_length）的矩阵来为每个时间步上的样本赋不同的权。这种情况下请确定在编译模型时添加了sample_weight_mode='temporal'。
workers：最大进程数
max_q_size：生成器队列的最大容量
pickle_safe: 若为真，则使用基于进程的线程。由于该实现依赖多进程，不能传递non picklable（无法被pickle序列化）的参数到生成器中，因为无法轻易将它们传入子进程中。
initial_epoch: 从该参数指定的epoch开始训练，在继续之前的训练时有用。

# from tqdm import tqdm
# def evaluate(model,batch_num=100):
#     batch_acc = 0
#     with tqdm(CaptchaSequence(characters,batch_size=128,steps=100))as pbar:       #使用进度条，定义进度条参数
#         for X,y in pbar:
#             y_pred = model.predict(x)
#             y_pred = np.argmax(y_pred,axis=-1).T
#             y_true = np.argmax(y,axis=-1).mean()
#     return batch_acc/batch_num
# evaluate(model)

进度条美化（跑不起来就让我注释掉了）