使用Python进行图像处理—图像分割的无监督学习

共 3573字，需浏览 8分钟

· 2021-02-11

来源：深度学习与计算机视觉

到目前为止，我们使用的大多数技术都要求我们通过其特征手动分割图像。

但是我们实际上可以使用无监督的聚类算法为我们完成此任务。在本文中，我们将讨论如何做到这一点。

让我们开始吧！

导入所需的Python库

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import colors
from skimage.color import rgb2gray, rgb2hsv, hsv2rgb
from skimage.io import imread, imshow
from sklearn.cluster import KMeans

太好了，让我们现在导入将要使用的图像。

dog = imread('beach_doggo.PNG')
plt.figure(num=None, figsize=(8, 6), dpi=80)
imshow(dog);

我们知道，图像本质上是一个三维矩阵，每个像素包含一个红、绿、蓝通道的值。但实际上，我们可以使用备受喜爱的Pandas库将每个像素存储为单独的数据点。下面的代码就是这样做的。

def image_to_pandas(image):
    df = pd.DataFrame([image[:,:,0].flatten(),
                       image[:,:,1].flatten(),
                       image[:,:,2].flatten()]).T
    df.columns = [‘Red_Channel’,’Green_Channel’,’Blue_Channel’]
    return df
df_doggo = image_to_pandas(dog)
df_doggo.head(5)

这使得图像的操作更加简单，因为更容易将其视为可以输入到机器学习算法中的数据。

在我们的实例中，我们将使用K-means算法对图像进行聚类。

plt.figure(num=None, figsize=(8, 6), dpi=80)
kmeans = KMeans(n_clusters=  4, random_state = 42).fit(df_doggo)
result = kmeans.labels_.reshape(dog.shape[0],dog.shape[1])
imshow(result, cmap='viridis')
plt.show()

如我们所见，图像被分为四个不同的区域。让我们分别可视化每个区域。

fig, axes = plt.subplots(2,2, figsize=(12, 12))
for n, ax in enumerate(axes.flatten()):
    ax.imshow(result==[n], cmap='gray');
    ax.set_axis_off()
    
fig.tight_layout()

该算法根据R，G和B像素值分割图像。当然，一个缺点是这是一种完全不受监督的学习算法。它并不特别关心任何特定群集背后的含义。作为证据，我们可以看到第二和第四簇都具有狗的突出部分（阴影部分和未阴影部分）。也许运行4个集群过多，让我们重试集群，但将集群数设置为3。

太好了，我们可以看到狗是一个整体。现在让我们看看如果将每个聚类作为单独的蒙版应用于图像会发生什么。

fig, axes = plt.subplots(1,3, figsize=(15, 12))
for n, ax in enumerate(axes.flatten()):
    dog = imread('beach_doggo.png')
    dog[:, :, 0] = dog[:, :, 0]*(result==[n])
    dog[:, :, 1] = dog[:, :, 1]*(result==[n])
    dog[:, :, 2] = dog[:, :, 2]*(result==[n])
    ax.imshow(dog);
    ax.set_axis_off()
fig.tight_layout()

我们可以看到，该算法生成了三个不同的簇，即沙子，生物和天空。当然，算法本身对这些簇并不十分在意，只是它们共享相似的RGB值。要由人类来解释这些簇。

在我们离开之前，我认为如果简单地将其绘制在3D图形上，则对实际显示我们的图像会有所帮助。

def pixel_plotter(df):
    x_3d = df['Red_Channel']
    y_3d = df['Green_Channel']
    z_3d = df['Blue_Channel']
    
    color_list = list(zip(df['Red_Channel'].to_list(),
                          df['Blue_Channel'].to_list(),
                          df['Green_Channel'].to_list()))
    norm = colors.Normalize(vmin=0,vmax=1.)
    norm.autoscale(color_list)
    p_color = norm(color_list).tolist()
    
    fig = plt.figure(figsize=(12,10))
    ax_3d = plt.axes(projection='3d')
    ax_3d.scatter3D(xs = x_3d, ys =  y_3d, zs = z_3d, 
                    c = p_color, alpha = 0.55);
    
    ax_3d.set_xlim3d(0, x_3d.max())
    ax_3d.set_ylim3d(0, y_3d.max())
    ax_3d.set_zlim3d(0, z_3d.max())
    ax_3d.invert_zaxis()
    
    
    ax_3d.view_init(-165, 60)
pixel_plotter(df_doggo)

我们应该记住，这实际上是算法定义“紧密度”的方式。如果我们将K-Means算法应用于该图，则其分割图像的方式将变得非常清晰。

df_doggo['cluster'] = result.flatten()
def pixel_plotter_clusters(df):
    x_3d = df['Red_Channel']
    y_3d = df['Green_Channel']
    z_3d = df['Blue_Channel']
    
    fig = plt.figure(figsize=(12,10))
    ax_3d = plt.axes(projection='3d')
    ax_3d.scatter3D(xs = x_3d, ys =  y_3d, zs = z_3d, 
                    c = df['cluster'], alpha = 0.55);
    
    ax_3d.set_xlim3d(0, x_3d.max())
    ax_3d.set_ylim3d(0, y_3d.max())
    ax_3d.set_zlim3d(0, z_3d.max())
    ax_3d.invert_zaxis()
    
    
    ax_3d.view_init(-165, 60)
pixel_plotter_clusters(df_doggo)