精华内容
参与话题
问答
  • mask rcnn训练自己的数据集

    万次阅读 多人点赞 2018-07-13 21:05:51
    最近迷上了mask rcnn,也是由于自己工作需要吧,特意研究了其源代码,并基于自己的数据进行训练~ 本博客参考https://blog.csdn.net/disiwei1012/article/details/79928679#commentsedit 实验目的 ...

    前言

    最近迷上了mask rcnn,也是由于自己工作需要吧,特意研究了其源代码,并基于自己的数据进行训练~
    本博客参考https://blog.csdn.net/disiwei1012/article/details/79928679#commentsedit

    实验目的

    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述
    哎~说多了都是泪,谁让我是工科生呢?只能检测工件了。。。做不了高大上的东西了,哈哈

    主要参考及工具

    基于Mask RCNN开源项目:https://github.com/matterport/Mask_RCNN
    图片标记工具基于开源项目:https://github.com/wkentaro/labelme
    训练工具:win10+GTX1060+cuda9.1+cudnn7+tensorflow-gpu-1.6.0+keras-2.1.6,140幅图像,一共3类,1小时左右

    有关labelme的使用可以参考:https://blog.csdn.net/shwan_ma/article/details/77823281

    有关mask-rcnn和Faster RCNN算法可以参考:
    https://blog.csdn.net/linolzhang/article/details/71774168
    https://blog.csdn.net/lk123400/article/details/54343550/

    准备训练数据集

    这是我简历的四个文件夹,下面一一道来~
    这里写图片描述
    1.pic
    这里写图片描述
    这是训练的图像,一共700幅

    2.json
    这里写图片描述
    这是通过labelme处理训练图像后生成的文件

    3.labelme_json
    这里写图片描述
    这里写图片描述
    这个是处理.json文件后产生的数据,使用方法为labelme_json_to_dataset+空格+文件名称.json,这个前提是labelme要准确安装并激活。但是这样会产生一个问题,对多幅图像这样处理,太麻烦,在这里提供一个工具,可以直接在.json文件目录下转换所有的json文件,链接:json数据转换工具

    4.cv2_mask文件

    由于labelme生成的掩码标签 label.png为16位存储,opencv默认读取8位,需要将16位转8位,可通过C++程序转化,代码请参考这篇博文:http://blog.csdn.net/l297969586/article/details/79154150
    这里写图片描述
    一团黑,不过不要怕,正常的~

    源代码

    运行该代码,需要安装pycocotools,在windows下安装该工具非常烦,有的可以轻松的安装成功,有的重装系统也很难成功,哎,都是坑~~关于Windows下安装pycocotools请参考:https://blog.csdn.net/chixia1785/article/details/80040172https://blog.csdn.net/gxiaoyaya/article/details/78363391

    测试的源代码

    Github上开源的代码,是基于ipynb的,我直接把它转换成.py文件,首先做个测试,基于coco数据集上训练好的模型,可以调用摄像头~~~

    import os
    import sys
    import random
    import math
    import numpy as np
    import skimage.io
    import matplotlib
    import matplotlib.pyplot as plt
    import cv2
    import time
    # Root directory of the project
    ROOT_DIR = os.path.abspath("../")
    
    # Import Mask RCNN
    sys.path.append(ROOT_DIR)  # To find local version of the library
    from mrcnn import utils
    import mrcnn.model as modellib
    from mrcnn import visualize
    # Import COCO config
    sys.path.append(os.path.join(ROOT_DIR, "samples/coco/"))  # To find local version
    import coco
    
    
    # Directory to save logs and trained model
    MODEL_DIR = os.path.join(ROOT_DIR, "logs")
    
    # Local path to trained weights file
    COCO_MODEL_PATH = os.path.join(MODEL_DIR ,"mask_rcnn_coco.h5")
    # Download COCO trained weights from Releases if needed
    if not os.path.exists(COCO_MODEL_PATH):
        utils.download_trained_weights(COCO_MODEL_PATH)
        print("cuiwei***********************")
    
    # Directory of images to run detection on
    IMAGE_DIR = os.path.join(ROOT_DIR, "images")
    
    class InferenceConfig(coco.CocoConfig):
        # Set batch size to 1 since we'll be running inference on
        # one image at a time. Batch size = GPU_COUNT * IMAGES_PER_GPU
        GPU_COUNT = 1
        IMAGES_PER_GPU = 1
    
    config = InferenceConfig()
    config.display()
    
    
    # Create model object in inference mode.
    model = modellib.MaskRCNN(mode="inference", model_dir=MODEL_DIR, config=config)
    
    # Load weights trained on MS-COCO
    model.load_weights(COCO_MODEL_PATH, by_name=True)
    
    # COCO Class names
    # Index of the class in the list is its ID. For example, to get ID of
    # the teddy bear class, use: class_names.index('teddy bear')
    class_names = ['BG', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',
                   'bus', 'train', 'truck', 'boat', 'traffic light',
                   'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird',
                   'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear',
                   'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie',
                   'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball',
                   'kite', 'baseball bat', 'baseball glove', 'skateboard',
                   'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup',
                   'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
                   'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza',
                   'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed',
                   'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote',
                   'keyboard', 'cell phone', 'microwave', 'oven', 'toaster',
                   'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors',
                   'teddy bear', 'hair drier', 'toothbrush']
    # Load a random image from the images folder
    #file_names = next(os.walk(IMAGE_DIR))[2]
    #image = skimage.io.imread(os.path.join(IMAGE_DIR, random.choice(file_names)))
    cap = cv2.VideoCapture(0)
    
    while(1):
        # get a frame
        ret, frame = cap.read()
        # show a frame
        start =time.clock()
        results = model.detect([frame], verbose=1)
        r = results[0]
        #cv2.imshow("capture", frame)
        visualize.display_instances(frame, r['rois'], r['masks'], r['class_ids'], 
                                class_names, r['scores'])
        end = time.clock()
        print(end-start)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows() 
    
    #image= cv2.imread("C:\\Users\\18301\\Desktop\\Mask_RCNN-master\\images\\9.jpg")
    ## Run detection
    #
    #results = model.detect([image], verbose=1)
    #
    #print(end-start)
    ## Visualize results
    #r = results[0]
    #visualize.display_instances(image, r['rois'], r['masks'], r['class_ids'], 
    #                            class_names, r['scores'])
    

    这里写图片描述
    这里写图片描述
    这里写图片描述
    关于训练好的mask rcnn模型,可从此处下载:https://github.com/matterport/Mask_RCNN/releases,下载好后,配置路径即可

    训练数据源代码

    # -*- coding: utf-8 -*-
    
    import os
    import sys
    import random
    import math
    import re
    import time
    import numpy as np
    import cv2
    import matplotlib
    import matplotlib.pyplot as plt
    import tensorflow as tf
    from mrcnn.config import Config
    #import utils
    from mrcnn import model as modellib,utils
    from mrcnn import visualize
    import yaml
    from mrcnn.model import log
    from PIL import Image
    
    
    #os.environ["CUDA_VISIBLE_DEVICES"] = "0"
    # Root directory of the project
    ROOT_DIR = os.getcwd()
    
    #ROOT_DIR = os.path.abspath("../")
    # Directory to save logs and trained model
    MODEL_DIR = os.path.join(ROOT_DIR, "logs")
    
    iter_num=0
    
    # Local path to trained weights file
    COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
    # Download COCO trained weights from Releases if needed
    if not os.path.exists(COCO_MODEL_PATH):
        utils.download_trained_weights(COCO_MODEL_PATH)
    
    
    class ShapesConfig(Config):
        """Configuration for training on the toy shapes dataset.
        Derives from the base Config class and overrides values specific
        to the toy shapes dataset.
        """
        # Give the configuration a recognizable name
        NAME = "shapes"
    
        # Train on 1 GPU and 8 images per GPU. We can put multiple images on each
        # GPU because the images are small. Batch size is 8 (GPUs * images/GPU).
        GPU_COUNT = 1
        IMAGES_PER_GPU = 2
    
        # Number of classes (including background)
        NUM_CLASSES = 1 + 3  # background + 3 shapes
    
        # Use small images for faster training. Set the limits of the small side
        # the large side, and that determines the image shape.
        IMAGE_MIN_DIM = 320
        IMAGE_MAX_DIM = 384
    
        # Use smaller anchors because our image and objects are small
        RPN_ANCHOR_SCALES = (8 * 6, 16 * 6, 32 * 6, 64 * 6, 128 * 6)  # anchor side in pixels
    
        # Reduce training ROIs per image because the images are small and have
        # few objects. Aim to allow ROI sampling to pick 33% positive ROIs.
        TRAIN_ROIS_PER_IMAGE = 100
    
        # Use a small epoch since the data is simple
        STEPS_PER_EPOCH = 100
    
        # use small validation steps since the epoch is small
        VALIDATION_STEPS = 50
    
    
    config = ShapesConfig()
    config.display()
    
    class DrugDataset(utils.Dataset):
        # 得到该图中有多少个实例(物体)
        def get_obj_index(self, image):
            n = np.max(image)
            return n
    
        # 解析labelme中得到的yaml文件,从而得到mask每一层对应的实例标签
        def from_yaml_get_class(self, image_id):
            info = self.image_info[image_id]
            with open(info['yaml_path']) as f:
                temp = yaml.load(f.read())
                labels = temp['label_names']
                del labels[0]
            return labels
    
        # 重新写draw_mask
        def draw_mask(self, num_obj, mask, image,image_id):
            #print("draw_mask-->",image_id)
            #print("self.image_info",self.image_info)
            info = self.image_info[image_id]
            #print("info-->",info)
            #print("info[width]----->",info['width'],"-info[height]--->",info['height'])
            for index in range(num_obj):
                for i in range(info['width']):
                    for j in range(info['height']):
                        #print("image_id-->",image_id,"-i--->",i,"-j--->",j)
                        #print("info[width]----->",info['width'],"-info[height]--->",info['height'])
                        at_pixel = image.getpixel((i, j))
                        if at_pixel == index + 1:
                            mask[j, i, index] = 1
            return mask
    
        # 重新写load_shapes,里面包含自己的类别,可以任意添加
        # 并在self.image_info信息中添加了path、mask_path 、yaml_path
        # yaml_pathdataset_root_path = "/tongue_dateset/"
        # img_floder = dataset_root_path + "rgb"
        # mask_floder = dataset_root_path + "mask"
        # dataset_root_path = "/tongue_dateset/"
        def load_shapes(self, count, img_floder, mask_floder, imglist, dataset_root_path):
            """Generate the requested number of synthetic images.
            count: number of images to generate.
            height, width: the size of the generated images.
            """
            # Add classes,可通过这种方式扩展多个物体
            self.add_class("shapes", 1, "tank") # 黑色素瘤
            self.add_class("shapes", 2, "triangle")
            self.add_class("shapes", 3, "white")
            for i in range(count):
                # 获取图片宽和高
    
                filestr = imglist[i].split(".")[0]
                #print(imglist[i],"-->",cv_img.shape[1],"--->",cv_img.shape[0])
                #print("id-->", i, " imglist[", i, "]-->", imglist[i],"filestr-->",filestr)
                #filestr = filestr.split("_")[1]
                mask_path = mask_floder + "/" + filestr + ".png"
                yaml_path = dataset_root_path + "labelme_json/" + filestr + "_json/info.yaml"
                print(dataset_root_path + "labelme_json/" + filestr + "_json/img.png")
                cv_img = cv2.imread(dataset_root_path + "labelme_json/" + filestr + "_json/img.png")
    
                self.add_image("shapes", image_id=i, path=img_floder + "/" + imglist[i],
                               width=cv_img.shape[1], height=cv_img.shape[0], mask_path=mask_path, yaml_path=yaml_path)
    
        # 重写load_mask
        def load_mask(self, image_id):
            """Generate instance masks for shapes of the given image ID.
            """
            global iter_num
            print("image_id",image_id)
            info = self.image_info[image_id]
            count = 1  # number of object
            img = Image.open(info['mask_path'])
            num_obj = self.get_obj_index(img)
            mask = np.zeros([info['height'], info['width'], num_obj], dtype=np.uint8)
            mask = self.draw_mask(num_obj, mask, img,image_id)
            occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)
            for i in range(count - 2, -1, -1):
                mask[:, :, i] = mask[:, :, i] * occlusion
    
                occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))
            labels = []
            labels = self.from_yaml_get_class(image_id)
            labels_form = []
            for i in range(len(labels)):
                if labels[i].find("tank") != -1:
                    # print "box"
                    labels_form.append("tank")
                elif labels[i].find("triangle")!=-1:
                    #print "column"
                    labels_form.append("triangle")
                elif labels[i].find("white")!=-1:
                    #print "package"
                    labels_form.append("white")
            class_ids = np.array([self.class_names.index(s) for s in labels_form])
            return mask, class_ids.astype(np.int32)
    
    def get_ax(rows=1, cols=1, size=8):
        """Return a Matplotlib Axes array to be used in
        all visualizations in the notebook. Provide a
        central point to control graph sizes.
    
        Change the default size attribute to control the size
        of rendered images
        """
        _, ax = plt.subplots(rows, cols, figsize=(size * cols, size * rows))
        return ax
    
    #基础设置
    dataset_root_path="train_data/"
    img_floder = dataset_root_path + "pic"
    mask_floder = dataset_root_path + "cv2_mask"
    #yaml_floder = dataset_root_path
    imglist = os.listdir(img_floder)
    count = len(imglist)
    
    #train与val数据集准备
    dataset_train = DrugDataset()
    dataset_train.load_shapes(count, img_floder, mask_floder, imglist,dataset_root_path)
    dataset_train.prepare()
    
    #print("dataset_train-->",dataset_train._image_ids)
    
    dataset_val = DrugDataset()
    dataset_val.load_shapes(7, img_floder, mask_floder, imglist,dataset_root_path)
    dataset_val.prepare()
    
    #print("dataset_val-->",dataset_val._image_ids)
    
    # Load and display random samples
    #image_ids = np.random.choice(dataset_train.image_ids, 4)
    #for image_id in image_ids:
    #    image = dataset_train.load_image(image_id)
    #    mask, class_ids = dataset_train.load_mask(image_id)
    #    visualize.display_top_masks(image, mask, class_ids, dataset_train.class_names)
    
    # Create model in training mode
    model = modellib.MaskRCNN(mode="training", config=config,
                              model_dir=MODEL_DIR)
    
    # Which weights to start with?
    init_with = "coco"  # imagenet, coco, or last
    
    if init_with == "imagenet":
        model.load_weights(model.get_imagenet_weights(), by_name=True)
    elif init_with == "coco":
        # Load weights trained on MS COCO, but skip layers that
        # are different due to the different number of classes
        # See README for instructions to download the COCO weights
        model.load_weights(COCO_MODEL_PATH, by_name=True,
                           exclude=["mrcnn_class_logits", "mrcnn_bbox_fc",
                                    "mrcnn_bbox", "mrcnn_mask"])
    elif init_with == "last":
        # Load the last model you trained and continue training
        model.load_weights(model.find_last()[1], by_name=True)
    
    # Train the head branches
    # Passing layers="heads" freezes all layers except the head
    # layers. You can also pass a regular expression to select
    # which layers to train by name pattern.
    model.train(dataset_train, dataset_val,
                learning_rate=config.LEARNING_RATE,
                epochs=20,
                layers='heads')
    
    
    
    # Fine tune all layers
    # Passing layers="all" trains all layers. You can also
    # pass a regular expression to select which layers to
    # train by name pattern.
    model.train(dataset_train, dataset_val,
                learning_rate=config.LEARNING_RATE / 10,
                epochs=40,
                layers="all")
    

    这里写图片描述

    关于训练过程的参数设置,可在config.py文件中修改,根据自己的要求啦~官方也给出了修改建议:https://github.com/matterport/Mask_RCNN/wiki

    可修改的主要有:

    BACKBONE = “resnet50” ;这个是迁移学习调用的模型,分为resnet101和resnet50,电脑性能不是特别好的话,建议选择resnet50,这样网络更小,训练的更快。

    model.train(…, layers=‘heads’, …) # Train heads branches (least memory)
    model.train(…, layers=‘3+’, …) # Train resnet stage 3 and up
    model.train(…, layers=‘4+’, …) # Train resnet stage 4 and up
    model.train(…, layers=‘all’, …) # Train all layers (most memory)#这里是选择训练的层数,根据自己的要求选择

    IMAGE_MIN_DIM = 800
    IMAGE_MAX_DIM = 1024#设置训练时的图像大小,最终以IMAGE_MAX_DIM为准,如果电脑性能不是太好,建议调小

    GPU_COUNT = 1
    IMAGES_PER_GPU = 2#这个是对GPU的设置,如果显存不够,建议把2调成1(虽然batch_size为1并不利于收敛)

    TRAIN_ROIS_PER_IMAGE = 200;可根据自己数据集的真实情况来设定

    MAX_GT_INSTANCES = 100;设置图像中最多可检测出来的物体数量

    数据集按照上述格式建立,然后配置好路径即可训练,在windows训练的时候有个问题,就是会出现训练时一直卡在epoch1,这个问题是因为keras在低版本中不支持多线程(在windows上),推荐keras2.1.6,这个亲测可以~

    训练的模型会保存在logs文件夹下,.h5格式,训练好后直接调用即可

    测试模型的代码

    # -*- coding: utf-8 -*-
    import os
    import sys
    import random
    import math
    import numpy as np
    import skimage.io
    import matplotlib
    import matplotlib.pyplot as plt
    import cv2
    import time
    from mrcnn.config import Config
    from datetime import datetime 
    # Root directory of the project
    ROOT_DIR = os.getcwd()
    
    # Import Mask RCNN
    sys.path.append(ROOT_DIR)  # To find local version of the library
    from mrcnn import utils
    import mrcnn.model as modellib
    from mrcnn import visualize
    # Import COCO config
    sys.path.append(os.path.join(ROOT_DIR, "samples/coco/"))  # To find local version
    from samples.coco import coco
    
    
    # Directory to save logs and trained model
    MODEL_DIR = os.path.join(ROOT_DIR, "logs")
    
    # Local path to trained weights file
    COCO_MODEL_PATH = os.path.join(MODEL_DIR ,"mask_rcnn_coco.h5")
    # Download COCO trained weights from Releases if needed
    if not os.path.exists(COCO_MODEL_PATH):
        utils.download_trained_weights(COCO_MODEL_PATH)
        print("cuiwei***********************")
    
    # Directory of images to run detection on
    IMAGE_DIR = os.path.join(ROOT_DIR, "images")
    
    class ShapesConfig(Config):
        """Configuration for training on the toy shapes dataset.
        Derives from the base Config class and overrides values specific
        to the toy shapes dataset.
        """
        # Give the configuration a recognizable name
        NAME = "shapes"
    
        # Train on 1 GPU and 8 images per GPU. We can put multiple images on each
        # GPU because the images are small. Batch size is 8 (GPUs * images/GPU).
        GPU_COUNT = 1
        IMAGES_PER_GPU = 1
    
        # Number of classes (including background)
        NUM_CLASSES = 1 + 3  # background + 3 shapes
    
        # Use small images for faster training. Set the limits of the small side
        # the large side, and that determines the image shape.
        IMAGE_MIN_DIM = 320
        IMAGE_MAX_DIM = 384
    
        # Use smaller anchors because our image and objects are small
        RPN_ANCHOR_SCALES = (8 * 6, 16 * 6, 32 * 6, 64 * 6, 128 * 6)  # anchor side in pixels
    
        # Reduce training ROIs per image because the images are small and have
        # few objects. Aim to allow ROI sampling to pick 33% positive ROIs.
        TRAIN_ROIS_PER_IMAGE =100
    
        # Use a small epoch since the data is simple
        STEPS_PER_EPOCH = 100
    
        # use small validation steps since the epoch is small
        VALIDATION_STEPS = 50
    
    #import train_tongue
    #class InferenceConfig(coco.CocoConfig):
    class InferenceConfig(ShapesConfig):
        # Set batch size to 1 since we'll be running inference on
        # one image at a time. Batch size = GPU_COUNT * IMAGES_PER_GPU
        GPU_COUNT = 1
        IMAGES_PER_GPU = 1
    
    config = InferenceConfig()
    
    model = modellib.MaskRCNN(mode="inference", model_dir=MODEL_DIR, config=config)
    
    
    # Create model object in inference mode.
    model = modellib.MaskRCNN(mode="inference", model_dir=MODEL_DIR, config=config)
    
    # Load weights trained on MS-COCO
    model.load_weights(COCO_MODEL_PATH, by_name=True)
    
    # COCO Class names
    # Index of the class in the list is its ID. For example, to get ID of
    # the teddy bear class, use: class_names.index('teddy bear')
    class_names = ['BG', 'tank','triangle','white']
    # Load a random image from the images folder
    file_names = next(os.walk(IMAGE_DIR))[2]
    image = skimage.io.imread(os.path.join(IMAGE_DIR, random.choice(file_names)))
    
    a=datetime.now() 
    # Run detection
    results = model.detect([image], verbose=1)
    b=datetime.now() 
    # Visualize results
    print("shijian",(b-a).seconds)
    r = results[0]
    visualize.display_instances(image, r['rois'], r['masks'], r['class_ids'], 
                                class_names, r['scores'])
    
    

    这里写图片描述
    这里写图片描述
    当然,这里由于训练数据太少,效果不是特别好~~~工业上的图像不是太好获取。。。
    那么如何把定位坐标和分割像素位置输出呢?其实都在visualize.py文件中,就是里面的display_instances函数。
    这里写图片描述
    这里写图片描述
    最后的输出结果

    其中,mask输出box区域内的每个像素为true还是false,依次遍历box里的行和列。
    最后,该工程的源代码地址为:https://download.csdn.net/download/qq_29462849/10540423,其中train_test为训练代码,test_model为测试代码,配置好路径,即可直接运行~~~

    最后欢迎加入3D视觉工坊,一起交流学习~

    在这里插入图片描述

    展开全文
  • maskrcnn-benchmark has been deprecated. Please see detectron2, which includes implementations for all models in maskrcnn-benchmark This project aims at providing the necessary building blocks for ...
  • Mask RCNN训练自己的数据集

    万次阅读 多人点赞 2018-06-05 15:33:36
    该版本为tensorflow+keras版本的,官方版本刚开源10个小时(caffe2),以后再更新.. 一、工具 cuda与cudnn安装请参考我之前博客: http://blog.csdn.net/l297969586/article/details/53320706 ...

    该版本为tensorflow+keras版本的,官方版本刚开源10个小时(caffe2),以后再更新…

    一、工具

    cuda与cudnn安装请参考我之前博客:
    http://blog.csdn.net/l297969586/article/details/53320706
    http://blog.csdn.net/l297969586/article/details/67632608
    tensorflow安装:
    http://blog.csdn.net/l297969586/article/details/72820310
    ipython-notebook:
    http://blog.csdn.net/l297969586/article/details/77851039
    Mask-RCNN :

    https://github.com/matterport/Mask_RCNN

    labelme(标注mask数据集用的):

    https://github.com/wkentaro/labelme

    二、修改训练代码

    主要修改train_shapes.ipynb,我个人感觉ipython-notebook不好用,所以我将它转成.py格式,就是把代码粘出来。let’s go!
    1、注释%matplotlib inline
    2、在ShapesConfig类中,GPU_COUNT = 2,IMAGES_PER_GPU = 1两个参数自己根据自己电脑配置修改参数,由于该工程用的resnet101为主干的网络,训练需要大量的显存支持,我的图片尺寸为1280*800的,IMAGES_PER_GPU 设置为2,在两个GeForce GTX TITAN X上训练显存都会溢出,所以IMAGES_PER_GPU = 1,大佬可忽略。
    NUM_CLASSES = 1 + 4为你数据集的类别数,第一类为bg,我的是4类,所以为1+4
    IMAGE_MIN_DIM = 800,IMAGE_MAX_DIM = 1280修改为自己图片尺寸
    RPN_ANCHOR_SCALES = (8 * 6, 16 * 6, 32 * 6, 64 * 6, 128 * 6),根据自己情况设置anchor大小
    3、在全局定义一个iter_num=0
    △4、重新写一个训练类
    名字自己起,我的叫

    class DrugDataset(utils.Dataset):
    

    添加函数

    #得到该图中有多少个实例(物体)
    def get_obj_index(self, image):
            n = np.max(image)
            return n
    
    #解析labelme中得到的yaml文件,从而得到mask每一层对应的实例标签
    def from_yaml_get_class(self,image_id):
            info=self.image_info[image_id]
            with open(info['yaml_path']) as f:
                temp=yaml.load(f.read())
                labels=temp['label_names']
                del labels[0]
            return labels
    
    #重新写draw_mask
    def draw_mask(self, num_obj, mask, image):
            info = self.image_info[image_id]
            for index in range(num_obj):
                for i in range(info['width']):
                    for j in range(info['height']):
                        at_pixel = image.getpixel((i, j))
                        if at_pixel == index + 1:
                            mask[j, i, index] =1
            return mask
    
    #重新写load_shapes,里面包含自己的自己的类别(我的是box、column、package、fruit四类)
    #并在self.image_info信息中添加了path、mask_path 、yaml_path
    def load_shapes(self, count, height, width, img_floder, mask_floder, imglist,dataset_root_path):
            """Generate the requested number of synthetic images.
            count: number of images to generate.
            height, width: the size of the generated images.
            """
            # Add classes
            self.add_class("shapes", 1, "box")
            self.add_class("shapes", 2, "column")
            self.add_class("shapes", 3, "package")
            self.add_class("shapes", 4, "fruit")
            for i in range(count):
                filestr = imglist[i].split(".")[0]
                filestr = filestr.split("_")[1]
                mask_path = mask_floder + "/" + filestr + ".png"
                yaml_path=dataset_root_path+"total/rgb_"+filestr+"_json/info.yaml"
                self.add_image("shapes", image_id=i, path=img_floder + "/" + imglist[i],
                               width=width, height=height, mask_path=mask_path,yaml_path=yaml_path)
    
    #重写load_mask
        def load_mask(self, image_id):
            """Generate instance masks for shapes of the given image ID.
            """
            global iter_num
            info = self.image_info[image_id]
            count = 1  # number of object
            img = Image.open(info['mask_path'])
            num_obj = self.get_obj_index(img)
            mask = np.zeros([info['height'], info['width'], num_obj], dtype=np.uint8)
            mask = self.draw_mask(num_obj, mask, img)
            occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)
            for i in range(count - 2, -1, -1):
                mask[:, :, i] = mask[:, :, i] * occlusion
                occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))
            labels=[]
            labels=self.from_yaml_get_class(image_id)
            labels_form=[]
            for i in range(len(labels)):
                if labels[i].find("box")!=-1:
                    #print "box"
                    labels_form.append("box")
                elif labels[i].find("column")!=-1:
                    #print "column"
                    labels_form.append("column")
                elif labels[i].find("package")!=-1:
                    #print "package"
                    labels_form.append("package")
                elif labels[i].find("fruit")!=-1:
                    #print "fruit"
                    labels_form.append("fruit")
            class_ids = np.array([self.class_names.index(s) for s in labels_form])
            return mask, class_ids.astype(np.int32)
    

    4、代码主体修改

    #基础设置
    dataset_root_path="/home/lijing/workspace_lj/fg_dateset/"
    img_floder = dataset_root_path+"rgb"
    mask_floder = dataset_root_path+"mask"
    #yaml_floder = dataset_root_path
    imglist = listdir(img_floder)
    count = len(imglist)
    width = 1280
    height = 800
    
    #train与val数据集准备
    dataset_train = DrugDataset()
    dataset_train.load_shapes(count, 800, 1280, img_floder, mask_floder, imglist,dataset_root_path)
    dataset_train.prepare()
    
    dataset_val = DrugDataset()
    dataset_val.load_shapes(count, 800, 1280, img_floder, mask_floder, imglist,dataset_root_path)
    dataset_val.prepare()
    

    注释掉
    model.train(dataset_train,dataset_val,learning_rate=config.LEARNING_RATE/10,epochs=50,layers="all")之后的代码就好了

    三、使用labelme生成mask掩码数据集

    github地址:https://github.com/wkentaro/labelme
    安装方式:

    sudo apt-get install python-qt4 pyqt4-dev-tools
    sudo pip install labelme
    

    使用,只需在终端输入:

    labelme
    

    我的数据集命名如下
    这里写图片描述
    Note:在画掩码过程中如有多个box、fruit…命名规则为box1、box2…fruit1、fruit2…。因为labelme这个标定工具还是不太智能,最后生成的标签为一个label.png文件,这个文件只有一通道,在你标注时同一标签mask会被给予一个标签位,而mask要求不同的实例要放在不同的层中。最终训练索要得到的输入为一个whn的ndarray,其中n为该图片中实例的个数。总而言之,画mask时就按照上述命名规则就好了,具体的过程已经在上述代码中实现。如图:[外链图片转存失败(img-pz6XNqZO-1569381163426)(https://img-blog.csdn.net/20180124180622625?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvbDI5Nzk2OTU4Ng==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)]。
    此时labelme生成的为.json文件,需要将json文件转换为我们需要的标签文件,我这里写了一个简单的脚本,不用一个个去转化了,只需将s1改为你对应的路径及图片前缀名,循环数改为自己数据集数即可

    #!/bin/bash
    s1="/media/lj/GSP1RMCPRXV/fg_dateset/json/rgb_"
    s2=".json"
    for((i=1;i<901;i++))
    do 
    s3=${i}
    labelme_json_to_dataset ${s1}${s3}${s2}
    done
    
    

    在你图片目录下会生成多个rgb_x_json文件夹,每个文件夹中有img.png(原图),info.yaml,label.png,label_viz.png四个文件,其中需要用的只有info.yaml以及label.png
    转化出来的可视化标签如图:
    这里写图片描述

    四、转化label.png为可用格式

    注:貌似labelme已经升级,现在mask图直接为8位,大家可以用cv读一下,若是8位这一步就省了。

    labelme生成的掩码标签 label.png为16位存储,opencv默认读取8位,需要将16位转8位
    参考:http://blog.csdn.net/l297969586/article/details/79154150

    五、训练

    直接运行修改后的py文件即可,训练中图片展示:
    这里写图片描述

    六、结果展示

    我只训练了四个类(box,column,package,friut)
    测试图片未参与训练,测试结果如下:
    这里写图片描述
    [外链图片转存失败(img-zhg5jkXk-1569381163433)(https://img-blog.csdn.net/20180124181808641?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvbDI5Nzk2OTU4Ng==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)]

    2018.4.22NOTE:介于很多人问到怎么计算单张图片的AP值,现添加计算f1_measure与AP计算代码如下:

    local:为测试代码里得出的mask
    ground_truth:为从mask文件夹直接读取label.png的ndarray

    #计算单张f1_measure
    def compute_f1_measure(local,ground_truth):
        overlap_area=0
        mask_area=0
        FP=0
        FN=0
        for i in range(800):
            for j in range(1280):
                if ground_truth[i][j]:
                    mask_area+=1
                for k in range (local.shape[2]):
                    if local[i][j][k] == ground_truth[i][j] and ground_truth[i][j] :
                        overlap_area+=1
                    if local[i][j][k] and ground_truth[i][j] != local[i][j][k]:
                        FP+=1
                    if local[i][j][k] != ground_truth[i][j] and ground_truth[i][j]:
                        FN+=1
        print ("overlap_area",overlap_area)
        print ("mask_area:",mask_area)
        TP=overlap_area
        P=TP/(TP+FP)
        R=TP/(TP+FN)
        f1_measure=2*P*R/(P+R)
        return f1_measure
    #计算单张mAP值
    def compute_mAP(local,ground_truth):
        overlap_area=0
        mask_area=0
        FP=0
        FN=0
        for i in range(800):
            for j in range(1280):
                if ground_truth[i][j]:
                    mask_area+=1
                for k in range (local.shape[2]):
                    if local[i][j][k] == ground_truth[i][j] and ground_truth[i][j] :
                        overlap_area+=1
                    if local[i][j][k] and ground_truth[i][j] != local[i][j][k]:
                        FP+=1
                    if local[i][j][k] != ground_truth[i][j] and ground_truth[i][j]:
                        FN+=1
        print ("overlap_area",overlap_area)
        print ("mask_area:",mask_area)
        TP=overlap_area
        P=TP/(TP+FP)
        #R=TP/(TP+FN)
        #f1_measure=2*P*R/(P+R)
        return P
    
    展开全文
  • Mask RCNN是大神Kaiming He的一大神作。 1、概述 Mask RCNN主要是再Faster RCNN上进行了一些调整(将RoIpooling层替换为了RoIAlign层),并且在RoIAlign后增加了一个进行instance segmentation的分支。 图片来源...

    Mask RCNN是大神Kaiming He的一大神作。

    1、概述

    Mask RCNN主要是再Faster RCNN上进行了一些调整(将RoIpooling层替换为了RoIAlign层),并且在RoIAlign后增加了一个进行instance segmentation的分支。

    上图展示了一个Mask RCNN的网络结构,用RoIAlign来代替RoIpooling部分,并且在分类与回归中添加了并列的分支FCN(mask层)

    2、loss function

    训练中,文章定义了多个任务的损失是对每一个RoI有L=L_{cls}+L_{reg}+L_{mask},其中的前两个损失是同faster RCNN中一样的定义,而第三个损失L_{mask}是mask层的损失计算。mask对应的每个RoI的输出维度是K*m^2,表示K个类别共有K个mxm的二进制掩码【论文中m*m对应池化分辨率7*7,通过对每个class对应一个mask可以有效地避免同类竞争】,这里使用的是per-pixel sigmoid【在论文中有与per-pixel softmax进行对比】,将损失函数定义为L_mask average binary cross-entropy,loss只定义在有对应gt的mask上,其他mask不对loss有贡献值。

    3、RoIAlign【重点推荐:一篇不错的文

    论文比较主要的地方是用RoIAlign来代替RoIpooling,因为原来的faster RCNN是无需做实例分割的,而实例分割是需要在pixel级别上有较高的精确度,但是因为RoIpooling的量化操作,使其对实力分割上的一个精度会比较低,因此作者就提出了使用RoIAlign来代替RoIpooling。

    • RoIpooling的操作主要是为了将不同尺寸的feature map操作成尺寸一样大小的feature。
    • RoIAlign没有像RoIpooling那样做量化操作【in paper, use x/16 instead of round(x/16)】,并且使用了双线性插值to compute the exact values of the input features at four regularly sampled locations in each RoI bin, and aggregate the result(using max or average)【具体细节等看完代码吧】

    一张来自上面的链接博文的比较好的图。【理解:RoIAlign的RoI的边界无需量化取整,而是如图中RoIAlign部分,将得到的RoIAlign,框的边界仍然取浮点数,此时,在每个bin(最终需要得到的尺寸的规模为t*t,那么有t*t个bins)中取样四个点【平均取的四个点?】】,四个点的值由邻近的feature map的pixel值通过双线性插值法来取得,最后将这四个采样点的值进行max或average来作为这个bin的值,最终可得到尺寸大小一样的RoI所对应的更加精确的feature map区域值。   第三种方法是使用了积分的方法,链接博文中说会更加精确,但是会比较耗时。】

    4、结果对比

    5、Mask RCNN扩展——

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • Mask RCNN__Mask RCNN详细流程解析

    千次阅读 2018-12-20 15:43:23
    根据多篇文章整理,仅供参考相互学习。 ...Mask R-CNN 是一个两阶段的框架,第一个阶段扫描图像并生成提议(proposals,即有可能包含一个目标的区域),第二阶段分类提议并生成边界框和掩码。M...

    根据多篇文章整理,仅供参考相互学习。

    https://www.cnblogs.com/YouXiangLiThon/p/9178861.html

    上面这位博主对源码的讲解还是挺详细的,感兴趣的也可以去看看.

     Mask R-CNN

    Mask R-CNN 是一个两阶段的框架,第一个阶段扫描图像并生成提议(proposals,即有可能包含一个目标的区域),第二阶段分类提议并生成边界框和掩码。Mask R-CNN 扩展自 Faster R-CNN,由同一作者在去年提出。Faster R-CNN 是一个流行的目标检测框架,Mask R-CNN 将其扩展为实例分割框架。

    有效地检测图像中的目标,同时还能为每个实例生成一个高质量的分割掩码(segmentation mask)。这个方面被称为 Mask R-CNN,是在 Faster R-CNN 上的扩展——在其已有的用于边界框识别的分支上添加了一个并行的用于预测目标掩码的分支。

    何恺明大神的论文Mask R-CNN 获得ICCV最佳论文 ,是在 Feature Pyramid Network (FPN) 和 ResNet101基础上实现的。

    下图阐述了Mask R-CNN的Mask branch:

     

    在Mask R-CNN中的RoI Align之后有一个"head"部分,主要作用是将RoI Align的输出维度扩大,这样在预测Mask时会更加精确。在Mask Branch的训练环节,作者没有采用FCN式的SoftmaxLoss,反而是输出了K个Mask预测图(为每一个类都输出一张),并采用average binary cross-entropy loss训练,当然在训练Mask branch的时候,输出的K个特征图中,也只是对应ground truth类别的那一个特征图对Mask loss有贡献。

    Mask R-CNN的训练损失函数可以描述为:

     损失函数:分类误差+检测误差+分割误差,即L=Lcls+Lbox+Lmask 

     Lcls、Lbox:利用全连接预测出每个RoI的所属类别及其矩形框坐标值

     Lmask:

    1. mask分支采用FCN对每个RoI的分割输出维数为K*m*m(其中:m表示RoI Align特征图的大小),即K个类别的m*m的二  值mask;保持m*m的空间布局,pixel-to-pixel操作需要保证RoI特征 映射到原图的对齐性,这也是使用RoIAlign解决对齐问题原因,减少像素级别对齐的误差。
    2.  K*m*m二值mask结构解释:最终的FCN输出一个K层的mask,每一层为一类,Log输出,用0.5作为阈值进行二值化,产生背景和前景的分割Mask
    3. 这样,Lmask 使得网络能够输出每一类的 mask,且不会有不同类别 mask 间的竞争. 分类网络分支预测 object 类别标签,以选择输出 mask,对每一个ROI,如果检测得到ROI属于哪一个分 类,就只使用哪一个分支的相对熵误差作为误差值进行计算。(举例说明:分类有3类(猫,狗,人),检测得到当前ROI属于“人”这一类,那么所使用的Lmask为“人”这一分支的mask,即,每个class类别对应一个mask可以有效避免类间竞争(其他class不贡献Loss)
    4. 对每一个像素应用sigmoid,然后取RoI上所有像素的交叉熵的平均值作为Lmask。

    在Mask R-CNN中,相较于Faster R-CNN还有些略微的调整,比如positive RoI被定义成了与Ground truth的IoU大于0.5的(Faster R-CNN中是0.7)。

    1. Mask R-CNN算法步骤

    首先,输入一幅你想处理的图片,然后进行对应的预处理操作,或者预处理后的图片;

    然后,将其输入到一个预训练好的神经网络中(ResNeXt等)获得对应的feature map;

    接着,对这个feature map中的每一点设定预定个的ROI,从而获得多个候选ROI;

    接着,将这些候选的ROI送入RPN网络进行二值分类(前景或背景)和BB回归,过滤掉一部分候选的ROI;

    接着,对这些剩下的ROI进行ROIAlign操作(即先将原图和feature map的pixel对应起来,然后将feature map和固定的feature对应起来);

    最后,对这些ROI进行分类(N类别分类)、BB回归和MASK生成(在每一个ROI里面进行FCN操作)。

    2. Mask R-CNN架构分解

    2.1.1 主干架构

    主干网络是一个标准的卷积神经网络(通常来说是 ResNet50 和 ResNet101),作为特征提取器。

    代码提示:主干网络在 resnet_graph() 函数中。代码支持 ResNet50 和 ResNet101。

    2.1.2 FPN

    特征金字塔网络(FPN)是对该主干网络的扩展,可以在多个尺度上更好地表征目标。

    前面说的CNN其实就是下图中左侧那一组,最下面橙色框框里是一个输入图片,越往上层,视野越大,但是由于卷积和池化,图片的尺寸实际是越来越小的,所以上面用越来越小的方块代表没一层的输出,整体看起来,就像是金字塔一样,这就是Pyramid这个词的来源了。

    那FPN就是在原来CNN一个金字塔旁边又增加了一个金字塔。

     

    FPN增加一个金字塔是要干什么那?实际是想要在大视野的时候还能看见小东西。所以,如果把前一个金字塔中大视野特征(如左侧金字塔最高层特征)拿到后一个金字塔的底层中,这样就可以在小视野中也能看见大视野中的图像了。这类似于井底之蛙看不见外面的大好景色,但是你可以录视频拿到井底放给他看,他就一样能知道外面的世界有什么了。

    在我们的 Mask R-CNN 实现中使用的是 ResNet101+FPN 主干网络。

    代码提示:FPN 在 MaskRCNN.build() 中创建,位于构建 ResNet 的部分之后。FPN 引入了额外的复杂度:在 FPN 中第二个金字塔拥有一个包含每一级特征的特征图,而不是标准主干中的单个主干特征图(即第一个金字塔中的最高层)。选用哪一级的特征是由目标的尺寸动态地确定的。

    2.2 区域建议网络(RPN)

    展示 49 个 anchor box 的简化图示

    RPN 是一个轻量的神经网络,它用滑动窗口来扫描图像,并寻找存在目标的区域。RPN 扫描的区域被称为 anchor.

    代码提示:RPN 在 rpn_graph() 中创建。anchor 的尺度和长宽比由 config.py 中的 RPN_ANCHOR_SCALES 和 RPN_ANCHOR_RATIOS 控制。

    RPN 为每个 anchor 生成两个输出

        1) anchor 类别:前景或背景(FG/BG)。前景类别意味着可能存在一个目标在 anchor box 中。

        2) 边框精调:前景 anchor(或称正 anchor)可能并没有完美地位于目标的中心。因此,RPN 评估了 delta 输出(x、y、宽、高的变化百分数)以精调 anchor box 来更好地拟合目标。

    使用 RPN 的预测,我们可以选出最好地包含了目标的 anchor,并对其位置和尺寸进行精调。如果有多个 anchor 互相重叠,我们将保留拥有最高前景分数的 anchor,并舍弃余下的(非极大值抑制)。然后我们就得到了最终的区域建议,并将其传递到下一个阶段。

    代码提示:ProposalLayer 是一个自定义的 Keras 层,可以读取 RPN 的输出,选取最好的 anchor,并应用边框精调。

    2.3  ROI 分类器和边界框回归器

    这个阶段是在由 RPN 提出的 ROI 上运行的。

    阶段 2 的图示。来源:Fast R-CNN

    正如 RPN 一样,它为每个 ROI 生成了两个输出:

        1)  类别:ROI 中的目标的类别。和 RPN 不同(两个类别,前景或背景),这个网络更深并且可以将区域分类为具体的类别(人、车、椅子等)。它还可以生成一个背景类别,然后就可以弃用 ROI 了。

        2)  边框精调:和 RPN 的原理类似,它的目标是进一步精调边框的位置和尺寸以将目标封装。

    代码提示:分类器和边框回归器已在 fpn_classifier_graph() 中创建。

    2.3.1 ROI 池化

    在我们继续之前,需要先解决一些问题。分类器并不能很好地处理多种输入尺寸。它们通常只能处理固定的输入尺寸。但是,由于 RPN 中的边框精调步骤,ROI 框可以有不同的尺寸。因此,我们需要用 ROI 池化来解决这个问题。

    图中展示的特征图来自较底层。

    ROI 池化是指裁剪出特征图的一部分,然后将其重新调整为固定的尺寸。这个过程实际上和裁剪图片并将其缩放是相似的(在实现细节上有所不同)。

    Mask R-CNN 的作者提出了一种方法 ROIAlign,在特征图的不同点采样,并应用双线性插值。在我们的实现中,为简单起见,我们使用 TensorFlow 的 crop_and_resize 函数来实现这个过程。

    代码提示:ROI 池化在类 PyramidROIAlign 中实现。

    2.4  分割掩码

    到第2.3 节为止,我们得到的正是一个用于目标检测的 Faster R-CNN。而分割掩码网络正是 Mask R-CNN 的论文引入的附加网络。

    掩码分支是一个卷积网络,取 ROI 分类器选择的正区域为输入,并生成它们的掩码。其生成的掩码是低分辨率的:28x28 像素。但它们是由浮点数表示的软掩码,相对于二进制掩码有更多的细节。掩码的小尺寸属性有助于保持掩码分支网络的轻量性。在训练过程中,我们将真实的掩码缩小为 28x28 来计算损失函数,在推断过程中,我们将预测的掩码放大为 ROI 边框的尺寸以给出最终的掩码结果,每个目标有一个掩码。

    代码提示:掩码分支网络在 build_fpn_mask_graph() 中。

    2.4.1 建立一个颜色填充过滤器

    和大多数图像编辑 app 中包含的过滤器不同,我们的过滤器更加智能一些:它能自动找到目标。当你希望把它应用到视频上而不是图像上时,这种技术更加有用。

    ===========================================================================================

    在这里,我将Mask R-CNN的ROIAlign和FCN分别进行讲解,这也是该算法的核心

    接下来到了Mask R-CNN,我们来看看RoI Pooling出了什么问题:

    问题1:从输入图上的RoI到特征图上的RoI feature,RoI Pooling是直接通过四舍五入取整得到的结果。这样会带来什么坏处呢?就是RoI Pooling过后的得到的输出可能和原图像上的RoI对不上,如下图所示:

     

    右图中蓝色部分表示包含了轿车主体的的信息的方格,RoI Pooling Layer的四舍五入取整操作导致其进行了偏移。

    问题2:再将每个RoI对应的特征转化为固定大小的维度时,又采用了取整操作。在这里笔者举例讲解一下RoI Pooling的操作:

    在从RoI得到对应的特征图时,进行了问题1描述的取整,在得到特征图后,如何得到一个6×6的全连接层的输入呢?RoI Pooling这样做:将RoI对应的特征图分成6×6块,然后直接从每块中找到最大值。在上图中的例子中,比如原图上的的RoI大小是280×480,得到对应的特征图是18×30。将特征图分成6块,每块大小是3×5,然后在每一块中分别选择最大值放入6×6的对应区域中。在将特征图分块的时候,又用到了取整这种取整操作(在Mask R-CNN中被称为quantization)对RoI分类影响不大,可是对逐像素的预测目标是有害的,因为对每个RoI取得的特征并没有与RoI对齐。因此,Mask R-CNN对RoI Pooling做了改进并提出了RoI Align。

    RoI Align的主要创新点是,针对问题1,不再进行取整操作。针对问题2,使用双线性插值来更精确地找到每个块对应的特征。总的来说,RoI Align的作用主要就是剔除了RoI Pooling的取整操作,并且使得为每个RoI取得的特征能够更好地对齐原图上的RoI区域。

    ROIPooling和ROIAlign的分析与比较

    ROI Pooling和ROIAlign最大的区别是:前者使用了两次量化操作,而后者并没有采用量化操作,使用了线性插值算法

    双线性插值是一种比较好的图像缩放算法,它充分的利用了原图中虚拟点(比如20.56这个浮点数,像素位置都是整数值,没有浮点值)四周的四个真实存在的像素值来共同决定目标图中的一个像素值,即可以将20.56这个虚拟的位置点对应的像素值估计出来。

    该网络可以在一定程度上面提高检测的精度,当前很多的方法都用到了它。由于FPN网络已经包含了res5,可以更加高效的使用特征,因此这里使用了较少的filters。

     FCN

    Mask R-CNN在Faster-RCNN上添加一个分支网络:Fully Convolution Networ(FCN)。FCN算法是一个经典的语义分割算法,可以对图片中的目标进行准确的分割。其总体架构如上图所示,它是一个端到端的网络,主要的模快包括卷积和去卷积,即先对图像进行卷积和池化,使其feature map的大小不断减小;然后进行反卷积操作,即进行插值操作,不断的增大其feature map,最后对每一个像素值进行分类。从而实现对输入图像的准确分割。

    展开全文
  • 并且从官网下载好代码包了:https://github.com/matterport/Mask_RCNN,注意不是detrecton那个 直接到setup.py路径,也就是根路径 python3 setup.py install 看下都干啥了: WARNING:root:Fail load ...
  • MaskRCNN

    2020-11-29 10:22:33
    <div><p>Hello, is there support for MaskRCNN? I am using the torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True) model, but get an error when trying to convert to torch2trt. Thanks...
  • mask rcnn模型踩坑指南(MxNet框架): 1. 环境:anaconda2+tensorflow-gpu+python2.7.14 pip freeze: certifi==2017.11.5 / Cython==0.27.3 / easydict==1.7 / frcnn-cython==0.0.0 / numpy==1.13.3 / olefile==0.44 ...
  • 自己精心整理的目标检测系列视频讲解mp4,从RCNN>FastRCNN>FasterRCNN>FPN>MaskRCNN,华文讲解,很详细! 01懒人学RCNN.mp4 02懒人学FastRCNN.mp4 03懒人讲FasterRCNN之简介.mp4 04懒人学FasterRCNN之融合.mp4 05懒人...
  • 大名鼎鼎的 Mask RCNN 一举夺得 ICCV2017 Best Paper,名声大造。Mask RCNN 是何恺明基于以往的 Faster RCNN 架构提出的新的卷积网络,实现高效地检测图中的物体,并同时生成一张高质量的每个个体的分割掩码,即有效...
  • 大名鼎鼎的 Mask RCNN 一举夺得 ICCV2017 Best Paper,名声大造。Mask RCNN 是何恺明基于以往的 Faster RCNN 架构提出的新的卷积网络,实现高...
  • 第一次写博客,主要想赚点积分(开篇点题,不好意思哈,不过你们不会亏的,有问题可以联系我,非常热心) 先说个大概,opencv是intel的所以不支持竞争对手的功能(nvidia的gpu),那个OPENCL选项其实是intel的核显,...
  • 2.3 配置maskrcnn-benchmark maskrcnn-benchmark是facebook research开源的目标检测和实例分割的算法仓库,可以实现的模型有Faster RCNN,Mask RCNN,RetinaNet等。 1. 环境要求 PyTorch...
  • /home/jade/Workspace/scripting/t-vi/maskrcnn-benchmark/maskrcnn_benchmark/modeling/rpn/inference.py(120): forward_for_single_feature_map /home/jade/Workspace/scripting/t-vi/maskrcnn-benchmark/maskrcnn...
  • m sorry, this would be very naive question but I couldnt run demo because utils.py couldnt properly import maskrcnn_benchmark.layers.nms as nms $ python demo.py --input-video path/to/your/input/video ...
  • 大家好,这是我的第一篇博客。作为深度学习的初学者,从实战的角度,详细介绍基于maskrcnn-benchmark框架下,使用Maskrcnn网络训练自己的数据集的过程。这其中,踩的坑不少,但也受益匪浅。
  • 1. 前言 这一节将从代码库里面的demo.ipynb笔记本入手,来整体理解一下Mask RCNN的网络架构。 2. 代码理解 首先导入需要用到的
  • 项目源码:https://github.com/facebookresearch/maskrcnn-benchmark 包含faster rcnn、mask rcnn等等框架的库,非常强大。自己摸索了一下如何用自己定义的Dataset来训练。 参考资料: 介绍了一些核心py文件的...
  • 主要参考: https://blog.csdn.net/qq_29462849/article/details/81037343#commentBox https://blog.csdn.net/l297969586/article/details/79140840 ... 一、配置MaskRCNN环境 1、...
  • RCNN-FastRCNN-FasterRCNN-MaskRCNN-TensorMask论文打包 2014 Rich feature hierarchies for accurate object detection and semantic segmentation 2015 Fast R-CNN 2016 Faster R-CNN: Towards Real-Time Object ...
  • mask rcnn解读

    万次阅读 多人点赞 2017-11-21 00:08:52
    上一篇中介绍faster rcnn,这次mask 基本在上次的基础上加了点代码,参考和引用1. mask rcnn slides 2. kaiming he maskrcnn 3. Ardian Umam mask rcnn,欢迎fork简版mask rcnn。

空空如也

1 2 3 4 5 ... 20
收藏数 3,397
精华内容 1,358
关键字:

mask rcnn