Introducción a la competencia
Título de la competencia:
Concurso de reconocimiento de captcha basado en caracteres de texto
Unidad de pregunta:
Banco Industrial Co., Ltd.
Antecedentes del concurso:
Como método de verificación de seguridad rentable, los códigos de verificación se han utilizado ampliamente en muchas ocasiones, evitando de manera efectiva que los robots realicen suplantación de identidad.Entre ellos, los códigos de verificación estáticos basados en caracteres de texto son los más comunes. Con la profundización del uso, los puntos de ruido, las líneas de ruido, la superposición, la deformación y otros métodos de interferencia emergen en un flujo interminable, y el nivel de seguridad se mejora constantemente. Como clave para la transformación digital de las empresas, las empresas prefieren la tecnología RPA debido a su implementación no intrusiva, y la baja tasa de reconocimiento del código de verificación a menudo limita la aplicación de la tecnología RPA. Un modelo CAPTCHA que puede filtrar múltiples interferencias al mismo tiempo tiene cierto valor comercial para la expansión y el uso de tecnologías de automatización relacionadas.
Tareas del concurso:
En esta competencia, los datos de la imagen del código de verificación de caracteres de ejemplo con información de caracteres marcados se utilizan como muestra de entrenamiento. Los concursantes deben construir un modelo basado en las muestras proporcionadas, identificar las imágenes del código de verificación de caracteres en el conjunto de prueba y extraer caracteres válidos. información. El conjunto de datos de entrenamiento no se limita a los datos proporcionados y se puede agregar a conjuntos de datos disponibles públicamente.
Introducción de datos
Esta competencia proporciona a los jugadores 15 000 conjuntos de datos de entrenamiento con información de anotaciones. Cada dato de entrenamiento es una imagen captcha que contiene un carácter de texto de 4 dígitos, y los caracteres de texto en la imagen actual están marcados; el conjunto de datos de prueba contiene 25 000 imágenes captcha.
Hacer quejas
¡Hay mucha gente quejándose de este juego! Para resumir los siguientes puntos:
1. Hay una gran brecha entre la distribución de datos de la lista A y la lista B, lo que hace que muchas filas delanteras cambien a la fila trasera. Hizo que innumerables expertos se inclinaran.
2. El juego tiene poca importancia Este es un juego por el bien del juego.
solución
Mirando los chats de los grandes en el grupo de competencia, aprendí que los mejores métodos de puntuación utilizados por todos son: validación cruzada de 50 veces, CutOut, CutMix, MixUp, datos generados, etc. El modelo generalmente utiliza EfficientNetV1 y V2.
También utilicé algunos de los métodos anteriores en la subsección superior.Mi solución es: EfficientNetV1-B7+MixUp+CutOut. Más tarde, se agregó CutMix y no hubo tiempo para probar el efecto. El reconocimiento del código de verificación se realiza de acuerdo con la clasificación multietiqueta.
Github de referencia de la solución: https://github.com/zyf-xtu/captcha_ocr
Puntaje de entrenamiento: 0.9854, debido a que la evaluación ha sido cerrada, no hay forma de saber el puntaje en la lista A.
A continuación se muestra una descripción detallada de mi plan.
datos
Las modificaciones a la sección de datos se encuentran en el archivo captcha_dataset.py. Modificado el método geitem:
def __getitem__(self, index):
img_path, target = self.samples[index]
# #print('target', target)
# #print('random_t', random_t)
img = img_loader(img_path)
if np.random.random() > 0.5 and self.train_type==True:
img_arr = np.array(img)
index_arr=np.random.permutation(img_arr.shape[2])
img_arr=img_arr[:,:,index_arr]
img = Image.fromarray(img_arr.astype('uint8')).convert('RGB')
if np.random.random() > 0.5 and self.train_type==True:
img_random_path, random_t = self.samples[np.random.randint(0, len(self.samples))]
img_random = img_loader(img_random_path)
img_arr = np.array(img)
img_random_arr = np.array(img_random)
img_arr[:, 50:100, :] = img_random_arr[:, 50:100, :]
img = Image.fromarray(img_arr.astype('uint8')).convert('RGB')
target = target[:124] + random_t[124:]
if self.transform is not None:
img = self.transform(img)
if self.target_transform is not None:
target = self.target_transform(target)
return img, torch.Tensor(target)
En este método, agregué dos mejoras de datos, una es aleatoria al canal, es decir, la aleatoria de RGB; la otra es CutMix, que empalma la primera mitad de la imagen con la segunda mitad de otra imagen. Luego Label también hace el empalme correspondiente.
Capacitación
El entrenamiento es la parte más importante, estas modificaciones están en train_1.py, enumero los lugares que modifiqué:
image_sizeh,image_sizew=240,600
Establezca el tamaño de cambio de tamaño de la imagen en 240 × 600 y amplíe 6 veces.
Aumento de datos Aumenté CutOut:
Cutout usa torchtoolbox, si no tiene torchtoolbox necesita instalarlo:
pip install torchtoolbox
Importar después de la instalación:
from torchtoolbox.transform import Cutout
Luego llámalo en transforms.
# transform = [, transforms.GaussianBlur(21, 10)]
train_transform = transforms.Compose([
Cutout(),
transforms.Resize((image_sizeh, image_sizew)), # 图像放缩
transforms.RandomRotation((-5, 5)), # 随机旋转
# transforms.RandomVerticalFlip(p=0.2), # 随机旋转
transforms.ToTensor(), # 转化成张量
transforms.Normalize(
mean=train_mean,
std=train_std
)
])
Modifiqué la parte de datos de carga:
# 加载训练数据集，转化成标准格式
train_dataset = CaptchaData(train_paths,train_type=True, transform=train_transform)
# 加载验证集，转化成标准格式
val_dataset = CaptchaData(val_paths,train_type=False, transform=val_transform)
El campo train_type se agrega para determinar si está entrenando, si está entrenando, se realiza la mejora de datos, y si no, no se realiza la mejora de datos.
# 如果是多个gpu，数据并行训练
device_ids = [0, 1]
model = torch.nn.DataParallel(model, device_ids=device_ids)
Para aumentar el paralelismo de varias GPU, mi entorno local tiene dos 3090, por lo que los id_dispositivos se establecen en 0 y 1.
cosine_schedule = optim.lr_scheduler.CosineAnnealingLR(optimizer=optimizer, T_max=20, eta_min=1e-6)
Para el ajuste de la tasa de aprendizaje, utilizo el recocido de coseno. El valor inicial de la tasa de aprendizaje es 1e-3, y la configuración mínima es 1e-6.
inputs, labels_a, labels_b, lam = mixup_data(inputs, labels, 0.2)
# 预测输出
outputs = model(inputs)
# 计算MixUp loss
loss = mixup_criterion(loss_func, outputs, labels_a, labels_b, lam)
Al agregar confusión, la puntuación de confusión sigue siendo relativamente obvia.
Otro gran tipo en esta competencia también hizo código abierto, dirección de github: https://github.com/xiaoxiaokuaile/2022DCIC_OCR
Resumir
Aunque esta competencia no es perfecta, he aprendido mucho durante la competencia, creo que esto es lo más importante.
Código completo: https://download.csdn.net/download/hhhhhhhhhhwwwwwwwwwwwwwww/85050647