昇思25天学习打卡

FCN图像语义分割

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

• 不含全毗连层(fc)的全卷积(fully conv)网络，可顺应任意尺寸输入。
  
• 增大数据尺寸的反卷积(deconv)层，能够输出精致的结果。
  
• 结合差异深度层结果的跳级(skip)结构，同时确保鲁棒性和准确性。
  

语义分割

图像语义分割（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企服之家，中国第一个企服评测及商务社交产业平台。