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

Barbara Streisand
Freigeben: 2024-09-24 06:20:15
Original
485 Leute haben es durchsucht

A Guide to Unsupervised Image Segmentation using Normalized Cuts (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**
Nach dem Login kopieren

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
Nach dem Login kopieren

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()
Nach dem Login kopieren

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
Nach dem Login kopieren

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)')
Nach dem Login kopieren

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)
Nach dem Login kopieren

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}")
Nach dem Login kopieren

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!

Quelle:dev.to
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Neueste Artikel des Autors
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage