Panduan untuk Pembahagian Imej Tanpa Pengawasan menggunakan Normalized Cuts (NCut) dalam Python

pengenalan

Segmentasi imej memainkan peranan penting dalam memahami dan menganalisis data visual, dan Normalized Cuts (NCut) ialah kaedah yang digunakan secara meluas untuk segmentasi berasaskan graf. Dalam artikel ini, kami akan meneroka cara menggunakan NCut untuk pembahagian imej yang tidak diselia dalam Python menggunakan set data daripada Microsoft Research, dengan tumpuan pada meningkatkan kualiti pembahagian menggunakan superpixel.
Gambaran Keseluruhan Set Data
Set data yang digunakan untuk tugasan ini boleh dimuat turun daripada pautan berikut: Pangkalan Data Imej Kategori Objek MSRC. Set data ini mengandungi imej asal serta pembahagian semantiknya kepada sembilan kelas objek (ditunjukkan oleh fail imej yang berakhir dengan "_GT"). Imej ini dikumpulkan ke dalam subset tematik, di mana nombor pertama dalam nama fail merujuk kepada subset kelas. Set data ini sesuai untuk bereksperimen dengan tugasan pembahagian.

Pernyataan Masalah

Kami melakukan pembahagian imej pada imej dalam set data menggunakan algoritma NCut. Segmentasi pada tahap piksel adalah mahal dari segi pengiraan dan selalunya bising. Untuk mengatasinya, kami menggunakan SLIC (Simple Linear Iterative Clustering) untuk menjana superpixel, yang mengumpulkan piksel yang serupa dan mengurangkan saiz masalah. Untuk menilai ketepatan pembahagian metrik yang berbeza (cth., Intersection over Union, SSIM, Rand Index) boleh digunakan.

Perlaksanaan

1. Pasang Perpustakaan Diperlukan
Kami menggunakan skimage untuk pemprosesan imej, numpy untuk pengiraan berangka dan matplotlib untuk visualisasi.

pip install numpy matplotlib
pip install scikit-image==0.24.0
**2. Load and Preprocess the Dataset**

Selepas memuat turun dan mengekstrak set data, muatkan imej dan pembahagian kebenaran tanah:

wget http://download.microsoft.com/download/A/1/1/A116CD80-5B79-407E-B5CE-3D5C6ED8B0D5/msrc_objcategimagedatabase_v1.zip -O msrc_objcategimagedatabase_v1.zip
unzip msrc_objcategimagedatabase_v1.zip
rm msrc_objcategimagedatabase_v1.zip

Kini kami bersedia untuk memulakan pengekodan.

from skimage import io, segmentation, color, measure
from skimage import graph
import numpy as np
import matplotlib.pyplot as plt

# Load the image and its ground truth
image = io.imread('/content/MSRC_ObjCategImageDatabase_v1/1_16_s.bmp')
ground_truth = io.imread('/content/MSRC_ObjCategImageDatabase_v1/1_16_s_GT.bmp')

# show images side by side
fig, ax = plt.subplots(1, 2, figsize=(10, 5))
ax[0].imshow(image)
ax[0].set_title('Image')
ax[1].imshow(ground_truth)
ax[1].set_title('Ground Truth')
plt.show()

3. Hasilkan Superpixel menggunakan SLIC dan buat Graf Bersebelahan Rantau

Kami menggunakan algoritma SLIC untuk mengira superpixel sebelum menggunakan NCut. Menggunakan superpiksel yang dijana, kami membina Graf Bersebelahan Wilayah (RAG) berdasarkan persamaan warna min:

from skimage.util import img_as_ubyte, img_as_float, img_as_uint, img_as_float64

compactness=30 
n_segments=100 
labels = segmentation.slic(image, compactness=compactness, n_segments=n_segments, enforce_connectivity=True)
image_with_boundaries = segmentation.mark_boundaries(image, labels, color=(0, 0, 0))
image_with_boundaries = img_as_ubyte(image_with_boundaries)
pixel_labels = color.label2rgb(labels, image_with_boundaries, kind='avg', bg_label=0

kekompakan mengawal keseimbangan antara persamaan warna dan kedekatan ruang piksel apabila membentuk superpiksel. Ia menentukan sejauh mana penekanan diberikan pada memastikan superpixel padat (lebih dekat dari segi ruang) berbanding memastikan ia dikumpulkan secara homogen mengikut warna.
Nilai Lebih Tinggi: Nilai kekompakan yang lebih tinggi menyebabkan algoritma mengutamakan penciptaan superpiksel yang padat dari segi ruang dan saiz seragam, dengan kurang memperhatikan persamaan warna. Ini mungkin menyebabkan superpiksel yang kurang sensitif kepada tepi atau kecerunan warna.
Nilai Lebih Rendah: Nilai kekompakan yang lebih rendah membolehkan superpixel berubah lebih dalam saiz spatial untuk menghormati perbezaan warna dengan lebih tepat. Ini biasanya menghasilkan superpiksel yang mengikut sempadan objek dalam imej dengan lebih dekat.

n_segments mengawal bilangan superpixel (atau segmen) yang algoritma SLIC cuba hasilkan dalam imej. Pada asasnya, ia menetapkan resolusi pembahagian.
Nilai Lebih Tinggi: Nilai n_segmen yang lebih tinggi menghasilkan lebih banyak superpixel, yang bermaksud setiap superpixel akan menjadi lebih kecil dan pembahagian akan menjadi lebih halus. Ini boleh berguna apabila imej mempunyai tekstur kompleks atau objek kecil.
Nilai Lebih Rendah: Nilai n_segmen yang lebih rendah menghasilkan superpiksel yang lebih kecil dan lebih besar. Ini berguna apabila anda mahukan pembahagian kasar imej, mengumpulkan kawasan yang lebih besar kepada superpiksel tunggal.

4. Gunakan Potongan Normal (NCut) dan Visualisasikan Hasilnya

# using the labels found with the superpixeled image
# compute the Region Adjacency Graph using mean colors
g = graph.rag_mean_color(image, labels, mode='similarity')

# perform Normalized Graph cut on the Region Adjacency Graph
labels2 = graph.cut_normalized(labels, g)
segmented_image = color.label2rgb(labels2, image, kind='avg')
f, axarr = plt.subplots(nrows=1, ncols=4, figsize=(25, 20))

axarr[0].imshow(image)
axarr[0].set_title("Original")

#plot boundaries
axarr[1].imshow(image_with_boundaries)
axarr[1].set_title("Superpixels Boundaries")

#plot labels
axarr[2].imshow(pixel_labels)
axarr[2].set_title('Superpixel Labels')

#compute segmentation
axarr[3].imshow(segmented_image)
axarr[3].set_title('Segmented image (normalized cut)')

5. Metrik Penilaian
Cabaran utama dalam segmentasi tanpa pengawasan ialah NCut tidak mengetahui bilangan kelas yang tepat dalam imej. Bilangan segmen yang ditemui oleh NCut mungkin melebihi bilangan sebenar wilayah kebenaran tanah. Akibatnya, kami memerlukan metrik yang mantap untuk menilai kualiti pembahagian.

Persimpangan atas Kesatuan (IoU) ialah metrik yang digunakan secara meluas untuk menilai tugasan pembahagian, terutamanya dalam penglihatan komputer. Ia mengukur pertindihan antara wilayah terbahagi yang diramalkan dan wilayah kebenaran asas. Secara khusus, IoU mengira nisbah kawasan pertindihan antara pembahagian yang diramalkan dan kebenaran asas kepada kawasan kesatuan mereka.

Indeks Kesamaan Struktur (SSIM) ialah metrik yang digunakan untuk menilai kualiti imej yang dilihat dengan membandingkan dua imej dari segi kecerahan, kontras dan struktur.

To apply these metrics we need that the prediction and the ground truth image have the same labels. To compute the labels we compute a mask on the ground and on the prediction assign an ID to each color found on the image
Segmentation using NCut however may find more regions than ground truth, this will lower the accuracy.

def compute_mask(image):
  color_dict = {}

  # Get the shape of the image
  height,width,_ = image.shape

  # Create an empty array for labels
  labels = np.zeros((height,width),dtype=int)
  id=0
  # Loop over each pixel
  for i in range(height):
      for j in range(width):
          # Get the color of the pixel
          color = tuple(image[i,j])
          # Check if it is in the dictionary
          if color in color_dict:
              # Assign the label from the dictionary
              labels[i,j] = color_dict[color]
          else:
              color_dict[color]=id
              labels[i,j] = id
              id+=1

  return(labels)
def show_img(prediction, groundtruth):
  f, axarr = plt.subplots(nrows=1, ncols=2, figsize=(15, 10))

  axarr[0].imshow(groundtruth)
  axarr[0].set_title("groundtruth")
  axarr[1].imshow(prediction)
  axarr[1].set_title(f"prediction")
prediction_mask = compute_mask(segmented_image)
groundtruth_mask = compute_mask(ground_truth)

#usign the original image as baseline to convert from labels to color
prediction_img = color.label2rgb(prediction_mask, image, kind='avg', bg_label=0)
groundtruth_img = color.label2rgb(groundtruth_mask, image, kind='avg', bg_label=0)

show_img(prediction_img, groundtruth_img)

Now we compute the accuracy scores

from sklearn.metrics import jaccard_score
from skimage.metrics import structural_similarity as ssim

ssim_score = ssim(prediction_img, groundtruth_img, channel_axis=2)
print(f"SSIM SCORE: {ssim_score}")

jac = jaccard_score(y_true=np.asarray(groundtruth_mask).flatten(),
                        y_pred=np.asarray(prediction_mask).flatten(),
                        average = None)

# compute mean IoU score across all classes
mean_iou = np.mean(jac)
print(f"Mean IoU: {mean_iou}")

Conclusion

Normalized Cuts is a powerful method for unsupervised image segmentation, but it comes with challenges such as over-segmentation and tuning parameters. By incorporating superpixels and evaluating the performance using appropriate metrics, NCut can effectively segment complex images. The IoU and Rand Index metrics provide meaningful insights into the quality of segmentation, though further refinement is needed to handle multi-class scenarios effectively.
Finally, a complete example is available in my notebook here.

Atas ialah kandungan terperinci Panduan untuk Pembahagian Imej Tanpa Pengawasan menggunakan Normalized Cuts (NCut) dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!