Ein Leitfaden zur unbeaufsichtigten Bildsegmentierung mit normalisierten Schnitten (NCut) in Python

Einführung

Bildsegmentierung spielt eine entscheidende Rolle beim Verständnis und der Analyse visueller Daten, und Normalized Cuts (NCut) ist eine weit verbreitete Methode zur diagrammbasierten Segmentierung. In diesem Artikel untersuchen wir, wie man NCut für die unbeaufsichtigte Bildsegmentierung in Python mithilfe eines Datensatzes von Microsoft Research anwendet, wobei der Schwerpunkt auf der Verbesserung der Segmentierungsqualität mithilfe von Superpixeln liegt.
Datensatzübersicht
Der für diese Aufgabe verwendete Datensatz kann unter folgendem Link heruntergeladen werden: MSRC Object Category Image Database. Dieser Datensatz enthält Originalbilder sowie deren semantische Segmentierung in neun Objektklassen (gekennzeichnet durch Bilddateien mit der Endung „_GT“). Diese Bilder sind in thematische Teilmengen gruppiert, wobei sich die erste Zahl im Dateinamen auf eine Klassenteilmenge bezieht. Dieser Datensatz eignet sich perfekt zum Experimentieren mit Segmentierungsaufgaben.

Problemstellung

Wir führen eine Bildsegmentierung an einem Bild im Datensatz mithilfe des NCut-Algorithmus durch. Die Segmentierung auf Pixelebene ist rechenintensiv und häufig verrauscht. Um dies zu überwinden, verwenden wir SLIC (Simple Linear Iterative Clustering), um Superpixel zu generieren, wodurch ähnliche Pixel gruppiert und die Problemgröße reduziert werden. Um die Genauigkeit der Segmentierung zu bewerten, können verschiedene Metriken (z. B. Intersection over Union, SSIM, Rand Index) verwendet werden.

Durchführung

1. Erforderliche Bibliotheken installieren
Wir verwenden Skimage für die Bildverarbeitung, Numpy für numerische Berechnungen und Matplotlib für die Visualisierung.

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

Nachdem Sie den Datensatz heruntergeladen und extrahiert haben, laden Sie die Bilder und die Ground-Truth-Segmentierung:

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

Jetzt können wir mit dem Codieren beginnen.

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. Generieren Sie Superpixel mit SLIC und erstellen Sie ein Region Adjacency Graph

Wir verwenden den SLIC-Algorithmus, um Superpixel zu berechnen, bevor wir NCut anwenden. Mithilfe der generierten Superpixel erstellen wir einen Region Adjacency Graph (RAG) basierend auf der mittleren Farbähnlichkeit:

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

Kompaktheit steuert das Gleichgewicht zwischen der Farbähnlichkeit und der räumlichen Nähe von Pixeln bei der Bildung von Superpixeln. Es bestimmt, wie viel Wert darauf gelegt wird, die Superpixel kompakt (räumlich näher beieinander) zu halten, anstatt sicherzustellen, dass sie homogener nach Farben gruppiert sind.
Höhere Werte: Ein höherer Kompaktheitswert führt dazu, dass der Algorithmus die Erstellung von Superpixeln priorisiert, die räumlich eng und gleichmäßig groß sind, wobei der Farbähnlichkeit weniger Aufmerksamkeit geschenkt wird. Dies kann dazu führen, dass Superpixel weniger empfindlich auf Kanten oder Farbverläufe reagieren.
Niedrigere Werte: Ein niedrigerer Kompaktheitswert ermöglicht es den Superpixeln, in ihrer räumlichen Größe stärker zu variieren, um die Farbunterschiede genauer zu berücksichtigen. Dies führt typischerweise zu Superpixeln, die den Grenzen von Objekten im Bild genauer folgen.

n_segments steuert die Anzahl der Superpixel (oder Segmente), die der SLIC-Algorithmus im Bild zu generieren versucht. Im Wesentlichen legt es die Auflösung der Segmentierung fest.
Höhere Werte: Ein höherer n_segments-Wert erzeugt mehr Superpixel, was bedeutet, dass jedes Superpixel kleiner und die Segmentierung feinkörniger ist. Dies kann nützlich sein, wenn das Bild komplexe Texturen oder kleine Objekte aufweist.
Niedrigere Werte: Ein niedrigerer n_segments-Wert erzeugt weniger, größere Superpixel. Dies ist nützlich, wenn Sie eine grobe Segmentierung des Bildes wünschen und größere Bereiche in einzelne Superpixel gruppieren möchten.

4. Wenden Sie normalisierte Schnitte (NCut) an und visualisieren Sie das Ergebnis

# 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. Bewertungsmetriken
Die größte Herausforderung bei der unbeaufsichtigten Segmentierung besteht darin, dass NCut die genaue Anzahl der Klassen im Bild nicht kennt. Die Anzahl der von NCut gefundenen Segmente kann die tatsächliche Anzahl der Ground-Truth-Regionen überschreiten. Daher benötigen wir robuste Metriken zur Beurteilung der Segmentierungsqualität.

Intersection over Union (IoU) ist eine weit verbreitete Metrik zur Bewertung von Segmentierungsaufgaben, insbesondere in der Computer Vision. Es misst die Überlappung zwischen den vorhergesagten segmentierten Regionen und den Ground-Truth-Regionen. Insbesondere berechnet IoU das Verhältnis der Überlappungsfläche zwischen der vorhergesagten Segmentierung und der Grundwahrheit zur Fläche ihrer Vereinigung.

Struktureller Ähnlichkeitsindex (SSIM) ist eine Metrik zur Beurteilung der wahrgenommenen Qualität eines Bildes durch den Vergleich zweier Bilder hinsichtlich Luminanz, Kontrast und 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.

Das obige ist der detaillierte Inhalt vonEin Leitfaden zur unbeaufsichtigten Bildsegmentierung mit normalisierten Schnitten (NCut) in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!