|
import os |
|
import io |
|
import numpy as np |
|
import matplotlib.pyplot as plt |
|
from PIL import Image |
|
import paddle |
|
from paddle.nn import functional as F |
|
import random |
|
from paddle.io import Dataset |
|
from visualdl import LogWriter |
|
from paddle.vision.transforms import transforms as T |
|
import warnings |
|
import cv2 as cv |
|
from PIL import Image |
|
import re |
|
warnings.filterwarnings("ignore") |
|
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE" |
|
|
|
class SeparableConv2D(paddle.nn.Layer): |
|
def __init__(self, |
|
in_channels, |
|
out_channels, |
|
kernel_size, |
|
stride=1, |
|
padding=0, |
|
dilation=1, |
|
groups=None, |
|
weight_attr=None, |
|
bias_attr=None, |
|
data_format="NCHW"): |
|
super(SeparableConv2D, self).__init__() |
|
|
|
self._padding = padding |
|
self._stride = stride |
|
self._dilation = dilation |
|
self._in_channels = in_channels |
|
self._data_format = data_format |
|
|
|
|
|
filter_shape = [in_channels, 1] + self.convert_to_list(kernel_size, 2, 'kernel_size') |
|
self.weight_conv = self.create_parameter(shape=filter_shape, attr=weight_attr) |
|
|
|
|
|
filter_shape = [out_channels, in_channels] + self.convert_to_list(1, 2, 'kernel_size') |
|
self.weight_pointwise = self.create_parameter(shape=filter_shape, attr=weight_attr) |
|
self.bias_pointwise = self.create_parameter(shape=[out_channels], |
|
attr=bias_attr, |
|
is_bias=True) |
|
|
|
def convert_to_list(self, value, n, name, dtype=np.int): |
|
if isinstance(value, dtype): |
|
return [value, ] * n |
|
else: |
|
try: |
|
value_list = list(value) |
|
except TypeError: |
|
raise ValueError("The " + name + |
|
"'s type must be list or tuple. Received: " + str( |
|
value)) |
|
if len(value_list) != n: |
|
raise ValueError("The " + name + "'s length must be " + str(n) + |
|
". Received: " + str(value)) |
|
for single_value in value_list: |
|
try: |
|
dtype(single_value) |
|
except (ValueError, TypeError): |
|
raise ValueError( |
|
"The " + name + "'s type must be a list or tuple of " + str( |
|
n) + " " + str(dtype) + " . Received: " + str( |
|
value) + " " |
|
"including element " + str(single_value) + " of type" + " " |
|
+ str(type(single_value))) |
|
return value_list |
|
|
|
def forward(self, inputs): |
|
conv_out = F.conv2d(inputs, |
|
self.weight_conv, |
|
padding=self._padding, |
|
stride=self._stride, |
|
dilation=self._dilation, |
|
groups=self._in_channels, |
|
data_format=self._data_format) |
|
|
|
out = F.conv2d(conv_out, |
|
self.weight_pointwise, |
|
bias=self.bias_pointwise, |
|
padding=0, |
|
stride=1, |
|
dilation=1, |
|
groups=1, |
|
data_format=self._data_format) |
|
|
|
return out |
|
class Encoder(paddle.nn.Layer): |
|
def __init__(self, in_channels, out_channels): |
|
super(Encoder, self).__init__() |
|
|
|
self.relus = paddle.nn.LayerList( |
|
[paddle.nn.ReLU() for i in range(2)]) |
|
self.separable_conv_01 = SeparableConv2D(in_channels, |
|
out_channels, |
|
kernel_size=3, |
|
padding='same') |
|
self.bns = paddle.nn.LayerList( |
|
[paddle.nn.BatchNorm2D(out_channels) for i in range(2)]) |
|
|
|
self.separable_conv_02 = SeparableConv2D(out_channels, |
|
out_channels, |
|
kernel_size=3, |
|
padding='same') |
|
self.pool = paddle.nn.MaxPool2D(kernel_size=3, stride=2, padding=1) |
|
self.residual_conv = paddle.nn.Conv2D(in_channels, |
|
out_channels, |
|
kernel_size=1, |
|
stride=2, |
|
padding='same') |
|
|
|
def forward(self, inputs): |
|
previous_block_activation = inputs |
|
|
|
y = self.relus[0](inputs) |
|
y = self.separable_conv_01(y) |
|
y = self.bns[0](y) |
|
y = self.relus[1](y) |
|
y = self.separable_conv_02(y) |
|
y = self.bns[1](y) |
|
y = self.pool(y) |
|
|
|
residual = self.residual_conv(previous_block_activation) |
|
y = paddle.add(y, residual) |
|
|
|
return y |
|
class Decoder(paddle.nn.Layer): |
|
def __init__(self, in_channels, out_channels): |
|
super(Decoder, self).__init__() |
|
|
|
self.relus = paddle.nn.LayerList( |
|
[paddle.nn.ReLU() for i in range(2)]) |
|
self.conv_transpose_01 = paddle.nn.Conv2DTranspose(in_channels, |
|
out_channels, |
|
kernel_size=3, |
|
padding=1) |
|
self.conv_transpose_02 = paddle.nn.Conv2DTranspose(out_channels, |
|
out_channels, |
|
kernel_size=3, |
|
padding=1) |
|
self.bns = paddle.nn.LayerList( |
|
[paddle.nn.BatchNorm2D(out_channels) for i in range(2)] |
|
) |
|
self.upsamples = paddle.nn.LayerList( |
|
[paddle.nn.Upsample(scale_factor=2.0) for i in range(2)] |
|
) |
|
self.residual_conv = paddle.nn.Conv2D(in_channels, |
|
out_channels, |
|
kernel_size=1, |
|
padding='same') |
|
|
|
def forward(self, inputs): |
|
previous_block_activation = inputs |
|
|
|
y = self.relus[0](inputs) |
|
y = self.conv_transpose_01(y) |
|
y = self.bns[0](y) |
|
y = self.relus[1](y) |
|
y = self.conv_transpose_02(y) |
|
y = self.bns[1](y) |
|
y = self.upsamples[0](y) |
|
|
|
residual = self.upsamples[1](previous_block_activation) |
|
residual = self.residual_conv(residual) |
|
|
|
y = paddle.add(y, residual) |
|
|
|
return y |
|
class PetNet(paddle.nn.Layer): |
|
def __init__(self, num_classes): |
|
super(PetNet, self).__init__() |
|
|
|
self.conv_1 = paddle.nn.Conv2D(3, 32, |
|
kernel_size=3, |
|
stride=2, |
|
padding='same') |
|
self.bn = paddle.nn.BatchNorm2D(32) |
|
self.relu = paddle.nn.ReLU() |
|
|
|
in_channels = 32 |
|
self.encoders = [] |
|
self.encoder_list = [64, 128, 256] |
|
self.decoder_list = [256, 128, 64, 32] |
|
|
|
for out_channels in self.encoder_list: |
|
block = self.add_sublayer('encoder_{}'.format(out_channels), |
|
Encoder(in_channels, out_channels)) |
|
self.encoders.append(block) |
|
in_channels = out_channels |
|
|
|
self.decoders = [] |
|
|
|
for out_channels in self.decoder_list: |
|
block = self.add_sublayer('decoder_{}'.format(out_channels), |
|
Decoder(in_channels, out_channels)) |
|
self.decoders.append(block) |
|
in_channels = out_channels |
|
|
|
self.output_conv = paddle.nn.Conv2D(in_channels, |
|
num_classes, |
|
kernel_size=3, |
|
padding='same') |
|
|
|
def forward(self, inputs): |
|
y = self.conv_1(inputs) |
|
y = self.bn(y) |
|
y = self.relu(y) |
|
|
|
for encoder in self.encoders: |
|
y = encoder(y) |
|
|
|
for decoder in self.decoders: |
|
y = decoder(y) |
|
|
|
y = self.output_conv(y) |
|
return y |
|
IMAGE_SIZE = (512, 512) |
|
num_classes = 2 |
|
network = PetNet(num_classes) |
|
model = paddle.Model(network) |
|
|
|
optimizer = paddle.optimizer.RMSProp(learning_rate=0.001, parameters=network.parameters()) |
|
layer_state_dict = paddle.load("mymodel.pdparams") |
|
opt_state_dict = paddle.load("optimizer.pdopt") |
|
|
|
network.set_state_dict(layer_state_dict) |
|
optimizer.set_state_dict(opt_state_dict) |
|
|
|
def FinalImage(mask,image): |
|
|
|
|
|
|
|
|
|
th = cv.threshold(mask,140,255,cv.THRESH_BINARY)[1] |
|
blur = cv.GaussianBlur(th,(33,33), 15) |
|
heatmap_img = cv.applyColorMap(blur, cv.COLORMAP_OCEAN) |
|
Blendermap = cv.addWeighted(heatmap_img, 0.5, image, 1, 0) |
|
return Blendermap |
|
|
|
import gradio as gr |
|
def Showsegmentation(image): |
|
mask = paddle.argmax(network(paddle.to_tensor([((image - 127.5) / 127.5).transpose(2, 0, 1)]))[0], axis=0).numpy() |
|
mask=mask.astype('uint8')*255 |
|
immask=cv.resize(mask, (512, 512)) |
|
image=cv.resize(image,(512,512)) |
|
blendmask=FinalImage(immask,image) |
|
return blendmask |
|
|
|
gr.Interface(fn=Showsegmentation, inputs="image", outputs="image").launch(share=True) |
|
|
