IT评测·应用市场-qidao123.com技术社区

标题: 昇思25天学习打卡 [打印本页]
作者: 忿忿的泥巴坨    时间: 2024-7-31 15:26
标题: 昇思25天学习打卡
FCN图像语义分割

FCN全卷网络,舍弃了传统的全毗连层，仅使用卷积和池化等操作完成，end-to-end的像素集预测网络。
网络特点：
语义分割

图像语义分割（semantic segmentation）是图像处置惩罚和机器视觉技术中关于图像理解的紧张一环，AI范畴中一个紧张分支，常被应用于人脸识别、物体检测、医学影像、卫星图像分析、自动驾驶感知等范畴。
这个就不消过多赘述了，目标检测是画框，语义分割就是把目标从图内里抠出来。
1. 数据处置惩罚

起首下载数据
  1. from download import download
  3. url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/dataset_fcn8s.tar"
  5. download(url, "./dataset", kind="tar", replace=True)
复制代码
数据预处置惩罚
  1. import numpy as np
  2. import cv2
  3. import mindspore.dataset as ds
  5. class SegDataset:
  6.     def __init__(self,
  7.                  image_mean,
  8.                  image_std,
  9.                  data_file='',
  10.                  batch_size=32,
  11.                  crop_size=512,
  12.                  max_scale=2.0,
  13.                  min_scale=0.5,
  14.                  ignore_label=255,
  15.                  num_classes=21,
  16.                  num_readers=2,
  17.                  num_parallel_calls=4):
  19.         self.data_file = data_file
  20.         self.batch_size = batch_size
  21.         self.crop_size = crop_size
  22.         self.image_mean = np.array(image_mean, dtype=np.float32)
  23.         self.image_std = np.array(image_std, dtype=np.float32)
  24.         self.max_scale = max_scale
  25.         self.min_scale = min_scale
  26.         self.ignore_label = ignore_label
  27.         self.num_classes = num_classes
  28.         self.num_readers = num_readers
  29.         self.num_parallel_calls = num_parallel_calls
  30.         max_scale > min_scale
  31. # 初始化数据集的参数，如文件路径、批次大小、裁剪大小、缩放比例、忽略标签、类别数、读取线程数和并行调用数。
  32.     def preprocess_dataset(self, image, label):
  33.         image_out = cv2.imdecode(np.frombuffer(image, dtype=np.uint8), cv2.IMREAD_COLOR)
  34.         label_out = cv2.imdecode(np.frombuffer(label, dtype=np.uint8), cv2.IMREAD_GRAYSCALE)
  35.         sc = np.random.uniform(self.min_scale, self.max_scale)
  36.         new_h, new_w = int(sc * image_out.shape[0]), int(sc * image_out.shape[1])
  37.         image_out = cv2.resize(image_out, (new_w, new_h), interpolation=cv2.INTER_CUBIC)
  38.         label_out = cv2.resize(label_out, (new_w, new_h), interpolation=cv2.INTER_NEAREST)
  40.         image_out = (image_out - self.image_mean) / self.image_std
  41.         out_h, out_w = max(new_h, self.crop_size), max(new_w, self.crop_size)
  42.         pad_h, pad_w = out_h - new_h, out_w - new_w
  43.         if pad_h > 0 or pad_w > 0:
  44.             image_out = cv2.copyMakeBorder(image_out, 0, pad_h, 0, pad_w, cv2.BORDER_CONSTANT, value=0)
  45.             label_out = cv2.copyMakeBorder(label_out, 0, pad_h, 0, pad_w, cv2.BORDER_CONSTANT, value=self.ignore_label)
  46.         offset_h = np.random.randint(0, out_h - self.crop_size + 1)
  47.         offset_w = np.random.randint(0, out_w - self.crop_size + 1)
  48.         image_out = image_out[offset_h: offset_h + self.crop_size, offset_w: offset_w + self.crop_size, :]
  49.         label_out = label_out[offset_h: offset_h + self.crop_size, offset_w: offset_w+self.crop_size]
  50.         if np.random.uniform(0.0, 1.0) > 0.5:
  51.             image_out = image_out[:, ::-1, :]
  52.             label_out = label_out[:, ::-1]
  53.         image_out = image_out.transpose((2, 0, 1))
  54.         image_out = image_out.copy()
  55.         label_out = label_out.copy()
  56.         label_out = label_out.astype("int32")
  57.         return image_out, label_out
  58. # 随机缩放图像和标签。对图像进行标准化（减去均值，除以标准差）。对图像和标签进行裁剪和翻转等数据增强操作。将图像转换为适合深度学习模型的格式（CHW）。
  59.     def get_dataset(self):
  60.         ds.config.set_numa_enable(True)
  61.         dataset = ds.MindDataset(self.data_file, columns_list=["data", "label"],
  62.                                  shuffle=True, num_parallel_workers=self.num_readers)
  63.         transforms_list = self.preprocess_dataset
  64.         dataset = dataset.map(operations=transforms_list, input_columns=["data", "label"],
  65.                               output_columns=["data", "label"],
  66.                               num_parallel_workers=self.num_parallel_calls)
  67.         dataset = dataset.shuffle(buffer_size=self.batch_size * 10)
  68.         dataset = dataset.batch(self.batch_size, drop_remainder=True)
  69.         return dataset
  70. # 使用 MindDataset 从 self.data_file 读取数据，指定需要的列（"data" 和 "label"）以及读取线程数。将 preprocess_dataset 方法应用于数据集。打乱数据集，并按指定的批次大小进行批处理。
  72. # 定义创建数据集的参数
  73. IMAGE_MEAN = [103.53, 116.28, 123.675]
  74. IMAGE_STD = [57.375, 57.120, 58.395]
  75. DATA_FILE = "dataset/dataset_fcn8s/mindname.mindrecord"
  77. # 定义模型训练参数
  78. train_batch_size = 4
  79. crop_size = 512
  80. min_scale = 0.5
  81. max_scale = 2.0
  82. ignore_label = 255
  83. num_classes = 21
  85. # 实例化Dataset
  86. dataset = SegDataset(image_mean=IMAGE_MEAN,
  87.                      image_std=IMAGE_STD,
  88.                      data_file=DATA_FILE,
  89.                      batch_size=train_batch_size,
  90.                      crop_size=crop_size,
  91.                      max_scale=max_scale,
  92.                      min_scale=min_scale,
  93.                      ignore_label=ignore_label,
  94.                      num_classes=num_classes,
  95.                      num_readers=2,
  96.                      num_parallel_calls=4)
  98. dataset = dataset.get_dataset()
复制代码
2. 构建网络

  1. import mindspore.nn as nn
  3. class FCN8s(nn.Cell):
  4.     def __init__(self, n_class):
  5.         super().__init__()
  6.         self.n_class = n_class
  7.         self.conv1 = nn.SequentialCell(
  8.             nn.Conv2d(in_channels=3, out_channels=64,
  9.                       kernel_size=3, weight_init='xavier_uniform'),
  10.             nn.BatchNorm2d(64),
  11.             nn.ReLU(),
  12.             nn.Conv2d(in_channels=64, out_channels=64,
  13.                       kernel_size=3, weight_init='xavier_uniform'),
  14.             nn.BatchNorm2d(64),
  15.             nn.ReLU()
  16.         )
  17.         self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
  18.         self.conv2 = nn.SequentialCell(
  19.             nn.Conv2d(in_channels=64, out_channels=128,
  20.                       kernel_size=3, weight_init='xavier_uniform'),
  21.             nn.BatchNorm2d(128),
  22.             nn.ReLU(),
  23.             nn.Conv2d(in_channels=128, out_channels=128,
  24.                       kernel_size=3, weight_init='xavier_uniform'),
  25.             nn.BatchNorm2d(128),
  26.             nn.ReLU()
  27.         )
  28.         self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
  29.         self.conv3 = nn.SequentialCell(
  30.             nn.Conv2d(in_channels=128, out_channels=256,
  31.                       kernel_size=3, weight_init='xavier_uniform'),
  32.             nn.BatchNorm2d(256),
  33.             nn.ReLU(),
  34.             nn.Conv2d(in_channels=256, out_channels=256,
  35.                       kernel_size=3, weight_init='xavier_uniform'),
  36.             nn.BatchNorm2d(256),
  37.             nn.ReLU(),
  38.             nn.Conv2d(in_channels=256, out_channels=256,
  39.                       kernel_size=3, weight_init='xavier_uniform'),
  40.             nn.BatchNorm2d(256),
  41.             nn.ReLU()
  42.         )
  43.         self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2)
  44.         self.conv4 = nn.SequentialCell(
  45.             nn.Conv2d(in_channels=256, out_channels=512,
  46.                       kernel_size=3, weight_init='xavier_uniform'),
  47.             nn.BatchNorm2d(512),
  48.             nn.ReLU(),
  49.             nn.Conv2d(in_channels=512, out_channels=512,
  50.                       kernel_size=3, weight_init='xavier_uniform'),
  51.             nn.BatchNorm2d(512),
  52.             nn.ReLU(),
  53.             nn.Conv2d(in_channels=512, out_channels=512,
  54.                       kernel_size=3, weight_init='xavier_uniform'),
  55.             nn.BatchNorm2d(512),
  56.             nn.ReLU()
  57.         )
  58.         self.pool4 = nn.MaxPool2d(kernel_size=2, stride=2)
  59.         self.conv5 = nn.SequentialCell(
  60.             nn.Conv2d(in_channels=512, out_channels=512,
  61.                       kernel_size=3, weight_init='xavier_uniform'),
  62.             nn.BatchNorm2d(512),
  63.             nn.ReLU(),
  64.             nn.Conv2d(in_channels=512, out_channels=512,
  65.                       kernel_size=3, weight_init='xavier_uniform'),
  66.             nn.BatchNorm2d(512),
  67.             nn.ReLU(),
  68.             nn.Conv2d(in_channels=512, out_channels=512,
  69.                       kernel_size=3, weight_init='xavier_uniform'),
  70.             nn.BatchNorm2d(512),
  71.             nn.ReLU()
  72.         )
  73.         self.pool5 = nn.MaxPool2d(kernel_size=2, stride=2)
  74.         self.conv6 = nn.SequentialCell(
  75.             nn.Conv2d(in_channels=512, out_channels=4096,
  76.                       kernel_size=7, weight_init='xavier_uniform'),
  77.             nn.BatchNorm2d(4096),
  78.             nn.ReLU(),
  79.         )
  80.         self.conv7 = nn.SequentialCell(
  81.             nn.Conv2d(in_channels=4096, out_channels=4096,
  82.                       kernel_size=1, weight_init='xavier_uniform'),
  83.             nn.BatchNorm2d(4096),
  84.             nn.ReLU(),
  85.         )
  86.         self.score_fr = nn.Conv2d(in_channels=4096, out_channels=self.n_class,
  87.                                   kernel_size=1, weight_init='xavier_uniform')
  88.         self.upscore2 = nn.Conv2dTranspose(in_channels=self.n_class, out_channels=self.n_class,
  89.                                            kernel_size=4, stride=2, weight_init='xavier_uniform')
  90.         self.score_pool4 = nn.Conv2d(in_channels=512, out_channels=self.n_class,
  91.                                      kernel_size=1, weight_init='xavier_uniform')
  92.         self.upscore_pool4 = nn.Conv2dTranspose(in_channels=self.n_class, out_channels=self.n_class,
  93.                                                 kernel_size=4, stride=2, weight_init='xavier_uniform')
  94.         self.score_pool3 = nn.Conv2d(in_channels=256, out_channels=self.n_class,
  95.                                      kernel_size=1, weight_init='xavier_uniform')
  96.         self.upscore8 = nn.Conv2dTranspose(in_channels=self.n_class, out_channels=self.n_class,
  97.                                            kernel_size=16, stride=8, weight_init='xavier_uniform')
  99.     def construct(self, x):
  100.         x1 = self.conv1(x)
  101.         p1 = self.pool1(x1)
  102.         x2 = self.conv2(p1)
  103.         p2 = self.pool2(x2)
  104.         x3 = self.conv3(p2)
  105.         p3 = self.pool3(x3)
  106.         x4 = self.conv4(p3)
  107.         p4 = self.pool4(x4)
  108.         x5 = self.conv5(p4)
  109.         p5 = self.pool5(x5)
  110.         x6 = self.conv6(p5)
  111.         x7 = self.conv7(x6)
  112.         sf = self.score_fr(x7)
  113.         u2 = self.upscore2(sf)
  114.         s4 = self.score_pool4(p4)
  115.         f4 = s4 + u2
  116.         u4 = self.upscore_pool4(f4)
  117.         s3 = self.score_pool3(p3)
  118.         f3 = s3 + u4
  119.         out = self.upscore8(f3)
  120.         return out
复制代码
3. 训练准备

下载预训练VGG-16模型
  1. from download import download
  2. from mindspore import load_checkpoint, load_param_into_net
  4. url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/fcn8s_vgg16_pretrain.ckpt"
  5. download(url, "fcn8s_vgg16_pretrain.ckpt", replace=True)
  6. def load_vgg16():
  7.     ckpt_vgg16 = "fcn8s_vgg16_pretrain.ckpt"
  8.     param_vgg = load_checkpoint(ckpt_vgg16)
  9.     load_param_into_net(net, param_vgg)
复制代码
评估函数定义
  1. import numpy as np
  2. import mindspore as ms
  3. import mindspore.nn as nn
  4. import mindspore.train as train
  6. class PixelAccuracy(train.Metric):
  7.     def __init__(self, num_class=21):
  8.         super(PixelAccuracy, self).__init__()
  9.         self.num_class = num_class
  11.     def _generate_matrix(self, gt_image, pre_image):
  12.         mask = (gt_image >= 0) & (gt_image < self.num_class)
  13.         label = self.num_class * gt_image[mask].astype('int') + pre_image[mask]
  14.         count = np.bincount(label, minlength=self.num_class**2)
  15.         confusion_matrix = count.reshape(self.num_class, self.num_class)
  16.         return confusion_matrix
  18.     def clear(self):
  19.         self.confusion_matrix = np.zeros((self.num_class,) * 2)
  21.     def update(self, *inputs):
  22.         y_pred = inputs[0].asnumpy().argmax(axis=1)
  23.         y = inputs[1].asnumpy().reshape(4, 512, 512)
  24.         self.confusion_matrix += self._generate_matrix(y, y_pred)
  26.     def eval(self):
  27.         pixel_accuracy = np.diag(self.confusion_matrix).sum() / self.confusion_matrix.sum()
  28.         return pixel_accuracy
  31. class PixelAccuracyClass(train.Metric):
  32.     def __init__(self, num_class=21):
  33.         super(PixelAccuracyClass, self).__init__()
  34.         self.num_class = num_class
  36.     def _generate_matrix(self, gt_image, pre_image):
  37.         mask = (gt_image >= 0) & (gt_image < self.num_class)
  38.         label = self.num_class * gt_image[mask].astype('int') + pre_image[mask]
  39.         count = np.bincount(label, minlength=self.num_class**2)
  40.         confusion_matrix = count.reshape(self.num_class, self.num_class)
  41.         return confusion_matrix
  43.     def update(self, *inputs):
  44.         y_pred = inputs[0].asnumpy().argmax(axis=1)
  45.         y = inputs[1].asnumpy().reshape(4, 512, 512)
  46.         self.confusion_matrix += self._generate_matrix(y, y_pred)
  48.     def clear(self):
  49.         self.confusion_matrix = np.zeros((self.num_class,) * 2)
  51.     def eval(self):
  52.         mean_pixel_accuracy = np.diag(self.confusion_matrix) / self.confusion_matrix.sum(axis=1)
  53.         mean_pixel_accuracy = np.nanmean(mean_pixel_accuracy)
  54.         return mean_pixel_accuracy
  57. class MeanIntersectionOverUnion(train.Metric):
  58.     def __init__(self, num_class=21):
  59.         super(MeanIntersectionOverUnion, self).__init__()
  60.         self.num_class = num_class
  62.     def _generate_matrix(self, gt_image, pre_image):
  63.         mask = (gt_image >= 0) & (gt_image < self.num_class)
  64.         label = self.num_class * gt_image[mask].astype('int') + pre_image[mask]
  65.         count = np.bincount(label, minlength=self.num_class**2)
  66.         confusion_matrix = count.reshape(self.num_class, self.num_class)
  67.         return confusion_matrix
  69.     def update(self, *inputs):
  70.         y_pred = inputs[0].asnumpy().argmax(axis=1)
  71.         y = inputs[1].asnumpy().reshape(4, 512, 512)
  72.         self.confusion_matrix += self._generate_matrix(y, y_pred)
  74.     def clear(self):
  75.         self.confusion_matrix = np.zeros((self.num_class,) * 2)
  77.     def eval(self):
  78.         mean_iou = np.diag(self.confusion_matrix) / (
  79.             np.sum(self.confusion_matrix, axis=1) + np.sum(self.confusion_matrix, axis=0) -
  80.             np.diag(self.confusion_matrix))
  81.         mean_iou = np.nanmean(mean_iou)
  82.         return mean_iou
  85. class FrequencyWeightedIntersectionOverUnion(train.Metric):
  86.     def __init__(self, num_class=21):
  87.         super(FrequencyWeightedIntersectionOverUnion, self).__init__()
  88.         self.num_class = num_class
  90.     def _generate_matrix(self, gt_image, pre_image):
  91.         mask = (gt_image >= 0) & (gt_image < self.num_class)
  92.         label = self.num_class * gt_image[mask].astype('int') + pre_image[mask]
  93.         count = np.bincount(label, minlength=self.num_class**2)
  94.         confusion_matrix = count.reshape(self.num_class, self.num_class)
  95.         return confusion_matrix
  97.     def update(self, *inputs):
  98.         y_pred = inputs[0].asnumpy().argmax(axis=1)
  99.         y = inputs[1].asnumpy().reshape(4, 512, 512)
  100.         self.confusion_matrix += self._generate_matrix(y, y_pred)
  102.     def clear(self):
  103.         self.confusion_matrix = np.zeros((self.num_class,) * 2)
  105.     def eval(self):
  106.         freq = np.sum(self.confusion_matrix, axis=1) / np.sum(self.confusion_matrix)
  107.         iu = np.diag(self.confusion_matrix) / (
  108.             np.sum(self.confusion_matrix, axis=1) + np.sum(self.confusion_matrix, axis=0) -
  109.             np.diag(self.confusion_matrix))
  111.         frequency_weighted_iou = (freq[freq > 0] * iu[freq > 0]).sum()
  112.         return frequency_weighted_iou
复制代码
模型训练
  1. import mindspore
  2. from mindspore import Tensor
  3. import mindspore.nn as nn
  4. from mindspore.train import ModelCheckpoint, CheckpointConfig, LossMonitor, TimeMonitor, Model
  6. device_target = "Ascend"
  7. mindspore.set_context(mode=mindspore.PYNATIVE_MODE, device_target=device_target)
  9. train_batch_size = 4
  10. num_classes = 21
  11. # 初始化模型结构
  12. net = FCN8s(n_class=21)
  13. # 导入vgg16预训练参数
  14. load_vgg16()
  15. # 计算学习率
  16. min_lr = 0.0005
  17. base_lr = 0.05
  18. train_epochs = 1
  19. iters_per_epoch = dataset.get_dataset_size()
  20. total_step = iters_per_epoch * train_epochs
  22. lr_scheduler = mindspore.nn.cosine_decay_lr(min_lr,
  23.                                             base_lr,
  24.                                             total_step,
  25.                                             iters_per_epoch,
  26.                                             decay_epoch=2)
  27. lr = Tensor(lr_scheduler[-1])
  29. # 定义损失函数
  30. loss = nn.CrossEntropyLoss(ignore_index=255)
  31. # 定义优化器
  32. optimizer = nn.Momentum(params=net.trainable_params(), learning_rate=lr, momentum=0.9, weight_decay=0.0001)
  33. # 定义loss_scale
  34. scale_factor = 4
  35. scale_window = 3000
  36. loss_scale_manager = ms.amp.DynamicLossScaleManager(scale_factor, scale_window)
  37. # 初始化模型
  38. if device_target == "Ascend":
  39.     model = Model(net, loss_fn=loss, optimizer=optimizer, loss_scale_manager=loss_scale_manager, metrics={"pixel accuracy": PixelAccuracy(), "mean pixel accuracy": PixelAccuracyClass(), "mean IoU": MeanIntersectionOverUnion(), "frequency weighted IoU": FrequencyWeightedIntersectionOverUnion()})
  40. else:
  41.     model = Model(net, loss_fn=loss, optimizer=optimizer, metrics={"pixel accuracy": PixelAccuracy(), "mean pixel accuracy": PixelAccuracyClass(), "mean IoU": MeanIntersectionOverUnion(), "frequency weighted IoU": FrequencyWeightedIntersectionOverUnion()})
  43. # 设置ckpt文件保存的参数
  44. time_callback = TimeMonitor(data_size=iters_per_epoch)
  45. loss_callback = LossMonitor()
  46. callbacks = [time_callback, loss_callback]
  47. save_steps = 330
  48. keep_checkpoint_max = 5
  49. config_ckpt = CheckpointConfig(save_checkpoint_steps=10,
  50.                                keep_checkpoint_max=keep_checkpoint_max)
  51. ckpt_callback = ModelCheckpoint(prefix="FCN8s",
  52.                                 directory="./ckpt",
  53.                                 config=config_ckpt)
  54. callbacks.append(ckpt_callback)
  55. model.train(train_epochs, dataset, callbacks=callbacks)
复制代码
4. 模型评估

  1. IMAGE_MEAN = [103.53, 116.28, 123.675]
  2. IMAGE_STD = [57.375, 57.120, 58.395]
  3. DATA_FILE = "dataset/dataset_fcn8s/mindname.mindrecord"
  5. # 下载已训练好的权重文件
  6. url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/FCN8s.ckpt"
  7. download(url, "FCN8s.ckpt", replace=True)
  8. net = FCN8s(n_class=num_classes)
  10. ckpt_file = "FCN8s.ckpt"
  11. param_dict = load_checkpoint(ckpt_file)
  12. load_param_into_net(net, param_dict)
  14. if device_target == "Ascend":
  15.     model = Model(net, loss_fn=loss, optimizer=optimizer, loss_scale_manager=loss_scale_manager, metrics={"pixel accuracy": PixelAccuracy(), "mean pixel accuracy": PixelAccuracyClass(), "mean IoU": MeanIntersectionOverUnion(), "frequency weighted IoU": FrequencyWeightedIntersectionOverUnion()})
  16. else:
  17.     model = Model(net, loss_fn=loss, optimizer=optimizer, metrics={"pixel accuracy": PixelAccuracy(), "mean pixel accuracy": PixelAccuracyClass(), "mean IoU": MeanIntersectionOverUnion(), "frequency weighted IoU": FrequencyWeightedIntersectionOverUnion()})
  19. # 实例化Dataset
  20. dataset = SegDataset(image_mean=IMAGE_MEAN,
  21.                      image_std=IMAGE_STD,
  22.                      data_file=DATA_FILE,
  23.                      batch_size=train_batch_size,
  24.                      crop_size=crop_size,
  25.                      max_scale=max_scale,
  26.                      min_scale=min_scale,
  27.                      ignore_label=ignore_label,
  28.                      num_classes=num_classes,
  29.                      num_readers=2,
  30.                      num_parallel_calls=4)
  31. dataset_eval = dataset.get_dataset()
  32. model.eval(dataset_eval)
复制代码
5. 模型推理

  1. import cv2
  2. import matplotlib.pyplot as plt
  4. net = FCN8s(n_class=num_classes)
  5. # 设置超参
  6. ckpt_file = "FCN8s.ckpt"
  7. param_dict = load_checkpoint(ckpt_file)
  8. load_param_into_net(net, param_dict)
  9. eval_batch_size = 4
  10. img_lst = []
  11. mask_lst = []
  12. res_lst = []
  13. # 推理效果展示(上方为输入图片，下方为推理效果图片)
  14. plt.figure(figsize=(8, 5))
  15. show_data = next(dataset_eval.create_dict_iterator())
  16. show_images = show_data["data"].asnumpy()
  17. mask_images = show_data["label"].reshape([4, 512, 512])
  18. show_images = np.clip(show_images, 0, 1)
  19. for i in range(eval_batch_size):
  20.     img_lst.append(show_images[i])
  21.     mask_lst.append(mask_images[i])
  22. res = net(show_data["data"]).asnumpy().argmax(axis=1)
  23. for i in range(eval_batch_size):
  24.     plt.subplot(2, 4, i + 1)
  25.     plt.imshow(img_lst[i].transpose(1, 2, 0))
  26.     plt.axis("off")
  27.     plt.subplots_adjust(wspace=0.05, hspace=0.02)
  28.     plt.subplot(2, 4, i + 5)
  29.     plt.imshow(res[i])
  30.     plt.axis("off")
  31.     plt.subplots_adjust(wspace=0.05, hspace=0.02)
  32. plt.show()
复制代码
打卡：


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com技术社区 (https://dis.qidao123.com/) Powered by Discuz! X3.4