机器学习中的图像处理

2025年3月17日 | 阅读18分钟

图像处理涉及对图像进行操作和分析，以增强其质量、提取特征或识别模式。传统的图像处理技术依赖于预定义的规则和算法来执行特定任务，例如边缘检测、图像分割或对象识别。然而，当处理复杂多样的视觉数据时，这些技术经常会遇到局限性。

另一方面，机器学习为图像处理提供了一种更灵活、更自适应的方法。通过在大量标记图像数据集上训练算法，机器学习模型可以自动学习识别模式并提取相关特征。这种从数据中学习并适应新情况的能力，使机器学习成为图像分析和处理的强大工具。

机器学习在图像处理中的关键应用之一是目标检测和识别。通过在包含感兴趣对象（如汽车、人物或建筑物）的标记图像上训练模型，机器学习算法可以学会识别和定位新图像中的这些对象。这种能力在监控等领域具有重要意义，因为自动对象检测可以协助识别潜在威胁或异常情况。

机器学习在图像处理中的另一个应用是图像分类。通过在不同类别（如动物、风景或医学图像）的标记图像上训练模型，机器学习算法可以学会将新图像分类到相应的类别中。这种能力在医疗保健等领域尤其有用，因为准确的自动图像分类可以帮助疾病诊断、医学影像分析和治疗计划。

现在，为了便于理解，我们将尝试实现它。这里我们将进行细胞核检测的图像处理。

代码

导入库

#Importing the other necessary libraries
import numpy as np
import pandas as pd
import os
import pathlib
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline
import warnings
warnings.filterwarnings('ignore')
import cv2

读取图像

# Glob the training data and load a single image path
training_paths = pathlib.Path('../input/stage1_train').glob('*/images/*.png')
training_sorted = sorted([x for x in training_paths])
im_path = training_sorted[45]

#To read the image 
bgrimg = cv2.imread(str(im_path))
plt.imshow(bgrimg)
plt.xticks([]) #To get rid of the x-ticks and y-ticks on the image axis
plt.yticks([])
print('Original Image Shape',bgrimg.shape)

输出

#To see the structure of the image, let's display one row of the image matrix
print('The first row of the image matrix contains',len(bgrimg[1]),'pixels')
print(bgrimg[1])

输出

图像以 BGR（蓝-绿-红）色彩空间进行解释，这意味着图像中的每个像素都由三个值表示：蓝色强度、绿色强度和红色强度。当在 OpenCV 中读取图像时，此色彩空间是默认选择。

在 BGR/RGB 色彩空间中，红色、绿色和蓝色的特定组合用于创建各种颜色。这三种原色混合在一起可以生成由它们各自值形成的三角形内的任何色度。简单来说，您可以将 RGB 颜色视为通过混合三种彩色光：红色、绿色和蓝色产生的各种颜色。通过调整这些原色的强度，我们可以创建和显示图像中的大量不同颜色。

基本步骤

在这里，我们将实现经典的图像技术，希望能起到有用的入门作用。

这些经典的图像技术包括

处理颜色
去除背景
为每个对象导出蒙版
对象识别
游程编码

处理颜色

#To transform the colourspace from BGR to grayscale so as to make things simpler
grayimg = cv2.cvtColor(bgrimg,cv2.COLOR_BGR2GRAY)

#To plot the image
plt.imshow(grayimg,cmap='gray') #cmap has been used as matplotlib uses some default colormap to plot grayscale images
plt.xticks([]) #To get rid of the x-ticks and y-ticks on the image axis
plt.yticks([])
print('New Image Shape',grayimg.shape)

输出

当我们从 BGR 色彩空间转换为灰度时，我们实际上减少了一个维度。之所以发生这种情况，是因为灰度表示一系列从黑色到白色的单色色调。换句话说，灰度图像仅包含各种灰色调，不包含任何颜色信息（它主要由黑色和白色组成）。

从 BGR 到灰度的转换消除了所有颜色数据，仅保留每个像素的亮度。在数字图像中，颜色使用红色、绿色和蓝色 (RGB) 值的组合显示。因此，每个像素都有三个与这些颜色通道相对应的独立亮度值。但是，在去除颜色并创建灰度图像时，需要将这三个值合并为一个值。

亮度也可以描述为明度或强度，它在一个从黑色（零强度）到白色（完全强度）的尺度上进行测量。通过将图像简化为灰度，我们简化了其表示，仅关注图像亮度的变化，而忽略存在的特定颜色。

#To understand this further, let's display one entire row of the image matrix
print('The first row of the image matrix contains',len(grayimg[1]),'pixels')
print(grayimg[1])

输出

当显示灰度图像矩阵的整个一行时，您实际上是在显示该行中每个像素的亮度或强度值。每个像素的亮度值表示其亮度级别，范围从黑色（最低强度）到白色（最高强度）。

通过可视化灰度图像矩阵的一行，您可以观察该行中像素的各种强度。这提供了对图像水平方向亮度模式和变化的洞察。它允许您专注于亮度变化，而不会被颜色信息干扰，突出灰度图像的色调值，并强调该特定行中存在的对比度和阴影。

因此，这显示了图像矩阵的整行以及每个像素对应的亮度或强度。

去除背景

#Okay, let's look at the distribution of the intensity values of all the pixels
plt.figure(figsize=(10,5))

plt.subplot(1,2,1)
sns.distplot(grayimg.flatten(),kde=False)#This is to flatten the matrix and put the intensity values of all the pixels in one single row vector
plt.title('Distribution of intensity values')

#To zoom in on the distribution and see if there is more than one prominent peak 
plt.subplot(1,2,2)
sns.distplot(grayimg.flatten(),kde=False) 
plt.ylim(0,30000) 
plt.title('Distribution of intensity values (Zoomed In)')

输出

在强度分布中，我们可以观察到两个明显的峰值。强度值接近 0 的像素数量很多是符合预期的，因为与占主导地位的黑色背景相比，细胞核占据的图像部分较小。我们的任务是将细胞核与背景分开。根据描述性统计数据，我们预计最佳分离值为大约 20。但是，我们不应仅依赖于此类统计数据，而应采用更正式的方法，如 Otsu 方法。

Otsu 方法，以 Nobuyuki Otsu 命名，是一种用于自动基于聚类的图像阈值处理技术。它旨在通过识别最佳阈值将灰度图像转换为二值图像。该算法假定图像由两类像素组成，即前景像素（细胞核）和背景像素。它计算最小化两个类别的组合散布或类内方差的阈值，从而最大化它们之间的方差。简单来说，Otsu 方法根据像素强度的直方图分布确定将细胞核与背景分离的最佳阈值。

from skimage.filters import threshold_otsu
thresh_val = threshold_otsu(grayimg)
print('The optimal seperation value is',thresh_val)

输出

我们将使用 np.where 函数根据像素的强度值对其进行编码，我们可以创建一个蒙版，将所有强度值大于阈值的所有像素设置为 1，所有其他像素设置为 0。生成的蒙版将指示细胞核（编码为 1）和背景（编码为 0）之间的分离。

导出每个对象的蒙版

mask=np.where(grayimg>thresh_val,1,0)

#To plot the original image and mask side by side
plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.imshow(grayimg,cmap='gray')
plt.title('Original Image')

plt.subplot(1,2,2)
maskimg = mask.copy()
plt.imshow(maskimg, cmap='viridis')
plt.title('Mask')

输出

当前生成的蒙版存在一些局限性。它未能准确检测到所有细胞核，特别是右上角的两个。此外，围绕 (500, 400) 标记的三个细胞核已合并为一个集群。问题源于较暗的细胞核的强度值低于阈值。

为了改进对单个细胞核的检测，我们需要使用更高级的技术。这些技术涉及额外的图像处理步骤，如形态学操作或自适应阈值处理。通过应用这些方法，我们可以增强分离并准确识别每个细胞核。

#Let's see if K-Means does a good job on this data 
from sklearn.cluster import KMeans
kmeans=KMeans(n_clusters=2) #2 as we're still trying to separate the lighter coloured nuclei from the darker coloured background 
kmeans.fit(grayimg.reshape(grayimg.shape[0]*grayimg.shape[1],1))

plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.imshow(kmeans.labels_.reshape(520,696),cmap='magma')
plt.title('K-Means')

plt.subplot(1,2,2)
plt.imshow(maskimg, cmap='viridis')
plt.title('Mask with Otsu Seperation')

输出

为了确定 Otsu 方法和 K-Means 聚类在像素级别获得的标签之间是否存在任何差异，我们可以比较标签并计算匹配标签的百分比。如果结果百分比为 1，则表示完全没有差异。

#To check if there's any difference
sum((kmeans.labels_.reshape(520,696)==mask).flatten())/(mask.shape[0]*mask.shape[1])

输出

完全没有差异。

对象识别

要获得细胞核总数的计数，我们可以使用 ndimage.label 函数，该函数根据像素的相互连接性来标记数组中的特征（像素）。因此，例如，如果 [1 1 1 0 0 1 1] 是我们的行向量，那么使用 ndimage.label 将得到 [1 1 1 0 0 2 2]，表示行向量中有 2 个不同的对象。该函数返回标记的数组以及它找到的不同对象的数量。

from scipy import ndimage
#To see this at a matrix level
matrix = np.array([[0,0,1,1,1,1],
                  [0,0,0,0,1,1],
                  [1,1,0,1,1,1],
                  [1,1,0,1,1,1]])
matrix

输出

#Applying the ndimage.label function
ndimage.label(matrix)

输出

labels,nlabels=ndimage.label(mask)
print('There are',nlabels,'distinct nuclei in the mask.')

输出

图像中可能存在的细胞核比我们目前识别的要多。一些细胞核已合并在一起，导致它们被视为我们蒙版中的单个对象。此外，我们的蒙版可能未能成功检测到所有细胞核，特别是位于右上角的细胞核。有趣的是，在右上角，有两个独立的光斑被标记为不同的对象，即使它们属于同一组或集群。

一些不相关的光斑或点被错误地标记为细胞核。为了解决这个问题，如果这些小光斑的大小低于某个阈值，我们可以将它们的标签（来自 K-Means 和 Otsu）设置为 0。出现此问题是因为某些细胞核的像素强度值低于 Otsu 的阈值，导致只有部分像素被标记为 1。通过考虑光斑的大小并将它们的大小设置为 0（如果太小），我们可以确保只有重要的细胞核被准确识别和标记。
当细胞核彼此靠近时，它们倾向于被分组为一个细胞核。为了解决这个问题，我们可以采用边缘检测算法，例如 Sobel 滤波器或 Canny 边缘检测器。这些算法可以帮助识别图像中对象之间的边界或边缘。

通过应用 Sobel 滤波器或 Canny 边缘检测器，我们可以检测到聚集的细胞核之间的边缘。这使我们能够区分单个细胞核并根据检测到的边缘进行分离。生成的分割将能够更准确地识别和描绘每个细胞核，即使它们彼此靠近。

为了获得每个细胞核的单独蒙版，我们可以利用“stage1_train_labels.csv.zip”文件，该文件包含图像 ID 以及每个细胞核蒙版对应的游程编码 (RLE) 向量。RLE 向量表示蒙版内像素的位置。

#Since we need to create a separate mask for every nucleus, let's store  the masks in an iterable like a list 
label_array=[]
#We need to iterate from 1 as ndimage.label encodes every object starting from number 1
for i in range(1,nlabels+1):
    label_mask = np.where(labels==i,1,0)
    label_array.append(label_mask)
#To see one such mask
label_array[68]

输出

1 表示整个图像中的 1 个此类对象（细胞核）。

游程编码

RLE 或游程编码将矩阵转换为向量，并返回我们观察到对象（由 1 标识）的第一个像素的位置/起始点，并给出从该像素开始看到 1 系列的像素数量。在 ndimage.label 函数的 [1 1 1 0 0 1 1] 示例中，运行 RLE 将得到 1 3 6 2，这意味着从第 0 个像素（包含）开始的 3 个像素和从第 5 个像素开始的 2 个像素我们看到了一系列 1。

#Function for rle encoding
def rle(x):
    '''
    x: numpy array of shape (height, width), 1 - mask, 0 - background
    Returns run length as list
    '''
    dots = np.where(x.T.flatten()==1)[0] # .T sets Fortran order down-then-right
    run_lengths = []
    prev = -2
    for b in dots:
        if (b>prev+1): run_lengths.extend((b+1, 0))
        run_lengths[-1] += 1
        prev = b
    return " ".join([str(i) for i in run_lengths])

#Running RLE on the last label_mask in label_array gives us 
rle(label_mask)

输出

合并所有内容

#To take a look at the different parts
im_path.parts

输出

#Now defining a function that is applicable to all images
def basic(im_path):
    #Reading the image
    im_id=im_path.parts[-3] #To extract the image ID
    bgr = cv2.imread(str(im_path)) #Reading it in OpenCV
    gray = cv2.cvtColor(bgr,cv2.COLOR_BGR2GRAY) #Converting everything to grayscale from BGR

    #To remove the background
    thresh_val = threshold_otsu(gray) #Using Otsu's method to separate the foreground objects from the background
    mask = np.where(gray > thresh_val, 1, 0) #Coding objects with intensity values higher than background as 1
    
    #Extracting connected objects
    test_rle=pd.DataFrame()
    labels, nlabels = ndimage.label(mask) #labels give us the label of the different objects in every image starting from 1 ,and nlabels gives us the total number of objects in every image
    for i in range(1,nlabels+1): #Iterating through every object/label
        label_mask = np.where(labels==i,1,0) #Individual masks for every nucleus
        RLE = rle(label_mask) #RLE for every mask
        solution = pd.Series({'ImageId': im_id, 'EncodedPixels': RLE})
        test_rle = test_rle.append(solution, ignore_index=True)
    
    #Return the dataframe
    return(test_rle)

#Defining a function that takes a list of image paths (pathlib.Path objects), analyzes each and returns a submission ready DataFrame
def list_of_images(im_path_list):
    all_df = pd.DataFrame()
    for im_path in im_path_list: #We'll use this for the test images
        im_df = basic(im_path) #Creating one dataframe for every image 
        all_df = all_df.append(im_df, ignore_index=True) #Appending all these dataframes
    
    #Returing the submission ready dataframe
    return (all_df)

边缘检测

边缘检测是图像处理中的一个基本概念，涉及识别图像中不同对象或区域之间的边界或边缘。它在计算机视觉、机器人和医学成像等各种领域发挥着至关重要的作用。传统的边缘检测算法，如 Sobel 算子和 Canny 边缘检测器，使用数学运算来定位快速强度变化的区域。

在这里，我们将首先使用 Sobel 滤波器。

#cv2.Sobel arguments - the image, output depth, order of derivative of x, order of derivative of y, kernel/filter matrix size
sobelx = cv2.Sobel(grayimg,int(cv2.CV_64F),1,0,ksize=3) #ksize=3 means we'll be using the 3x3 Sobel filter
sobely = cv2.Sobel(grayimg,int(cv2.CV_64F),0,1,ksize=3)

#To plot the vertical and horizontal edge detectors side by side
plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.imshow(sobelx,cmap='gray')
plt.title('Sobel X (vertical edges)')
plt.xticks([])
plt.yticks([])

plt.subplot(1,2,2)
plt.imshow(sobely,cmap='gray')
plt.xticks([])
plt.yticks([])
plt.title('Sobel Y (horizontal edges)')

输出

#Plotting the original image
plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.imshow(grayimg,cmap='gray')
plt.title('Original image')

#Now to combine the 2 sobel filters
sobel = np.sqrt(np.square(sobelx) + np.square(sobely))
plt.subplot(1,2,2)
plt.imshow(sobel,cmap='gray')
plt.title('Sobel Filter')

输出

Sobel 滤波器在识别图像中的独立对象方面比 Otsu/K-Means 表现更好。它成功检测到了右上角的两个细胞核以及 (530,410) 区域附近的两个小细胞核。但是，仍有改进的空间，因为它合并了该区域中三个重叠细胞核中的两个，而不是将它们识别为独立的物体。

#To highlight the problem areas
plt.figure(figsize=(12,6))
plt.subplot(1,3,1)
plt.imshow(grayimg[350:450,485:530],cmap='gray')
plt.title('Original image (zoomed in)')
plt.xticks([])
plt.yticks([])

plt.subplot(1,3,2)
plt.imshow(sobel[350:450,485:530],cmap='gray')
plt.title('Sobel Filter (zoomed in)')
plt.xticks([])
plt.yticks([])

plt.subplot(1,3,3)
plt.imshow(maskimg[350:450,485:530], cmap='gray')
plt.title('Otsu/K-Means (zoomed in)')
plt.xticks([])
plt.yticks([])

输出

我们现在将使用 Canny 边缘检测器，它是一种更智能的 Sobel 滤波器。

plt.figure(figsize=(12,6))

plt.subplot(1,2,1)
plt.imshow(grayimg,cmap='gray')
plt.title('Original image')
plt.xticks([])
plt.yticks([])

#Let's see how the Canny Edge Detector does on the image
plt.subplot(1,2,2)
canny = cv2.Canny(grayimg,0,21)
plt.imshow(canny,cmap='gray')
plt.title('Canny Edge Detection')
plt.xticks([])
plt.yticks([])

输出

Canny 边缘检测器检测到了细胞核内的梯度，这似乎有点过多。但是，如果我们只关注提取外部轮廓并使用它们来创建蒙版，我们可以更准确地捕获感兴趣的区域。值得注意的是，这里仍然存在与 Sobel 滤波器遇到的类似问题。然而，Canny 边缘检测器生成了一个由二值（0 和 255）组成的修改后的图像矩阵，简化了检测到的边缘的表示。

#Using contouring to create the masks
canny_cont=cv2.findContours(canny,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1] #Using an approximation function to obtain the contour points and retrieving only the external contours

#To show the contour points
plt.figure(figsize=(14,8))
plt.imshow(canny,cmap='gray')
plt.title('Canny Edge Detection with contours')
plt.xticks([])
plt.yticks([])

for i in (range(len(canny_cont))):
    plt.scatter(canny_cont[i].flatten().reshape(len(canny_cont[i]),2)[:,0],
         canny_cont[i].flatten().reshape(len(canny_cont[i]),2)[:,1])

输出

plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.imshow(grayimg, cmap='gray')
plt.title('Original Image')

#Now to create masks with contours
background=np.zeros(grayimg.shape)
canny_mask=cv2.drawContours(background,canny_cont,-1,255,-1)

plt.subplot(1,2,2)
plt.imshow(canny_mask,cmap='gray')
plt.title('Creating masks with contours')
plt.xticks([])
plt.yticks([])

输出

Canny 边缘检测器成功检测到大多数细胞核，但未能获得每个细胞核的完整蒙版。调整 cv2.Canny() 函数中的 minval 和 maxval 参数可能会改善结果，并考虑到被处理图像的特定特征。canny_mask 矩阵输出与 ndimage.labels 函数兼容，该函数用于识别连接的组件。然而，生成每个细胞核的完整蒙版至关重要，以确保我们检测到的对象不超过图像中实际存在的对象数量。

canny_mask_copy=canny_mask.copy()
canny_mask_clabels=ndimage.label(canny_mask_copy)[0]
for label_ind, label_mat in enumerate(ndimage.find_objects(canny_mask_clabels)):
    cell = canny_mask_clabels[label_mat]
    #Toheck if the label size is too small
    if np.product(cell.shape) < 100:
        canny_mask_clabels[np.where(canny_mask_clabels==label_ind+1)]=1
canny_mask_clabels=np.where(canny_mask_clabels>1,0,canny_mask_clabels)

#To show the original mask
plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.imshow(canny_mask,cmap='gray')
plt.title('Masks created with edge plus contour detection')
plt.xticks([])
plt.yticks([])

#To plot the problem areas
plt.subplot(1,2,2)
plt.imshow(canny_mask_clabels,cmap='gray')
plt.title('Incomplete Masks')
plt.xticks([])
plt.yticks([])

输出

#For convolving 2D arrays
from scipy import signal
plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
sns.distplot(np.where(canny_mask==255,1,0).flatten())
plt.title('Canny Mask')

plt.subplot(1,2,2)
#To smooth the canny_mask by convolving with a matrix that has all values = 1/9
canny_mask_smooth=signal.convolve2d(np.where(canny_mask==255,1,0),np.full((3,3),1/9),'same')
sns.distplot(canny_mask_smooth.flatten())
canny_mask_smooth_thresh=threshold_otsu(canny_mask_smooth)
plt.axvline(x=canny_mask_smooth_thresh)
plt.title('Smoothened Canny Mask with Otsu threshold value')

输出

强度值等于 1 的像素数量已减少。这种减少归因于平滑过程。我们使用局部滤波器（具体来说是一个所有值都设置为 1/9 的 3x3 矩阵）对 canny 蒙版进行卷积。此操作用邻近像素的平均强度值替换像素的强度值。如果一个像素被强度值为 1 的邻近像素包围，则其强度值保持为 1（因为 1/9 乘以 9 等于 1）。但是，位于对象边缘和有问题的区域的像素的强度值会降低。

plt.figure(figsize=(12,6))
plt.imshow(canny_mask_smooth,cmap='gray')
plt.title('Smoothened canny mask')
plt.xticks([])
plt.yticks([])

输出

#Setting all values above otsu's threshold as 0 in the matrix and in this image matrix setting all values above 0 as 1 
plt.figure(figsize=(12,6))
canny_conv1=np.where(np.where(canny_mask_smooth>canny_mask_smooth_thresh,0,canny_mask_smooth)>0,1,0)
plt.imshow(canny_conv1,cmap='gray')
plt.xticks([])
plt.yticks([])
plt.title('After 1 convolution')

输出

plt.figure(figsize=(12,6))
canny_mask_smooth2=signal.convolve2d(canny_conv1,np.full((3,3),1/9),'same')
canny_mask_smooth_thresh2=threshold_otsu(canny_mask_smooth2)
canny_conv2=np.where(canny_mask_smooth2>canny_mask_smooth_thresh2,1,0)
plt.imshow(canny_conv2,cmap='gray')
plt.xticks([])
plt.yticks([])
plt.title('After 2 convolutions')

输出

#Combing the 2 convolutions 
canny_cont=cv2.findContours(cv2.convertScaleAbs(canny_conv2),cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1]
background=np.zeros(grayimg.shape)
canny_mask=cv2.drawContours(background,canny_cont,-1,255,-1)

plt.figure(figsize=(12,6))
plt.imshow(canny_mask,cmap='gray')
plt.title('Contour detection after 2 convolutions')
plt.xticks([])
plt.yticks([])

输出

总的来说，当前结果令人满意。尽管仍然存在细胞核聚集在一起的情况，但重要的是我们已经成功识别了原始图像中的所有细胞核。然而，在继续进行并可能过度拟合到特定图像之前，探索 cv2.Canny() 函数中 MinVal 和 MaxVal 参数的不同值，以确定它们在其他图像上的有效性至关重要。这使我们能够建立一种更稳健的方法，这种方法可以很好地推广到各种场景。

#Let's try the same parameters for the canny edge on other types of images - starting with another black background and white foreground image
for i in range(len(training_sorted)):
    if training_sorted[i].parts[-1]=='feffce59a1a3eb0a6a05992bb7423c39c7d52865846da36d89e2a72c379e5398.png':
        bwimg=cv2.imread(str(training_sorted[i]))
        bwimg=cv2.cvtColor(bwimg,cv2.COLOR_BGR2RGB)
        plt.figure(figsize=(20,8))
        plt.subplot(1,3,1)
        plt.imshow(bwimg)
        plt.title('Black background and white foreground')
        
        plt.subplot(1,3,2)
        bwimg=cv2.cvtColor(bwimg,cv2.COLOR_RGB2GRAY)
        bwimg_canny=cv2.Canny(bwimg,0,21)
        plt.imshow(bwimg_canny,cmap='gray')
        plt.title('Canny edge detection')
        
        plt.subplot(1,3,3)
        bwimg_cont=cv2.findContours(bwimg_canny,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1]
        #Now to create masks with contours
        bwimg_bg=np.zeros(bwimg.shape)
        bwimg_mask=cv2.drawContours(bwimg_bg,bwimg_cont,-1,255,-1)
        
        #Convolving once
        bwimg_mask_smooth=signal.convolve2d(np.where(bwimg_mask==255,1,0),np.full((3,3),1/9),'same')
        bwimg_mask_smooth_thresh=threshold_otsu(bwimg_mask_smooth)
        bwimg_conv1=np.where(np.where(bwimg_mask_smooth>bwimg_mask_smooth_thresh,0,bwimg_mask_smooth)>0,1,0)
        
        #Convolving again
        bwimg_mask_smooth2=signal.convolve2d(bwimg_conv1,np.full((3,3),1/9),'same')
        bwimg_mask_smooth_thresh2=threshold_otsu(bwimg_mask_smooth2)
        bwimg_conv2=np.where(bwimg_mask_smooth2>bwimg_mask_smooth_thresh2,1,0)
        
        #Now to create masks with contours after 2 convolutions
        bwimg_cont=cv2.findContours(cv2.convertScaleAbs(bwimg_conv2),cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1]
        bwimg_bg=np.zeros(bwimg.shape)
        bwimg_mask=cv2.drawContours(bwimg_bg,bwimg_cont,-1,255,-1)

        plt.imshow(bwimg_mask,cmap='gray')
        plt.title('Contour detection after 2 convolutions')

输出

#Purple background and purple foreground
for i in range(len(training_sorted)):
    if training_sorted[i].parts[-1]=='0e21d7b3eea8cdbbed60d51d72f4f8c1974c5d76a8a3893a7d5835c85284132e.png':
        ppimg=cv2.imread(str(training_sorted[i]))
        ppimg=cv2.cvtColor(ppimg,cv2.COLOR_BGR2RGB)
        plt.figure(figsize=(20,8))
        plt.subplot(1,3,1)
        plt.imshow(ppimg)
        plt.title('Purple background and purple foreground')
        
        plt.subplot(1,3,2)
        ppimg=cv2.cvtColor(ppimg,cv2.COLOR_RGB2GRAY)
        ppimg_canny=cv2.Canny(ppimg,20,100)
        plt.imshow(ppimg_canny,cmap='gray')
        plt.title('Canny edge detection')
        
        plt.subplot(1,3,3)
        ppimg_cont=cv2.findContours(ppimg_canny,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1]
        #Now to create masks with contours
        ppimg_bg=np.zeros(ppimg.shape)
        ppimg_mask=cv2.drawContours(ppimg_bg,ppimg_cont,-1,255,-1)
        
        #Convolving once
        ppimg_mask_smooth=signal.convolve2d(np.where(ppimg_mask==255,1,0),np.full((3,3),1/9),'same')
        ppimg_mask_smooth_thresh=threshold_otsu(ppimg_mask_smooth)
        ppimg_conv1=np.where(np.where(ppimg_mask_smooth>ppimg_mask_smooth_thresh,0,ppimg_mask_smooth)>0,1,0)
        
        #Convolving again
        ppimg_mask_smooth2=signal.convolve2d(ppimg_conv1,np.full((3,3),1/9),'same')
        ppimg_mask_smooth_thresh2=threshold_otsu(ppimg_mask_smooth2)
        ppimg_conv2=np.where(ppimg_mask_smooth2>ppimg_mask_smooth_thresh2,1,0)
        
        #Now to create masks with contours after 2 convolutions
        ppimg_cont=cv2.findContours(cv2.convertScaleAbs(ppimg_conv2),cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1]
        ppimg_bg=np.zeros(ppimg.shape)
        ppimg_mask=cv2.drawContours(ppimg_bg,ppimg_cont,-1,255,-1)

        plt.imshow(ppimg_mask,cmap='gray')
        plt.title('Contour detection after 2 convolutions')

输出

#White background and purple foreground
for i in range(len(training_sorted)):
    if training_sorted[i].parts[-1]=='0121d6759c5adb290c8e828fc882f37dfaf3663ec885c663859948c154a443ed.png':
        wpimg=cv2.imread(str(training_sorted[i]))
        wpimg=cv2.cvtColor(wpimg,cv2.COLOR_BGR2RGB)
        plt.figure(figsize=(20,8))
        plt.subplot(1,3,1)
        plt.imshow(wpimg)
        plt.title('White background and purple foreground')
        
        plt.subplot(1,3,2)
        wpimg=cv2.cvtColor(wpimg,cv2.COLOR_RGB2GRAY)
        wpimg_canny=cv2.Canny(wpimg,20,100)
        plt.imshow(wpimg_canny,cmap='gray')
        plt.title('Canny edge detection')
        
        plt.subplot(1,3,3)
        wpimg_cont=cv2.findContours(wpimg_canny,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1]
        #Now to create masks with contours
        wpimg_bg=np.zeros(wpimg.shape)
        wpimg_mask=cv2.drawContours(wpimg_bg,wpimg_cont,-1,255,-1)
        
        #Convolving once
        wpimg_mask_smooth=signal.convolve2d(np.where(wpimg_mask==255,1,0),np.full((3,3),1/9),'same')
        wpimg_mask_smooth_thresh=threshold_otsu(wpimg_mask_smooth)
        wpimg_conv1=np.where(np.where(wpimg_mask_smooth>wpimg_mask_smooth_thresh,0,wpimg_mask_smooth)>0,1,0)
        
        #Convolving again
        wpimg_mask_smooth2=signal.convolve2d(wpimg_conv1,np.full((3,3),1/9),'same')
        wpimg_mask_smooth_thresh2=threshold_otsu(wpimg_mask_smooth2)
        wpimg_conv2=np.where(wpimg_mask_smooth2>wpimg_mask_smooth_thresh2,1,0)
        
        #Now to create masks with contours after 2 convolutions
        wpimg_cont=cv2.findContours(cv2.convertScaleAbs(wpimg_conv2),cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1]
        wpimg_bg=np.zeros(wpimg.shape)
        wpimg_mask=cv2.drawContours(wpimg_bg,wpimg_cont,-1,255,-1)

        plt.imshow(wpimg_mask,cmap='gray')
        plt.title('Contour detection after 2 convolutions')

输出

#White background and black foreground
for i in range(len(training_sorted)):
    if training_sorted[i].parts[-1]=='08275a5b1c2dfcd739e8c4888a5ee2d29f83eccfa75185404ced1dc0866ea992.png':
        wbimg=cv2.imread(str(training_sorted[i]))
        wbimg=cv2.cvtColor(wbimg,cv2.COLOR_BGR2RGB)
        plt.figure(figsize=(20,8))
        plt.subplot(1,3,1)
        plt.imshow(wbimg)
        plt.title('White background and black foreground')
        
        plt.subplot(1,3,2)
        wbimg=cv2.cvtColor(wbimg,cv2.COLOR_RGB2GRAY)
        wbimg_canny=cv2.Canny(wbimg,20,100)
        plt.imshow(wbimg_canny,cmap='gray')
        plt.title('Canny edge detection')
        
        plt.subplot(1,3,3)
        wbimg_cont=cv2.findContours(wbimg_canny,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1]
        #Now to create masks with contours
        wbimg_bg=np.zeros(wbimg.shape)
        wbimg_mask=cv2.drawContours(wbimg_bg,wbimg_cont,-1,255,-1)
        
        #Convolving once
        wbimg_mask_smooth=signal.convolve2d(np.where(wbimg_mask==255,1,0),np.full((5,5),1/25),'same')
        wbimg_mask_smooth_thresh=threshold_otsu(wbimg_mask_smooth)
        wbimg_conv1=np.where(np.where(wbimg_mask_smooth>wbimg_mask_smooth_thresh,0,wbimg_mask_smooth)>0,1,0)
        
        #Convolving again
        wbimg_mask_smooth2=signal.convolve2d(wbimg_conv1,np.full((5,5),1/25),'same')
        wbimg_mask_smooth_thresh2=threshold_otsu(wbimg_mask_smooth2)
        wbimg_conv2=np.where(wbimg_mask_smooth2>wbimg_mask_smooth_thresh2,1,0)
        
        #Now to create masks with contours after 2 convolutions
        wbimg_cont=cv2.findContours(cv2.convertScaleAbs(wbimg_conv2),cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1]
        wbimg_bg=np.zeros(wbimg.shape)
        wbimg_mask=cv2.drawContours(wbimg_bg,wbimg_cont,-1,255,-1)

        plt.imshow(wbimg_conv2,cmap='gray')
        plt.title('Contour detection after 2 convolutions')

输出

#There are some images in the test set with a yellow background and purple foreground
test_images = pathlib.Path('../input/stage1_test/').glob('*/images/*.png')
testing_sorted=sorted([x for x in test_images])
for i in range(len(testing_sorted)):
    if testing_sorted[i].parts[-1]=='9f17aea854db13015d19b34cb2022cfdeda44133323fcd6bb3545f7b9404d8ab.png':
        ypimg=cv2.imread(str(testing_sorted[i]))
        ypimg=cv2.cvtColor(ypimg,cv2.COLOR_BGR2RGB)
        plt.figure(figsize=(20,8))
        plt.subplot(1,3,1)
        plt.imshow(ypimg)
        plt.title('Yellow background and purple foreground')
        
        plt.subplot(1,3,2)
        ypimg=cv2.cvtColor(ypimg,cv2.COLOR_RGB2GRAY)
        ypimg_canny=cv2.Canny(ypimg,100,200)
        plt.imshow(ypimg_canny,cmap='gray')
        plt.title('Canny edge detection')
        
        plt.subplot(1,3,3)
        ypimg_cont=cv2.findContours(ypimg_canny,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1]
        #Now to create masks with contours
        ypimg_bg=np.zeros(ypimg.shape)
        ypimg_mask=cv2.drawContours(ypimg_bg,ypimg_cont,-1,255,-1)
        
        #Convolving once
        ypimg_mask_smooth=signal.convolve2d(np.where(ypimg_mask==255,1,0),np.full((3,3),1/9),'same')
        ypimg_mask_smooth_thresh=threshold_otsu(ypimg_mask_smooth)
        ypimg_conv1=np.where(np.where(ypimg_mask_smooth>ypimg_mask_smooth_thresh,0,ypimg_mask_smooth)>0,1,0)
        
        #Convolving again
        ypimg_mask_smooth2=signal.convolve2d(ypimg_conv1,np.full((3,3),1/9),'same')
        ypimg_mask_smooth_thresh2=threshold_otsu(ypimg_mask_smooth2)
        ypimg_conv2=np.where(ypimg_mask_smooth2>ypimg_mask_smooth_thresh2,1,0)
        
        #Now to create masks with contours after 2 convolutions
        ypimg_cont=cv2.findContours(cv2.convertScaleAbs(ypimg_conv2),cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[1]
        ypimg_bg=np.zeros(ypimg.shape)
        ypimg_mask=cv2.drawContours(ypimg_bg,ypimg_cont,-1,255,-1)

        plt.imshow(ypimg_conv2,cmap='gray')
        plt.title('Contour detection after 2 convolutions')

输出

不难看出，在黑色背景和白色前景图像上相同的参数在其他类型的图像上会非常糟糕。

像素分类器

我们将尝试构建一个像素分类器，该分类器根据像素及其邻居的灰度值将像素分类为 0 或 255。

train_path = '../input/stage1_train/'
test_path = '../input/stage1_test/'
train_ids = os.listdir(train_path)
def LabelMerge(imgpath):
    #to get all the png files
    png_files = [f for f in os.listdir(imgpath) if f.endswith('.png')]
    #to load the image as a grayscale
    img = cv2.imread(imgpath+'/'+png_files[0],0)
    for i in png_files[1:]:
        temp_img = cv2.imread(imgpath+'/'+i,0)
        img = img+temp_img
    return(img)

path = train_path+training_sorted[45].parts[-3]+'/masks/'
combined_mask=LabelMerge(path)
plt.imshow(combined_mask,cmap='gray')
plt.xticks([])
plt.yticks([])
plt.title('Combined Mask')

输出

我们将使用蒙版中找到的细胞核的边界框来定位和分类原始图像中的细胞核。通过考虑组合蒙版中的灰度值和相应的标签，我们将标签分配给边界框内的像素。虽然某些细胞核可能聚集在一起或导致误报，但我们的重点是感兴趣的区域。像素分类器依赖于灰度值和邻近像素信息来做出准确的分类。目标是确保捕获所有具有细胞核的区域，避免漏报，同时允许分类器将 0 值分配给非细胞核区域。像素分类器的性能取决于定义的特征及其准确分类像素的能力。

objects=ndimage.label(canny_mask)[0]
plt.figure(figsize=(16,8))
plt.subplot(1,3,1)
plt.imshow(grayimg[ndimage.find_objects(objects)[20]],cmap='gray')
plt.xticks([])
plt.yticks([])
plt.title('Nuclei in the original image')

plt.subplot(1,3,2)
plt.imshow(canny_mask[ndimage.find_objects(objects)[20]],cmap='gray')
plt.xticks([])
plt.yticks([])
plt.title('Created mask')

plt.subplot(1,3,3)
plt.imshow(combined_mask[ndimage.find_objects(objects)[20]],cmap='gray')
plt.xticks([])
plt.yticks([])
plt.title('Label from the combined mask')

输出

#To get one dataframe for all the pixels within all the bounding boxes in an image
pixels_gs=pd.DataFrame()
columns=[]
for i in range(9):
    columns.append('pixel-'+str(i))
columns=columns+['label']
bounding=ndimage.find_objects(objects)
for bbox in bounding:
    for i in range(1,canny_mask[bbox].shape[0]-1):
        for j in range(1,canny_mask[bbox].shape[1]-1):
            pixel0=grayimg[bbox][i][j] #center pixel
            pixel1=grayimg[bbox][i-1][j-1] #top left pixel
            pixel2=grayimg[bbox][i-1][j] #pixel above the center pixel
            pixel3=grayimg[bbox][i-1][j+1] #top right pixel
            pixel4=grayimg[bbox][i][j-1] #pixel to the left of center pixel
            pixel5=grayimg[bbox][i][j+1] #pixel to the right of center pixel
            pixel6=grayimg[bbox][i+1][j-1] #bottom left pixel
            pixel7=grayimg[bbox][i+1][j] #pixel to the bottom of center pixel 
            pixel8=grayimg[bbox][i+1][j+1] #bottom right pixel
            label=combined_mask[i][j] #label of the center pixel
            neighbors = pd.Series({a:b for (a,b) in zip(columns,[pixel0,pixel1,pixel2,pixel3,pixel4,pixel5,pixel6,pixel7,pixel8,label])})
            pixels_gs = pixels_gs.append(neighbors, ignore_index=True)

#To see the head of the dataframe
pixels_gs.head()

输出

当仅考虑边界框内的像素时，类分布似乎偏向 0，这是出乎意料的。这可能是因为边界框包含了比单个细胞核更大的区域。

#To divide the data into training and testing sets
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

X_train,X_test,y_train,y_test=train_test_split(pixels_gs.drop('label',axis=1),pixels_gs['label'],test_size=0.3,random_state=101)
rfc=RandomForestClassifier(n_estimators=100)
rfc.fit(X_train,y_train)
rfc_pred=rfc.predict(X_test)

from sklearn.metrics import classification_report, confusion_matrix
print(confusion_matrix(y_test,rfc_pred))
print(classification_report(y_test,rfc_pred))

输出

predicted=np.zeros((canny_mask.shape))
bbox=[]
bbox_dim_prod=[0]
rfc_pred = rfc.predict(pixels_gs.drop('label',axis=1))
for i in range(len(bounding)):
    bbox_dim=np.array(list(background[bounding[i]].shape))-2 #Since we are taking 1 to (n-1) rows and 1 to (n-1) columns
    bbox_dim_prod.append(np.product(bbox_dim)) #for indexing
    bbox_pred=rfc_pred[sum(bbox_dim_prod[0:i+1]):sum(bbox_dim_prod[0:i+1])+np.product(bbox_dim)].reshape(bbox_dim[0],bbox_dim[1]) #for reshaping the predicted labels into the reduced dimensions of the bounding box 
    bbox.append(bbox_pred)
    predicted[bounding[i]][1:predicted[bounding[i]].shape[0]-1,1:predicted[bounding[i]].shape[1]-1]=bbox[i]

plt.figure(figsize=(13,7))
plt.subplot(1,2,1)
plt.imshow(combined_mask,cmap='gray')
plt.title('Combined Mask')
plt.xticks([])
plt.yticks([])

plt.subplot(1,2,2)
plt.imshow(predicted,cmap='gray')
plt.title('Predicted Mask')
plt.xticks([])
plt.yticks([])

输出

像素分类器的性能取决于定义的特征。需要注意的是，我们在同一图像上训练和测试了分类器，这可能导致过度拟合。为了提高性能，我们可以考虑在所有训练图像的边界框内的像素上训练分类器。此外，使用 5x5 窗口并结合诸如像素与细胞核中心之间的距离或 Canny 蒙版内定义窗口中白色像素（255 或 1）的相对密度等特征，可以提高我们的结果。

结论

图像处理和机器学习的结合在各个领域开辟了令人兴奋的可能性。通过利用机器学习算法的力量，我们可以从视觉数据中提取有价值的信息，自动化图像分析任务，并增强决策过程。随着研究人员不断创新和完善图像处理中的机器学习技术，我们可以期待进一步的进展，这将改变我们与视觉数据交互和从中获取见解的方式。

下一个主题银行机器学习

← 上一步下一步 →

机器学习中的图像处理

导入库

读取图像

基本步骤

处理颜色

去除背景

导出每个对象的蒙版

对象识别

游程编码

合并所有内容

边缘检测

像素分类器

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

机器学习

监督式学习

分类

杂项

相关教程

面试题

机器学习中的图像处理

导入库

读取图像

基本步骤

处理颜色

去除背景

导出每个对象的蒙版

对象识别

游程编码

合并所有内容

边缘检测

像素分类器

结论

相关帖子

流行的机器学习平台

机器学习的 A/B 测试

机器学习中的性能指标

机器学习中的分类类型

神经网络中的学习率 (eta)

神经网络中 Batch 和 Epoch 的区别

机器学习中的网络入侵检测系统

KL 散度

LDA 在机器学习中的应用

处理不平衡数据的分类

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器