精华内容
参与话题
问答
  • 论文标题: U-Net: Convolutional Networks for Biomedical Image Segmentation 虽然主要运用医学领域但是在其他领域效果很好。 U-Net网络非常简单,前半部分作用是特征提取,后...U-Net与其他常见的分割网络有一点...

    论文标题:
    U-Net: Convolutional Networks for Biomedical Image Segmentation
    虽然主要运用医学领域但是在其他领域效果也很好。
    U-Net网络非常简单,前半部分作用是特征提取,后半部分是上采样。在一些文献中也把这样的结构叫做编码器-解码器结构。由于此网络整体结构类似于大写的英文字母U,故得名U-net。
    U-Net与其他常见的分割网络有一点非常不同的地方:U-net采用了完全不同的特征融合方式:拼接,U-net采用将特征在channel维度拼接在一起,形成更厚的特征。而FCN融合时使用的对应点相加,并不形成更厚的特征。
    U-Net只是一个网络结构的代号而已,只要符合此类特点都可以叫U-Net。
    根据论文原文:
    在这里插入图片描述
    我们把U-Net的左边叫做: contracting path
    我们把U-Net的右边叫做: expanding path
    在这里插入图片描述
    contracting path:常规的特征提取网络, 一直down sampling的过程,只是提供了四层的特征输出。
    expanding path:一直up sampling的过程,堆叠contracting path提供的四层特征,输出一张tensor
    语义分割:就是对像素的分类。

    直接写代码,我们迁移VGG16完成,contracting path的实现。

    import tensorflow as tf
    from tensorflow import keras
    from tensorflow.keras import datasets, layers, optimizers, Sequential, models, applications
    
    baseModel = applications.VGG16(weights="imagenet",include_top=False,input_shape = (512, 512, 3),pooling=None)
    baseModel.trainable = False
    contractingNet = models.Model(inputs=baseModel.input, outputs=baseModel.get_layer('block4_pool').output)
    contractingNet.summary()
    f1 = contractingNet.get_layer("block1_conv2").output
    f2 = contractingNet.get_layer("block2_conv2").output
    f3 = contractingNet.get_layer("block3_conv3").output
    f4 = contractingNet.get_layer("block4_conv3").output
    

    在这里插入图片描述
    expanding path实现:

    a = layers.Conv2D(1024, kernel_size=[3, 3], padding="same", activation="relu")(contractingNet.output)
    a = layers.Conv2D(512, kernel_size=[1, 1], padding="same", activation="relu")(a)
    a = layers.Conv2D(1024, kernel_size=[3, 3], padding="same", activation="relu")(a)
    
    a = layers.UpSampling2D(size = (2,2))(a)
    a = layers.concatenate([a,f4], axis = -1)
    a = layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation="relu")(a)
    a = layers.Conv2D(256, kernel_size=[1, 1], padding="same", activation="relu")(a)
    a = layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation="relu")(a)
    
    a = layers.UpSampling2D(size = (2,2))(a)
    a = layers.concatenate([a,f3], axis = -1)
    a = layers.Conv2D(256, kernel_size=[3, 3], padding="same", activation="relu")(a)
    a = layers.Conv2D(128, kernel_size=[1, 1], padding="same", activation="relu")(a)
    a = layers.Conv2D(256, kernel_size=[3, 3], padding="same", activation="relu")(a)
    
    a = layers.UpSampling2D(size = (2,2))(a)
    a = layers.concatenate([a,f2], axis = -1)
    a = layers.Conv2D(128, kernel_size=[3, 3], padding="same", activation="relu")(a)
    a = layers.Conv2D(64, kernel_size=[1, 1], padding="same", activation="relu")(a)
    a = layers.Conv2D(128, kernel_size=[3, 3], padding="same", activation="relu")(a)
    
    a = layers.UpSampling2D(size = (2,2))(a)
    a = layers.concatenate([a,f1], axis = -1)
    a = layers.Conv2D(64, kernel_size=[3, 3], padding="same", activation="relu")(a)
    a = layers.Conv2D(32, kernel_size=[1, 1], padding="same", activation="relu")(a)
    a = layers.Conv2D(64, kernel_size=[3, 3], padding="same", activation="relu")(a)
    
    a = layers.Conv2D(8, kernel_size=[3, 3], padding="same", activation="relu")(a)
    outputs = layers.Conv2D(1, kernel_size=[1, 1], padding="same", activation="sigmoid")(a)
    

    就这样实现了一个自己的U-Net网络了。
    再看看自己写的U-Net训练完的效果图。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    论文:http://www.arxiv.org/pdf/1505.04597.pdf
    源代码:https://github.com/wuyouyin/tensorflow2-unet
    dataset_cell:https://pan.baidu.com/s/1PfOMxGUwJhO-9p8yDsasag 提取码:nqhh
    dataset_sidewalk:https://pan.baidu.com/s/1SZ42yGLNf2C9XUNUQkQCbw 提取码:ntyh
    dataset_trafficRoad:https://pan.baidu.com/s/1mFFAx7dPcrdkXsbGQomGRg 提取码:20oh

    展开全文
  • 代码 class UNet(): def __init__(self, input_width, input_height, num_classes, train_class, train_images, train...

    代码

    import tensorflow as tf
    import tensorflow.keras as keras
    from tensorflow.keras import layers
    import numpy as np 
    import cv2
    import itertools
    import glob
    import matplotlib.pyplot as plt
    import tensorflow.keras.backend as K
    class UNet():
      def __init__(self,
                   input_width,
                   input_height,
                   num_classes,
                   train_class,
                   train_images,
                   train_instances,
                   val_images,
                   val_instances,
                   epochs,
                   lr,
                   lr_decay,
                   batch_size,
                   model_path,
                   save_path,
                   train_mode
                      ):
          self.input_width=input_width
          self.input_height=input_height
          self.num_classes=num_classes
          self.train_class=train_class
          self.train_images=train_images
          self.train_instances=train_instances
          self.val_images=val_images
          self.val_instances=val_instances
          self.epochs=epochs
          self.lr=lr
          self.lr_decay=lr_decay
          self.batch_size=batch_size
          self.model_path=model_path
          self.save_path=save_path
          self.train_mode=train_mode
    #--------------------------------------------------------------定义U—net网络结构
      def leftNetwork(self, inputs):  # U-net网络左侧下采样结构
        x = layers.Conv2D(32, (3, 3), padding='same', activation='relu')(inputs)
        o_1 = layers.Conv2D(32, (3, 3), padding='same', activation='relu')(x)
        x = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(o_1)
    
        x = layers.Conv2D(64, (3, 3), padding='same', activation='relu')(x)
        o_2 = layers.Conv2D(64, (3, 3), padding='same', activation='relu')(x)
        x = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(o_2)
    
        x = layers.Conv2D(128, (3, 3), padding='same', activation='relu')(x)
        o_3 = layers.Conv2D(128, (3, 3), padding='same', activation='relu')(x)
        x = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(o_3)
    
        x = layers.Conv2D(256, (3, 3), padding='same', activation='relu')(x)
        o_4 = layers.Conv2D(256, (3, 3), padding='same', activation='relu')(x)
    
        x = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(o_4)
        x = layers.Conv2D(512, (3, 3), padding='same', activation='relu')(x)
        o_5 = layers.Conv2D(512, (3, 3), padding='same', activation='relu')(x)
    
    
        print(o_1, o_2, o_3, o_4, o_5)
        return [o_1, o_2, o_3, o_4, o_5]
    
      def rightNetwork(self, inputs, num_classes, activation):  # U-net网络右侧上采样结构
        c_1, c_2, c_3, c_4, c_5 = inputs
    
        x = layers.UpSampling2D((2, 2))(c_5)
        print('1', x)
        x = layers.concatenate([c_4, x], axis=3)
        x = layers.Conv2D(256, (3, 3), padding='same', activation='relu')(x)
        x = layers.Conv2D(256, (3, 3), padding='same', activation='relu')(x)
        x = layers.UpSampling2D((2, 2))(x)
        print('2', x)
        x = layers.concatenate([c_3, x], axis=3)
        x = layers.Conv2D(128, (3, 3), padding='same', activation='relu')(x)
        x = layers.Conv2D(128, (3, 3), padding='same', activation='relu')(x)
        x = layers.UpSampling2D((2, 2))(x)
        print('3', x)
        x = layers.concatenate([c_2, x], axis=3)
        x = layers.Conv2D(64, (3, 3), padding='same', activation='relu')(x)
        x = layers.Conv2D(64, (3, 3), padding='same', activation='relu')(x)
        x = layers.UpSampling2D((2, 2))(x)
        print('4', x)
        x = layers.concatenate([c_1, x], axis=3)
        x = layers.Conv2D(32, (3, 3), padding='same', activation='relu')(x)
        x = layers.Conv2D(32, (3, 3), padding='same', activation='relu')(x)
        x = layers.Conv2D(num_classes, (1, 1), strides=(1, 1), padding='same')(x)
        x= layers.Reshape([self.input_height, self.input_width])(x)
        x = layers.Activation(activation)(x)
    
        return (x)
    
      def U_net(self, inputs, num_classes, activation):  # U-net网络结构
        leftout = self.leftNetwork(inputs)
        outputs = self.rightNetwork(leftout, num_classes, activation)
        return outputs
    #---------------------------------------------------------------
      def build_mode(self):#定义建立结构的方法
        inputs = keras.Input(shape=[self.input_height,self.input_width,3])
        outputs= self.U_net(inputs,num_classes=self.num_classes,activation='sigmoid')
    
        model =keras.Model(inputs=inputs , outputs=outputs)
        return model
    
    
    
    
    
      def dataGenerator(self,mode):#定义 数据生成器
        zeroMat=np.zeros(shape=[self.input_height,self.input_width])
        if mode =='training':#训练的数据
          images = glob.glob(self.train_images+'/*.jpg')
          images.sort()
    
    
          instances= glob.glob(self.train_instances +'/*.png')
          instances.sort()
    
          zipped = itertools.cycle(zip(images,instances))
          while True :
            x_train=[]
            y_train=[]
            for _ in range(self.batch_size):
              img,seg = next(zipped)
              img = cv2.imread(img,1)/255
              #----------------------------------------------------------------------------------------改变的地方
    
              seg = cv2.imread(seg, 0)
              if (self.train_class):
                seg = np.where(seg == self.train_class, 1, 0)
    
              # ----------------------------------------------------------------------------------------
              # seg = keras.utils.to_categorical(seg,num_classes=self.num_classes)
    
              x_train.append(img)
              y_train.append(seg)
            yield np.array(x_train),np.array(y_train)
        if mode == 'validation':#测试的数据
          images = glob.glob(self.val_images + '/*.jpg')#17年的数据用Jpg存放
          images.sort()
    
          instances = glob.glob(self.val_instances + '/*.png')#标签用PNG存放
          instances.sort()
          zipped = itertools.cycle(zip(images,instances))
          while True:
            x_eval = []
            y_eval = []
            img,seg = next(zipped)
            img = cv2.resize(cv2.imread(img, 1), (self.input_width, self.input_height))/255
    
            #----------------------------------------------------------------------------------------
    
    
            seg = cv2.imread(seg, 0)
            if (self.train_class):
              seg = np.where(seg == self.train_class, 1, 0)
    
            # ----------------------------------------------------------------------------------------
            # seg = keras.utils.to_categorical(seg,num_classes=self.num_classes)
            x_eval.append(img)
            y_eval.append(seg)
            yield np.array(x_eval), np.array(y_eval)
    
      def multi_category_focal_loss(self,y_true, y_pred):
        epsilon = 1.e-7
        gamma = 2.0
        # alpha = tf.constant([[2],[1],[1],[1],[1]], dtype=tf.float32)
        alpha = tf.constant([[1], [1], [1], [1], [1]], dtype=tf.float32)
        y_true = tf.cast(y_true, tf.float32)
        y_pred = tf.clip_by_value(y_pred, epsilon, 1. - epsilon)
        y_t = tf.multiply(y_true, y_pred) + tf.multiply(1 - y_true, 1 - y_pred)
        ce = -K.log(y_t)
        weight = tf.pow(tf.subtract(1., y_t), gamma)
        fl = tf.matmul(tf.multiply(weight, ce), alpha)
        loss = tf.reduce_mean(fl)
        return loss
      def focal_loss(self,y_true, y_pred):  # 定义损失函数
        gamma = 1.5
        alpha = 0.9
        pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.ones_like(y_pred))
        pt_0 = tf.where(tf.equal(y_true, 0), y_pred, tf.zeros_like(y_pred))
    
        pt_1 = K.clip(pt_1, 1e-3, .999)
        pt_0 = K.clip(pt_0, 1e-3, .999)
    
        return -tf.reduce_mean(alpha * K.pow(1. - pt_1, gamma) * K.log(pt_1)) - tf.reduce_mean(
          (1 - alpha) * K.pow(pt_0, gamma) * K.log(1. - pt_0))
    
      def train(self):#定义训练过程
    
    
    
        G_train =self.dataGenerator(mode='training')
        G_eval =self.dataGenerator(mode='validation')
        if (self.train_mode):
          model=keras.models.load_model(self.model_path,custom_objects={'focal_loss': self.focal_loss})
        else:
          model =self.build_mode()#实例化
        model.summary()
        model.compile(
          optimizer=keras.optimizers.Adam(self.lr,self.lr_decay),
          loss ='binary_crossentropy',#构造损失函数
          metrics=['binary_accuracy', 'Recall','AUC']#构造评价函数
        )
        checkpoint = keras.callbacks.ModelCheckpoint(self.save_path, monitor='val_Recall', verbose=1,
                                                     save_best_only=True, mode='max')
    
        callbacks = [checkpoint]
        model.fit_generator(G_train,2000,validation_data=G_eval,validation_steps=30,epochs=self.epochs,callbacks=callbacks)
        model.save(self.save_path)#保存模型
      def modelPred(self):#模型预测函数
        model = keras.models.load_model(self.model_path,custom_objects={'multi_category_focal_loss1': self.multi_category_focal_loss})
        model.summary()
        images = glob.glob(self.val_images + '/*.jpg')#17年的数据用Jpg格式存放
        images.sort()
        instances = glob.glob(self.val_instances + '/*.png')#标签用tif存放
        instances.sort()
        zipped = itertools.cycle(zip(images,instances))
    
        for _ in range(10):
          img,seg = next(zipped)
          img = cv2.resize(cv2.imread(img, -1), (self.input_width, self.input_height))/255
          seg = cv2.imread(seg, 0)
          x1_eval=np.expand_dims(img,0)
          pred=tf.squeeze(tf.argmax(model.predict(x1_eval),axis=-1))
    
          plt.subplot(121)
          plt.title("pred")
          plt.imshow(pred)
    
          plt.subplot(122)
          plt.title("pred")
          plt.imshow(seg)
    
          plt.show()
    if __name__ == '__main__':
      unet=UNet(#开始模型的实例化,每个类别训练一个网络
        input_width=256,#图片resize成这个大小
        input_height=256,
        num_classes=1,#检测类别
        train_class=4,#训练第几个类别
        train_images=r'F:\BaiduNetdiskDownload\remoteSensing\U_net\train_x',#训练数据存放的地方
        train_instances=r'F:\BaiduNetdiskDownload\remoteSensing\U_net\train_y',
        val_images=r'F:\BaiduNetdiskDownload\remoteSensing\U_net\test_x',#测试数据存放的地方
        val_instances=r'F:\BaiduNetdiskDownload\remoteSensing\U_net\test_y',
        epochs=200,
        lr=0.0001,
        lr_decay=0.000001,
        batch_size=4,
        model_path=r'F:\BaiduNetdiskDownload\remoteSensing\U_net\U_netClass3.h5',
        save_path=r'F:\BaiduNetdiskDownload\remoteSensing\U_net\U_netClass4.h5',#模型存储绝对路径
        train_mode=0
    )
      unet.train()#开始训练
      # unet.modelPred()
    

    将双时相的图片拼接成六通道的图片送入网络,然后将网络检测类别变成2,就可以进行变化检测了,因为变化检测受数据集影响非常大,我就只给一个骨干网络不误解人了,具体的参数还得自己找。

    展开全文
  • 语义分割网络--U-net

    2019-05-30 16:31:56
    U-net: Convolutional Networks for Biomedical Image Segmentation (2015) 论文地址:http://www.arxiv.org/pdf/1505.04597.pdf(此网络用于分割细胞图像) 论文翻译:...

    U-net: Convolutional Networks for Biomedical Image Segmentation
    (2015)

    论文地址:http://www.arxiv.org/pdf/1505.04597.pdf(此网络用于分割细胞图像)
    论文翻译:https://blog.csdn.net/natsuka/article/details/78565229
    源码(基于caffe):https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/

    论文解读:https://www.jianshu.com/p/f9b0c2c74488
    https://www.jianshu.com/p/ab0a10c2e710

    通用U-net复现代码(tensorflow):https://github.com/jakeret/tf_unet

    Unet复现(pytorch)本人参考https://github.com/milesial/Pytorch-UNet
    此复现代码解读:https://www.cnblogs.com/wanghui-garcia/p/10719121.html

    Paper and implementation of UNet-related model:https://github.com/ShawnBIT/UNet-family

    展开全文
  • 语义分割-U-Net

    2019-02-21 21:09:01
    1.熟悉Flink大数据生态圈以及未来发展趋势 2.快速上手开发Flink批处理程序和流处理程序 3.掌握了Flink核心知识与编程模型,深入理解Flink计算框架 4.掌握了Flink HA分布式集群安装部署
  • U-Net语义分割U-Net详解

    万次阅读 2018-09-05 01:04:01
    1、分割网络现状: 当前有不少好用的分割网络,比如Mask RCNN、DeepLabv3+、COCO-16图像分割冠军FCIS 2、关于分割图像的标记方式 有两种:一种是提供单个物体的掩模(多使用RLE格式);另一种是提供轮廓点。 2...

    一、简介

      语义分割(Semantic Segmentation)是图像处理和机器视觉一个重要分支。与分类任务不同,语义分割需要判断图像每个像素点的类别,进行精确分割。语义分割目前在自动驾驶、自动抠图等领域有着比较广泛的应用。

    分割网络现状:
      在ResNet以后使用深度学习进行分类任务的性能已经超过了人类,但是目标检测任务和分割任务的准确度却一直较低,其中分割任务的准确度是最低的。因为分割任务需要对每个像素点进行精确的分类,其难度最大。针对语义分割的需求,最早由Jonathan Long等人提出的Fully Convolutional Networks(FCN)成为了语义分割领域的基本框架之一,后续很多框架都多少参考了FCN的思想。但是FCN的准确度较低,不如U-net用的广泛。
      目前已经有不少其他好用的分割网络:

    二、U-net典型应用

      我第一次使用Unet是在Kaggle挑战赛上,它是Kaggle的常客。因为它简单,高效,易懂,容易定制,可以从相对较小的训练集中学习。Unet的第一次提出是在2015年(论文),经过发展,目前有多个变形和应用。

    1. Kaggle-Airbus Ship Detection Challenge
      在卫星图像中找到船,在公开的kernal中最受欢迎的是Unet,达到了84.7的精度。

    2. Kaggle-卫星图像分割与识别:
      需要在卫星图像中分割出:房屋、道路、铁路、树木、农作物、河流、积水区、大型车辆、小轿车。在Unet基础上微调,针对不同的分割对象,微调的地方不同,会产生不同的分割模型,最后融合。推荐一篇不错的博文:
      Kaggle优胜者详解:如何用深度学习实现卫星图像分割与识别

    3. Supervise.ly公司:
      在用Faster-RCNN(基于resnet)定位+Unet-like架构的分割,来做他们数据众包图像分割方向的主动学习,当时没有使用mask-rcnn,因为靠近物体边缘的分割质量很低(终于!Supervise.ly发布人像分割数据集啦(免费开源)

    4. 广东政务数据创新大赛—智能算法赛 :
      国土监察业务中须监管地上建筑物的建、拆、改、扩,高分辨率图像和智能算法以自动化完成工作。并且:八通道U-Net:直接输出房屋变化,可应对高层建筑倾斜问题;数据增强:增加模型泛化性,简单有效;加权损失函数:增强对新增建筑的检测能力;模型融合:取长补短,结果更全。其中季军公布了源码

    5. Kaggle车辆边界识别——TernausNet 由VGG初始化权重 + U-Net网络,Kaggle Carvana Image
      Masking Challenge
      第一名,使用的预训练权重改进U-Net,提升图像分割的效果。开源的代码在TernausNet

    三、 U-net详解

      U-net的源码很容易从上面应用的连接中找到。

      U-net网络非常简单,前半部分作用是特征提取,后半部分是上采样。在一些文献中也把这样的结构叫做编码器-解码器结构。由于此网络整体结构类似于大写的英文字母U,故得名U-net。

      U-net与其他常见的分割网络有一点非常不同的地方:U-net采用了完全不同的特征融合方式:拼接,U-net采用将特征在channel维度拼接在一起,形成更厚的特征。而FCN融合时使用的对应点相加,并不形成更厚的特征。

    所以语义分割网络在特征融合时有两种办法:
    1. FCN式的对应点相加,对应于TensorFlow中的tf.add()函数;
    2. U-net式的channel维度拼接融合,对应于TensorFlow的tf.concat()函数,比较占显存。

    除了上述新颖的特征融合方式,U-net还有以下几个优点:

    1. 5个pooling layer实现了网络对图像特征的多尺度特征识别。
    2. 上采样部分会融合特征提取部分的输出,这样做实际上是将多尺度特征融合在了一起,以最后一个上采样为例,它的特征既来自第一个卷积block的输出(同尺度特征),也来自上采样的输出(大尺度特征),这样的连接是贯穿整个网络的,你可以看到上图的网络中有四次融合过程,相对应的FCN网络只在最后一层进行融合。

    参考文献:
    1、https://blog.csdn.net/Formlsl/article/details/80373200
    2、https://blog.csdn.net/u012931582/article/details/70215756/
    3、https://blog.csdn.net/sinat_26917383/article/details/80107783
    4、https://zhuanlan.zhihu.com/p/26377387
    5、http://www.sohu.com/a/169159196_465975

    展开全文
  • 简介2.U-net典型应用3. U-net详解4.参考文献 1.简介 语义分割(Semantic Segmentation)是图像处理和机器视觉一个重要分支。与分类任务不同,语义分割需要判断图像每个像素点的类别,进行精确分割。语义分割目前在自动...
  • u-net语义分割Picture By Martei Macru On Unsplash 图片由Martei Macru在Unsplash上​​拍摄 Semantic segmentation is a computer vision problem where we try to assign a class to each pixel . Unlike the ...
  • 语义分割——U-Net

    2019-10-22 09:09:26
    本案例我们将主要介绍关于语义分割的应用,一个图像分类任务和关于这个任务...4 动态U-Net 简介 根据定义,语义分割是将图像分割成不同的部分,每个部分代表一个实体。例如,我们对图片中的像素进行分类,这个像素...
  • 语义分割_U-net

    2020-07-16 11:55:15
    前两天简单入门学习图像分割,学习了最基础的U-net,实现训练自己的数据集,今天做一些简单的记录。 参考的文章: https://arxiv.org/pdf/1505.04597v1.pdf https://cloud.tencent.com/developer/article/1354435 ...
  • Unet 的初衷是为了解决生物医学图像方面的问题,由于效果确实很好后来也被广泛的应用在语义分割的各个方向,比如卫星图像分割,工业瑕疵检测等。 Unet 跟 FCN 都是 Encoder-Decoder 结构,结构简单但很有效。Encoder...
  • 转载自:https://blog.csdn.net/u011974639 DenseASPP DenseASPP for Semantic Segmentation in Street Scenes 原文地址:DenseASPP 收录:CVPR2018(IEEE Conference on Computer Vision and Pattern Reco...
  • U-Net是一种基于深度学习的图像语义分割方法,尤其在医学图像分割中表现优异。 本课程将手把手地教大家使用labelme图像标注工具制作自己的数据集,生成Mask图像,并使用U-Net训练自己的数据集,从而能开展自己的...
  • 语义分割U-net个人总结

    千次阅读 2018-10-13 20:36:56
    U-net的特点在于,通过将下采样时feature map和上采样(反卷积)时feature map进行concat,来融合位置信息和语义信息。 图中,input是一张单通道图片,最后output之前,通道数2表示num_classes=2. 同时,图中的crop: ...
  • 语义分割——U-Net(二)

    千次阅读 2019-05-05 00:12:56
    U-Net通俗来讲也是卷积神经网络的一种变形,主要其结构经论文作者画出来形似字母U,因而得名U-Net
  • code: https://lmb.informatik.uni-freiburg.de/Publications/2016/OB16b/针对路面检测和分割问题,本文结合FCN 和 U-Net 提出一个网络,在速度和精度方面得到不错的效果 KITTI benchmark lane/ro
  • 语义分割——U-Net++(三)

    千次阅读 2019-05-22 10:43:39
    这篇论文《UNet++: A Nested U-Net Architecture for Medical Image Segmentation》是2018年6月的文章,DLMIA2018会议。文章对Unet改进的点主要是skip connection。
  • 用于语义分割U-Net为什么这么强?

    千次阅读 热门讨论 2019-01-24 14:55:22
    对于医学图像,有很多地方都会用到U-Net,包括2018 Data Science Bowl 用于分割细胞核的冠军模型,使用的都是U-Net结构,只是其用了大量的数据扩增,以及最后用了分水岭算法。由此可见,这个2015年的网络,在如今的...
  • LinkNet: Exploiting Encoder Representations for Efficient Semantic Segmentationhttps://arxiv.org/abs/1707.03718Torch7 code: https://github.com/e-lab/LinkNet本文主要侧重语义...U-Net,引入了 residual blo
  • 自从FCN打开了图像语义分割的新世界大门,各种优秀的分割算法迅速发展。在医学图像方面Unet展现出了期强大的性能,是小规模数据集的医学图像也能分割出较好的效果。...U-net去掉FC层,且全程使用valid来进行卷
  • FCN 简介 FCN全称是‘Fully Convolutional...作者在论文里说,这是第一个可以端到端训练、输出像素级预测(pixels-to-pixels)语义分割网络,它可以处理任意大小的图片输入。本网络使用上采样层进行预测,使用降采...
  • 图像语义分割U-Net网络和PSP网络1. Recap of FCN回顾FCN分割网络的基本结构分析FCN网络的优缺点2. What is U-NetU-Net网络结构具体操作和实现原理3. How to build U-Net如何实现一个U-Net网络U-Net的扩展4. What ...
  • U-net 是基于FCN的一个语义分割网络修改的,适合用来做医学图像的分割。论文出现在2015年,在U-Net结构中,包括一个捕获上下文信息的收缩路径和一个允许精确定位的对称拓展路径。 本文的创新点: 提出了U-net这种...
  • U-Net

    2018-12-20 23:05:56
    U-Net:用于医学图像分割的卷积神经网络 摘要: 本文提出新的网络结构和新的训练方法,该方法利用数据增强更高效地使用已有数据。该网络结构包括捕获上下文的收缩路径和实现精确定位的对称扩展路径,收缩路径主要是...
  • 【Semantic Segmentation】语义分割综述 -- AttentionAttention[Attention U-Net] Learning Where to Look for the Pancreas( MIDL 2018)[PAN] Pyramid Attention Network for Semantic Segmentation (BMVC 2018)...
  • 前言:语义分割的基本模型大都是在FCN的基础之上进行改进的,本文所要讨论的U-Net网络便是如此,U-net 是基于FCN的一个语义分割网络,适合与少量样本的图像分割,比如用来做医学图像的分割,能够取得非常好的成绩。...
  • Pothole分割U-Net实战

    2019-07-22 23:30:15
    学习和掌握U-Net图像语义分割技术来训练自己的数据集 学习U-Net语义分割原理 学习使用labelme图像标注 学习Kaggle参数流程
  • 【Semantic Segmentation】语义分割综述--Encoder And DecoderEncoder And Decoder[FCN] Fully Convolutional Networks for Semantic Segmentation 2016-05FCN-32FCN-16FCN-8code by pytorch[U-Net] Convolutional ...
  • 论文一:U-Net: Convolutional Networks for Biomedical Image Segmentation 发表时间:2015 论文二:TernausNet: U-Net with VGG11 Encoder Pre-Trained on ImageNet for Image Segmentation 发表时间:2018 1....

空空如也

1 2 3 4 5 ... 20
收藏数 13,459
精华内容 5,383
关键字:

语义分割