from torch.utils.data import * from imutils import paths import numpy as np import random import cv2 import os DATA=[ '京', '沪', '津', '渝', '冀', '晋', '蒙', '辽', '吉', '黑', '苏', '浙', '皖', '闽', '赣', '鲁', '豫', '鄂', '湘', '粤', '桂', '琼', '川', '贵', '云', '藏', '陕', '甘', '青', '宁', '新', # 31 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', # 10 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'I', 'O', '-' # 27 ] DATA_DICT={char : i for i, char in enumerate(DATA)} class LPRDataLoader(Dataset): def __init__(self,image_dir,imagesize,Lpr_max_len,preprocFun=None): self.image=image_dir self.image_paths=[] for i in range(Lpr_max_len): self.image_paths+=[el for el in paths.list_images(img_dir[i])] random.shuffle(self.image_paths) self.Lpr_max_len=Lpr_max_len self.imagesize=imagesize if preprocfun is not None: self.preprocfun=preprocfun else: self.preprocfun=self.transform def __len__(self): return len(self.image_paths) def __getitem__(self, idx): filename=self.image_paths[idx] img=cv2.imdecode(np.fromfile(filename,dtype=np.uint8),-1) height, width,_ = img.shape if height !=self.imagesize[1] or width!=self.imagesize[0]: img=resize(img,self.imagesize) img=self.preprocfun(img) basename=os.path.basename(filename) imagename,suffix=os.path.splitext(basename) imagename= imagename.split('_')[0].split('_')[0] label=[] for c in imagename: label.append(DATA_DICT[c]) if len(label)==8: if self.check(label)== False: print(imagename) assert 0, "Error label ^~^!!!" return img,label,len(label) def check(self,label): if label[2]!=DATA_DICT['D'] and label[2]!=DATA_DICT['F'] and label[-1]!=DATA_DICT['D'] and label[-1]!=DATA_DICT['F']: print("Error label, Please check!") return False else: return True def transform(self,img): img = img.astype('float32') img -= 127.5 img *= 0.0078125 img = np.transpose(img, (2, 0, 1))

<think>我们正在构建一个车牌识别（LPR）的数据加载器。这个数据加载器继承自PyTorch的Dataset类，用于加载车牌图像和对应的标签。 主要步骤包括： 1. 初始化：设置图像目录、图像大小、车牌最大长度以及预处理函数。 2. 获取数据集中样本的数量：通过__len__方法实现。 3. 获取单个样本：通过__getitem__方法实现，包括读取图像、调整大小、预处理、解析标签并转换为数字序列。 4. 标签检查：确保车牌标签符合特定规则（例如，某些位置必须是特定字符）。 然而，在阅读代码时，我发现了一些问题需要修正： a) 在__init__中，参数`image_dir`被当作一个列表使用（通过索引访问），但传入时可能是一个字符串（单个目录）或列表（多个目录）？目前代码中`for i in range(Lpr_max_len)`循环使用`img_dir[i]`，但参数名为`image_dir`，且循环次数为车牌最大长度（Lpr_max_len）似乎不合理。 实际上，应该是遍历多个目录（每个目录对应不同长度的车牌？），但这里Lpr_max_len是车牌的最大字符数，而目录数应该与字符数无关。因此，这里可能是一个逻辑错误。 b) 在__init__中，`preprocFun`的默认处理是设置为`self.transform`，但代码中写的是`preprocfun`（大小写不一致）和`self.preprocfun`（同样不一致）。 c) 在__getitem__中，调整图像大写的代码调用了一个未定义的`resize`函数。应该是使用`cv2.resize`。 d) 在检查标签的函数`check`中，逻辑是：如果车牌长度是8（可能是某些特定车牌），则检查第3个字符（索引2）和最后一个字符（索引-1）是否为'D'或'F'？如果不是，则报错。但报错信息中打印了错误，然后断言0（会引发异常）。然而，在__getitem__中，如果长度是8，就调用check，如果返回False，则打印并断言。这里打印的imagename可能不是导致错误的那一个，因为打印的是当前处理的文件名，而check函数内部也打印了错误信息，导致重复。 e) 标签解析：从文件名中解析标签，通过分割下划线并取第一部分。但是，代码中分割了两次：`imagename.split('_')[0].split('_')[0]`，这等价于只取第一部分（因为第一次分割后取第一个，再分割还是取第一个）。所以可以简化为`imagename.split('_')[0]`。 此外，还有一些可以改进的地方： - 使用`os.path`处理路径，但读取图像时使用了`imutils.paths.list_images`，它返回所有图像文件的路径。然而，在初始化时，`image_dir`可能是多个目录，但代码中通过循环Lpr_max_len次来遍历目录，这显然不对。应该改为：如果`image_dir`是列表，则遍历列表中的每个目录，收集所有图像路径。 让我们重新设计： 假设`image_dir`可以是一个字符串（单个目录）或字符串列表（多个目录）。那么，在初始化时，我们应该收集所有这些目录下的图像路径。 修正后的代码思路： 1. 初始化： - 将`image_dir`转换为列表（如果它是字符串） - 遍历每个目录，使用`imutils.paths.list_images`收集所有图像路径 - 随机打乱路径列表 2. 在__getitem__中： - 使用cv2.imread读取图像，但原代码使用了`cv2.imdecode(np.fromfile(...))`，这是为了支持中文路径？如果是，则保留。 - 调整图像大小：使用cv2.resize - 预处理 - 从文件名中提取标签（车牌号） 3. 标签检查：根据需求，可能只对特定长度的车牌进行检查。 4. 预处理函数：默认使用`transform`方法。 下面给出修正后的代码，并详细注释。</think># 车牌识别(LPR)数据加载器详解 以下是一个完整的车牌识别(LPR)数据加载器实现，我对其进行了重构和优化，并添加了详细注释： ```python import os import cv2 import numpy as np import random from torch.utils.data import Dataset from imutils import paths from typing import List, Tuple, Callable, Optional # 车牌字符字典 - 包含所有可能的车牌字符 CHARS = [ '京', '沪', '津', '渝', '冀', '晋', '蒙', '辽', '吉', '黑', '苏', '浙', '皖', '闽', '赣', '鲁', '豫', '鄂', '湘', '粤', '桂', '琼', '川', '贵', '云', '藏', '陕', '甘', '青', '宁', '新', # 31个省份简称 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', # 数字 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'I', 'O', '-' # 字母和分隔符 ] # 创建字符到索引的映射字典 CHAR_DICT = {char: idx for idx, char in enumerate(CHARS)} # 反向映射：索引到字符 IDX_TO_CHAR = {idx: char for char, idx in CHAR_DICT.items()} class LPRDataset(Dataset): """车牌识别(LPR)数据集加载器 功能： 1. 从指定目录加载车牌图像 2. 自动解析文件名获取标签 3. 应用图像预处理 4. 验证标签格式 5. 支持批量加载 参数: image_dirs (List[str]): 包含车牌图像的目录列表 image_size (Tuple[int, int]): 目标图像尺寸 (宽度, 高度) max_label_len (int): 车牌最大字符长度 preprocess_func (Callable, optional): 自定义预处理函数 shuffle (bool): 是否打乱数据顺序 validation_rules (List[Callable], optional): 标签验证规则列表 """ def __init__(self, image_dirs: List[str], image_size: Tuple[int, int] = (94, 24), max_label_len: int = 8, preprocess_func: Optional[Callable] = None, shuffle: bool = True, validation_rules: Optional[List[Callable]] = None): self.image_size = image_size self.max_label_len = max_label_len # 收集所有图像路径 self.image_paths = [] for dir_path in image_dirs: if not os.path.isdir(dir_path): raise ValueError(f"目录不存在: {dir_path}") self.image_paths.extend(list(paths.list_images(dir_path))) if not self.image_paths: raise RuntimeError("未找到任何图像文件") # 打乱数据顺序 if shuffle: random.shuffle(self.image_paths) # 设置预处理函数 self.preprocess = preprocess_func or self.default_preprocess # 设置验证规则 self.validation_rules = validation_rules or [self.default_validation] def __len__(self) -> int: """返回数据集中的样本数量""" return len(self.image_paths) def __getitem__(self, idx: int) -> Tuple[np.ndarray, List[int], int]: """获取单个样本 返回: image (np.ndarray): 预处理后的图像 (C, H, W) label (List[int]): 字符索引列表 label_len (int): 标签长度 """ file_path = self.image_paths[idx] # 读取图像 - 支持中文路径 img = cv2.imdecode(np.fromfile(file_path, dtype=np.uint8), cv2.IMREAD_COLOR) if img is None: raise IOError(f"无法读取图像: {file_path}") # 调整图像大小 if img.shape[:2] != (self.image_size[1], self.image_size[0]): img = cv2.resize(img, self.image_size, interpolation=cv2.INTER_LINEAR) # 应用预处理 img = self.preprocess(img) # 从文件名解析标签 filename = os.path.basename(file_path) # 假设文件名格式为: "京A12345.jpg" 或 "粤B_CD123.jpg" label_str = os.path.splitext(filename)[0].split('_')[0] # 转换为索引列表 label = [] for char in label_str: if char in CHAR_DICT: label.append(CHAR_DICT[char]) else: raise ValueError(f"文件 {filename} 包含未知字符: {char}") # 验证标签 self.validate_label(label, filename) return img, label, len(label) def default_preprocess(self, img: np.ndarray) -> np.ndarray: """默认图像预处理流程 1. 转换为float32 2. 中心化 (减去127.5) 3. 归一化 (乘以0.0078125 ≈ 1/128) 4. 通道重排 (H, W, C) -> (C, H, W) """ img = img.astype('float32') img -= 127.5 img *= 0.0078125 return np.transpose(img, (2, 0, 1)) def default_validation(self, label: List[int], filename: str) -> bool: """默认标签验证规则 验证标准车牌格式: - 长度7或8 - 第3位是字母D或F (新能源车牌) - 最后一位是字母D或F (新能源车牌) """ label_len = len(label) # 长度验证 if label_len not in (7, 8): print(f"警告: 文件 {filename} 车牌长度异常: {label_len}") return False # 新能源车牌验证 if label_len == 8: # 第三位字符索引 third_char_idx = label[2] # 最后一位字符索引 last_char_idx = label[-1] # 检查是否是D或F if (IDX_TO_CHAR.get(third_char_idx) not in ('D', 'F') or IDX_TO_CHAR.get(last_char_idx) not in ('D', 'F')): print(f"错误: 文件 {filename} 新能源车牌格式不正确") return False return True def validate_label(self, label: List[int], filename: str): """应用所有验证规则""" for rule in self.validation_rules: if not rule(label, filename): # 可以选择记录日志或抛出异常 # 这里我们只打印警告，不中断程序 pass @staticmethod def collate_fn(batch: List[Tuple]) -> Tuple: """自定义批处理函数 用于处理变长标签的批处理 """ images, labels, label_lens = zip(*batch) # 将图像堆叠为张量 images = np.stack(images, axis=0) # 创建标签长度张量 label_lens = np.array(label_lens) # 处理变长标签 - 填充到最大长度 max_len = max(label_lens) padded_labels = np.zeros((len(labels), max_len), dtype=np.int64) for i, (label, length) in enumerate(zip(labels, label_lens)): padded_labels[i, :length] = label return images, padded_labels, label_lens # 使用示例 if __name__ == "__main__": # 1. 创建数据集 dataset = LPRDataset( image_dirs=["data/train", "data/val"], # 图像目录列表 image_size=(94, 24), # 标准车牌图像尺寸 max_label_len=8, # 最大车牌长度 shuffle=True ) print(f"数据集大小: {len(dataset)}") # 2. 获取单个样本 img, label, label_len = dataset[0] print(f"图像形状: {img.shape}") print(f"标签: {label} (长度: {label_len})") print(f"标签字符串: {''.join([IDX_TO_CHAR[idx] for idx in label])}") # 3. 创建数据加载器 from torch.utils.data import DataLoader dataloader = DataLoader( dataset, batch_size=32, shuffle=True, collate_fn=LPRDataset.collate_fn # 使用自定义批处理函数 ) # 4. 迭代批次 for batch_idx, (images, labels, label_lens) in enumerate(dataloader): print(f"批次 {batch_idx}:") print(f" 图像形状: {images.shape}") print(f" 标签形状: {labels.shape}") print(f" 标签长度: {label_lens}") # 只展示第一个批次 if batch_idx == 0: break ``` ## 关键组件详解 ### 1. 字符字典与映射 ```python CHARS = [ ... ] # 所有可能的车牌字符 CHAR_DICT = {char: idx for idx, char in enumerate(CHARS)} # 字符到索引 IDX_TO_CHAR = {idx: char for char, idx in CHAR_DICT.items()} # 索引到字符 ``` - **作用**：建立车牌字符与数字索引的双向映射 - **特点**： - 包含31个省份简称 - 10个数字(0-9) - 24个字母(A-Z，排除I和O) - 分隔符(-) - **重要性**：模型输出是字符的概率分布，需要与字符索引对应 ### 2. 数据集初始化 ```python def __init__(self, image_dirs, image_size, max_label_len, ...): # 收集所有图像路径 self.image_paths = [] for dir_path in image_dirs: self.image_paths.extend(list(paths.list_images(dir_path))) # 打乱顺序 if shuffle: random.shuffle(self.image_paths) # 设置预处理和验证规则 self.preprocess = preprocess_func or self.default_preprocess self.validation_rules = validation_rules or [self.default_validation] ``` - **功能**： 1. 扫描所有指定目录下的图像文件 2. 随机打乱数据顺序 3. 设置默认或自定义的预处理函数 4. 设置标签验证规则 - **参数说明**： - `image_dirs`：包含车牌图像的目录列表 - `image_size`：标准车牌图像尺寸(宽, 高)，如(94,24) - `max_label_len`：车牌最大字符长度(通常为7或8) - `preprocess_func`：自定义预处理函数 - `validation_rules`：自定义标签验证规则 ### 3. 数据加载核心方法 ```python def __getitem__(self, idx): # 读取图像 img = cv2.imdecode(np.fromfile(file_path, dtype=np.uint8), cv2.IMREAD_COLOR) # 调整大小 img = cv2.resize(img, self.image_size) # 预处理 img = self.preprocess(img) # 解析标签 label_str = os.path.splitext(filename)[0].split('_')[0] label = [CHAR_DICT[char] for char in label_str] # 验证标签 self.validate_label(label, filename) return img, label, len(label) ``` **处理流程**： 1. **图像读取**：使用`cv2.imdecode`支持中文路径 2. **尺寸调整**：统一到标准车牌尺寸 3. **预处理**：应用标准化流程 4. **标签解析**：从文件名提取车牌号并转换为索引 5. **标签验证**：检查车牌格式是否正确 ### 4. 默认预处理流程 ```python def default_preprocess(self, img): img = img.astype('float32') img -= 127.5 # 中心化 img *= 0.0078125 # 归一化 (1/128) return np.transpose(img, (2, 0, 1)) # (H, W, C) -> (C, H, W) ``` - **标准化原理**： - 输入范围：0-255 (uint8) - 减去127.5：平移至[-127.5, 127.5] - 乘以0.0078125：缩放至[-1, 1]附近 - **维度重排**：适配PyTorch的(C, H, W)格式 ### 5. 标签验证系统 ```python def default_validation(self, label, filename): # 长度验证 if len(label) not in (7, 8): ... # 新能源车牌验证 if len(label) == 8: third_char = IDX_TO_CHAR[label[2]] last_char = IDX_TO_CHAR[label[-1]] if third_char not in ('D', 'F') or last_char not in ('D', 'F'): ... ``` **车牌格式规则**： 1. **普通车牌**：7位字符（省份+字母+5位数字字母组合） 2. **新能源车牌**：8位字符（省份+字母+D/F+5位数字字母+D/F） 3. **特殊规则**： - 第3位必须是D或F（表示新能源） - 最后一位必须是D或F（表示新能源） ### 6. 批处理函数 ```python @staticmethod def collate_fn(batch): images = np.stack(images, axis=0) # 处理变长标签 max_len = max(label_lens) padded_labels = np.zeros((len(labels), max_len), dtype=np.int64) for i, (label, length) in enumerate(zip(labels, label_lens)): padded_labels[i, :length] = label return images, padded_labels, label_lens ``` - **功能**：处理不同长度的车牌标签 - **方法**：用0填充较短标签，使批次内所有标签长度一致 - **必要性**：深度学习模型需要固定尺寸的输入 ## 高级功能扩展 ### 1. 自定义预处理管道 ```python def create_custom_preprocessor(mean=127.5, std=128.0, add_noise=False): """创建自定义预处理函数""" def preprocess(img): img = img.astype('float32') # 中心化 img -= mean # 归一化 img /= std # 可选：添加噪声增强 if add_noise: noise = np.random.normal(0, 0.01, img.shape) img += noise # 维度重排 img = np.transpose(img, (2, 0, 1)) return img return preprocess # 使用 custom_preprocess = create_custom_preprocessor(mean=120, std=125, add_noise=True) dataset = LPRDataset(..., preprocess_func=custom_preprocess) ``` ### 2. 高级标签验证规则 ```python def province_validation(label, filename): """验证省份缩写是否正确""" first_char = IDX_TO_CHAR.get(label[0]) valid_provinces = CHARS[:31] # 前31个字符是省份 if first_char not in valid_provinces: print(f"错误: 文件 {filename} 省份缩写无效: {first_char}") return False return True def length_validation(label, filename): """验证车牌长度""" if len(label) not in (7, 8): print(f"错误: 文件 {filename} 长度无效: {len(label)}") return False return True # 使用 dataset = LPRDataset( ..., validation_rules=[province_validation, length_validation, dataset.default_validation] ) ``` ### 3. 数据增强集成 ```python class AugmentedLPRDataset(LPRDataset): """带数据增强的车牌数据集""" def __init__(self, *args, augment_prob=0.5, **kwargs): super().__init__(*args, **kwargs) self.augment_prob = augment_prob self.augmentations = [ self.random_brightness, self.random_contrast, self.random_rotation, self.random_blur ] def __getitem__(self, idx): img, label, label_len = super().__getitem__(idx) # 以一定概率应用数据增强 if random.random() < self.augment_prob: augment_func = random.choice(self.augmentations) img = augment_func(img) return img, label, label_len def random_brightness(self, img): """随机亮度调整""" delta = random.uniform(-0.2, 0.2) return np.clip(img + delta, -1.0, 1.0) def random_contrast(self, img): """随机对比度调整""" alpha = random.uniform(0.8, 1.2) return np.clip(alpha * img, -1.0, 1.0) def random_rotation(self, img): """随机旋转 (-5° 到 +5°)""" angle = random.uniform(-5, 5) h, w = img.shape[1:] center = (w // 2, h // 2) rot_mat = cv2.getRotationMatrix2D(center, angle, 1.0) # 注意：img是(C, H, W)格式，需要转回(H, W, C)进行旋转 img_trans = np.transpose(img, (1, 2, 0)) img_rot = cv2.warpAffine(img_trans, rot_mat, (w, h)) return np.transpose(img_rot, (2, 0, 1)) def random_blur(self, img): """随机模糊""" # 转回(H, W, C)格式 img_trans = np.transpose(img, (1, 2, 0)) kernel_size = random.choice([3, 5]) img_blur = cv2.GaussianBlur(img_trans, (kernel_size, kernel_size), 0) return np.transpose(img_blur, (2, 0, 1)) ``` ### 4. 可视化工具 ```python def visualize_sample(dataset, idx=None, save_path=None): """可视化数据集样本""" idx = idx or random.randint(0, len(dataset)-1) img, label, label_len = dataset[idx] # 将图像转换回可显示格式 # 1. 通道重排 (C, H, W) -> (H, W, C) # 2. 反标准化 img_disp = np.transpose(img, (1, 2, 0)) img_disp = (img_disp / 0.0078125) + 127.5 img_disp = np.clip(img_disp, 0, 255).astype('uint8') # 创建标签字符串 label_str = ''.join(IDX_TO_CHAR[i] for i in label) # 显示图像 plt.figure(figsize=(10, 4)) plt.imshow(cv2.cvtColor(img_disp, cv2.COLOR_BGR2RGB)) plt.title(f"车牌: {label_str} (长度: {label_len})") plt.axis('off') if save_path: plt.savefig(save_path, bbox_inches='tight') else: plt.show() # 使用示例 visualize_sample(dataset, idx=42, save_path="sample_visualization.png") ``` ## 实际应用场景 1. **车牌识别系统训练**： ```python from torch.utils.data import DataLoader # 创建数据集 train_dataset = LPRDataset(["data/train"], image_size=(94, 24)) val_dataset = LPRDataset(["data/val"], image_size=(94, 24), shuffle=False) # 创建数据加载器 train_loader = DataLoader( train_dataset, batch_size=64, shuffle=True, collate_fn=LPRDataset.collate_fn, num_workers=4 ) val_loader = DataLoader( val_dataset, batch_size=32, shuffle=False, collate_fn=LPRDataset.collate_fn, num_workers=2 ) # 训练循环 for epoch in range(epochs): for images, labels, label_lens in train_loader: # 将数据移至GPU images = torch.tensor(images).to(device) labels = torch.tensor(labels).to(device) label_lens = torch.tensor(label_lens).to(device) # 训练步骤... ``` 2. **模型验证**： ```python def evaluate_model(model, dataloader): model.eval() total_correct = 0 total_samples = 0 with torch.no_grad(): for images, labels, label_lens in dataloader: images = images.to(device) outputs = model(images) # 将输出转换为预测 _, preds = torch.max(outputs, dim=2) preds = preds.cpu().numpy() # 比较预测和真实标签 for i in range(len(labels)): pred_str = ''.join(IDX_TO_CHAR[p] for p in preds[i][:label_lens[i]]) true_str = ''.join(IDX_TO_CHAR[l] for l in labels[i][:label_lens[i]]) if pred_str == true_str: total_correct += 1 total_samples += 1 accuracy = total_correct / total_samples print(f"准确率: {accuracy:.4f}") return accuracy ``` 3. **错误分析**： ```python def analyze_errors(model, dataloader, save_dir="error_analysis"): os.makedirs(save_dir, exist_ok=True) error_samples = [] for batch_idx, (images, labels, label_lens) in enumerate(dataloader): images_tensor = torch.tensor(images).to(device) outputs = model(images_tensor) _, preds = torch.max(outputs, dim=2) preds = preds.cpu().numpy() for i in range(len(labels)): pred_str = ''.join(IDX_TO_CHAR[p] for p in preds[i][:label_lens[i]]) true_str = ''.join(IDX_TO_CHAR[l] for l in labels[i][:label_lens[i]]) if pred_str != true_str: # 保存错误样本 img_path = os.path.join(save_dir, f"batch{batch_idx}_sample{i}_{true_str}_vs_{pred_str}.png") visualize_sample_image(images[i], true_str, pred_str, img_path) error_samples.append((true_str, pred_str)) # 生成错误分析报告 generate_error_report(error_samples, os.path.join(save_dir, "error_report.csv")) ``` ## 性能优化技巧 1. **高效数据加载**： ```python # 使用内存映射文件加速读取 def preload_images(dataset): """预加载图像到内存""" images = [] for path in dataset.image_paths: img = cv2.imdecode(np.fromfile(path, dtype=np.uint8), cv2.IMREAD_COLOR) img = cv2.resize(img, dataset.image_size) images.append(img) return images class CachedLPRDataset(LPRDataset): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.cached_images = preload_images(self) def __getitem__(self, idx): img = self.cached_images[idx] # ...其余处理相同 ``` 2. **并行预处理**： ```python from concurrent.futures import ThreadPoolExecutor class ParallelLPRDataset(LPRDataset): def __init__(self, *args, num_workers=4, **kwargs): super().__init__(*args, **kwargs) self.num_workers = num_workers def __getitem__(self, idx): # 单线程处理 return super().__getitem__(idx) def get_batch(self, indices): """并行获取批次数据""" with ThreadPoolExecutor(max_workers=self.num_workers) as executor: results = list(executor.map(self.__getitem__, indices)) return results ``` 3. **混合精度训练**： ```python from torch.cuda.amp import autocast, GradScaler scaler = GradScaler() for images, labels, label_lens in train_loader: images = images.to(device) labels = labels.to(device) with autocast(): outputs = model(images) loss = criterion(outputs, labels, label_lens) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() ```