En este tutorial, exploramos técnicas avanzadas de visión por computadora utilizando transformaciones V2 de TorchVision, estrategias de aumento modernas y potentes mejoras de capacitación. Caminamos por el proceso de construcción de una tubería de aumento, aplicando Mezcla y Cutmix, diseñando un CNN moderno con atención e implementando un bucle de capacitación robusto. Al ejecutar todo sin problemas en Google Colab, nos posicionamos para comprender y aplicar prácticas de vanguardia en un aprendizaje profundo con claridad y eficiencia. Mira los códigos completos aquí.
Comenzamos instalando las bibliotecas e importando todos los módulos esenciales para nuestro flujo de trabajo. Configuramos Pytorch, transformaciones V2 de Vision V2 y herramientas de soporte como Numpy, PIL y Matplotlib, por lo que estamos listos para construir y probar tuberías avanzadas de visión por computadora. Mira los códigos completos aquí.
v2.ToImage(),
v2.ToDtype(torch.uint8, scale=True),
]
Si capacita: self.transform = v2.comPose ([
*base_transforms,
v2.Resize((image_size + 32, image_size + 32)),
v2.RandomResizedCrop(image_size, scale=(0.8, 1.0), ratio=(0.9, 1.1)),
v2.RandomHorizontalFlip(p=0.5),
v2.RandomRotation(degrees=15),
v2.ColorJitter(brights=0.4, contst=0.4, sation=0.4, hue=0.1),
v2.RandomGrayscale(p=0.1),
v2.GaussianBlur(kernel_size=3, sigma=(0.1, 2.0)),
v2.RandomPerspective(distortion_scale=0.1, p=0.3),
v2.RandomAffine(degrees=10, translate=(0.1, 0.1), scale=(0.9, 1.1)),
v2.ToDtype(torch.float32, scale=True),
v2.Normalize(mean=[0.485, 0.456, 0.406]std =[0.229, 0.224, 0.225])]) else: self.transform = v2.comPose ([
*base_transforms,
v2.Resize((image_size, image_size)),
v2.ToDtype(torch.float32, scale=True),
v2.Normalize(mean=[0.485, 0.456, 0.406]std =[0.229, 0.224, 0.225])]) def __call __ (self, imagen): return self.transform (imagen)
Definimos una tubería de aumento avanzada que se adapta a los modos de entrenamiento y validación. Aplicamos poderosas transformaciones de V2 V2, como recortar, voltear, fluctuar de color, desenfoque, perspectiva y transformaciones afines, durante el entrenamiento, mientras mantienen el preprocesamiento de validación simple con el cambio de tamaño y la normalización. De esta manera, nos aseguramos de enriquecer los datos de capacitación para una mejor generalización mientras mantenemos una evaluación consistente y estable. Mira los códigos completos aquí.
y_a, y_b = y, y[index]
return mixed_x, y_a, y_b, lam def CutMix (self, x, y): batch_size = x.size (0) lam = np.random.beta (self.cutmix_alpha, self.cutmix_alpha) if self.cutmix_alpha> 0 else 1 index.randperm (batch_size) Y_B, y_b, y_, y_be, y_be, y_be, y_be, y_be, y_be, y_, y_be, y_be, y_be, y_be, y_be, y_be, y_be, y_be, y_be, y_, y_, y_, y_, y_, y_bat.[index]
BBX1, BBY1, BBX2, BBY2 = Self._rand_bbox (x.size (), Lam) X[:, :, bbx1:bbx2, bby1:bby2] = x[index, :, bbx1:bbx2, bby1:bby2]
Lam = 1 – ((BBX2 – BBX1) * (BBY2 – BBY1) / (X.Size ()[-1] * x.size ()[-2])) return x, y_a, y_b, lam def _rand_bbox (self, size, lam): w = tamaño[2]
H = tamaño[3]
Cut_rat = np.sqrt (1. – Lam) Cut_w = int (W * CUT_RAT) CUT_H = INT (H * CUT_RAT) CX = NP.RANDOM.RANDINT (W) CY = NP.RANDOM.RANDINT (H) BBX1 = NP.CLIP (CX – CUT_W // 2, 0, W) BBY1 = NP.CLIP 2, 0, h) bbx2 = np.clip (cx + cut_w // 2, 0, w) bby2 = np.clip (cy + cut_h // 2, 0, h) return bbx1, bby1, bbx2, bby2 def __call __ (self, x, y): si np.random.random ()> self.pRob: np.random.random () <0.5: return self.mixup (x, y) else: return self.cutmix (x, y) clase moderncnn (nn.module): def __init __ (self, num_classes = 10, dsout = 0.3): super (moderncnnn, self) .__ __ () self.conv1 = self._convv_block (3, 64) self.conv2 = self._conv_block (64, 128, downsample = true) self.conv3 = self._conv_block (128, 256, downsample = true) self.conv4 = self._conv_block (256, 512, downsample = true) self.gap = nn.adaptiveAvgPool2d (1) Self.attention (nnne. nn.linear (512, 256), nn.relu (), nn.linear (256, 512), nn.sigmoid ()) self.classifier = nn.sequential (nn.dropout (desacelerado), nn.linear (512, 256), nn.batchnorm1d (256), nn.Relu (),),), nn.dropout (desacuerdo/2), nn.linear (256, num_classes)) def _conv_block (self, in_channels, out_channels, downsample = false): stride = 2 si downsample más 1 return nn.shonentsuencial (nn.conv2d (in_channels, out_channels, 3, stride = stride, padding = 1- 1Sequential, nn.batchnorm2d (out_channels), nn.relu (inplace = true), nn.conv2d (out_channels, out_channels, 3, padding = 1), nn.batchnorm2d (out_channels), nn.relu (injace = true)) defle (self): x = self.conv1 (x) x) x) self.conv3 (x) x = self.conv4 (x) x = self.gap (x) x = tortch.flatten (x, 1) Attitude_weights = Self.attention (x) x = x * Atenty_weights return Self.classifier (x)
Fortalecemos nuestro entrenamiento con un módulo unificado de mezcla/CutMix, donde combinamos estocásticamente imágenes o regiones de intercambio de parches y calculamos la interpolación de etiquetas con la relación píxel exacta. Combinamos esto con un CNN moderno que apila los bloques de convivencia progresiva, aplica la agrupación promedio global y utiliza una puerta de atención aprendida antes de un clasificador regularizado de abandono, por lo que mejoramos la generalización mientras mantenemos la inferencia directa. Mira los códigos completos aquí.
Orquestamos el entrenamiento con Adamw, Onecyclelr y Dynamic Michup/Cutmix, por lo que estabilizamos la optimización y aumentamos la generalización. Calculamos una pérdida interpolada al mezclar, recortar gradientes por seguridad y pasar el planificador cada lote, por lo que seguimos el seguimiento de la pérdida/precisión por época en un solo bucle apretado. Mira los códigos completos aquí.
Pérdida, ACC = Trainer.train_epoch (Dummy_Loader) Print (f “Pérdida de entrenamiento: {pérdida: .4f}”) print (f “precisión de entrenamiento: {acc: .2f}%”) imprime (f “tasa de aprendizaje: {entrenador.scheduler.get_last_lr ()[0]: .6f} “) print (” \ n✅ tutorial completado con éxito! “) Impresión (” Este código demuestra técnicas de estado de arte en aprendizaje profundo: “) Impresión (” • Aumento de datos avanzado con TorchVision v2 “) imprimir (” • MIXP y CUTMIX para una mejor generalización “) Impresión (” • Arquitectura moderna con atención “) y descomposición de peso “) si __name__ ==” __main__ “: Demo_advanced_techniques ()
Ejecutamos una demostración compacta de extremo a extremo donde visualizamos nuestra tubería de aumento, aplicamos MIXP/CUTMIX y verificamos dos veces el Moderncnn con un pase hacia adelante. Luego simulamos una época de entrenamiento en los datos ficticios para verificar la pérdida, la precisión y la programación de la tasa de aprendizaje, por lo que confirmamos que los trabajos de pila completo antes de escalar a un conjunto de datos real.
En conclusión, hemos desarrollado y probado con éxito un flujo de trabajo integral que integra aumentos avanzados, diseño innovador de CNN y estrategias de capacitación modernas. Al experimentar con TorchVision V2, mezcla, Cutmix, mecanismos de atención y Onecyclelr, no solo fortalecemos el rendimiento del modelo, sino que también profundizamos nuestra comprensión de las técnicas de vanguardia.
Mira los códigos completos aquí. No dude en consultar nuestra página de GitHub para obtener tutoriales, códigos y cuadernos. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro subreddit de 100k+ ml y suscribirse a nuestro boletín.
Asif Razzaq es el CEO de MarktechPost Media Inc .. Como empresario e ingeniero visionario, ASIF se compromete a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, MarktechPost, que se destaca por su cobertura profunda de noticias de aprendizaje automático y de aprendizaje profundo que es técnicamente sólido y fácilmente comprensible por una audiencia amplia. La plataforma cuenta con más de 2 millones de vistas mensuales, ilustrando su popularidad entre el público.
🔥[Recommended Read] NVIDIA AI Open-Sources Vipe (motor de pose de video): una herramienta de anotación de video 3D potente y versátil para AI espacial