精华内容
下载资源
问答
  • 对一个文件夹中的所有照片切割成任意个小块图像

    在这里插入图片描述

    1.Introduction

    又是一年四季在轮回,而我终于入门了深度学习!

    话说上周终于在Paddle框架下跑通了目标检测,激动了好几天,哈哈哈,深度学习的门槛是真的高(我是真的菜),由于拍的照片有点大,所以就需要对图片进行切割,切成2×2,3×3之类的。开始是是想用Matlab的,毕竟现在最熟悉的就是Matlab了,不过转念一想,都深度学习了,还是用Python吧~

    2.Materials and methods

    本文所实现的目的是对一个文件内的所有照片,进行批量切割,其中切割的个数可以自己选择,比如横着切2块,竖着切3块。

    话不多说,上代码

    # -*- coding: utf-8 -*-
    """
    Created on Sun Dec 13 21:49:55 2020
    
    @author: YaoYee
    """
    
    import cv2
    import os
    
    # Cutting the input image to h*w blocks
    heightCutNum = 2;
    widthCutNum = 2;
    
    
    # The folder path of input and output
    inPath = "C:/Users/YaoYee/Desktop/original/"
    outPath = "C:/Users/YaoYee/Desktop/cutting/"
    
    
    for f in os.listdir(inPath):
    
        path = inPath + f.strip()
        print(path)
        img = cv2.imread(path)    
    
        # The size of each input image
        height = img.shape[0]
        width = img.shape[1]
        
        # The size of block that you want to cut
        heightBlock = int(height / heightCutNum)
        widthBlock = int(width / widthCutNum)
    
        for i in range(0,heightCutNum):
            for j in range(0,widthCutNum):
                cutImage = img[i*heightBlock:(i+1)*heightBlock, j*widthBlock:(j+1)*widthBlock]
                savePath = outPath + f.strip()[0:5] + "_" + str(i) + str(j) + ".jpg"
                cv2.imwrite(savePath,cutImage)
            
    

    emmm,注释啥的都写了,也没啥说的了吧

    3. Results and discussion

    运行下看看效果,这里我们把巴基和路飞大卸四块~
    在这里插入图片描述
    :输出文件夹路径自己先构建好,也就是告诉代码把结果存到哪

    4. Conclusion

    I have nothing to loss

    猜你喜欢:👇🏻
    【Python】如何在文件夹里批量替换文本中的内容?
    【Python】如何在文件夹里批量修改文件名(001-100)?
    【Python】随机划分数据集并生成VOC格式列表

    在这里插入图片描述

    展开全文
  • 早上,朋友发来一张照片说要把它切分成单张,我一看发现这张照片是几张照片组合起来的,现在很多手机都可以连拍,然后自行组合在一起,是不是感觉每一张都是萌萌哒呢?为了体现单张的独特性,现在我要把它切分成单张...

          今天情人节,博主在这里祝大家节日快乐!早上,朋友发来一张照片说要把它切分成单张,我一看发现这张照片是几张照片组合起来的,现在很多手机都可以连拍,然后自行组合在一起,是不是感觉每一张都是萌萌哒呢?为了体现单张的独特性,现在我要把它切分成单张,使用Photoshop CS5该怎么弄呢?


       1.首先,在photoshop中打开这张图;

      2.找到最左边的工具箱里的第五个小框“切片工具”,然后右击出现三个选项,单击“切片工具”,如下图所示:


     

      3.此时鼠标变成小刀形状,然后在图片上右击,在出现的菜单中选择“划分切片”,出现下图小窗口:

      4.单击该窗口中右上方的“确定”按钮,出现下图效果,也就是说,上一步骤的参数是把此图切成了2行2列的四张图片;


      5.单击ps菜单栏中“文件”里的“存储为web和设备所用格式(D)”,出现下图窗口:


      6.根据自己的需求,修改其中的参数,然后点击右下方的“存储”按钮,然后会弹出如下窗口,提示你选择想要保存的路径,默认是桌面,填写要保存的图片名称:


      7.单击“保存”按钮之后,弹出如下窗口:

      8.单击“确定”按钮,大功告成!在刚才的路径下查看效果,发现在桌面出现一个images的文件夹,里面是四张更加萌萌哒照片。


      第一篇博客,希望多多指教!谢谢!

         (向以往的朋友道个歉,刚发现,本文的许多图片加载不出来,查询后得知原因是图片采用中文名,所以重新整理,望见谅!)

    转载于:https://www.cnblogs.com/lsxs-wy/p/6398881.html

    展开全文
  • 作者 | Aleksey Bilogur 译者 | 风车云马 责编 | Jane 出品 | AI科技大本营(公众号id:rgznai100) ...在本文中,我们将从一个完整的工作流:下载数据→图像分割与处理→建模→发布模型,教...

    https://www.toutiao.com/a6674844350158995976/

     

    作者 | Aleksey Bilogur

    译者 | 风车云马

    责编 | Jane

    出品 | AI科技大本营(公众号id:rgznai100)

     

    【CSDN 编者按】完成一个简单的端到端的机器学习模型需要几步?在本文中,我们将从一个完整的工作流:下载数据→图像分割与处理→建模→发布模型,教大家如何对 900 万张图像进行分类,分类标签多达 600 个。可是如此庞大的数据集又是从何而来呢?之前为大家介绍过一篇文章在过去十年间,涵盖 CV、NLP 和语音等领域,有 68 款大规模数据集,本文所用的数据集也在其中,大家也可以以此为借鉴,学习如何利用好这些数据。

     

     

    前言

    如果您想构建一个图像分类器,哪里可以得到训练数据呢?这里给大家推荐 Google Open Images,这个巨大的图像库包含超过 3000 万张图像和 1500 万个边框,高达 18tb 的图像数据!并且,它比同级别的其他图像库更加开放,像 ImageNet 就有权限要求。

    但是,对单机开发人员来说,在这么多的图像数据中筛选过滤并不是一件易事,需要下载和处理多个元数据文件,还要回滚自己的存储空间,也可以申请使用谷歌云服务。另一方面,实际中并没有那么多定制的图像训练集,实话讲,创建、共享这么多的训练数据是一件头疼的事情。

    在今天的教程中,我们将教大家如何使用这些开源图像创建一个简单的端到端机器学习模型。

    先来看看如何使用开源图像中自带的 600 类标签来创建自己的数据集。下面以类别为“三明治”的照片为例,展示整个处理过程。

     

     

    如何从 900 万张图片中对 600 类照片进行分类? | 技术头条

    谷歌开源图像-三明治图片

     

    下载数据

    首先需要下载相关数据,然后才能使用。这是使用谷歌开源图像(或其他外部数据集)的第一步。而下载数据集需要编写相关脚本,没有其他简单的方法,不过不用担心,我写了一个Python脚本,大家可以直接用。思路:首先根据指定的关键字,在开源数据集中搜索元数据,找到对应图像的原始 url(在 Flickr 上),然后下载到本地,下面是实现的 Python 代码:

     1import sys
     2import os
     3import pandas as pd
     4import requests
     5
     6from tqdm import tqdm
     7import ratelim
     8from checkpoints import checkpoints
     9checkpoints.enable()
    10
    11
    12def download(categories):
    13 # Download the metadata
    14 kwargs = {'header': None, 'names': ['LabelID', 'LabelName']}
    15 orig_url = "https://storage.googleapis.com/openimages/2018_04/class-descriptions-boxable.csv"
    16 class_names = pd.read_csv(orig_url, **kwargs)
    17 orig_url = "https://storage.googleapis.com/openimages/2018_04/train/train-annotations-bbox.csv"
    18 train_boxed = pd.read_csv(orig_url)
    19 orig_url = "https://storage.googleapis.com/openimages/2018_04/train/train-images-boxable-with-rotation.csv"
    20 image_ids = pd.read_csv(orig_url)
    21
    22 # Get category IDs for the given categories and sub-select train_boxed with them.
    23 label_map = dict(class_names.set_index('LabelName').loc[categories, 'LabelID']
    24 .to_frame().reset_index().set_index('LabelID')['LabelName'])
    25 label_values = set(label_map.keys())
    26 relevant_training_images = train_boxed[train_boxed.LabelName.isin(label_values)]
    27
    28 # Start from prior results if they exist and are specified, otherwise start from scratch.
    29 relevant_flickr_urls = (relevant_training_images.set_index('ImageID')
    30 .join(image_ids.set_index('ImageID'))
    31 .loc[:, 'OriginalURL'])
    32 relevant_flickr_img_metadata = (relevant_training_images.set_index('ImageID').loc[relevant_flickr_urls.index]
    33 .pipe(lambda df: df.assign(LabelValue=df.LabelName.map(lambda v: label_map[v]))))
    34 remaining_todo = len(relevant_flickr_urls) if checkpoints.results is None else
    35 len(relevant_flickr_urls) - len(checkpoints.results)
    36
    37# Download the images
    38 with tqdm(total=remaining_todo) as progress_bar:
    39 relevant_image_requests = relevant_flickr_urls.safe_map(lambda url: _download_image(url, progress_bar))
    40 progress_bar.close()
    41
    42 # Write the images to files, adding them to the package as we go along.
    43 if not os.path.isdir("temp/"):
    44 os.mkdir("temp/")
    45 for ((_, r), (_, url), (_, meta)) in zip(relevant_image_requests.iteritems(), relevant_flickr_urls.iteritems(),
    46 relevant_flickr_img_metadata.iterrows()):
    47 image_name = url.split("/")[-1]
    48 image_label = meta['LabelValue']
    49
    50 _write_image_file(r, image_name)
    51
    52
    53@ratelim.patient(5, 5)
    54def _download_image(url, pbar):
    55 """Download a single image from a URL, rate-limited to once per second"""
    56 r = requests.get(url)
    57 r.raise_for_status()
    58 pbar.update(1)
    59 return r
    60
    61
    62def _write_image_file(r, image_name):
    63 """Write an image to a file"""
    64 filename = f"temp/{image_name}"
    65 with open(filename, "wb") as f:
    66 f.write(r.content)
    67
    68
    69if __name__ == '__main__':
    70 categories = sys.argv[1:]
    71 download(categories)
    

     

    该脚本可以下载原始图像的子集,其中包含我们选择的类别的边框信息:

     

    1$ git clone https://github.com/quiltdata/open-images.git
    2$ cd open-images/
    3$ conda env create -f environment.yml
    4$ source activate quilt-open-images-dev
    5$ cd src/openimager/
    6$ python openimager.py "Sandwiches" "Hamburgers"
    

     

    图像类别采用多级分层的方式。例如,类别三明治和汉堡包还都属于食物类标签。我们可以使用 Vega 将其可视化为径向树:

     

    如何从 900 万张图片中对 600 类照片进行分类? | 技术头条

     

     

    并不是开源图像中的所有类别都有与之关联的边框数据。但这个脚本可以下载 600 类标签中的任意子集, 本文主要通过”汉堡包“和”三明治“两个类别展开讨论。

     

    football, toy, bird, cat, vase, hair dryer, kangaroo, knife, 
    briefcase, pencil case, tennis ball, nail, high heels, sushi, 
    skyscraper, tree, truck, violin, wine, wheel, whale, pizza cutter, 
    bread, helicopter, lemon, dog, elephant, shark, flower, furniture, 
    airplane, spoon, bench, swan, peanut, camera, flute, helmet, 
    pomegranate, crown… 
    

     

     

    图像分割和处理

     

    我们在本地处理图像时,可以使用 matplotlib 显示这些图片:

    1import matplotlib.pyplot as plt
    2from matplotlib.image import imread
    3%matplotlib inline
    4import os
    5fig, axarr = plt.subplots(1, 5, figsize=(24, 4))
    6for i, img in enumerate(os.listdir('../data/images/')[:5]):
    7 axarr[i].imshow(imread('../data/images/' + img))
    

     

     

    如何从 900 万张图片中对 600 类照片进行分类? | 技术头条

     

     

    可见这些图像并不容易训练,也存在其他网站的源数据集所面临的所有问题。比如目标类中可能存在不同大小、不同方向和遮挡等问题。有一次,我们甚至没有成功下载到实际的图像,只是得到一个占位符——我们想要的图像已经被删除了!

    我们下载得到了几千张这样的图片之后就要利用边界框信息将这些图像分割成三明治,汉堡。下面给出一组包含边框的图像:

     

    如何从 900 万张图片中对 600 类照片进行分类? | 技术头条

    带边界框

     

     

    此处省略了这部分代码,它有点复杂。下面要做的就是重构图像元数据,剪裁分割图像;再提取匹配的图像。在运行上述代码之后,本地会生成一个 images_ cropped 文件夹,其中包含所有分割后的图像。

     

     

    建模

    完成了下载数据,图像分割和处理,就可以训练模型了。接下来,我们对数据进行卷积神经网络(CNN)训练。卷积神经网络利用图像中的像素点逐步构建出更高层次的特征。然后对图像的这些不同特征进行得分和加权,最终生成分类结果。这种分类的方式很好的利用了局部特征。因为任何一个像素与附近像素的特征相似度几乎都远远大于远处像素的相似度。

    CNNs 还具有其他吸引之处,如噪声容忍度和(一定程度上的)尺度不变性。这进一步提高了算法的分类性能。

    接下来就要开始训练一个非常简单的卷积神经网络,看看它是如何训练出结果的。这里使用 Keras 来定义和训练模型。

    1、首先把图像放在一个特定的目录下

     

    1images_cropped/
    2 sandwich/
    3 some_image.jpg
    4 some_other_image.jpg
    5 ...
    6 hamburger/
    7 yet_another_image.jpg
    8 ...
    

     

    然后 Keras 调用这些文件夹,Keras会检查输入的文件夹,并确定是二分类问题,并创建“图像生成器”。如以下代码:

     

     1from keras.preprocessing.image import ImageDataGenerator
     2
     3train_datagen = ImageDataGenerator(
     4 rotation_range=40,
     5 width_shift_range=0.2,
     6 height_shift_range=0.2,
     7 rescale=1/255,
     8 shear_range=0.2,
     9 zoom_range=0.2,
    10 horizontal_flip=True,
    11 fill_mode='nearest'
    12)
    13
    14test_datagen = ImageDataGenerator(
    15 rescale=1/255
    16)
    17
    18train_generator = train_datagen.flow_from_directory(
    19 '../data/images_cropped/quilt/open_images/',
    20 target_size=(128, 128),
    21 batch_size=16,
    22 class_mode='binary'
    23)
    24
    25validation_generator = test_datagen.flow_from_directory(
    26 '../data/images_cropped/quilt/open_images/',
    27 target_size=(128, 128),
    28 batch_size=16,
    29 class_mode='binary'
    30)
    

     

    我们不只是返回图像本身,而是要对图像进行二次采样、倾斜和缩放等处理(通过train_datagen.flow_from_directory)。其实,这就是实际应用中的数据扩充。数据扩充为输入数据集经过图像分类后的裁剪或失真提供必要的补偿,这有助于我们克服数据集小的问题。我们可以在单张图像上多次训练算法模型,每次用稍微不同的方法预处理图像的一小部分。

    2、定义了数据输入后,接下来定义模型本身

     1from keras.models import Sequential
     2from keras.layers import Conv2D, MaxPooling2D
     3from keras.layers import Activation, Dropout, Flatten, Dense
     4from keras.losses import binary_crossentropy
     5from keras.callbacks import EarlyStopping
     6from keras.optimizers import RMSprop
     7
     8
     9model = Sequential()
    10model.add(Conv2D(32, kernel_size=(3, 3), input_shape=(128, 128, 3), activation='relu'))
    11model.add(MaxPooling2D(pool_size=(2, 2)))
    12
    13model.add(Conv2D(32, (3, 3), activation='relu'))
    14model.add(MaxPooling2D(pool_size=(2, 2)))
    15
    16model.add(Conv2D(64, (3, 3), activation='relu'))
    17model.add(MaxPooling2D(pool_size=(2, 2)))
    18
    19model.add(Flatten()) # this converts our 3D feature maps to 1D feature vectors
    20model.add(Dense(64, activation='relu'))
    21model.add(Dropout(0.5))
    22model.add(Dense(1))
    23model.add(Activation('sigmoid'))
    24
    25model.compile(loss=binary_crossentropy,
    26 optimizer=RMSprop(lr=0.0005), # half of the default lr
    27 metrics=['accuracy'])
    

     

    这是一个简单的卷积神经网络模型。它只包含三个卷积层:输出层之前的后处理层,强正则化层和 Relu 激活函数层。这些层因素共同作用以保证模型不会过拟合。这一点很重要,因为我们的输入数据集很小。

    3、最后一步是训练模型

     1import pathlib
     2
     3sample_size = len(list(pathlib.Path('../data/images_cropped/').rglob('./*')))
     4batch_size = 16
     5
     6hist = model.fit_generator(
     7 train_generator,
     8 steps_per_epoch=sample_size // batch_size,
     9 epochs=50,
    10 validation_data=validation_generator,
    11 validation_steps=round(sample_size * 0.2) // batch_size,
    12 callbacks=[EarlyStopping(monitor='val_loss', min_delta=0, patience=4)]
    13)
    14
    15model.save("clf.h5")
    

     

    epoch 步长的选择是由图像样本大小和批处理量决定的。然后对这些数据进行 50 次训练。因为回调函数 EarlyStopping 训练可能会提前暂停。如果在前 4 个 epoch 中没有看到训练性能的改进,那么它会在 50 epoch 内返回一个相对性能最好的模型。之所以选择这么大的步长,是因为模型验证损失存在很大的可变性。

    这个简单的训练方案产生的模型的准确率约为75%。

     

     precision recall f1-score support
     0 0.90 0.59 0.71 1399
     1 0.64 0.92 0.75 1109
     micro avg 0.73 0.73 0.73 2508
     macro avg 0.77 0.75 0.73 2508
    weighted avg 0.78 0.73 0.73 2508
    

     

    有趣的是,我们的模型在分类汉堡包为第 0 类时信心不足,而在分类汉堡包为第 1 类时信心十足。90% 被归类为汉堡包的图片实际上是汉堡包,但是只分类得到 59% 的汉堡。

    另一方面,只有 64% 的三明治图片是真正的三明治,但是分类得到的是 92% 的三明治。这与 Francois Chollet 采用相似的模型,应用到一个相似大小的经典猫狗数据集中,所得到的结果为 80% 的准确率基本是一致的。这种差异很可能是谷歌 Open Images V4 数据集中的遮挡和噪声水平增加造成的。数据集还包括其他插图和照片,使分类更加困难。如果自己构建模型时,也可以先删除这些。

    使用迁移学习技术可以进一步提高算法性能。要了解更多信息,可以查阅 Francois Chollet 的博客文章:Building powerful image classification models using very little data,使用少量数据集构建图像分类模型

    https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html

    模型发布

    现在我们构建好了一个定制的数据集和训练模型,非常高兴可以与大家分享。基于此也进行了一些总结,机器学习项目应该是模块化的可复制的,体现在:

    • 将模型因素分为数据、代码和环境组件
    • 数据版本控制模型定义和训练数据
    • 代码版本控制训练模型的代码
    • 环境版本控制用于训练模型的环境。比如环境可能是一个Docker文件,也可能在本地使用pip或conda
    • 如果其他人要使用该模型,提供相应的{数据、代码、环境}元组即可

     

    遵循这些原则,就可以通过几行代码,训练出需要的模型副本:

     

    git clone https://github.com/quiltdata/open-images.git
    conda env create -f open-images/environment.yml
    source activate quilt-open-images-dev
    python -c "import t4; t4.Package.install('quilt/open_images', dest='open-images/', registry='s3://quilt-example')"
    

     

     

     

    结论

     

    在本文中,我们演示了一个端到端的图像分类的机器学习实现方法。从下载/转换数据集到训练模型的整个过程。最后以一种模块化的、可复制的便于其他人重构的方式发布出来。由于自定义数据集很难生成和发布,随着时间的积累,形成了这些广泛使用的示例数据集。并不是因为他们好用,而是因为它们很简单。例如,谷歌最近发布的机器学习速成课程大量使用了加州住房数据集。这些数据有将近 20 年的历史了!在此基础上应用新的数据,使用现实生活的一些有趣的图片,或许会变得比想象中更容易!

     

    如何从 900 万张图片中对 600 类照片进行分类? | 技术头条

     

     

     

    有关文中使用的数据、代码、环境等信息,可通过下面的链接获取更多:

    https://storage.googleapis.com/openimages/web/index.html

    https://github.com/quiltdata/open-images

    https://alpha.quiltdata.com/b/quilt-example/tree/quilt/open_images/

    https://blog.quiltdata.com/reproduce-a-machine-learning-model-build-in-four-lines-of-code-b4f0a5c5f8c8

    原文链接:

    https://medium.freecodecamp.org/how-to-classify-photos-in-600-classes-using-nine-million-open-images-65847da1a319

    展开全文
  • 本文将介绍并说明如何使用R编写的ImageSegmentation软件包根据包括至少三个波段的数码照片在内的光栅图像的像素值进行分割。此软件包基本上使用了star软件包的功能来读取图像,包统计信息可运行kmeans算法,包sf可...
  • 给定一张包含家具的照片,你可以让程序自动将家具与背景分开吗? 在这篇文章中,我将介绍如何使用当前最先进的深度学习来尝试解决这个问题。我不是机器学习的专家,所以我希望这个帖子对于其他希望使用这个强大新...

    更多深度文章,请关注云计算频道:https://yq.aliyun.com/cloud


    1.png

    给定一张包含家具的照片,你可以让程序自动将家具与背景分开吗?

    在这篇文章中,我将介绍如何使用当前最先进的深度学习来尝试解决这个问题。我不是机器学习的专家,所以我希望这个帖子对于其他希望使用这个强大新工具的非专家们有一定的帮助作用。

    这个问题称为分割。也就是说,从这张图开始:

    2.png

    到这张图:

    3.png

    我们可以将这个遮罩应用到源图像上,获得没有背景的椅子。我们将使用一些工具来简化这个工作:

    keras - 一个非常棒的用于创建神经网络的库。 Keras是像Tensorflow这样的较低级别库的前端,它能为用户处理构建神经网络过程中存在的大量繁琐的细节。。

    U-Net - 用于图像分割的神经网络架构。 U-Net最初被设计用于生物医学图像分割(例如,在CT扫描中识别肺结节),但它也可用于分割常规2D图像。在下文将看到,即使没有大数据集,U-Net的强大功能也能让你大吃一惊。

    Brine - 一个数据集管理器,可以利用该管理器轻松地共享和管理图像数据集。构建模型最令人讨厌的部分就是获取和选择用于训练模型的数据集。我创建了brine来轻松共享数据集,使之能应用在PyTorch/Keras模型上。我们将使用它来下载数据集并将其与Keras进行交互。

    一个Github代码库 - Carvana图像遮罩挑战赛是Kaggle的一项赛事,它提出了类似的问题:将汽车从背景中扣出来。人们经常在Kaggle比赛中分享他们的解决方案,而在这个代码库中,有人分享了一个使用Keras和U-Net的解决方案。我们的目标是利用这个解决方案来解决我们当前这个家具分割问题。

    一个数据集 - 这是一个朋友提供的数据集。请注意,它非常的小,只包含了97张椅子和相应的遮罩。一般来说我不会指望通过这么少的数据来做很多的工作(Carvana挑战赛中提供了数千个样本),但是让我们来看看最终到底可以做到何种程度吧。

    代码

    这里有一个jupyter笔记,其中包含了建立模型的所有代码。我将重点介绍其中最重要的部分,并解释它的原理。

    第一步是安装数据集。由于它托管在Brine上,所以可以用一个简单的命令来实现:brine install rohan/chairs-with-masks

    下一步是加载数据集。可以通过Brine的load_dataset函数来执行此操作:chairs = brine.load_dataset('rohan/chairs-with-masks')。该数据集包含了97个样本,每个样本是图像及其遮罩。遮罩是一个只有两种颜色的图像,蓝色代表背景,红色代表前景。

    数据集加载了,现在来加载U-Net网络。把“Kaggle-Carvana-Image-Masking-Challenge”代码库中的model目录复制下来。导入这个网络,执行model = unet.get_unet_256() 。感谢petrosgk的工作,只需调用这一个函数即可返回一个Keras内置的U-Net网络。 Keras提供了model.summary()方法来查看网络的结构,虽然从中可以看到大量的信息,但最重要的是第一个和最后一个,它告诉了我们网络期望的输入和输出的形状。

    我们可以看到输入的形状是(None, 256, 256, 3),输出的形状是(None, 256, 256, 1)。元组的第一个元素是批量的大小,所以我们现在可以忽略它。这告诉我们,网络期望的输入是一批256x256的三通道图像,并将输出一批256x256个单通道遮罩。我们的遮罩也需要匹配这个形状。

    下一步是准备样本,使之与网络一起使用。我们将为训练数据定义一个处理函数,在样本传给网络之前需应用于每个样本。

    def fix_mask(mask):
        mask[mask < 100] = 0.0
        mask[mask >= 100] = 255.0
    
    def train_process(sample):
        img, mask = sample
        img = img[:,:,:3]
        mask = mask[:, :, :3]
        mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
        fix_mask(mask)
        img = cv2.resize(img, SIZE)
        mask = cv2.resize(mask, SIZE)
        img = randomHueSaturationValue(img,
                                       hue_shift_limit=(-50, 50),
                                       sat_shift_limit=(0, 0),
                                       val_shift_limit=(-15, 15))
        img, mask = randomShiftScaleRotate(img, mask,
                                           shift_limit=(-0.062, 0.062),
                                           scale_limit=(-0.1, 0.1),
                                           rotate_limit=(-20, 20))
        img, mask = randomHorizontalFlip(img, mask)
        fix_mask(mask)
        img = img/255.
        mask = mask/255.
        mask = np.expand_dims(mask, axis=2)
        return (img, mask)

    这里做了很多事情,我会一步一步进行解释。样本作为一个元组被传递进去,所以首先要进行解包。接下来的两行使用numpy切片来确保图像只有3个通道,如果有第四个alpha通道,则忽略。然后,使用cv2(OpenCV的python绑定)将遮罩转换为灰度图,这样,我们现在就有了一个单通道遮罩,这是网络所期望的。这里没有为两种颜色使用两个随机的灰度数字,而是强制使用fix_mask函数将掩码设置为0和255以表示背景和前景。然后,我们将图像和掩码的大小调整为256x256,以匹配网络指定的大小。

    由于数据集较小,因此我们将使用数据扩充。数据扩充是指在训练期间在保留原始信息的基础上随机修改图像,人为地生成更多的数据。例如,旋转5度的椅子仍然是椅子,所以网络应该能够正确地识别出来。在代码中,我们使用petrosgk的Carvana示例中的3个函数来随机改变图像的色相、饱和度和值,并随机旋转和翻转图像。如果旋转或翻转了图像,则必须对遮罩执行相同的操作,以使遮罩与原始图像保持一致。

    最后,我们通过将所有像素值除以255来对数据进行归一化操作,这样,所有的值都在0和1之间了。如果在此时打印image.shape,结果是256x256x3,这正是网络所需要的。尽管mask.shape是256x256,但网络是256x256x1,所以我们使用np.expand_dims来让遮罩匹配这个形状。最后,返回新的图像和遮罩。

    在开始训练网络之前,还需要用一些样本进行验证。验证集不能用于训练,只能用于检查模型的性能。我们可以使用Brine的create_folds来创建:

    validation_fold, train_fold = chairs.create_folds((20,))

    我们将样本集中的20个图像作为验证集,剩下的77个图像作为训练集。

    我们还定义了用于样本验证的处理函数,这与用于训练的处理函数非常相似,除了在验证时不使用数据扩充之外。

    最后,Brine返回一个可用于训练和校验集的图片生成器:

    train_generator = train_fold.to_keras(
        'image',
        'mask',
        batch_size=BATCH_SIZE,
        shuffle=True, 
        processing_function=train_process)
    
    validation_generator = validation_fold.to_keras(
        'image',
        'mask',
        batch_size=BATCH_SIZE,
        shuffle=False,
        processing_function=validation_process)

    这些生成器将返回样品的批处理,以及之前定义的处理函数。它们可以被直接传给Keras的fit_generator方法来训练模型。

    现在,准备开始训练模型了:

    callbacks = [EarlyStopping(monitor='val_loss',
                               patience=8,
                               verbose=1,
                               min_delta=1e-4),
                 ReduceLROnPlateau(monitor='val_loss',
                                   factor=0.1,
                                   patience=4,
                                   verbose=1,
                                   epsilon=1e-4),
                 ModelCheckpoint(monitor='val_loss',
                                 filepath='weights/best_weights.hdf5',
                                 save_best_only=True,
                                 save_weights_only=True)]

    这些回调会改变Keras的训练过程。 EarlyStopping将在验证损失的改进停止后停止训练,ReduceLROnPlateau将降低学习率,ModelCheckpoint将对在验证集上表现最佳的模型版本进行保存。

    最后,可以开始训练了:

    epochs=100
    model.fit_generator(generator=train_generator,
                        steps_per_epoch=train_generator.steps_per_epoch(),
                        epochs=epochs,
                        callbacks=callbacks,
                        validation_data=validation_generator,
                        validation_steps=validation_generator.steps_per_epoch())

    Keras开始训练模型了,它将在数据集上运行多次(由于数据增加和混洗,每次运行的结果会略有不同),并输出训练和验证集的损失和DICE分数。在某些时候,运行会停止,可能是因为EarlyStopping回调,或是因为达到了100次迭代。

    好了,就这些!我们训练了一个U-Net网络,并尝试在图像中把椅子分割出来。让我们来看看它的实际表现如何吧。

    生成预测

    要产生一些预测,首先使用model.load_weights('weights/best_weights.hdf5')来加载最佳模型的权重,然后在验证集中的某些图像上使用模型的predict方法:

    def predict_one():
        image_batch, mask_batch = next(validation_generator)
        predicted_mask_batch = model.predict(image_batch)
        image = image_batch[0]
        predicted_mask = predicted_mask_batch[0].reshape(SIZE)
        plt.imshow(image)
        plt.imshow(predicted_mask, alpha=0.6)

    以下是一些样本的结果:

    4.png
    在原始图像上覆盖了网络预测出来的遮罩。颜色越黄,则说明网络对该像素的预测具有更高的置信度

    虽然这对于生产系统来说还不够好,但网络已经学到了有关前景与背景、椅子与非椅子的一些内容。我个人觉得这个网络在没有进行预先训练,并且只有77张图片的情况下表现得已经非常不错了。如果有更大的数据集,网络的准确性可能会大大提高,或许就能用于生产系统了。

    文章原标题《A Non-Expert’s Guide to Image Segmentation Using Deep Neural Nets》,作者:Rohan Relan,译者:夏天,审校:主题曲。

    文章为简译,更为详细的内容请查看原文

    本文由北邮@爱可可-爱生活老师推荐,阿里云云栖社区组织翻译。

    展开全文
  • 本文介绍如何使用当前最先进的深度学习方法来区分图像中的前景与背景、家具与非家具,并从一张照片中提取出椅子。 给定一张包含家具的照片,你可以让程序自动将家具与背景分开吗? 在这篇文章中,我将介绍如何...
  • 目前在做一个app应用,涉及的等级申请的问题,需要客户端上传身份证正反两面的两面,考虑到一张照片有4,5,M这么大,所有决定图片切割通过二进制流上传,那么服务器端应该如何来处理(服务器用的是springMVC),我...
  • 上期给大家介绍了如何使用如何用华为HMS MLKit SDK 三十分钟在安卓上开发一个微笑抓拍神器详情请戳,本次给大家分享一篇新的实战经验。 不知道大家是否有这样的经历,忽然学校或者公司需要提供让提供个人的一寸或者...
  • 照片OCR:photo optical character recognition照片光学字符识别:注重的问题是如何让计算机读出图片中的文字信息: 1.文字检测 2.字符分割 3.字符分类 这个过程称作机器学习流水线。 课时148 滑动窗口分类器 ...
  • Funnycoin-去中心化图像档案 分散的有趣图片分类帐,任何人都可以提交他们的图片。 Funnycoin有两类矿工... 创建投票系统,创建网站以查看存档的图像,创建选项以从存档中删除照片,从而允许删除从裂缝中滑出的照片
  • 您将在下面找到一些有关如何执行常见任务的信息。 您可以在找到本指南的最新版本。 目录 自动格式化代码 更改页面<title> 安装依赖项 导入组件 代码分割 添加样式表 后处理CSS 添加CSS预处理器(Sass,Less...
  • 如何制作微课.doc

    2019-06-20 11:04:51
    4、将知识点按照一定逻辑分割成很多个小知识点; 5、将各知识点做成汇总表格; 如: 编号 微课名称 微课出处 01 等腰三角形的一般标记法 《数学》,人民教育出版社,2010年版,8年级,上册,第140页(没有出处者...
  • 您将在下面找到一些有关如何执行常见任务的信息。 您可以在找到本指南的最新版本。 目录 自动格式化代码 更改页面<title> 安装依赖项 导入组件 代码分割 添加样式表 后处理CSS 添加CSS预处理器(Sass,Less...
  • 目录 课程概况 27 目标对象和前提要求................................................. 27 学生职责 .............................................................. Ubuntu课程计划 .........................
  • 引子   不知道大家是否有这样的经历,忽然学校或者公司需要提供让提供个人的一寸...  多年以后华为的HMS MLKit机器学习有了图像分割的功能,使用这个SDK开发一个证件照DIY的小程序,可以完美解决小编当年遇到的
  • 从基于云的备份解决方案到高可用性内容传送网络(CDN),对象存储已成为现代技术领域不可分割的一部分。而且,由于其占地面积小,界面简单,与多个云存储服务兼容,Minio对象存储服务器具有很大的冲击力。 Minio是...
  • 在您的相机、计算机或其他储存设备上意外遗失了您的旅行照片?不小心删除了您一整个礼拜工作的论文?因为格式化、删除、病毒攻击、分割区遗失…等原因,大多数计算机使用者可能体验过遗失重要资料的感受。在这个时候...
  • 您将在下面找到一些有关如何执行常见任务的信息。 您可以在找到本指南的最新版本。 目录 自动格式化代码 更改页面<title> 安装依赖项 导入组件 代码分割 添加样式表 后处理CSS 添加CSS预处理器(Sass,Less...
  • 如何照片或者视频中的人物头发换发色? 换发色算法流程如下图所示: 1,AI头发分割模块 基于深度学习的目标分割算法已经比较成熟,比较常用的有FCN,SegNet,UNet,PspNet,DenseNet等等。 这里我们使用Unet...
  • 我使用智能手机拍摄了每个微控制器的约25张照片,其中包含25个包含多个微控制器的图片。确保将其转换为适合训练的分辨率(我使用了800x600)。 3.标签数据 收集了足够的图像之后,就可以为它们加上标签了,这样您的...
  • R-CNN同时检测和分割乳房X线照片的算法。 代码:[GitHub存储库–] 遮罩R-CNN代码:[GitHub存储库–] 数据: 训练有素的模型示例:[GitHub页面-] 简而言之 所提出的方法使用多尺度形态筛分法(MMS)将常规的灰度X线...
  • 如何照片或者视频中的人物头发换发色? 换发色算法流程如下图所示: 1,AI头发分割模块 基于深度学习的目标分割算法已经比较成熟,比较常用的有FCN,SegNet,UNet,PspNet,DenseNet等等。 这里我们使用Unet...

空空如也

空空如也

1 2 3 4
收藏数 75
精华内容 30
关键字:

如何分割照片