Yönlendirilmiş Gradyanların Histogramı (HOG)

Bilgisayarla görü algılama ve görü tabanlı nesne tespiti, son yıllarda giderek daha fazla önem kazanmaktadır. Bu alanda çok sayıda algoritma geliştirilmiş olup, bu algoritmalar özellikle; nesne sınıflandırma, nesne tanıma ve hareket analizi gibi görevlerde kullanılmaktadır. Yönlendirilmiş Gradyanların Histogramı (Histogram of Oriented Gradients, HOG) algoritması, bu bağlamda sıkça kullanılan ve etkinliği kanıtlanmış bir özellik çıkarma yöntemidir.

HOG Algoritması örneği (Kaynak: Batuhan Daz)

HOG Algoritmasının Temelleri

HOG algoritması, bir görüntüdaki nesneleri tanımlamak için gradyan yön bilgilerini kullanan bir özellik çıkarma yöntemidir. Algoritma temel olarak şu adımlardan oluşmaktadır:

1. Gri Tonlamaya Dönüştürme: Renkli görüntüler genellikle gri tonlamaya dönüştürülür. Bu, hesaplama yükünü azaltarak gradyan hesaplamalarını daha verimli hale getirir.

2. Gradyan Hesaplama: Görüntünün yatay (x) ve dikey (y) yönlerinde parlaklık farklarını hesaplamak için Sobel filtresi gibi kenar tespit operatörleri kullanılır. Bu farklar, görüntünün kenar bilgilerini çıkarmaya yardımcı olur.

3. Hücre Tabanlı Histogram Oluşturma: Görüntü belirli bölgelere (hücrelere) bölünür ve her hücrede bulunan piksellerin gradyan yönleri belirlenir. Her hücrede, gradyan yönü ve büyüklüğü baz alınarak bir histogram oluşturulur.

4. Blok Normalizasyonu: HOG algoritmasında bloklar, belirli sayıda hücrenin birleştirilmesiyle oluşur. Blok normalizasyonu, ışık değişkenliklerinden etkilenmeyi azaltmak için histogram değerlerinin normalize edilmesini sağlar.

5. Özellik Vektörünün Oluşturulması: Elde edilen hücre histogramları birleştirilerek bir özellik vektörü oluşturulur. Bu vektör, makine öğrenmesi algoritmalarında veya nesne tanıma sistemlerinde kullanılabilir.

Bu adımlar, bir görüntüde nesne sınıflandırma veya tespit için güçlü ve kararlı özellikler oluşturur.

HOG Algoritmasının Çalışma Prensibi

1. Gradyan Hesaplama: Gradyan hesaplama, Sobel filtresi gibi kenar tespit operatörleri kullanarak görüntünün yatay ve dikey parlaklık farklarını belirlemeyi içerir. Bu adım, görüntünün kenar bilgilerini belirleyerek sonraki analiz için temel oluşturur.

2. Histogram Oluşturma: Her pikselin gradyan yönü ve büyüklüğü hesaplanarak hücreler içinde histogramlar oluşturulur. Her hücrede belirlenen histogram, piksellerin gradyan yönlerine göre düzenlenir.

3. Blok Normalizasyonu: Histogramlar belirli bölgeler halinde (bloklar) gruplanarak normalize edilir. Bu işlem, ışık ve kontrast farklılıklarından etkilenmeyi azaltarak daha tutarlı bir özellik vektörü oluşturulmasını sağlar.

4. Özellik Vektörünün Oluşturulması: Son aşamada, elde edilen histogram değerleri düz bir vektöre dönüştürülerek, nesne tanıma veya sınıflandırma için kullanılabilir hale getirilir. Bu vektör, makine öğrenmesi algoritmalarıyla nesne saptama ve sınıflandırma görevlerinde kullanılabilir.

Python ile HOG Algoritması Hesaplama Adımları

# Gerekli kütüphaneler ve görüntü import edilir. 

import matplotlib.pyplot as plt
from skimage import io
from skimage import color
from skimage.transform import resize
import math
from skimage.feature import hog
import numpy as np
     
img = resize(color.rgb2gray(io.imread("B.jpg")), (128, 64))

# Görüntü görselleştirilir
plt.figure(figsize=(15, 8))
plt.imshow(img, cmap="gray")
plt.axis("off")
plt.show()

Çıktı:

img = np.array(img)

# Görüntünün gradyanının ve açısının hesaplanması

mag = []
theta = []
for i in range(128):
  magnitudeArray = []
  angleArray = []
  for j in range(64):
    if j-1 <= 0 or j+1 >= 64:
      if j-1 <= 0:
        Gx = img[i][j+1] - 0
      elif j + 1 >= len(img[0]):
        Gx = 0 - img[i][j-1]
    else:
      Gx = img[i][j+1] - img[i][j-1]
    
    if i-1 <= 0 or i+1 >= 128:
      if i-1 <= 0:
        Gy = 0 - img[i+1][j]
      elif i +1 >= 128:
        Gy = img[i-1][j] - 0
    else:
      Gy = img[i-1][j] - img[i+1][j]


    magnitude = math.sqrt(pow(Gx, 2) + pow(Gy, 2))
    magnitudeArray.append(round(magnitude, 9))

    if Gx == 0:
      angle = math.degrees(0.0)
    else:
      angle = math.degrees(abs(math.atan(Gy / Gx)))
    angleArray.append(round(angle, 9))
  mag.append(magnitudeArray)
  theta.append(angleArray)

mag = np.array(mag)
theta = np.array(theta)

# Görüntü büyüklüğünün görselleştirilmesi

plt.figure(figsize=(15, 8))
plt.imshow(mag, cmap="gray")
plt.axis("off")
plt.show()

Çıktı:

# Görüntü açısının görselleştirilmesi

plt.figure(figsize=(15, 8))
plt.imshow(theta, cmap="gray")
plt.axis("off")
plt.show()

Çıktı:

number_of_bins = 9
step_size = 180 / number_of_bins

# J. bölmeyi hesaplama fonksiyonu

def calculate_j(angle):
  temp = (angle / step_size) - 0.5
  j = math.floor(temp)
  return j

# J. bölmenin merkez değerini hesaplayan fonksiyon 

def calculate_Cj(j):
  Cj = step_size * (j + 0.5)
  return round(Cj, 9)

# J. bölmenin değerini hesaplayan fonksiyon

def calculate_value_j(magnitude, angle, j):
  Cj = calculate_Cj(j+1)
  Vj = magnitude * ((Cj - angle) / step_size)
  return round(Vj, 9)

# 8x8 hücreler için 9 noktalı histogram oluşturma

histogram_points_nine = []
for i in range(0, 128, 8):
  temp = []
  for j in range(0, 64, 8):
    magnitude_values = [[mag[i][x] for x in range(j, j+8)] for i in range(i,i+8)]
    angle_values = [[theta[i][x] for x in range(j, j+8)] for i in range(i, i+8)]
    for k in range(len(magnitude_values)):
      for l in range(len(magnitude_values[0])):
        bins = [0.0 for _ in range(number_of_bins)]
        value_j = calculate_j(angle_values[k][l])
        Vj = calculate_value_j(magnitude_values[k][l], angle_values[k][l], value_j)
        Vj_1 = magnitude_values[k][l] - Vj
        bins[value_j]+=Vj
        bins[value_j+1]+=Vj_1
        bins = [round(x, 9) for x in bins]
    temp.append(bins)
  histogram_points_nine.append(temp)

print(len(histogram_points_nine))
print(len(histogram_points_nine[0]))
print(len(histogram_points_nine[0][0]))
     
16
8
9

# 2x2 bloklarla 9 noktalı histogram için yönlendirilmiş gradyan özellik vektörü histogramı oluşturma 

epsilon = 1e-05

feature_vectors = []
for i in range(0, len(histogram_points_nine) - 1, 1):
  temp = []
  for j in range(0, len(histogram_points_nine[0]) - 1, 1):
    values = [[histogram_points_nine[i][x] for x in range(j, j+2)] for i in range(i, i+2)]
    final_vector = []
    for k in values:
      for l in k:
        for m in l:
          final_vector.append(m)
    k = round(math.sqrt(sum([pow(x, 2) for x in final_vector])), 9)
    final_vector = [round(x/(k + epsilon), 9) for x in final_vector]
    temp.append(final_vector)
  feature_vectors.append(temp)

print(len(feature_vectors))
print(len(feature_vectors[0]))
print(len(feature_vectors[0][0]))
     
15
7
36

# Elde Edilen Yönlendirilmiş Gradyan Özelliklerinin Histogram Sayısı

print(f'Number of HOG features = {len(feature_vectors) * len(feature_vectors[0]) * len(feature_vectors[0][0])}')
     
Number of HOG features = 3780

HOG Algoritmasının Avantajları ve Dezavantajları

Avantajlar

• Işık ve kontrast değişimlerine dayanıklıdır.
• Kenar ve doku bilgisini etkin bir şekilde çıkarır.
• Ölçeklenebilir ve esnek bir yöntemdir.
• Gerçek zamanlı uygulamalarda yüksek performans sunar.
• 
  

Dezavantajlar

• Hesaplama maliyeti düşüktür.
• Döndürme ve ölçek değişikliklerine duyarlı olabilir.
• Derin öğrenme tabanlı yöntemlere kıyasla daha düşük doğruluk oranına sahiptir.

HOG Algoritmasının Kullanım Alanları

• İnsan tespiti (Güvenlik kameraları, otonom araçlar)
• Araç ve trafik analizi
• Tıbbi görüntü analizi
• Robotik ve otonom sistemler
• Yüz tanıma ve jest analizi