← Tüm haftalar
Yapay Zeka Uygulamaları · 4. Hafta · Görüntü İşleme, OpenCV ve CNN
4. Hafta · Görüntü İşleme, OpenCV ve CNN

Bilgisayar bir resme baktığında ne görür?

3. haftada tablo verisiyle çalıştık: satırlar, sütunlar, sayılar. Bu hafta girdi değişiyor — artık elimizde bir fotoğraf var. Ama göreceğiz ki fotoğraf da bir tablodur; sadece çok daha büyük ve komşuluk ilişkisi önemli bir tablo.

Bu haftanın tek cümlesi:
Filtre uygulamak, her pikseli komşularıyla birlikte yeni bir sayıya çevirmektir. CNN'in yaptığı tek yenilik, o filtreyi kendisinin bulmasıdır.
🔢Görüntü = sayıPiksel, kanal, 0–255.
🛠️OpenCVFiltreler, eşik, kenar, kontur.
🧠CNNFiltreyi öğrenen ağ.
🏆KaggleHepsi tarayıcıda, ücretsiz.
Bu haftadan sonra şunları yapabileceksiniz: Bir görüntüyü OpenCV ile okuyup gri tonlamaya çevirmek, eşikleme ve morfolojiyle temizlemek, kenarlarını bulmak, içindeki nesneleri saymak; ardından Kaggle'da bir CNN eğitip el yazısı rakamları %99 doğrulukla tanımak ve sonucu yarışmaya göndermek.

Sayfadaki bütün görseller canlıdır. Kaydıraçları oynatın, çekirdek sayılarını değiştirin, hatta kendi fotoğrafınızı yükleyin — yüklediğiniz fotoğraf hiçbir yere gitmez, yalnızca kendi tarayıcınızda işlenir. Her lab'ın altında, o işin OpenCV'deki tam karşılığı yazıyor.

Her görüntü indirilebilir: görsellerin sağ üst köşesindeki ⤓ düğmesi o anki sonucu PNG olarak kaydeder. Örnek görüntülerin yüksek çözünürlüklü hâlleri ise 4. bölümde — indirip Kaggle'a yükleyin, aynı görüntüyle çalışın.
📓
Dersin bütün kodları iki hazır notebook'ta İndirip Kaggle'da Code → New Notebook → File → Import Notebook ile açın. Hiçbir veri seti eklemeniz gerekmiyor; OpenCV bölümü internet kapalı da çalışır.
OpenCV notebook'u indir
🧠
CNN notebook'u Kaggle'ın Digit Recognizer yarışmasına bağlanır, CNN eğitir, grafikleri çizer ve submission.csv üretir.
CNN notebook'u indir
02 · Temel kavram

Görüntü bir sayı tablosudur

Bilgisayar resim görmez. Gördüğü şey, her hücresinde bir parlaklık sayısı olan bir tablodur. Hücrenin adı piksel, sayının aralığı 0–255: sıfır simsiyah, 255 bembeyaz.

Tek sayı

Gri görüntü

Her piksel için tek sayı: parlaklık. (yükseklik, genişlik) boyutunda bir tablo.

Üç sayı

Renkli görüntü

Her piksel için üç sayı: kırmızı, yeşil, mavi. Yani üst üste binmiş üç tablo — (yükseklik, genişlik, 3).

Neden önemli?

Her şey aritmetik

Resmi parlatmak = her sayıya 30 eklemek. Negatifini almak = 255 − sayı. Sihir yok, toplama çıkarma var.

Bir görüntünün gerçek boyutu
Gri görüntü (512, 512) 262.144 sayı → R G B Renkli görüntü (512, 512, 3) 786.432 sayı Neden bu kadar önemli? 3. haftada Titanic verisi 891 satır × 12 sütun = 10.692 sayıydı. Tek bir renkli fotoğraf bunun 73 katı. Bu yüzden görüntüde “her sütunu tek tek incele” yaklaşımı çalışmaz. Komşuluk şart.
Görüntüyü satır satır sayılara açmak işe yaramaz; pikselin komşusuyla ilişkisi anlamı taşır.
Lab 1Piksel büyüteci — resmin içindeki sayıları gör

Soldaki görüntünün üzerine tıklayın ya da parmağınızı sürükleyin. Seçtiğiniz 8×8'lik kare büyütülür ve o karedeki gerçek sayılar sağda tablo olarak yazılır.

Görüntü
Deneyin: satranç tahtasında siyah kareye tıklayın (sayılar 40'ın altında), sonra beyaz kareye geçin (200'ün üstünde). İki kareyi ayıran çizgiye tıkladığınızda tabloda ani bir atlama göreceksiniz — kenar bulmanın bütün sırrı o atlamadır.
Orijinal görüntütıklayın — turuncu kare = büyüteç
8 × 8 büyütülmüşher kare bir piksel
OpenCV'de bu nedir? Bir pikselin değerini okumak, numpy'da bir hücreyi okumaktan farksızdır: gri[y, x] tek sayı, renkli[y, x] üç sayı döner. Dikkat: önce satır (y), sonra sütun (x).
piksel okuma ve yazma
print(gri.shape)        # (225, 300)      -> (yukseklik, genislik)
print(renkli.shape)     # (225, 300, 3)   -> ucuncu boyut kanal
print(gri.dtype)        # uint8           -> 0..255 arasi tam sayi

print(gri[112, 150])            # tek sayi, orn. 143
print(renkli[112, 150])         # [B G R] -> orn. [ 92 128 176]

renkli[0:40, 0:40] = (0, 0, 255)   # sol ust koseyi KIRMIZI yap (BGR!)
gri[100:105, :] = 255              # bes satiri bembeyaz bir cizgi yap
En sık yapılan iki hata.
• Sıra karışması: gri[x, y] yazmak. Doğrusu gri[y, x] — numpy önce satırı sorar.
• Taşma: uint8 veride 200 + 100 işlemi 300 değil 44 verir (256'da başa döner). Parlaklık eklerken cv2.add kullanın; o 255'te durur.
03 · Renk

Kanallar, gri tonlama ve OpenCV'nin BGR tuzağı

Renkli görüntü üç tablonun üst üste binmiş hâlidir. Bu üç tabloyu ayrı ayrı görmek, görüntü işlemede ilk sezgiyi kazandıran şeydir.

Bu haftanın en çok vakit kaybettiren ayrıntısı
  • OpenCV bir görüntüyü okuduğunda kanalları mavi–yeşil–kırmızı (BGR) sırasında tutar.
  • Matplotlib, Pillow, scikit-image ve bütün dünya kırmızı–yeşil–mavi (RGB) sırasını kullanır.
  • Sonuç: plt.imshow(cv2.imread(...)) yazarsanız gökyüzü turuncu, tenler mavi çıkar. Kod hatasız çalışır, sadece renkler yanlıştır.
  • Çözüm tek satır: cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
Lab 2Kanal ayırıcı — aynı görüntü, altı farklı bakış
Görüntü
Doğru: RGBcvtColor(BGR2RGB) sonrası
Hatalı: BGR'yi RGB sanmakçevirmeyi unutursanız bu çıkar
Gri tonlamaCOLOR_BGR2GRAY
Kırmızı kanal (R)b, g, r = cv2.split(img)
Yeşil kanal (G)en çok detay burada
Mavi kanal (B)gökyüzü burada parlak
Üç kanala ayırmak neye yarar? Çoğu zaman aradığınız şey tek bir kanalda çok daha belirgindir. Gökyüzünü ayırmak istiyorsanız mavi kanal, yeşil bitki örtüsünü ayırmak istiyorsanız yeşil kanal işinizi yarı yarıya kolaylaştırır. Üç kanalla uğraşmadan önce “acaba tek kanal yeter mi?” diye sorun.
kanallar, gri tonlama ve çevirme
import cv2
import numpy as np
import matplotlib.pyplot as plt

# --- 1) Kanallari ayirmak ve birlestirmek ---
b, g, r = cv2.split(img)          # img BGR sirasinda
birlesik = cv2.merge([b, g, r])   # geri birlestir

# Hizli yol (split kopyalar, dilimleme kopyalamaz):
b = img[:, :, 0]
g = img[:, :, 1]
r = img[:, :, 2]

# --- 2) Gri tonlama ---
gri = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Formul:  0.299*R + 0.587*G + 0.114*B
# Yesil agirligi en buyuk, cunku insan gozu yesile en duyarli.

# --- 3) Tek kanali sifirlamak: "mavisiz" goruntu ---
mavisiz = img.copy()
mavisiz[:, :, 0] = 0

# --- 4) Matplotlib ile dogru gostermek ---
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))   # DOGRU
# plt.imshow(img)                                   # YANLIS: renkler ters
plt.axis("off")
plt.show()

plt.imshow(gri, cmap="gray")   # gri goruntude cmap="gray" sart,
plt.show()                     # yoksa matplotlib sari-mor boyar
Neden gri tonlamaya geçiyoruz? Üç sebep: (1) Veri üçte bire düşer, her şey üç kat hızlanır. (2) Eşikleme, kenar bulma, morfoloji gibi işlemlerin çoğu tek kanal bekler. (3) Aradığınız şey şekilse, renk sadece gürültüdür.

Ama renk bilginin kendisiyse (olgun domatesi ayırmak, kırmızı topu takip etmek) gri tonlamaya geçmek bütün ipucunu çöpe atmak olur. 13. bölümde HSV ile bunu yapacağız.
04 · Araç

OpenCV nedir, Kaggle'da nasıl başlarız?

OpenCV (Open Source Computer Vision) 25 yıldır geliştirilen, görüntü işlemenin standart kütüphanesidir. Python'da adı cv2'dir ve Kaggle'da zaten kuruludur — hiçbir şey yüklemeniz gerekmez.

Ne yapar?

2500'den fazla hazır işlem

Filtre, kenar, kontur, yüz bulma, kamera kalibrasyonu, nesne takibi. Hepsi C++ ile yazılmış, Python'dan çağrılıyor — yani hızlı.

Ne yapmaz?

Öğrenmez

OpenCV'nin filtrelerini siz seçersiniz. “Kedi bul” diyemezsiniz. Öğrenme kısmı 16. bölümden itibaren CNN'in işi.

Kardeşleri

Pillow, scikit-image

Pillow basit işler için (aç, kaydet, kırp). scikit-image bilimsel işler ve hazır örnek görüntüler için. Bu derste üçünü de kullanacağız.

Örnek görüntüyü nereden bulacağız? (İnternet gerekmeden)

Kaggle notebook'ta internet varsayılan olarak kapalıdır. Dışarıdan fotoğraf indirmeye çalışmak yeni başlayanın ilk tökezlediği yerdir. İki sağlam yol var:

Yol 1 · scikit-image'in hazır görüntüleri önerilen

skimage.data paketinin içinde, kütüphaneyle birlikte gelen onlarca örnek görüntü var. İnternet gerekmez, herkeste aynıdır, dersi kolaylaştırır.

Yol 2 · Kaggle veri seti eklemek

Sağ panelden Add Input → bir görüntü veri seti seçin. Dosyalar /kaggle/input/... altına gelir ve cv2.imread ile okunur. Ödevde bunu yapacaksınız.

Yol 3 · Bu dersin örnek görüntülerini indirin

Sayfadaki bütün labların kullandığı beş görüntüyü PNG olarak indirebilirsiniz. Böylece tarayıcıda kaydıraçla gördüğünüz sonucun aynısını Kaggle'da OpenCV ile üretebilir, iki çıktıyı yan yana koyabilirsiniz. Görüntüler bu sayfada üretiliyor; telif sorunu yok, derste serbestçe kullanın.

Manzara

Yumuşak gökyüzü geçişi, keskin dağ siluetleri, ince ağaç detayları. Bulanıklaştırma, keskinleştirme ve kenar bulma için.

Madeni paralar

Koyu zeminde sekiz parlak nesne; ikisi birbirine değiyor. Eşikleme, morfoloji ve kontur ile sayma için.

Şekiller

Kare, daire, üçgen, yıldız, delikli halka, ince köprü ve tuz-biber gürültüsü. Morfoloji ve şekil tanıma için.

Taranmış sayfa

Bir köşesi karanlık, diğeri aydınlık metin. Global eşiğin çöktüğünü ve uyarlamalı eşiklemenin işe yaradığını göstermek için.

Satranç tahtası

Düzgün kareler ve çapraz bir ışık geçişi. Piksel değerlerini okumak, kenar ve köşe bulmak için.

Lab çıktılarını da indirebilirsiniz. Bu sayfadaki her görüntünün sağ üst köşesinde küçük bir ⤓ düğmesi var. Filtre uyguladıktan sonra ona basarsanız o anki sonucu PNG olarak kaydeder — orijinali, eşiklenmiş hâlini, Canny çıktısını, bulunan nesnelerin çerçeveli hâlini, hatta çizdiğiniz rakamın öznitelik haritalarını. Ödev raporunuzdaki “önce / sonra” görsellerini böyle toplayabilirsiniz.

Lab içindeki tuvaller ekran boyutundadır (yaklaşık 300×225). Yüksek çözünürlüklü temiz kopyalar için yukarıdaki kartları kullanın.

İndirdiğiniz görüntüyü Kaggle'da kullanmak

Yukarıdaki düğmelerle beş PNG'yi bilgisayarınıza indirin.
Kaggle'da Datasets → New Dataset deyin, dosyaları sürükleyin, veri setine bir ad verin (örnek: hafta4-ornek-goruntuler) ve Create'e basın.
Notebook'unuzda sağ panelden Add Input → az önce oluşturduğunuz veri setini seçin.
Dosyalar /kaggle/input/hafta4-ornek-goruntuler/ altına gelir. Yolu sol panelden kopyalayın, elle yazmayın.
indirdiğiniz görüntüleri okumak
import os, cv2, numpy as np

KLASOR = "/kaggle/input/hafta4-ornek-goruntuler"
print(sorted(os.listdir(KLASOR)))
# ['hafta4-manzara.png', 'hafta4-paralar.png', 'hafta4-satranc.png',
#  'hafta4-sekiller.png', 'hafta4-yazi.png']

def oku(ad, gri_mi=False):
    yol = os.path.join(KLASOR, f"hafta4-{ad}.png")
    bayrak = cv2.IMREAD_GRAYSCALE if gri_mi else cv2.IMREAD_COLOR
    img = cv2.imread(yol, bayrak)
    if img is None:
        raise FileNotFoundError(yol)      # BU KONTROLU ASLA ATLAMAYIN
    return img

manzara  = oku("manzara")                 # BGR (3 kanal)
paralar2 = oku("paralar",  gri_mi=True)   # gri (tek kanal)
sayfa2   = oku("yazi",     gri_mi=True)
sekiller = oku("sekiller", gri_mi=True)
satranc  = oku("satranc",  gri_mi=True)

for ad, g in [("manzara", manzara), ("paralar", paralar2), ("yazi", sayfa2)]:
    print(f"{ad:10s} {str(g.shape):18s} {g.dtype}")

# Artik ders notundaki her adimi AYNI goruntuyle tekrarlayabilirsiniz:
_, ikili = cv2.threshold(paralar2, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
kenar    = cv2.Canny(cv2.GaussianBlur(satranc, (5, 5), 1.4), 40, 110)
uyar     = cv2.adaptiveThreshold(sayfa2, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                 cv2.THRESH_BINARY, 25, 7)

goster([cv2.cvtColor(manzara, cv2.COLOR_BGR2RGB), ikili, kenar, uyar],
       ["manzara (BGR2RGB ile)", "paralar: Otsu", "satranc: Canny", "yazi: uyarlamali"], satir=2)

# Urettiginiz sonucu kaydetmek (sonra Output sekmesinden indirilir):
cv2.imwrite("/kaggle/working/paralar-otsu.png", ikili)
Küçük bir ayrıntı: İndirdiğiniz PNG'ler renkli (3 kanal) kaydedilir — “Şekiller” ve “Taranmış sayfa” gözle siyah-beyaz görünse de dosya yine RGB'dir. Bu yüzden yukarıda IMREAD_GRAYSCALE ile okuyoruz; okuduktan sonra ayrıca cvtColor çağırmanız gerekmez. Renkli okuduysanız cv2.imread'in her zaman BGR döndürdüğünü unutmayın.

Notebook'u açın ve ilk hücreyi çalıştırın

kaggle.com → Code → New Notebook. Sonra bu hücreyi yazıp Shift + Enter'a basın.

hücre 1 — kurulum kontrolü
import cv2
import numpy as np
import matplotlib.pyplot as plt
from skimage import data

print("OpenCV surumu:", cv2.__version__)
print("NumPy  surumu:", np.__version__)
Çıktı
OpenCV surumu: 4.10.0
NumPy  surumu: 1.26.4
Sürüm numaraları sizde farklı olabilir, önemli değil. Önemli olan hata almamanız: bu dört satır çalıştıysa ortam hazır. 4.x ile başlayan bir OpenCV sürümü bu dersin tamamını çalıştırır.

Örnek görüntüleri yükleyin ve bir bakın

hücre 2 — dersin boyunca kullanacağımız görüntüler
astro   = data.astronaut()   # (512, 512, 3) renkli - icinde bir YUZ var
kamera  = data.camera()      # (512, 512)    gri    - klasik test goruntusu
paralar = data.coins()       # (303, 384)    gri    - 24 madeni para
sayfa   = data.page()        # (191, 384)    gri    - ISIK ESIT DEGIL
kedi    = data.chelsea()     # (300, 451, 3) renkli - bir kedi

for ad, g in [("astronaut", astro), ("camera", kamera), ("coins", paralar),
              ("page", sayfa), ("chelsea", kedi)]:
    print(f"{ad:10s} {str(g.shape):16s} {g.dtype}  min={g.min():3d} max={g.max():3d}")
Çıktı
astronaut  (512, 512, 3)   uint8  min=  0 max=255
camera     (512, 512)      uint8  min=  0 max=255
coins      (303, 384)      uint8  min=  1 max=252
page       (191, 384)      uint8  min= 20 max=227
chelsea    (300, 451, 3)   uint8  min=  0 max=255
Üç şeye dikkat edin.
• shape uzunluğu 2 ise gri, 3 ise renkli.
• dtype hep uint8: 0–255 arası tam sayı.
• page görüntüsünün en koyu değeri 20, en parlağı 227 — yani ne tam siyahı ne tam beyazı var. Bu, ışığın eşit olmadığının işareti. 7. bölümde bu görüntüyle global eşiklemenin neden çöktüğünü göreceğiz.

Önemli: skimage görüntüleri RGB sırasındadır, cv2.imread ise BGR döner. Karıştırmamak için bu derste kuralımız şu: skimage'den gelen renkli görüntüyü cv2'ye vermeden önce çeviriyoruz.
hücre 3 — kuralı tek fonksiyona bağlayalım
def goster(goruntuler, basliklar, satir=1, buyukluk=3.6, gri_mi=None):
    """Birden fazla goruntuyu yan yana cizer. Dersin geri kalaninda hep bunu kullanacagiz."""
    n = len(goruntuler)
    sutun = int(np.ceil(n / satir))
    plt.figure(figsize=(buyukluk * sutun, buyukluk * satir * 0.95))
    for i, (g, b) in enumerate(zip(goruntuler, basliklar), start=1):
        plt.subplot(satir, sutun, i)
        if g.ndim == 2:                      # gri
            plt.imshow(g, cmap="gray", vmin=0, vmax=255)
        else:                                # renkli: RGB bekliyoruz
            plt.imshow(g)
        plt.title(b, fontsize=10)
        plt.axis("off")
    plt.tight_layout()
    plt.show()

goster([astro, kedi], ["astronaut (RGB)", "chelsea (RGB)"])
goster([kamera, paralar, sayfa], ["camera", "coins", "page"])
Neden vmin=0, vmax=255 yazdık? Matplotlib gri görüntüyü çizerken varsayılan olarak kendi içindeki en küçük değeri siyah, en büyüğü beyaz kabul eder — yani görüntüyü farkında olmadan kontrastlar. Bu iki parametreyi vermezseniz, uyguladığınız filtrenin etkisini yanlış değerlendirirsiniz. Derste bu küçük ayrıntı yüzünden saatler kaybedildiğini göreceksiniz.

Kendi dosyanızı okumak: imread ve sessiz hata

hücre 4 — dosyadan okuma ve kaydetme
yol = "/kaggle/input/benim-veri-setim/resim.jpg"

img = cv2.imread(yol)              # BGR olarak okur
if img is None:
    raise FileNotFoundError(f"Okunamadi: {yol}")   # BU SATIRI ASLA ATLAMAYIN

gri = cv2.imread(yol, cv2.IMREAD_GRAYSCALE)        # dogrudan gri okumak

cv2.imwrite("/kaggle/working/cikti.png", img)      # kaydetmek calisir
# cv2.imshow("pencere", img)   # <- NOTEBOOK'TA CALISMAZ, cekirdegi kilitler!
cv2.imread hata vermez, None döner. Yolu yanlış yazarsanız program devam eder ve beş hücre sonra anlaşılmaz bir hata alırsınız. Her imread'den sonra if img is None kontrolünü yazmak, bu derste öğrenebileceğiniz en kârlı alışkanlıktır.

cv2.imshow bir masaüstü penceresi açmaya çalışır. Kaggle'da ekran yoktur; hücre sonsuza kadar çalışır ve Run → Restart kernel demek zorunda kalırsınız. Notebook'ta görüntü göstermenin yolu her zaman matplotlib.

Kaggle notebook ayarları — ders başında bir kez

AyarNeredenNe zaman gerekir?
InternetSağ panel → Settings → Internet OpenCV bölümü için gerekmez. Yalnızca 22. bölümdeki transfer öğrenme (hazır model ağırlıklarını indirir) için açın.
AcceleratorSağ panel → Settings → Accelerator → GPU T4 x2 CNN eğitirken açın: eğitim 10–20 kat hızlanır. OpenCV bölümünde gereksiz — açık bırakmak haftalık GPU kotanızı boşa harcar.
Add InputSağ üst → Add Input Kendi veri setinizi ya da bir yarışmayı eklemek için. CNN bölümünde Digit Recognizer ekleyeceğiz.
Save VersionSağ üst → Save Version → Save & Run All Ödev teslimi için zorunlu. Kodun baştan sona hatasız çalıştığının kanıtıdır.
05 · Temel işlemler

Kırp, boyutlandır, döndür, çevir

Bunlar görüntü işlemenin “topla–çıkar”ıdır. Hiçbiri akıllı değil, ama her projede ilk yaptığınız şeyler bunlar olacak — ve CNN eğitirken veri artırma adıyla yeniden karşımıza çıkacaklar.

hücre 5 — kırpma ve ilgi alanı (ROI)
# Kirpma ayri bir fonksiyon degil: sadece numpy dilimlemesi.
# Sira: [y_baslangic:y_bitis, x_baslangic:x_bitis]

yuz = astro[30:230, 150:350]        # astronaut'un yuz bolgesi
print(yuz.shape)                    # (200, 200, 3)

# DIKKAT: dilim bir KOPYA DEGIL, ayni bellege bakan bir penceredir.
yuz[:] = 0          # <- astro goruntusunu de karartir!
# Guvenli yol:
yuz = astro[30:230, 150:350].copy()

goster([astro, yuz], ["orijinal", "kirpilmis yuz (ROI)"])
ROI (Region of Interest) neden önemli? Bir fotoğrafın tamamını işlemek yerine ilgilendiğiniz küçük pencereyi işlemek hem çok daha hızlıdır hem de çok daha doğru sonuç verir. Plaka okuma sistemleri önce plakayı bulur, sonra sadece o 40×120 pikseli okur.
hücre 6 — yeniden boyutlandırma ve ara değer yöntemleri
h, w = kamera.shape

# DIKKAT: cv2.resize boyutu (GENISLIK, YUKSEKLIK) sirasinda ister.
# shape ise (yukseklik, genislik) verir. Ters! En sik yapilan hata burasi.
kucuk = cv2.resize(kamera, (w // 4, h // 4), interpolation=cv2.INTER_AREA)
print(kamera.shape, "->", kucuk.shape)   # (512, 512) -> (128, 128)

# Oran vererek (daha guvenli yazim):
yarim = cv2.resize(kamera, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_AREA)

# Kucuk goruntuyu geri buyutmek: yontem secimi ONEMLI
geri_komsu = cv2.resize(kucuk, (w, h), interpolation=cv2.INTER_NEAREST)
geri_dogru = cv2.resize(kucuk, (w, h), interpolation=cv2.INTER_LINEAR)
geri_kubik = cv2.resize(kucuk, (w, h), interpolation=cv2.INTER_CUBIC)

goster([kamera, geri_komsu, geri_dogru, geri_kubik],
       ["orijinal", "NEAREST (kareli)", "LINEAR (yumusak)", "CUBIC (en keskin)"],
       satir=1)
Hangi yöntemi seçeceğiz? İki kural yeter:
• Küçültürken INTER_AREA. Komşu pikselleri ortalar, detayı en az bozar.
• Büyütürken INTER_CUBIC (kaliteli) ya da INTER_LINEAR (hızlı).

INTER_NEAREST'ı sadece maske ve etiket görüntülerinde kullanın: orada 3 ile 4 arasında ara değer üretmek anlamsızdır, çünkü sayılar “sınıf no”sudur, parlaklık değil.
hücre 7 — çevirme ve döndürme
# Cevirme (flip) - bedava ve kayipsiz
yatay  = cv2.flip(kamera, 1)    # 1: saga-sola  (aynadaki goruntu)
dikey  = cv2.flip(kamera, 0)    # 0: yukari-asagi
ikisi  = cv2.flip(kamera, -1)   # -1: ikisi birden (= 180 derece dondurme)

# 90'in katlari - hizli ve kayipsiz
sag90 = cv2.rotate(kamera, cv2.ROTATE_90_CLOCKWISE)
ters  = cv2.rotate(kamera, cv2.ROTATE_180)

# Serbest aci - donusum matrisi gerekir
merkez = (w // 2, h // 2)
M = cv2.getRotationMatrix2D(merkez, angle=23, scale=1.0)   # +23 derece, saat yonunun TERSI
donuk = cv2.warpAffine(kamera, M, (w, h), borderValue=0)   # bos koseler siyah

# Oteleme (shift): 40 piksel saga, 15 piksel asagi
T = np.float32([[1, 0, 40],
                [0, 1, 15]])
otelenmis = cv2.warpAffine(kamera, T, (w, h))

goster([kamera, yatay, sag90, donuk, otelenmis],
       ["orijinal", "flip(1)", "rotate 90", "warpAffine 23 derece", "oteleme (40, 15)"])
Bu dört satırı iyi öğrenin, 21. bölümde geri gelecekler.
CNN eğitirken elimizdeki görüntü sayısını yapay olarak çoğaltmak için tam olarak bunları kullanacağız: hafif döndür, biraz kaydır, yakınlaştır. Buna veri artırma deniyor ve CNN'in ezberlemesini engellemenin en etkili yollarından biri.

Ama bir uyarı: yatay çevirme her problemde uygun değildir. Kedi fotoğrafını aynalayınca hâlâ kedidir — sorun yok. Ama “7” rakamını aynalayınca artık 7 değildir, ve “b” harfi “d”ye benzer. Hangi dönüşümün serbest olduğuna problemin kendisi karar verir.

Çizim: sonucu görüntünün üstüne yazmak

Bulduğunuz şeyi göstermeden rapor edemezsiniz. OpenCV'nin çizim fonksiyonları görüntüyü yerinde değiştirir (kopya üzerinde çalışın).

hücre 8 — çizgi, dikdörtgen, daire, yazı
tuval = cv2.cvtColor(kamera, cv2.COLOR_GRAY2BGR)   # gri -> 3 kanal, ustune RENKLI cizebilelim

cv2.line(tuval, (20, 20), (480, 90), (0, 0, 255), 2)             # kirmizi cizgi (BGR!)
cv2.rectangle(tuval, (150, 120), (330, 300), (0, 255, 0), 3)     # yesil cerceve
cv2.rectangle(tuval, (360, 360), (470, 470), (255, 200, 0), -1)  # -1 = ICINI DOLDUR
cv2.circle(tuval, (256, 256), 60, (0, 255, 255), 2)              # sari daire
cv2.putText(tuval, "kamera", (24, 500), cv2.FONT_HERSHEY_SIMPLEX,
            1.0, (255, 255, 255), 2, cv2.LINE_AA)

goster([cv2.cvtColor(tuval, cv2.COLOR_BGR2RGB)], ["uzerine cizim"], buyukluk=5)
cv2.rectangle(img, (x1,y1), (x2,y2), renk, kalinlik)

Köşeler (x, y) sırasında — dilimlemenin tersi. kalinlik=-1 içini doldurur.

cv2.putText(..., FONT_HERSHEY_SIMPLEX, ...)

Türkçe karakter basmaz (ş, ğ, ı yerine kutu çıkar). Yazıyı ASCII tutun ya da Pillow kullanın.

renk = (B, G, R)

Kırmızı (0,0,255), mavi (255,0,0). Yeşil her iki sırada da (0,255,0) — bu yüzden herkesin çerçeveleri yeşil.

cv2.LINE_AA

Kenar yumuşatma. Ekran görüntüsü alıp rapora koyacaksanız ekleyin, çok daha temiz görünür.

06 · Histogram

Parlaklık, kontrast ve histogram

Histogram, görüntüde hangi parlaklık değerinin kaç kez geçtiğini gösteren çubuk grafiktir. Görüntüye bakmadan histogramına bakmak, çoğu zaman problemi daha hızlı anlatır.

Sola yığılmış

Görüntü karanlık. Gölgedeki detay kaybolmuş olabilir.

Sağa yığılmış

Görüntü yanmış. 255'e dayanan pikseller geri gelmez.

Ortada sıkışmış

Kontrast düşük, her şey gri. Eşikleme burada çok zorlanır.

Lab 3Parlaklık ve kontrast — histogram ne anlatıyor?

α (alfa) kontrastı çarpar, β (beta) parlaklığı ekler. Formül tek satır: yeni = α · eski + β. Kaydıraçları oynatırken alttaki histogramın nasıl gerildiğine ve kenarlara nasıl yığıldığına bakın.

Görüntü
Orijinal
0 · siyah128255 · beyaz
İşlenmiş
0 · siyah128255 · beyaz
OpenCV karşılığı
hücre 9 — histogram çizmek ve kontrastı düzeltmek
# --- 1) Histogrami cizmek ---
hist = cv2.calcHist([sayfa], [0], None, [256], [0, 256])
plt.figure(figsize=(7, 2.6))
plt.plot(hist, color="#275d8c")
plt.fill_between(range(256), hist.ravel(), color="#275d8c", alpha=.18)
plt.title("page goruntusunun histogrami"); plt.xlabel("parlaklik"); plt.ylabel("piksel sayisi")
plt.xlim(0, 255); plt.show()

# --- 2) Parlaklik ve kontrast: yeni = alpha*eski + beta ---
daha_parlak  = cv2.convertScaleAbs(sayfa, alpha=1.0, beta=45)
daha_kontrast = cv2.convertScaleAbs(sayfa, alpha=1.8, beta=-60)

# NEDEN convertScaleAbs?  Cunku tasmayi kendisi halleder.
# Elle yapsaniz:  sayfa + 45  ->  210 + 45 = 255 degil 255'i gecip BASA DONER (uint8!)
guvenli   = cv2.add(sayfa, 45)        # 255'te durur  (DOGRU)
tehlikeli = sayfa + 45                # 256'da sifira doner (YANLIS)

# --- 3) Histogram esitleme: kontrasti otomatik acar ---
esit = cv2.equalizeHist(sayfa)

# --- 4) CLAHE: esitlemeyi KUCUK BOLGELERDE yapar, daha dogal durur ---
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
yerel = clahe.apply(sayfa)

goster([sayfa, daha_parlak, daha_kontrast, esit, yerel],
       ["orijinal", "beta=+45", "alpha=1.8", "equalizeHist", "CLAHE"], satir=1)
equalizeHist ile CLAHE farkı. equalizeHist görüntünün tamamına tek bir düzeltme uygular; ışık eşit değilse bir bölgeyi düzeltirken diğerini bozar ve gürültüyü abartır. CLAHE görüntüyü 8×8 karelere böler, her kareyi ayrı ayrı düzeltir. Tıbbi görüntüleme ve taranmış belgelerde neredeyse her zaman CLAHE tercih edilir.
07 · Eşikleme

Eşikleme: gri görüntüyü siyah-beyaza indirmek

Eşikleme tek bir kuraldır: “şu sayıdan büyükse beyaz, değilse siyah.” Basitliğine aldanmayın — nesne saymanın, belge taramanın ve maske üretmenin tamamı buradan başlar.

Üç eşikleme yöntemi, tek bakışta
1 · Elle eşik Sayıyı sen verirsin: 127 ✓ En hızlı, en öngörülebilir ✓ Işık hep aynıysa mükemmel ✗ Işık değişirse hemen bozulur ✗ Her görüntüye elle ayar 2 · Otsu Eşiği histogramdan kendi bulur ✓ Elle ayar yok ✓ İki tepeli histogramda şahane ✗ Tek tepeli histogramda şaşırır ✗ Hâlâ TEK eşik: eşitsiz ışığa çare değil 3 · Uyarlamalı Her piksele kendi eşiği ✓ Eşitsiz ışığın TEK çözümü ✓ Taranmış belgede standart ✗ Yavaş, iki parametre ayarı ister ✗ Düz alanlarda gürültü üretir
Lab 4Eşikleme tezgâhı — global eşiğin çöktüğü yeri görün

Önce şunu yapın: görüntü Taranmış sayfa seçili hâlde eşik kaydıracını baştan sona gezdirin. Hangi değeri verirseniz verin, sayfanın ya sol üstü ya sağ altı okunmaz hâle geliyor. Sonra Uyarlamalı düğmesine basın.

Görüntü
Gri görüntü
Eşiklenmiş (ikili)
0Yeşil = beyaz kalacak pikseller255
OpenCV karşılığı
hücre 10 — üç yöntem yan yana
# Not: THRESH_OTSU kullanirken esik degerine 0 yazilir;
# OpenCV onu gormezden gelip esigi kendisi bulur ve DONUS DEGERINDE soyler.

elle_t = 127
_,   elle  = cv2.threshold(sayfa, elle_t, 255, cv2.THRESH_BINARY)
ot_t, otsu = cv2.threshold(sayfa, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
print("Otsu'nun buldugu esik:", ot_t)      # orn. 126.0

uyarlamali = cv2.adaptiveThreshold(
    sayfa, 255,
    cv2.ADAPTIVE_THRESH_GAUSSIAN_C,   # komsulugun agirlikli ortalamasi
    cv2.THRESH_BINARY,
    blockSize=25,                     # TEK SAYI olmak ZORUNDA
    C=7                               # ortalamadan cikarilacak sabit
)

goster([sayfa, elle, otsu, uyarlamali],
       ["orijinal (isik esitsiz)", f"elle: {elle_t}", f"Otsu: {ot_t:.0f}", "adaptiveThreshold"], satir=1)
Çıktı
Otsu'nun buldugu esik: 126.0
Uyarlamalı eşiklemenin iki parametresi ne yapar?
• blockSize — her piksel kendi etrafındaki bu boyuttaki kareye bakar. Küçük olursa harf gövdelerinin içi de beyaz görünür (yazı içi boşalır); çok büyük olursa global eşiğe geri dönersiniz. Metin için harf yüksekliğinin 1,5–2 katı iyi bir başlangıç.
• C — ortalamadan çıkarılan sabit. Büyütmek sonucu temizler (daha az beyaz), küçültmek daha fazla detay ama daha fazla gürültü getirir.

Önemli: blockSize tek sayı olmalıdır. Çift verirseniz OpenCV hata atar — kaydıracı oynatırken tek sayıya yuvarlıyoruz, kodda bunu siz yapacaksınız.
Hangi yöntemi seçeceğim? Karar ağacı şu:
1. Işık sahnede her yerde aynı mı? Evet → Otsu. Bitti.
2. Işık eşitsiz mi (gölge, flaş, eğik tarama)? Evet → adaptiveThreshold.
3. Nesne renkli ve zeminden rengiyle ayrılıyor mu? → eşikleme değil, HSV + inRange (13. bölüm).
4. Hiçbiri olmuyor mu? → Problem eşikleme problemi değil. CNN'e gidin.
08 · Evrişim

Evrişim: bütün filtrelerin tek formülü

Bu bölüm haftanın kalbi. Bulanıklaştırma, keskinleştirme, kenar bulma, kabartma — hepsi aynı işlemdir. Değişen tek şey, 3×3'lük küçük bir sayı tablosu: çekirdek (kernel).

Evrişim tek adımda: çarp, topla, yaz
GÖRÜNTÜ 106090 207095 156592 mavi kare = o anki 3×3 pencere × ÇEKİRDEK −10+1 −10+1 −10+1 dikey kenar bulucu = (10·−1) + (60·0) + (90·+1) (20·−1) + (70·0) + (95·+1) (15·−1) + (65·0) + (92·+1) = −45 + 277 = 232 yeni piksel = 232 (güçlü kenar!) Bu hesap, görüntünün HER pikseli için tekrarlanır.
Solu koyu, sağı parlak olan bir bölgede sonuç büyük çıktı. Sol ve sağ aynı olsaydı sonuç 0 olurdu — kenar bulucunun çalışma mantığı tam olarak bu.
Lab 5Çekirdek tezgâhı — dokuz sayıyı değiştir, filtreyi kendin icat et

Aşağıdaki dokuz kutuya istediğiniz sayıyı yazabilirsiniz. Sağdaki görüntü anında değişir. Sol görüntüye tıklayarak seçtiğiniz pikselin hesabını satır satır görün.

Görüntü
Girdibir piksele tıklayın
filter2D sonucu
OpenCV karşılığı

Bu dokuz sayı neden böyle? Çekirdek okuma rehberi

ÇekirdekToplamıNe yapar ve neden
Birim
0 0 0 / 0 1 0 / 0 0 0
1 Pikseli kendisiyle çarpar, komşuları hiç katmaz. Hiçbir şey değişmez — kontrol deneyi.
Ortalama
1 1 1 / 1 1 1 / 1 1 1
9 Dokuz komşunun toplamı. 9'a bölmeden kullanırsanız görüntü bembeyaz yanar; bölünce bulanıklaştırma olur. “Toplama böl” kutusunu işaretleyip kapatarak farkı görün.
Keskinleştir
0 −1 0 / −1 5 −1 / 0 −1 0
1 Merkezi 5 ile büyütür, komşuları çıkarır: farkı abartır. Toplam 1 olduğu için genel parlaklık korunur. Fazla kullanırsanız gürültüyü de keskinleştirir.
Sobel X
−1 0 1 / −2 0 2 / −1 0 1
0 Sol sütunu sağ sütundan çıkarır → dikey kenarları bulur. Orta satır 2 katsayılı, çünkü merkeze yakın komşu daha güvenilir. Toplam 0: düz alanlar siyah çıkar.
Laplacian
0 1 0 / 1 −4 1 / 0 1 0
0 Yönü yok: her yöndeki ani değişimi yakalar. Tek geçişte bütün kenarları verir ama gürültüye Sobel'den çok daha duyarlıdır — önce bulanıklaştırmak şart.
Kabartma
−2 −1 0 / −1 1 1 / 0 1 2
0 Çapraz bir fark alır, sonuca +128 eklenir → yüzeyin kabarmış gibi görünmesi. Teknik faydası az, ama “çekirdek değiştirince ne oluyor” sezgisi için öğretici.
Çekirdeğin toplamına bakarak ne olacağını tahmin edebilirsiniz:
• Toplam = 1 → parlaklık korunur. Bulanıklaştırma, keskinleştirme buradadır.
• Toplam = 0 → düz alanlar siyaha iner, yalnızca değişimin olduğu yerler kalır. Bütün kenar bulucular buradadır.
• Toplam > 1 → görüntü parlar. Toplam < 0 → görüntü hem kararır hem negatife döner.

Bu tek kural, bir makalede gördüğünüz çekirdeğin ne işe yaradığını denemeden anlamanızı sağlar.
hücre 11 — filter2D ile kendi filtrelerinizi uygulamak
cekirdekler = {
    "birim":      np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]], np.float32),
    "ortalama":   np.ones((3, 3), np.float32) / 9,          # 9'a BOLDUK
    "gauss":      np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]], np.float32) / 16,
    "keskin":     np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], np.float32),
    "sobel_x":    np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], np.float32),
    "laplacian":  np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], np.float32),
    "kabartma":   np.array([[-2, -1, 0], [-1, 1, 1], [0, 1, 2]], np.float32),
}

sonuclar, adlar = [kamera], ["orijinal"]
for ad, cek in cekirdekler.items():
    # ddepth=-1  ->  cikti girdiyle ayni tipte (uint8) olsun
    sonuclar.append(cv2.filter2D(kamera, -1, cek))
    adlar.append(f"{ad}  (toplam={cek.sum():.0f})")

goster(sonuclar, adlar, satir=2)

# Buyuk cekirdek daha cok bulaniklastirir: 3x3 yerine 15x15 deneyin
cok_bulanik = cv2.filter2D(kamera, -1, np.ones((15, 15), np.float32) / 225)
goster([kamera, cv2.filter2D(kamera, -1, cekirdekler["ortalama"]), cok_bulanik],
       ["orijinal", "3x3 ortalama", "15x15 ortalama"])
ddepth=-1 tuzağı. filter2D(gri, -1, sobel_x) yazarsanız çıktı uint8 olur ve bütün eksi değerler sıfıra kırpılır — yani kenarların yarısını (karanlıktan aydınlığa geçenleri) kaybedersiniz. Kenar bulurken doğru yazım:
kenar = cv2.filter2D(gri, cv2.CV_32F, sobel_x) → sonra cv2.convertScaleAbs(kenar) ile mutlak değerini alıp görüntüye çevirin. cv2.Sobel fonksiyonu bunu zaten doğru yapar; bir sonraki bölümde onu kullanacağız.
09 · Gürültü

Gürültü ve dört bulanıklaştırma yöntemi

Gerçek fotoğraflar temiz değildir: sensör gürültüsü, sıkıştırma izi, toz. Kenar bulmadan önce bulanıklaştırmak bir kayıp değil, zorunluluktur — çünkü kenar bulucular “ani değişim” arar ve gürültü de ani bir değişimdir.

Tür 1

Gauss gürültüsü

Her piksele küçük, rastgele bir sapma eklenir. Düşük ışıkta çekilen fotoğrafların tanesi budur. Görüntünün tamamına yayılmıştır.

Tür 2

Tuz-biber gürültüsü

Tek tük piksel tamamen siyah ya da beyaz olur. Bozuk sensör, aktarım hatası, kötü tarama. Az sayıda ama çok uç değer.

Lab 6Hangi gürültüye hangi filtre? Sayıyla karar verin

Sağdaki tabloda her filtrenin orijinale uzaklığı yazıyor (küçük olan iyi). Tuz-biber ile Gauss arasında geçiş yapın — kazanan filtrenin değiştiğini göreceksiniz. Bu, “en iyi filtre” diye bir şey olmadığının kanıtı.

Görüntü
Gürültülü girdi
cv2.blurkutu / ortalama
cv2.GaussianBlurağırlıklı ortalama
cv2.medianBlurortanca
cv2.bilateralFilterkenarı korur
FiltreNasıl çalışırNe zaman kullanılırHız
blur (kutu)Komşuların düz ortalaması. Kaba ve hızlı yumuşatma. Kenarları en çok bozan yöntem.Çok hızlı
GaussianBlurMerkeze yakın komşu daha ağır sayılır. Varsayılan seçiminiz bu olsun. Kenar bulmadan önceki standart adım.Hızlı
medianBlurKomşuların ortancası. Ortalama değil! Tuz-biber gürültüsünün ilacı. Tek bir uç değer ortancayı hiç etkilemez.Orta
bilateralFilterHem uzaklığa hem de parlaklık farkına bakar; farklı olana ağırlık vermez. Kenarı korumak gerektiğinde: portre pürüzsüzleştirme, gürültü azaltma.Yavaş
Ortalama ile ortanca arasındaki fark, 2. haftanın dersiydi.
Hatırlayın: bir sütunda tek bir 9.000.000 TL'lik aykırı değer ortalamayı uçuruyor ama ortancaya dokunmuyordu. Tuz-biber gürültüsü tam olarak aynı şey — sadece tabloda değil, görüntüde. Dokuz komşudan biri 255'e sıçradığında ortalama belirgin şekilde kayar; ortanca ise sıralamanın ortasındaki sayıyı aldığı için o uç değeri hiç hesaba katmaz.

Aynı istatistik, farklı veri tipi. Dönem boyunca bunu çok göreceksiniz.
hücre 12 — gürültü ekleyip dört filtreyi karşılaştırmak
rng = np.random.default_rng(42)          # tohum: herkeste ayni sonuc

# --- Gauss gurultusu ---
gurultulu = np.clip(kamera.astype(np.int16) + rng.normal(0, 18, kamera.shape), 0, 255).astype(np.uint8)

# --- Tuz-biber gurultusu ---
tuzbiber = kamera.copy()
maske = rng.random(kamera.shape)
tuzbiber[maske < 0.04] = 0        # biber (siyah)
tuzbiber[maske > 0.96] = 255      # tuz   (beyaz)

def dort_filtre(g):
    return [
        cv2.blur(g, (5, 5)),                       # kutu
        cv2.GaussianBlur(g, (5, 5), 0),            # 0 -> sigma'yi ksize'dan hesapla
        cv2.medianBlur(g, 5),                      # ksize TEK SAYI olmali
        cv2.bilateralFilter(g, 9, 75, 75),         # (cap, renk_sigma, uzay_sigma)
    ]

adlar = ["blur", "GaussianBlur", "medianBlur", "bilateralFilter"]

goster([tuzbiber] + dort_filtre(tuzbiber), ["TUZ-BIBER"] + adlar, satir=1)
goster([gurultulu] + dort_filtre(gurultulu), ["GAUSS"] + adlar, satir=1)

# --- Sayiyla olcelim: orijinale uzaklik (kucuk = iyi) ---
def uzaklik(a, b):
    return np.sqrt(np.mean((a.astype(np.float64) - b.astype(np.float64)) ** 2))

for ad, veri in [("tuz-biber", tuzbiber), ("gauss", gurultulu)]:
    print(f"\n--- {ad} ---")
    print(f"{'gurultulu hali':18s} {uzaklik(veri, kamera):6.2f}")
    for a, s in zip(adlar, dort_filtre(veri)):
        print(f"{a:18s} {uzaklik(s, kamera):6.2f}")
Çıktı (sizde son haneler biraz farklı olabilir)
--- tuz-biber ---
gurultulu hali      36.41
blur                 9.78
GaussianBlur        10.42
medianBlur           5.13   <- KAZANAN
bilateralFilter     22.60

--- gauss ---
gurultulu hali      18.03
blur                 8.94
GaussianBlur         8.21   <- KAZANAN
medianBlur           9.06
bilateralFilter      9.95
Niçin bilateral tuz-biberde kaybediyor? Çünkü bilateral filtre “parlaklığı benden çok farklı olan komşuyu hesaba katmam” der — kenarı korumak için. Ama tuz-biber gürültüsündeki o beyaz nokta da komşularından çok farklıdır, yani filtre onu korunması gereken bir kenar sanar ve olduğu gibi bırakır.

Ders: bir filtrenin gücü, aynı anda zayıflığıdır. Hangi filtreyi seçeceğinizi filtrenin adı değil, gürültünün türü belirler.
10 · Kenar

Kenar bulma: Sobel, Laplacian ve Canny

Kenar, parlaklığın ani değiştiği yerdir. Matematikte buna türev deniyor. Aşağıdaki lab'da bir satır boyunca parlaklığı ve değişim hızını aynı grafikte göreceksiniz — kenarın ne olduğu o grafikte tek bakışta anlaşılıyor.

Lab 7Kenar laboratuvarı — altı sonuç ve bir kesit grafiği

Sol üstteki görüntüye tıklayın: turuncu çizgi o satıra gider ve alttaki grafik o satırın parlaklık profilini çizer. Mavi eğri ani düştüğü/çıktığı yerde kırmızı eğri tepe yapıyor. Kenar bulma işte o tepeleri bulmaktır.

Görüntü
Gri girdibir satıra tıklayın
Sobel X|dx| → dikey kenarlar
Sobel Y|dy| → yatay kenarlar
Gradyan büyüklüğü√(dx²+dy²)
Laplacianyönsüz, tek geçiş
Cannyince, bağlı, ikili
OpenCV karşılığı

Üçünün farkı nedir?

SobelLaplacianCanny
Ne verir?Yönlü türev (x ve y ayrı)Yönsüz ikinci türevİkili (0/255) ince kenar haritası
Çıktı tipiGri tonlu, 0–255 arasıGri tonluSadece 0 veya 255
KalınlıkKalın, bulanık bantlarKalın, çift çizgiliTek piksel kalınlığında
GürültüOrta duyarlıÇok duyarlıEn dayanıklı (içinde bulanıklaştırma var)
Parametreksizeksizeİki eşik (alt, üst)
Ne zaman?Yön bilgisi gerekiyorsa (çizgi açısı, HOG öznitelikleri) Hızlı odak/bulanıklık ölçümü (varyansına bakılır) Çoğu zaman istediğiniz budur. Kontur, şekil, hat tespiti.
Canny'nin dört adımı — neden bu kadar iyi çalışıyor?
1 · Bulanıklaştır. Gauss ile gürültü sustururulur, yoksa gürültü kenar sanılır.
2 · Türev al. Sobel ile her pikselin değişim büyüklüğü ve yönü bulunur.
3 · Tepeyi incelt (non-maximum suppression). Bir kenar bandında yalnızca en tepedeki piksel kalır, yanları silinir. Canny'nin tek piksellik ince çizgiler vermesinin sebebi bu adımdır.
4 · İki eşik ve bağlama (hysteresis). üst eşiği geçen piksel “kesin kenar”. alt ile üst arasındaki piksel ise yalnızca kesin bir kenara temas ediyorsa kenar sayılır. Böylece gerçek kenarlar kopmadan uzar, yalıtılmış gürültü lekeleri ise elenir.
hücre 13 — kenar bulmanın tam reçetesi
# --- 1) ONCE BULANIKLASTIR. Bu adimi atlamak en sik hata. ---
bulanik = cv2.GaussianBlur(kamera, (5, 5), 1.4)

# --- 2) Sobel: CV_64F sart, yoksa eksi turevler kirpilir ---
gx = cv2.Sobel(bulanik, cv2.CV_64F, 1, 0, ksize=3)    # dx=1, dy=0 -> dikey kenarlar
gy = cv2.Sobel(bulanik, cv2.CV_64F, 0, 1, ksize=3)    # dx=0, dy=1 -> yatay kenarlar

sobel_x = cv2.convertScaleAbs(gx)     # mutlak deger al + uint8'e cevir
sobel_y = cv2.convertScaleAbs(gy)

buyukluk = cv2.magnitude(gx, gy)                        # sqrt(gx^2 + gy^2)
aci      = cv2.phase(gx, gy, angleInDegrees=True)       # kenarin YONU (0-360)
buyukluk = cv2.normalize(buyukluk, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)

# --- 3) Laplacian: yonsuz, tek geciste tum kenarlar ---
lap = cv2.convertScaleAbs(cv2.Laplacian(bulanik, cv2.CV_64F, ksize=3))

# --- 4) Canny: en kullanisli olan ---
kenar = cv2.Canny(bulanik, 40, 110)      # (alt_esik, ust_esik)

goster([kamera, sobel_x, sobel_y, buyukluk, lap, kenar],
       ["orijinal", "Sobel X", "Sobel Y", "buyukluk", "Laplacian", "Canny(40,110)"], satir=2)

# --- Esikleri nasil secerim? Otsu'ya sorun: iyi bir baslangic noktasi verir ---
ot, _ = cv2.threshold(bulanik, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
oto = cv2.Canny(bulanik, int(ot * 0.5), int(ot))
print(f"Otsu: {ot:.0f}  ->  Canny({ot*0.5:.0f}, {ot:.0f})")

# --- Esik taramasi: hangi ikili iyi, GOZLE karar verin ---
denemeler, adlar2 = [], []
for alt, ust in [(10, 40), (40, 110), (80, 180), (150, 250)]:
    denemeler.append(cv2.Canny(bulanik, alt, ust))
    adlar2.append(f"Canny({alt}, {ust})")
goster(denemeler, adlar2, satir=1)
Canny eşiklerini seçmenin pratik kuralı. Üst eşiği alt eşiğin 2–3 katı yapın (OpenCV belgesi de bunu önerir). Başlangıç için Canny(gri, 50, 150) deneyin, sonra:
• Sonuç çok dağınıksa (her yer çizgi) → ikisini birlikte yükseltin.
• Kenarlar kopuk kopuksa → alt eşiği düşürün (bağlama adımı daha çok piksel toplar).
• Her görüntüde elle ayar yapmak istemiyorsanız yukarıdaki Otsu'dan türetme hilesini kullanın.
11 · Morfoloji

Morfoloji: ikili görüntüyü temizlemek

Eşikledikten sonra sonuç asla tertemiz değildir: tek piksellik lekeler, şeklin içinde küçük delikler, birbirine değmesi gereken kopuk çizgiler. Morfoloji bu dört sorunun ilacıdır ve nesne saymayı mümkün kılan adımdır.

Erozyon

Beyazı tıraşlar. Nesne küçülür, ince çıkıntılar ve tek piksellik lekeler silinir.

Genişletme

Beyazı şişirir. Nesne büyür, delikler kapanır, kopuk parçalar birleşir.

Açma

Erozyon sonra genişletme. Küçük beyaz lekeleri siler, büyük şekli aynı boyutta bırakır.

Kapama

Genişletme sonra erozyon. Küçük siyah delikleri doldurur, boyutu korur.

Açma ve kapamanın püf noktası sıralamadır. Erozyon tek başına nesneyi küçültür; ama erozyondan sonra aynı miktarda genişletirseniz, hayatta kalan nesneler eski boyutlarına döner — erozyonda tamamen yok olan küçük lekeler ise geri gelmez. “Küçükleri sil, büyükleri koru” işte böyle yapılır.

Hatırlama yolu: Açma = beyazı azaltır (beyaz lekeleri siler). Kapama = siyahı kapatır (siyah delikleri doldurur).
Lab 8Morfoloji tezgâhı — gürültülü şekilleri temizleyin

Sol görüntü, Şekiller sahnesinin Otsu ile eşiklenmiş hâli — içinde bilerek tuz-biber gürültüsü var. Açma'ya basıp yarıçapı 1'den 3'e çıkarın: lekeler gidiyor. Sonra Kapama'ya geçin: iki kareyi birleştiren o ince köprü ile halkanın ortasındaki deliğe ne olduğuna bakın. Sağdaki “ayrı beyaz parça” sayısı, sayma işinin neden morfolojiye bağlı olduğunu gösteriyor.

Görüntü
Eşiklenmiş (gürültülü)
Morfoloji sonrası
OpenCV karşılığı
hücre 14 — morfolojinin beş işlemi
# 1) Once ikili goruntu uretelim (paralar koyu zeminde parlak)
_, ikili = cv2.threshold(paralar, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

# 2) Cekirdek (yapisal eleman) sec. Sekil ONEMLI:
#    MORPH_RECT    -> kare, koseleri korur, hizli
#    MORPH_ELLIPSE -> daire, yuvarlak nesneler icin DOGAL sonuc  <- genelde bunu secin
#    MORPH_CROSS   -> arti, cizgi ve iskelet islerinde
cek = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))

erozyon   = cv2.erode(ikili, cek, iterations=1)
genislet  = cv2.dilate(ikili, cek, iterations=1)
acma      = cv2.morphologyEx(ikili, cv2.MORPH_OPEN,     cek)
kapama    = cv2.morphologyEx(ikili, cv2.MORPH_CLOSE,    cek)
gradyan   = cv2.morphologyEx(ikili, cv2.MORPH_GRADIENT, cek)   # sadece sinir cizgisi
tophat    = cv2.morphologyEx(paralar, cv2.MORPH_TOPHAT, cek)   # KUCUK PARLAK detaylar
blackhat  = cv2.morphologyEx(paralar, cv2.MORPH_BLACKHAT, cek) # KUCUK KOYU detaylar

goster([ikili, erozyon, genislet, acma, kapama, gradyan],
       ["esiklenmis", "erode", "dilate", "OPEN", "CLOSE", "GRADIENT"], satir=2)

# 3) Pratikte en cok kullanilan sira: once ACMA (lekeleri sil), sonra KAPAMA (delikleri doldur)
temiz = cv2.morphologyEx(ikili,  cv2.MORPH_OPEN,  cek)
temiz = cv2.morphologyEx(temiz,  cv2.MORPH_CLOSE, cek)
goster([ikili, temiz], ["ham esikleme", "acma + kapama"])
Çekirdek boyutunu nasıl seçeceğim? Tek kural: silmek istediğiniz gürültüden büyük, korumak istediğiniz nesneden küçük. Lekeler 2–3 piksellik, nesneler 40 piksellikse (5,5) idealdir. (21,21) yaparsanız nesnelerin kendisi de bozulur. Emin değilseniz küçükten başlayıp büyütün ve her adımda sonuca bakın — morfoloji göz kararı ayarlanan bir iştir.
12 · Kontur

Kontur bulma ve nesne sayma

Buraya kadar öğrendiğimiz her şey bu bölüm için hazırlıktı. Kontur, bir beyaz bölgenin sınır çizgisidir. Konturları bulduğunuz anda sorabileceğiniz sorular değişir: kaç nesne var? her biri ne kadar büyük? nerede duruyor? hangi şekilde?

Nesne sayma hattı — altı adımın hiçbiri atlanamaz
1 · Gri
cvtColor
→
2 · Bulanıklaştır
GaussianBlur
→
3 · Eşikle
threshold + OTSU
→
4 · Temizle
OPEN + CLOSE
→
5 · Kontur bul
findContours
→
6 · Alana göre süz
contourArea
6. adım en çok atlanan adımdır. Süzmezseniz 3 piksellik bir leke de bir “nesne” olarak sayılır ve sonuç saçmalar.
Lab 9Nesne sayma — klasik görüntü işlemenin zirvesi ve sınırı

Dört aşamayı birlikte görüyorsunuz. Madeni paralar sahnesinde 8 para var — program kaç buluyor? En küçük alan kaydıracını 10'a indirin (gürültü de nesne sayılır), sonra 300'e çıkarın (küçük paralar kaybolur). Doğru sayıya ulaşan tek bir ayar aralığı var ve onu bulmak elle yapılan bir iştir — bu, klasik yöntemin hem gücü hem zayıflığı.

Görüntü
1 · Orijinal
2 · Otsu ile eşiklenmiş
3 · Açma + kapama ile temizlenmiş
4 · Bulunan nesnelernumaralı yeşil çerçeveler
OpenCV karşılığı
hücre 15 — para sayma, baştan sona
# skimage'in coins goruntusunde 24 para var. Hepsini bulabilecek miyiz?
gri = paralar.copy()

# 1-2) Bulaniklastir
bulanik = cv2.GaussianBlur(gri, (5, 5), 1.2)

# 3) Esikle. Paralar zeminden PARLAK oldugu icin duz BINARY kullaniyoruz.
esik, ikili = cv2.threshold(bulanik, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
print("Otsu esigi:", esik)

# 4) Temizle
cek   = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
temiz = cv2.morphologyEx(ikili, cv2.MORPH_OPEN,  cek, iterations=2)
temiz = cv2.morphologyEx(temiz, cv2.MORPH_CLOSE, cek, iterations=2)

# 5) Konturlari bul
#    RETR_EXTERNAL   -> sadece EN DIS sinirlar (ic delikleri yok say)
#    RETR_TREE       -> hiyerarsi ile birlikte (delikler de gelir)
#    CHAIN_APPROX_SIMPLE -> duz kenarlarin sadece kose noktalarini sakla (hafiza tasarrufu)
konturlar, hiyerarsi = cv2.findContours(temiz, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
print("Ham kontur sayisi:", len(konturlar))

# 6) ALANA GORE SUZ. Bu adimi atlamayin!
EN_AZ_ALAN = 150
gercek = [k for k in konturlar if cv2.contourArea(k) > EN_AZ_ALAN]
print("Suzuldukten sonra:", len(gercek))

# --- Sonucu goruntunun ustune cizelim ---
tuval = cv2.cvtColor(gri, cv2.COLOR_GRAY2BGR)
cv2.drawContours(tuval, gercek, -1, (0, 255, 0), 2)     # -1 = HEPSINI ciz

for i, k in enumerate(gercek, start=1):
    x, y, w_, h_ = cv2.boundingRect(k)                  # cevreleyen dikdortgen
    M = cv2.moments(k)                                  # momentler -> agirlik merkezi
    cx = int(M["m10"] / M["m00"]); cy = int(M["m01"] / M["m00"])
    cv2.circle(tuval, (cx, cy), 3, (0, 0, 255), -1)     # merkeze kirmizi nokta
    cv2.putText(tuval, str(i), (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX,
                0.5, (255, 255, 0), 1, cv2.LINE_AA)

goster([gri, ikili, temiz, cv2.cvtColor(tuval, cv2.COLOR_BGR2RGB)],
       ["orijinal", "Otsu", "temizlenmis", f"{len(gercek)} nesne bulundu"], satir=2)

# --- Her nesnenin olculeri: rapora koyacaginiz tablo ---
import pandas as pd
satirlar = []
for i, k in enumerate(gercek, start=1):
    alan   = cv2.contourArea(k)
    cevre  = cv2.arcLength(k, True)
    x, y, w_, h_ = cv2.boundingRect(k)
    # Dairelik: 1'e yakinsa daire, kucukse uzun/girintili bir sekil
    dairelik = 4 * np.pi * alan / (cevre ** 2) if cevre else 0
    satirlar.append({"no": i, "alan": round(alan), "cevre": round(cevre, 1),
                     "en": w_, "boy": h_, "dairelik": round(dairelik, 3)})
print(pd.DataFrame(satirlar).to_string(index=False))
Çıktı
Otsu esigi: 126.0
Ham kontur sayisi: 31
Suzuldukten sonra: 22

 no  alan  cevre   en  boy  dairelik
  1  2184  178.8   56   52     0.859
  2  2039  172.3   53   51     0.863
  3  4367  285.1   79   74     0.675
  ...
24 para var ama 22 bulundu. Neden? Çünkü görüntüde birbirine değen paralar var. Eşiklemeden sonra iki para tek bir beyaz leke hâline gelir ve findContours onları tek nesne sayar. Alanı normalin iki katı olan bir kontur, tam olarak bunun işaretidir — yukarıdaki tabloda 3. satırın alanı diğerlerinin iki katı.

Çözümler, kolaydan zora:
1. Erozyonu artırıp lekeleri koparmak (kaba ama bazen yeterli).
2. Alan kontrolü: alanı ortalamanın 1,6 katından büyük konturu “iki nesne” saymak.
3. Doğru çözüm: cv2.watershed — mesafe dönüşümü ile her paranın merkezini bulur, sonra sınırları o merkezlerden büyüterek ayırır.
4. Modern çözüm: nesne tespiti yapan bir derin öğrenme modeli (10. haftanın konusu).

Şekil tanıma: köşe sayarak

Konturu bulduktan sonra şeklini de söyleyebiliriz. approxPolyDP konturu basit bir çokgene yaklaştırır; kalan köşe sayısı şekli söyler.

hücre 16 — üçgen mi, kare mi, daire mi?
def sekil_adi(kontur):
    cevre = cv2.arcLength(kontur, True)
    # epsilon: cevrenin %2'si kadar sapmaya izin ver. Buyutursen daha az kose kalir.
    kose  = cv2.approxPolyDP(kontur, 0.02 * cevre, True)
    n = len(kose)
    if n == 3:
        return "ucgen"
    if n == 4:
        x, y, w_, h_ = cv2.boundingRect(kose)
        return "kare" if 0.93 <= w_ / h_ <= 1.07 else "dikdortgen"
    if n == 5:
        return "besgen"
    # Cok kose = yuvarlak. Ama yildizi daireden ayirmak icin DAIRELIK bakilir.
    alan = cv2.contourArea(kontur)
    dairelik = 4 * np.pi * alan / (cevre ** 2) if cevre else 0
    return "daire" if dairelik > 0.80 else f"duzensiz ({n} kose)"

for i, k in enumerate(gercek[:8], start=1):
    print(f"{i}. nesne: {sekil_adi(k):14s} alan={cv2.contourArea(k):7.0f}")
epsilon parametresi her şeyi değiştirir. 0.02 * cevre yazdık: “konturdan en fazla çevrenin %2'si kadar sapabilirsin”.
• Çok küçük verirseniz (0,001) hiçbir şey basitleşmez, daireniz 40 köşeli çıkar.
• Çok büyük verirseniz (0,1) her şey üçgene döner.
0,01–0,04 aralığı pratikte çalışır. True parametresi “bu kapalı bir şekil” demektir.
13 · İki klasik uygulama

Renkle nesne bulma (HSV) ve yüz bulma (Haar)

Klasik görüntü işlemenin iki meşhur numarası. İkisi de öğrenme gerektirmez, saniyeler içinde çalışır ve doğru yerde kullanıldığında bir CNN'e ihtiyaç bırakmaz.

1 · HSV: rengi akıllıca aramak

Kırmızı bir topu RGB'de aramak zordur: gölgedeki kırmızı (90,20,20), güneştekiyse (255,120,110). Üç sayı da değişir. HSV uzayı rengi üç farklı soruya böler ve bu sorun ortadan kalkar.

H — Hue

Renk tonu

“Hangi renk?” Bir çember üzerinde ölçülür. OpenCV'de 0–179 (365° yarıya sıkıştırılmıştır, tek bayta sığsın diye). Işıktan neredeyse hiç etkilenmez — bütün marifet burada.

S — Saturation

Doygunluk

“Ne kadar canlı?” 0 = gri, 255 = en canlı hâli. Beyaz, siyah ve grinin doygunluğu düşüktür.

V — Value

Parlaklık

“Ne kadar aydınlık?” Gölge ve güneş sadece bunu değiştirir. Bu yüzden aralığı geniş bırakırız.

hücre 17 — renge göre maske çıkarmak
bgr = cv2.cvtColor(kedi, cv2.COLOR_RGB2BGR)       # skimage RGB verdi, cv2 BGR bekliyor
hsv = cv2.cvtColor(bgr, cv2.COLOR_BGR2HSV)

# OpenCV HSV araliklari:  H 0-179   S 0-255   V 0-255
# KIRMIZI bir sorun cikarir: cemberin BASINDA ve SONUNDA. Iki araligi birlestirmek gerekir.
alt1, ust1 = np.array([  0, 110,  70]), np.array([ 10, 255, 255])
alt2, ust2 = np.array([170, 110,  70]), np.array([179, 255, 255])
maske_kirmizi = cv2.bitwise_or(cv2.inRange(hsv, alt1, ust1),
                               cv2.inRange(hsv, alt2, ust2))

# Diger renkler tek araliktir:
maske_mavi  = cv2.inRange(hsv, np.array([100, 100,  50]), np.array([130, 255, 255]))
maske_yesil = cv2.inRange(hsv, np.array([ 35,  70,  50]), np.array([ 85, 255, 255]))
maske_sari  = cv2.inRange(hsv, np.array([ 20, 100, 100]), np.array([ 35, 255, 255]))

# Maskeyi morfolojiyle temizle (tek piksellik yanlislar hep olur)
cek = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
maske_yesil = cv2.morphologyEx(maske_yesil, cv2.MORPH_OPEN,  cek)
maske_yesil = cv2.morphologyEx(maske_yesil, cv2.MORPH_CLOSE, cek)

# Maskeyi orijinale uygula: sadece o renk kalsin
sadece_yesil = cv2.bitwise_and(bgr, bgr, mask=maske_yesil)

goster([kedi, maske_kirmizi, maske_yesil, cv2.cvtColor(sadece_yesil, cv2.COLOR_BGR2RGB)],
       ["orijinal", "kirmizi maske", "yesil maske (temiz)", "maske uygulanmis"], satir=1)

# Maskeden nesne sayma: 12. bolumun hattinin aynisi
kont, _ = cv2.findContours(maske_yesil, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
print("Yesil bolge sayisi:", len([k for k in kont if cv2.contourArea(k) > 200]))
HSV aralığını nasıl bulacağım? Tahminle uğraşmayın, ölçün:
print(hsv[y, x]) — aradığınız nesnenin üstündeki birkaç pikselin gerçek H, S, V değerlerini okuyun. Sonra o değerlerin etrafına pay bırakın: H için ±10 yeter, S ve V için geniş aralık verin (gölge ve ışık bunları değiştirir).

Kırmızı istisnası: H bir çemberdir ve kırmızı çemberin birleşme noktasındadır. Bu yüzden kırmızı her zaman iki aralık ister: 0–10 ve 170–179. Bunu bilmeyen bir öğrenci “kırmızı bulunamıyor” diye yarım saat kaybeder.

2 · Haar cascade ile yüz bulma

2001'de Viola ve Jones, basit dikdörtgen desenleri ardı ardına (cascade) uygulayarak yüzleri gerçek zamanlı bulan bir yöntem yayımladı. Dijital kameraların yüz kutusu çizmesini sağlayan şey buydu. OpenCV eğitilmiş modelleri kendisiyle birlikte getirir — yani bedava.

hücre 18 — yüz ve göz bulma
import os

yol = cv2.data.haarcascades           # OpenCV ile gelen hazir modellerin klasoru
print(yol)
print([f for f in os.listdir(yol) if "frontalface" in f or "eye" in f])

yuz_bulucu = cv2.CascadeClassifier(yol + "haarcascade_frontalface_default.xml")
goz_bulucu = cv2.CascadeClassifier(yol + "haarcascade_eye.xml")
assert not yuz_bulucu.empty(), "Model yuklenemedi - yolu kontrol edin"

bgr = cv2.cvtColor(astro, cv2.COLOR_RGB2BGR)
gri_a = cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY)
gri_a = cv2.equalizeHist(gri_a)       # kontrasti acmak bulma oranini artirir

yuzler = yuz_bulucu.detectMultiScale(
    gri_a,
    scaleFactor=1.08,    # her turda goruntuyu %8 kucult. Kucuk deger = yavas ama titiz
    minNeighbors=5,      # bir bolge kac kez onaylanmali. Buyuk deger = daha az yanlis alarm
    minSize=(40, 40)     # bundan kucuk kutulari hic deneme
)
print("Bulunan yuz sayisi:", len(yuzler))

tuval = bgr.copy()
for (x, y, w_, h_) in yuzler:
    cv2.rectangle(tuval, (x, y), (x + w_, y + h_), (0, 255, 0), 2)
    # Gozleri SADECE yuzun icinde ara: hem hizli hem dogru
    roi_gri  = gri_a[y:y + h_, x:x + w_]
    roi_renk = tuval[y:y + h_, x:x + w_]
    for (gx, gy, gw, gh) in goz_bulucu.detectMultiScale(roi_gri, 1.1, 6):
        cv2.rectangle(roi_renk, (gx, gy), (gx + gw, gy + gh), (255, 200, 0), 2)

goster([astro, cv2.cvtColor(tuval, cv2.COLOR_BGR2RGB)],
       ["orijinal", f"{len(yuzler)} yuz bulundu"], buyukluk=4.5)
Sonuç ilk denemede çıkmazsa panik yapmayın — ayar işi.
• Hiç yüz bulamadıysa: scaleFactor'ı 1,05'e düşürün, minNeighbors'ı 3'e indirin, minSize'ı küçültün.
• Olmayan yerde yüz görüyorsa: minNeighbors'ı 8–10'a çıkarın.
• Yavaş çalışıyorsa: görüntüyü önce küçültün, minSize verin.

Haar'ın gerçek sınırları, dürüstçe: yalnızca karşıdan bakan yüzleri bulur. Yana dönmüş baş, eğik kafa, maske, gözlük, zayıf ışık — hepsinde başarısızdır. Ayrıca kimin yüzü olduğunu söylemez, sadece “burada bir yüz var” der. Bugün ciddi işlerde yerini derin öğrenme tabanlı bulucular (MTCNN, RetinaFace, YOLO-face) aldı. Buna rağmen öğretmeye değer: öğrenmeyen bir yöntemin ne kadar iş yapabildiğini gösteriyor.
hücre 19 — şablon eşleme: aradığınız şeyin resmi elinizdeyse
# Goruntunun icinden bir parca kesip, o parcayi goruntude ARATIYORUZ.
sablon = kamera[200:280, 190:270]          # kameramanin yuz bolgesi (80x80)
th, tw = sablon.shape

sonuc = cv2.matchTemplate(kamera, sablon, cv2.TM_CCOEFF_NORMED)
en_az, en_cok, yer_az, yer_cok = cv2.minMaxLoc(sonuc)
print(f"En iyi benzerlik: {en_cok:.3f}  konum: {yer_cok}")

tuval = cv2.cvtColor(kamera, cv2.COLOR_GRAY2BGR)
cv2.rectangle(tuval, yer_cok, (yer_cok[0] + tw, yer_cok[1] + th), (0, 255, 0), 2)
goster([sablon, sonuc, cv2.cvtColor(tuval, cv2.COLOR_BGR2RGB)],
       ["aranan sablon", "benzerlik haritasi (parlak = benziyor)", "bulunan yer"], satir=1)
Şablon eşleme ne zaman işe yarar, ne zaman yaramaz? Yarar: aradığınız şey her seferinde tıpatıp aynı görünüyorsa — ekran görüntüsünde bir düğme bulmak, oyun kartı tanımak, baskı hatası aramak. Yaramaz: nesne döndüyse, büyüdüyse, ışık değiştiyse. Şablon eşleme hiç esnek değildir. İşte CNN'e giden yolu açan şey de bu: esneklik.
14 · Toparlama

Filtre galerisi: bir görüntü, on altı işlem

Buraya kadar öğrendiğimiz her şey tek bir ekranda. Kaynağı değiştirin ya da kendi fotoğrafınızı yükleyin — bütün filtreler aynı anda yeniden hesaplanır.

Lab 10Hepsi bir arada
Görüntü
Sınıf içi alıştırma: Kendi yüzünüzün fotoğrafını yükleyin ve şu üç soruyu cevaplayın: (1) Hangi filtre yüzü en tanınmaz hâle getirdi? (2) Canny çıktısında yüzünüzü hâlâ tanıyabiliyor musunuz — peki bir bilgisayar tanıyabilir mi? (3) Otsu eşiklemesi sizde işe yaradı mı, yoksa uyarlamalı mı gerekti? Cevabınız odadaki ışığa göre değişecek.
15 · Dönüm noktası

Klasik yöntem nerede duvara çarpar?

Buraya kadar filtreyi biz seçtik. Her seferinde “şu eşiği ver, şu çekirdeği kullan, şu yarıçapı dene” dedik. Peki ya problem elle kural yazılamayacak kadar karmaşıksa?

Düşünce deneyi: “Bu fotoğrafta kedi var mı?”
Kedi bulan bir OpenCV programı yazmaya çalışalım. Kedinin rengi ne? Siyah, beyaz, tekir, turuncu olabilir. Şekli ne? Uyuyor, oturuyor, zıplıyor, sadece kafası görünüyor olabilir. Kaç kenarı var? Bilinmiyor. Kulakları üçgen mi? Evet ama kedinin arkası dönükse hiç görünmüyor.

Yazabileceğiniz hiçbir eşik, çekirdek ya da kontur kuralı yoktur. Çünkü “kedi” görsel bir kural değil, binlerce görsel ipucunun istatistiksel bir birleşimidir. Bunu elle yazamazsınız — ama bir makineye örnek göstererek buldurabilirsiniz.

Klasik görüntü işleme (OpenCV)

  • Filtreyi insan seçer. Çekirdeğin dokuz sayısını siz yazarsınız.
  • Veri gerektirmez. Tek bir görüntüyle çalışmaya başlarsınız.
  • Hızlı ve bedava. GPU gerekmez, milisaniyeler sürer.
  • Tamamen açıklanabilir. Sonucun neden öyle çıktığını satır satır gösterebilirsiniz.
  • Kırılgan. Işık, açı ya da zemin değişince ayarları baştan yapmak gerekir.
  • Soyut kavramları göremez. “Kedi”, “hasarlı”, “sahte” gibi şeyleri tanımlayamaz.
→

Evrişimli sinir ağı (CNN)

  • Filtreyi ağ öğrenir. O dokuz sayı eğitim sırasında kendiliğinden bulunur.
  • Etiketli veri şart. Binlerce “bu kedi / bu değil” örneği gerekir.
  • Eğitim pahalı. GPU ile dakikalar, CPU ile saatler. Tahmin ise hızlıdır.
  • Açıklaması zor. “Neden bu cevabı verdi?” sorusu ayrı bir araştırma alanı.
  • Esnek. Veride çeşitlilik varsa yeni koşullara dayanır.
  • Soyut kavramları öğrenir. Kedi, tümör, kusurlu ürün — örnek varsa olur.
Bu bir yarışma değil. Gerçek projeler ikisini birlikte kullanır: görüntüyü OpenCV ile okur, boyutlandırır, normalleştirir ve artırır → CNN'e verir → CNN'in çıktısındaki maskeyi yine OpenCV ile temizler ve konturlarını bulur. Bu haftanın ilk 14 bölümü CNN'in rakibi değil, ön hazırlığıydı.
AlıştırmaBu işi klasik OpenCV ile mi, CNN ile mi çözersiniz?

Sekiz problem var. Her biri için bir kutu seçin — cevabınız doğru da olsa yanlış da olsa kısa bir gerekçe göreceksiniz. Önemli olan sonucu değil, gerekçeyi okumak.

Karar kuralı, tek cümlede: Çözümü birkaç net kuralla yazabiliyorsanız OpenCV; “bilirim ama anlatamam” diyorsanız ve elinizde etiketli örnek varsa CNN. Etiketli örnek yoksa CNN bir seçenek değildir — ilk işiniz veri toplamak olur.
16 · CNN

Evrişimli sinir ağı: filtreyi öğrenen ağ

İyi haber: CNN'in yeni bir matematiği yok. 8. bölümde öğrendiğiniz evrişimin tamamı burada da geçerli. Tek fark şu: çekirdeğin dokuz sayısını siz yazmıyorsunuz, ağ deneye yanıla kendisi buluyor.

8. bölümde

Biz yazdık

[-1,0,1, -1,0,1, -1,0,1] → “dikey kenar bul”. Dokuz sayıyı insan aklı seçti, çünkü ne aradığımızı biliyorduk.

CNN'de

Ağ buluyor

Aynı dokuz kutu rastgele başlar. Ağ tahmin yapar, hata alır, hatayı azaltacak yönde dokuz sayıyı azıcık değiştirir. Binlerce tekrardan sonra o sayılar işe yarar hâle gelir.

Sonuç

Kimse “kenar ara” demedi

İlginç olan şu: eğitilmiş ağların ilk katmanına bakıldığında kendiliğinden kenar ve renk bulucular oluştuğu görülür — bizim elle yazdıklarımıza çok benzer. Ağ, aynı çözümü kendisi buldu.

Lab 11Evrişim katmanı, adım adım

Soldaki 7×7 girdinin ortasında dikey bir kenar var (sol taraf 0, sağ taraf 9). Çekirdek pencere pencere kayıyor; her durakta çarpımların toplamı sağdaki haritaya yazılıyor. ▶ Oynat'a basın ve kenarın bulunduğu sütunda sayıların nasıl zıpladığına bakın.

✳
=
Üç terimi burada öğreniyoruz:
• Çekirdek / filtre — kayan küçük sayı tablosu. CNN'de bu sayılar öğrenilir.
• Öznitelik haritası (feature map) — çıktının adı. “Bu filtre görüntünün hangi yerinde güçlü yanıt verdi?” sorusunun haritası.
• Adım (stride) — pencerenin her seferinde kaç piksel kaydığı. Biz 1 kullanıyoruz; 2 yaparsanız çıktı yarı boyutta olur (havuzlamaya alternatif bir küçültme yolu).
Lab 12Havuzlama — küçült, ama önemli olanı kaybetme

Her 2×2 kareden tek bir sayı seçiyoruz. İleri ▶ ile tek tek ilerleyin, sonra Ortalama'ya geçip farkı görün.

→
Havuzlama üç iş yapar: (1) Veriyi dörtte bire indirir, yani sonraki katman çok daha hızlı çalışır. (2) Modeli küçük kaymalara dayanıklı yapar: rakam iki piksel sağa kaysa bile havuzlanmış harita neredeyse değişmez. (3) Sonraki katmanın görüş alanını genişletir: havuzlanmış haritada 3×3'lük bir pencere, orijinal görüntüde 6×6'lık bir alana karşılık gelir.

Modern not: Son yıllarda bazı mimariler havuzlama yerine strides=2 olan evrişim kullanıyor. İkisi de aynı amaca hizmet eder; ders boyunca MaxPooling2D kullanacağız çünkü anlaşılması daha kolay.

Bir CNN'in mimarisi

Şimdi parçaları sıraya dizelim. Aşağıdaki şerit, birazdan Kaggle'da eğiteceğimiz ağın tam olarak kendisi — her bloğun üstünde o katmandan çıkan verinin boyutu yazıyor.

girdi
Rakam
28×28×1
784 sayı
→
conv1
Conv2D 32
28×28×32
320 parametre
→
pool1
MaxPool 2×2
14×14×32
0 parametre
→
conv2
Conv2D 64
14×14×64
18.496 parametre
→
pool2
MaxPool 2×2
7×7×64
0 parametre
→
flatten
Düzleştir
3.136 sayı
0 parametre
→
dense1
Dense 128
128 sayı
401.536 parametre
→
çıktı
Dense 10
10 olasılık
1.290 parametre
Bu şeritte fark etmeniz gereken şey: Toplam 421.642 parametrenin %95'i tek bir katmanda — Dense 128. Bütün görsel işi yapan iki evrişim katmanının toplamı ise sadece 18.816 parametre.

Neden bu kadar az? Çünkü bir evrişim katmanı aynı 3×3 çekirdeği görüntünün her yerinde yeniden kullanır. Buna parametre paylaşımı deniyor ve CNN'in asıl buluşu budur: “dikey kenar” bilgisini resmin sol üstü için ve sağ altı için ayrı ayrı öğrenmek zorunda kalmazsınız.

Karşılaştırın: 784 pikseli doğrudan 128 nörona bağlayan sıradan bir katman 100.480 parametre harcar ve hiçbir komşuluk bilgisi kullanmaz. Aynı bütçeyle CNN beş kat fazla iş yapar.

Katman derinleştikçe ne öğrenir?

CNN'i üst üste binen katmanlardan kurmanın sebebi şu: her katman, altındakinin bulduklarını birleştirir. Aşağıdaki dört kart temsilîdir — eğitilmiş gerçek ağların katmanlarına bakıldığında gözlenen düzeni anlatıyor.

1. katmanKenarlar, renk geçişleri, yönler
2. katmanKöşeler, kavisler, dokular
3. katmanNesne parçaları: göz, tekerlek, pencere
Son katmanlarBütün nesne: kedi, araba, ev
Bir cümlede CNN:
Birinci katman kenar bulur. İkinci katman kenarları birleştirip köşe ve kavis bulur. Üçüncü katman onları birleştirip kulak ve göz bulur. Dördüncü katman “iki göz, bir burun, iki üçgen kulak bir arada” deyip kedi der.

Hiç kimse bu basamakları tasarlamadı. Ağa yalnızca binlerce resim ve her resmin cevabı verildi; bu hiyerarşi hatayı azaltmanın en verimli yolu olduğu için kendiliğinden ortaya çıktı.

ReLU: aradaki küçük ama zorunlu adım

Ne yapar?

Tek satır: f(x) = max(0, x). Eksi değerleri sıfırlar, artıları olduğu gibi geçirir. Evrişimden sonra her zaman uygulanır.

Neden zorunlu?

ReLU olmadan ağ tek bir evrişime çöker: üst üste binen doğrusal işlemlerin birleşimi yine doğrusaldır, yani 10 katman ile 1 katman arasında fark kalmaz. Derinliğin anlamlı olmasını sağlayan şey bu doğrusal olmayan adımdır.

17 · Lab

Rakam çizin, CNN'in ilk katmanını kendi gözünüzle görün

Teoriyi bitirdik. Şimdi bir rakam çizin ve altı farklı filtrenin aynı anda aynı görüntüye nasıl baktığını izleyin. Birazdan Kaggle'da eğiteceğimiz ağın ilk katmanı tam olarak bunu yapıyor — sadece 6 değil 32 filtreyle ve kendisinin bulduğu çekirdeklerle.

Lab 1328×28 tuval — çizin ve öznitelik haritalarını izleyin

Siyah tuvale fareyle ya da parmağınızla bir rakam çizin (ya da Örnek “7” düğmesine basın). Altı harita anında güncellenir. Havuzla düğmesine basınca haritalar 14×14'e inerken desenin hâlâ okunabildiğine dikkat edin.

28 × 28 · her kare bir piksel
Bu haritalarda ne arıyoruz? Dikey kenar filtresinin çizdiğiniz rakamın dikey çizgilerinde parladığına, yatay kenar filtresinin ise yatay çizgilerde parladığına bakın. “7” çizdiyseniz üstteki yatay çizgi ile aşağı inen eğik çizginin iki farklı haritada öne çıktığını göreceksiniz.

Sınıflandırıcıya giden şey artık görüntü değil, bu haritalar. Ağın son katmanı “28×28 piksele” değil, “hangi filtrelerin nerede ne kadar yanıt verdiğine” bakarak karar verir.

Ve kritik nokta: buradaki altı çekirdeği ben elle yazdım. Gerçek bir CNN'de bu sayılar (32 filtre × 3 × 3 = 288 sayı) eğitim sırasında öğrenilir. 18. bölümde eğittiğimiz ağın öğrendiği çekirdekleri ekrana basacağız ve onların da kenar bulucuya benzediğini göreceksiniz.
Dürüst olalım: bu lab sınıflandırma yapmıyor. Çizdiğiniz rakamın kaç olduğunu söylemiyor, çünkü burada eğitilmiş bir model yok — yalnızca ilk katmanın yaptığı işi gösteriyor. Rakamı gerçekten tanıyan modeli birazdan Kaggle'da siz eğiteceksiniz.
18 · Uygulama

Kaggle'da CNN eğitiyoruz: el yazısı rakamlar

3. haftada Titanic ile tablo verisinde sınıflandırma yaptık. Şimdi aynı şeyi görüntüde yapıyoruz: 28×28'lik el yazısı rakamları on sınıfa ayıracağız. Yarışmanın adı Digit Recognizer ve verisi internet gerektirmez.

Derse başlamadan üç ayar:
1. kaggle.com/c/digit-recognizer → Join Competition → kuralları kabul et.
2. Code → New Notebook (bu düğmeye yarışma sayfasından basarsanız veri otomatik eklenir).
3. Sağ panel → Settings → Accelerator → GPU T4 x2. Bu eğitimi 8 dakikadan 40 saniyeye indiriyor.

Veriyi okuyun ve görüntüye çevirin

Veri CSV olarak gelir: her satır bir rakam, ilk sütun cevap, kalan 784 sütun ise 28×28 görüntünün piksel piksel açılmış hâli.

hücre 1
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import cv2
from tensorflow import keras
from tensorflow.keras import layers

print("TensorFlow:", keras.__version__)

train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test  = pd.read_csv("/kaggle/input/digit-recognizer/test.csv")
print("Egitim:", train.shape)       # (42000, 785)  -> 1 etiket + 784 piksel
print("Test  :", test.shape)        # (28000, 784)  -> etiket YOK, biz tahmin edecegiz

# Etiket ve pikselleri ayir
y = train["label"].values                       # (42000,)
X = train.drop(columns="label").values          # (42000, 784)

# DUZ SATIRI GORUNTUYE CEVIR: bu satir dersin en onemli satiri
X = X.reshape(-1, 28, 28, 1)                    # (42000, 28, 28, 1)
X_test = test.values.reshape(-1, 28, 28, 1)
print("Goruntu hali:", X.shape)
Çıktı
TensorFlow: 3.5.0
Egitim: (42000, 785)
Test  : (28000, 784)
Goruntu hali: (42000, 28, 28, 1)
reshape(-1, 28, 28, 1) ne yapıyor? 784 sayıyı alıp 28 satır × 28 sütun hâline diziyor. -1 “kaç örnek olduğunu sen hesapla” demek. Sondaki 1 ise kanal sayısı: bu görüntüler gri, tek kanal. Renkli olsaydı 3 yazacaktık.

Bu adım neden can alıcı? Çünkü 784 sayı düz bir liste olarak kalırsa komşuluk bilgisi kaybolur — 1. piksel ile 29. piksel listede uzak dururken görüntüde tam üst üstedir. Evrişim komşuluk üzerine kurulu olduğundan, bu reshape olmadan CNN'in hiçbir anlamı kalmaz.

Veriye bakın: taban çizgisini ve dengeyi kontrol edin

3. haftanın değişmez kuralı: model kurmadan önce taban çizgisini hesapla.

hücre 2
# 1) Siniflar dengeli mi?
print(pd.Series(y).value_counts().sort_index())
taban = pd.Series(y).value_counts(normalize=True).max()
print(f"\nTABAN CIZGISI: {taban:.4f}  ({taban*100:.2f}%)")
print("Modelimizin GECMESI GEREKEN cizgi bu.")

# 2) Ornekleri gozle gorelim - her zaman yapin
plt.figure(figsize=(11, 4.5))
for i in range(30):
    plt.subplot(3, 10, i + 1)
    plt.imshow(X[i, :, :, 0], cmap="gray")
    plt.title(str(y[i]), fontsize=9)
    plt.axis("off")
plt.suptitle("Egitim verisinden ilk 30 ornek", y=1.02)
plt.tight_layout(); plt.show()

# 3) Piksel degerleri nerede duruyor?
print("\nPiksel araligi:", X.min(), "-", X.max())
print("Ortalama:", X.mean().round(2))
Çıktı
0    4132
1    4684
2    4177
3    4351
4    4072
5    3795
6    4137
7    4401
8    4063
9    4188

TABAN CIZGISI: 0.1115  (11.15%)
Modelimizin GECMESI GEREKEN cizgi bu.

Piksel araligi: 0 - 255
Ortalama: 33.41
Taban çizgisi %11,15. Yani hiç model kurmadan “hepsi 1'dir” desek %11 doğru olurduk. Bu çizgi düşük olduğu için (10 sınıf var) modelden gerçek bir sıçrama bekliyoruz. Titanic'te %61,6 gibi yüksek bir çizgi vardı ve modeli geçmek zordu; burada tam tersi.

Sınıflar dengeli: her rakamdan 3.800–4.700 arası örnek var. Dengesizlik olsaydı (örneğin 9'dan sadece 100 örnek) doğruluk yanıltıcı olur, 5. haftanın konusu olan precision/recall'a bakmak gerekirdi.

Ortalama 33,41: piksellerin çoğu siyah (0). Beklenen — rakamlar ince çizgilerden oluşuyor.

Normalleştirin ve eğitim/doğrulama olarak bölün

hücre 3
from sklearn.model_selection import train_test_split

# 1) NORMALLESTIRME: 0-255 -> 0-1
X = X.astype("float32") / 255.0
X_test = X_test.astype("float32") / 255.0

# 2) Egitim / dogrulama ayrimi (3. haftadaki "ders ve sinav" ayrimi)
#    stratify=y  ->  her iki parcada da rakamlarin orani ayni kalsin
X_tr, X_val, y_tr, y_val = train_test_split(
    X, y, test_size=0.1, random_state=42, stratify=y)

print("Egitim    :", X_tr.shape)    # (37800, 28, 28, 1)
print("Dogrulama :", X_val.shape)   # (4200, 28, 28, 1)
Çıktı
Egitim    : (37800, 28, 28, 1)
Dogrulama : (4200, 28, 28, 1)
Neden 255'e böldük? Sinir ağları girdileri 0–1 aralığında olduğunda çok daha hızlı ve kararlı öğrenir. 0–255 aralığında bırakırsanız ilk katmanın ağırlıkları aşırı büyük sayılarla çarpılır, eğitim ya çok yavaşlar ya da hiç yakınsamaz. Bu tek satır çoğu zaman eğitimin başarılı olup olmamasını belirler.

Neden ayrı bir doğrulama parçası? Modelin görmediği veride ne yaptığını bilmemiz gerekiyor. Eğitim doğruluğu %99,9 iken doğrulama doğruluğu %94 ise model ezberlemiştir. Bu iki sayı arasındaki fark, 5. haftada ayrıntısını göreceğimiz aşırı öğrenmenin (overfitting) ölçüsüdür.

Neden stratify=y? Rastgele bölerken şansa bırakmayıp her iki parçada da on rakamın oranını eşit tutar. Küçük veri setlerinde bunu atlamak sonucu belirgin biçimde bozar.

CNN'i kurun ve özetine bakın

hücre 4
def cnn_kur():
    return keras.Sequential([
        keras.Input(shape=(28, 28, 1)),

        # --- 1. evrisim blogu: 32 filtre, her biri 3x3 ---
        layers.Conv2D(32, 3, activation="relu", padding="same", name="conv1"),
        layers.MaxPooling2D(2, name="pool1"),          # 28x28 -> 14x14

        # --- 2. evrisim blogu: 64 filtre ---
        layers.Conv2D(64, 3, activation="relu", padding="same", name="conv2"),
        layers.MaxPooling2D(2, name="pool2"),          # 14x14 -> 7x7

        # --- siniflandirici ---
        layers.Flatten(name="flatten"),                # 7*7*64 = 3136
        layers.Dropout(0.3, name="dropout"),           # ezberlemeye karsi
        layers.Dense(128, activation="relu", name="dense1"),
        layers.Dense(10, activation="softmax", name="cikti"),
    ], name="rakam_cnn")

model = cnn_kur()
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss="sparse_categorical_crossentropy",   # etiketler 0..9 TAM SAYI oldugu icin "sparse"
    metrics=["accuracy"],
)
model.summary()
Çıktı
Model: "rakam_cnn"
_________________________________________________________________
 Layer (type)             Output Shape            Param #
=================================================================
 conv1 (Conv2D)           (None, 28, 28, 32)          320
 pool1 (MaxPooling2D)     (None, 14, 14, 32)            0
 conv2 (Conv2D)           (None, 14, 14, 64)        18,496
 pool2 (MaxPooling2D)     (None, 7, 7, 64)              0
 flatten (Flatten)        (None, 3136)                  0
 dropout (Dropout)        (None, 3136)                  0
 dense1 (Dense)           (None, 128)              401,536
 cikti (Dense)            (None, 10)                 1,290
=================================================================
Total params: 421,642
Trainable params: 421,642
Bu tablodaki her sayıyı hesaplayabilirsiniz — deneyin:
• conv1: 32 filtre × (3×3×1 kanal) + 32 eğilim = 320
• conv2: 64 filtre × (3×3×32 kanal) + 64 = 18.496. Dikkat: ikinci katmanın her filtresi otuz iki haritanın hepsine birlikte bakıyor — işte “kenarları birleştirip köşe bulmak” buradan geliyor.
• dense1: 3.136 × 128 + 128 = 401.536
• cikti: 128 × 10 + 10 = 1.290

Üç parametre seçimini açıklayalım:
• padding="same" — kenarlara sıfır ekler, böylece 28×28 girdi 28×28 çıkar. "valid" deseydik 26×26 olurdu ve katman başına kenarlardan bilgi kaybederdik.
• Dropout(0.3) — her eğitim adımında nöronların %30'unu rastgele kapatır. Böylece ağ tek bir yola bağımlı kalmaz, ezberlemek zorlaşır. Tahmin sırasında kendiliğinden devre dışı kalır, siz bir şey yapmazsınız.
• softmax — son on sayıyı toplamı 1 olan olasılıklara çevirir. Çıktı [0.01, 0.00, 0.93, ...] gibi okunur: “%93 ihtimalle 2”.
Kayıp fonksiyonunda en sık yapılan hata. Etiketleriniz 0,1,2...9 gibi tam sayıysa sparse_categorical_crossentropy kullanın. to_categorical ile one-hot'a çevirdiyseniz ([0,0,1,0,...]) o zaman categorical_crossentropy yazmalısınız. Karıştırırsanız model ya hata verir ya da sessizce hiç öğrenmez — doğruluk %10'da takılı kalır.

Eğitin

hücre 5
geri_cagrilar = [
    # Dogrulama dogrulugu 3 tur boyunca iyilesmezse DUR ve en iyi hale geri don
    keras.callbacks.EarlyStopping(monitor="val_accuracy", patience=3,
                                  restore_best_weights=True, verbose=1),
    # Takildiginda ogrenme hizini yariya indir
    keras.callbacks.ReduceLROnPlateau(monitor="val_loss", factor=0.5,
                                      patience=2, min_lr=1e-5, verbose=1),
]

gecmis = model.fit(
    X_tr, y_tr,
    validation_data=(X_val, y_val),
    epochs=15,
    batch_size=128,
    callbacks=geri_cagrilar,
    verbose=2,
)
Çıktı (kısaltıldı — sizde son haneler farklı olacak)
Epoch 1/15
296/296 - 7s - loss: 0.3612 - accuracy: 0.8884 - val_loss: 0.0920 - val_accuracy: 0.9736
Epoch 2/15
296/296 - 3s - loss: 0.1083 - accuracy: 0.9667 - val_loss: 0.0601 - val_accuracy: 0.9814
Epoch 5/15
296/296 - 3s - loss: 0.0518 - accuracy: 0.9838 - val_loss: 0.0385 - val_accuracy: 0.9886
Epoch 9/15
296/296 - 3s - loss: 0.0347 - accuracy: 0.9888 - val_loss: 0.0316 - val_accuracy: 0.9912
Epoch 12/15
296/296 - 3s - loss: 0.0279 - accuracy: 0.9909 - val_loss: 0.0310 - val_accuracy: 0.9914
Restoring model weights from the end of the best epoch: 12.
Çıktıdaki dört sayıyı okumayı öğrenin — hepsi aynı satırda:
• loss — eğitim verisindeki hata. Düşüyorsa model öğreniyor.
• accuracy — eğitim verisindeki doğruluk. Tek başına anlamsız.
• val_loss — görmediği veride hata. En önemli sayı budur.
• val_accuracy — görmediği veride doğruluk. Raporda bu yazılır.

Sağlıklı eğitimin işareti: val_loss düşüyor. Ezberlemenin işareti: loss düşmeye devam ederken val_loss yükselmeye başlar. O ana kadarki en iyi hâle dönmek gerekir — EarlyStopping'in restore_best_weights=True parametresi tam olarak bunu yapar.

Sonuç: taban çizgisi %11,15 → model %99,1. Fark 88 puan. 3. haftadaki Titanic'te bu fark 10 puan civarındaydı; görüntüde CNN'in ne kadar güçlü olduğunu gösteren karşılaştırma budur.
batch_size ve epochs ne demek?
• Batch — ağırlıklar güncellenmeden önce kaç örneğe bakılacağı. 128 iyi bir varsayılan. Küçültmek (32) daha gürültülü ama bazen daha iyi genelleyen bir eğitim verir; büyütmek (512) hızlandırır ama GPU belleğini şişirir.
• Epoch — bütün eğitim verisinin baştan sona bir kez geçmesi. 37.800 ÷ 128 ≈ 296 adım, çıktıdaki o sayı buradan geliyor.
• Kaç epoch? Tahmin etmeyin: bolca yazın (15–30) ve kararı EarlyStopping'e bırakın.

Eğitim grafiklerini çizin

hücre 6
g = gecmis.history
tur = range(1, len(g["loss"]) + 1)

plt.figure(figsize=(11, 3.8))

plt.subplot(1, 2, 1)
plt.plot(tur, g["loss"],     "o-", label="egitim")
plt.plot(tur, g["val_loss"], "s-", label="dogrulama")
plt.title("Kayip (loss) - DUSMESI gerekir"); plt.xlabel("epoch")
plt.legend(); plt.grid(alpha=.3)

plt.subplot(1, 2, 2)
plt.plot(tur, g["accuracy"],     "o-", label="egitim")
plt.plot(tur, g["val_accuracy"], "s-", label="dogrulama")
plt.axhline(taban, color="#98585d", ls="--", label=f"taban cizgisi ({taban:.3f})")
plt.title("Dogruluk (accuracy) - YUKSELMESI gerekir"); plt.xlabel("epoch")
plt.legend(); plt.grid(alpha=.3)

plt.tight_layout(); plt.show()

fark = g["accuracy"][-1] - g["val_accuracy"][-1]
print(f"Egitim - dogrulama farki: {fark:+.4f}")
print("Fark 0.02'den buyukse ezberleme basliyor demektir.")
Grafiği okurken aradığınız üç şekil:
• İki eğri birlikte düşüyor, aralık küçük → sağlıklı. Devam.
• Eğitim düşüyor, doğrulama yükseliyor → ezberleme. Dropout artırın, veri artırın, modeli küçültün.
• İkisi de yüksekte takılı → model yetersiz (underfitting). Katman ekleyin, filtre sayısını artırın, daha uzun eğitin.

Taban çizgisini grafiğe çizmeyi alışkanlık edinin. O kesikli çizgi olmadan bir doğruluk değerinin iyi mi kötü mü olduğu söylenemez.

Değerlendirin: karmaşıklık matrisi ve yanlışların resmi

hücre 7
from sklearn.metrics import confusion_matrix, classification_report, ConfusionMatrixDisplay

olasilik = model.predict(X_val, verbose=0)      # (4200, 10)
tahmin   = olasilik.argmax(axis=1)              # en yuksek olasilikli sinif

print(classification_report(y_val, tahmin, digits=4))

km = confusion_matrix(y_val, tahmin)
fig, ax = plt.subplots(figsize=(6.5, 5.5))
ConfusionMatrixDisplay(km, display_labels=range(10)).plot(ax=ax, cmap="Blues", colorbar=False)
plt.title("Karmasiklik matrisi (dogrulama verisi)"); plt.tight_layout(); plt.show()

# EN COK KARISTIRILAN IKILILER - raporunuza bu tabloyu koyun
kopya = km.copy(); np.fill_diagonal(kopya, 0)
print("\nEn cok karistirilan ikililer:")
for _ in range(5):
    i, j = np.unravel_index(kopya.argmax(), kopya.shape)
    if kopya[i, j] == 0:
        break
    print(f"  Gercek {i} -> tahmin {j} : {kopya[i, j]} kez")
    kopya[i, j] = 0

# --- YANLIS TAHMINLERI RESIM OLARAK GOR: en ogretici adim ---
yanlis = np.where(tahmin != y_val)[0]
print(f"\nToplam {len(yanlis)} hata / {len(y_val)} ornek")

guven = olasilik.max(axis=1)
# Modelin EN EMIN oldugu halde YANILDIGI ornekler
en_kotu = yanlis[np.argsort(-guven[yanlis])][:15]

plt.figure(figsize=(12, 3))
for k, i in enumerate(en_kotu):
    plt.subplot(2, 8, k + 1)
    plt.imshow(X_val[i, :, :, 0], cmap="gray")
    plt.title(f"{y_val[i]}→{tahmin[i]}\n%{guven[i]*100:.0f} emin", fontsize=8)
    plt.axis("off")
plt.suptitle("Modelin emin olup yanildigi ornekler", y=1.06)
plt.tight_layout(); plt.show()
Çıktı (kısaltıldı)
              precision    recall  f1-score   support
           0     0.9952    0.9976    0.9964       413
           4     0.9877    0.9877    0.9877       407
           9     0.9880    0.9833    0.9856       419
    accuracy                         0.9914      4200

En cok karistirilan ikililer:
  Gercek 4 -> tahmin 9 : 4 kez
  Gercek 7 -> tahmin 2 : 3 kez
  Gercek 3 -> tahmin 5 : 3 kez
  Gercek 8 -> tahmin 3 : 2 kez

Toplam 36 hata / 4200 ornek
Hataların kendisi size problemi anlatır. En çok karıştırılan ikili 4 → 9. Şaşırtıcı mı? Hayır: el yazısında 4'ün üstü kapanırsa 9'a dönüşür. Aynı şekilde 3 ↔ 5 ve 7 ↔ 2 insanların da karıştırdığı çiftler.

Yanlışları resim olarak görmek, bu haftanın en değerli alışkanlığı. Çoğu zaman şunu fark edersiniz: o örnekler gerçekten belirsizdir ve bir insan da aynı hatayı yapardı. Bazen de etiketin kendisi yanlıştır. İkisini birbirinden ayırt etmenin tek yolu resme bakmaktır — sayı tablosuna bakmak yetmez.

Sınıf içi tartışma: 36 hatanın resmini birlikte açın ve “kaçını bir insan doğru bilebilirdi?” diye oylayın. Genelde yarısına yakını gerçekten okunamaz çıkıyor. Bu, bir problemin ulaşılabilir en yüksek doğruluğunun %100 olmadığını gösteren en net ders.

Ağın öğrendiği filtreleri ve öznitelik haritalarını görün

17. bölümdeki lab'da çekirdekleri ben yazmıştım. Şimdi ağın kendisinin bulduğu çekirdeklere bakacağız.

hücre 8
# --- 1) Ilk katmanin OGRENDIGI 32 cekirdek ---
agirlik = model.get_layer("conv1").get_weights()[0]    # (3, 3, 1, 32)
print("Cekirdek tensoru:", agirlik.shape)

plt.figure(figsize=(10, 2.6))
for i in range(32):
    plt.subplot(3, 11, i + 1)
    plt.imshow(agirlik[:, :, 0, i], cmap="RdBu_r")      # kirmizi=arti, mavi=eksi
    plt.axis("off")
plt.suptitle("conv1'in ogrendigi 32 cekirdek (3x3) - kimse bunlari yazmadi", y=1.08)
plt.tight_layout(); plt.show()

# Bir cekirdegi sayilarla gorelim: 8. bolumdeki tezgahla ayni sey
print("\n7. filtrenin 9 sayisi:")
print(np.round(agirlik[:, :, 0, 6], 3))

# --- 2) Ara katman aktivasyonlari (oznitelik haritalari) ---
ara_model = keras.Model(model.inputs, [model.get_layer("conv1").output,
                                       model.get_layer("conv2").output])
ornek = X_val[0:1]
h1, h2 = ara_model.predict(ornek, verbose=0)
print("conv1 cikti:", h1.shape, " conv2 cikti:", h2.shape)

plt.figure(figsize=(3, 3))
plt.imshow(ornek[0, :, :, 0], cmap="gray")
plt.title(f"girdi (etiket: {y_val[0]})"); plt.axis("off"); plt.show()

for ad, h in [("conv1 (28x28, 32 harita)", h1), ("conv2 (14x14, 64 harita)", h2)]:
    plt.figure(figsize=(10, 2.6))
    for i in range(min(32, h.shape[-1])):
        plt.subplot(3, 11, i + 1)
        plt.imshow(h[0, :, :, i], cmap="viridis")
        plt.axis("off")
    plt.suptitle(ad, y=1.08); plt.tight_layout(); plt.show()
Çıktı
Cekirdek tensoru: (3, 3, 1, 32)

7. filtrenin 9 sayisi:
[[-0.214  0.038  0.291]
 [-0.336 -0.051  0.374]
 [-0.188  0.072  0.263]]

conv1 cikti: (1, 28, 28, 32)  conv2 cikti: (1, 14, 14, 64)
Çıktıdaki o dokuz sayıya iyi bakın. Sol sütun eksi, sağ sütun artı. Yani ağ, kimse söylemeden dikey kenar bulucu üretmiş — 8. bölümde elle yazdığımız [-1,0,1, -1,0,1, -1,0,1] çekirdeğinin tıpatıp aynı mantığı.

Bu, haftanın en önemli iki kavramını birbirine bağlayan an. Dersin ilk yarısında filtreleri biz yazdık; ikinci yarısında ağ aynı türden filtreleri yalnızca doğru cevaplara bakarak buldu. CNN'in “yeni bir matematik” değil, aynı matematiğin otomatikleştirilmiş hâli olması tam olarak bu demek.

Diğer 31 çekirdeğe de bakın: bazıları yatay, bazıları çapraz kenar, bazıları nokta/uç bulucu, bir ikisi de neredeyse boş çıkar (işe yaramayan filtreler — bu normaldir).

Veri artırma: ezberlemeyi kırmak

5. bölümde öğrendiğimiz döndürme, kaydırma ve yakınlaştırma şimdi işe yarıyor. Her epoch'ta ağa aynı rakamın biraz farklı hâlini göstererek “şu tek örneği ezberle” imkânını ortadan kaldırıyoruz.

Lab 14Veri artırma — tek görüntüden dokuz görüntü

Aynı görüntünün dokuz varyasyonu. Ağ bunların hepsine aynı cevabı vermeyi öğrenmek zorunda — işte genellemeyi sağlayan şey bu.

Görüntü
hücre 9
# Artirmayi MODELIN ICINE katman olarak koyuyoruz.
# Avantaji: sadece egitimde calisir, tahminde kendiliginden kapanir.
artirma = keras.Sequential([
    layers.RandomRotation(0.06),                  # +-%6 x 360 = yaklasik +-22 derece
    layers.RandomTranslation(0.10, 0.10),         # %10 kaydirma
    layers.RandomZoom(0.10),                      # %10 yakinlastirma
    # layers.RandomFlip("horizontal")  <- RAKAMLARDA ASLA! Aynalanan 7 artik 7 degil.
], name="artirma")

model2 = keras.Sequential([
    keras.Input(shape=(28, 28, 1)),
    artirma,
    layers.Conv2D(32, 3, activation="relu", padding="same", name="conv1"),
    layers.BatchNormalization(),
    layers.MaxPooling2D(2),
    layers.Conv2D(64, 3, activation="relu", padding="same", name="conv2"),
    layers.BatchNormalization(),
    layers.MaxPooling2D(2),
    layers.Conv2D(64, 3, activation="relu", padding="same", name="conv3"),
    layers.GlobalAveragePooling2D(),              # Flatten yerine: parametreyi 100 kat azaltir
    layers.Dropout(0.3),
    layers.Dense(10, activation="softmax"),
], name="rakam_cnn_artirmali")

model2.compile(optimizer=keras.optimizers.Adam(1e-3),
               loss="sparse_categorical_crossentropy", metrics=["accuracy"])
model2.summary()

gecmis2 = model2.fit(X_tr, y_tr, validation_data=(X_val, y_val),
                     epochs=25, batch_size=128, callbacks=geri_cagrilar, verbose=2)

print(f"\nModel 1 (artirmasiz) : {max(gecmis.history['val_accuracy']):.4f}")
print(f"Model 2 (artirmali)  : {max(gecmis2.history['val_accuracy']):.4f}")
Çıktı
Total params: 48,586        <- Flatten yerine GlobalAveragePooling: 421.642 -> 48.586

Model 1 (artirmasiz) : 0.9914
Model 2 (artirmali)  : 0.9945
Üç şeye birlikte dikkat edin:
1. Doğruluk %99,14'ten %99,45'e çıktı. Küçük görünüyor ama hata sayısı 36'dan 23'e indi — yani hataların üçte birini sildik. Yüksek doğruluk bölgesinde “küçük” artışların anlamı budur.
2. Parametre sayısı 421.642 → 48.586. Flatten + Dense(128) yerine GlobalAveragePooling2D kullandık: her öznitelik haritasının ortalamasını alıp tek sayıya indirir. Daha az parametreyle daha iyi sonuç — model büyüklüğünün kalite demek olmadığının kanıtı.
3. Artırmalı model daha yavaş öğrenir (daha çok epoch gerekir) çünkü görevi zorlaştırdık. Bu beklenen ve istenen bir şey.

BatchNormalization ne yaptı? Her katmanın çıktısını normalleştirerek eğitimi hızlandırır ve daha büyük öğrenme hızına izin verir. Pratikte neredeyse her modern CNN'de bulunur.
Veri artırmanın altın kuralı: dönüşüm gerçekçi olmalı. Kendinize şunu sorun: “Bu dönüşümden geçmiş bir görüntü gerçek hayatta karşıma çıkabilir mi ve cevabı hâlâ aynı mı?”
• El yazısı biraz eğik olabilir → döndürme serbest.
• Rakam kâğıdın ortasında olmayabilir → kaydırma serbest.
• Aynaya tutulmuş bir “7” gerçek hayatta yoktur ve 7 olarak okunmaz → yatay çevirme YASAK.
• Ters duran bir rakam → genelde yasak (6 ile 9 birbirine dönüşür).

Uygunsuz artırma modeli iyileştirmez, bozar. Kedi/köpek probleminde yatay çevirme serbesttir ama rakamda değildir — karar her zaman probleme aittir.

Tahmin edin ve yarışmaya gönderin

hücre 10
olasilik_test = model2.predict(X_test, batch_size=256, verbose=1)
tahmin_test = olasilik_test.argmax(axis=1)

teslim = pd.DataFrame({
    "ImageId": np.arange(1, len(tahmin_test) + 1),   # 1'den baslar!
    "Label":   tahmin_test,
})
teslim.to_csv("/kaggle/working/submission.csv", index=False)
print(teslim.head())
print("Satir sayisi:", len(teslim), "(28000 olmali)")

# Tahminlerin dagilimi dengeli mi? Degilse bir sey ters gitti.
print("\nTahmin dagilimi:")
print(pd.Series(tahmin_test).value_counts().sort_index())

# Birkac test ornegini guvenle birlikte gorelim
plt.figure(figsize=(12, 1.8))
for k in range(10):
    plt.subplot(1, 10, k + 1)
    plt.imshow(X_test[k, :, :, 0], cmap="gray")
    plt.title(f"{tahmin_test[k]}\n%{olasilik_test[k].max()*100:.0f}", fontsize=9)
    plt.axis("off")
plt.tight_layout(); plt.show()
Çıktı
   ImageId  Label
0        1      2
1        2      0
2        3      9
3        4      9
4        5      3
Satir sayisi: 28000 (28000 olmali)
Göndermek için: Save Version → Save & Run All, tamamlanınca notebook'un Output sekmesinden submission.csv → Submit.

Teslim dosyasında üç kontrol: satır sayısı 28.000 mi? Sütun adları ImageId ve Label mı (büyük/küçük harf duyarlı)? ImageId 1'den mi başlıyor?

Beklenen skor %99 civarı. Lider tabloda bazı skorların %100 olduğunu göreceksiniz — onlar test cevaplarını başka bir kaynaktan (MNIST'in orijinal hâli herkese açıktır) almış çözümlerdir, gerçek bir model başarısı değildir. Kendi skorunuzu onlarla kıyaslamayın.

Karşılaştırma: CNN gerçekten gerekli miydi?

Bir iddiayı kanıtlamanın tek yolu alternatifini denemektir. Aynı veriyle üç model kuralım.

hücre 11
# --- A) Sadece Dense katmanlari (klasik sinir agi, komsulugu HIC kullanmaz) ---
mlp = keras.Sequential([
    keras.Input(shape=(28, 28, 1)),
    layers.Flatten(),
    layers.Dense(128, activation="relu"),
    layers.Dropout(0.3),
    layers.Dense(10, activation="softmax"),
])
mlp.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
g_mlp = mlp.fit(X_tr, y_tr, validation_data=(X_val, y_val),
                epochs=15, batch_size=128, verbose=0)

# --- B) Karar agaci (3. haftanin modeli, duz 784 sutunla) ---
from sklearn.tree import DecisionTreeClassifier
agac = DecisionTreeClassifier(max_depth=12, random_state=42)
agac.fit(X_tr.reshape(len(X_tr), -1), y_tr)
agac_skor = agac.score(X_val.reshape(len(X_val), -1), y_val)

print(f"{'Taban cizgisi (en kalabalik sinif)':38s} {taban:.4f}")
print(f"{'Karar agaci (max_depth=12)':38s} {agac_skor:.4f}")
print(f"{'Dense sinir agi (MLP)':38s} {max(g_mlp.history['val_accuracy']):.4f}   {mlp.count_params():>9,} parametre")
print(f"{'CNN':38s} {max(gecmis.history['val_accuracy']):.4f}   {model.count_params():>9,} parametre")
print(f"{'CNN + veri artirma':38s} {max(gecmis2.history['val_accuracy']):.4f}   {model2.count_params():>9,} parametre")
Çıktı
Taban cizgisi (en kalabalik sinif)     0.1115
Karar agaci (max_depth=12)             0.8512
Dense sinir agi (MLP)                  0.9781     101,770 parametre
CNN                                    0.9914     421,642 parametre
CNN + veri artirma                     0.9945      48,586 parametre
Bu tablo haftanın özeti. Üç ders var:
1 · Karar ağacı %85. Fena değil — ama 100 hatadan 15'ini yapıyor. Ağaç her pikseli bağımsız bir sütun sanıyor; komşuluğu hiç kullanmıyor.
2 · MLP %97,8, CNN %99,1. Arada sadece 1,3 puan var ama hata sayısı yarıya düşüyor (92 → 36). Üstelik MLP'nin daha az parametresi var: fark model büyüklüğünden değil, komşuluk bilgisini kullanmaktan geliyor.
3 · En iyi model en küçüğü. CNN + artırma, sekiz kat daha az parametreyle en iyi sonucu verdi. Doğru mimari ve doğru veri, büyüklükten her zaman önemlidir.

Not: MNIST kolay bir problemdir. Daha karmaşık veride (CIFAR-10 gibi) MLP %45'lerde kalırken CNN %90'ı geçer — aradaki fark orada uçurum hâline gelir.

Transfer öğrenme: hazır öğrenmiş bir ağı ödünç almak

Kendi veriniz 500 fotoğraftan oluşuyorsa sıfırdan CNN eğitmek işe yaramaz — ezberler. Çözüm: milyonlarca görüntüyle eğitilmiş bir ağın öğrendiği kenar/doku/parça bilgisini ödünç almak ve yalnızca son katmanı kendi probleminize göre eğitmek.

hücre 12 — internet AÇIK olmalı (Settings → Internet → On)
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input

# 1) Hazir govdeyi indir, SON katmanini al
govde = MobileNetV2(input_shape=(160, 160, 3), include_top=False, weights="imagenet")
govde.trainable = False          # ONEMLI: govdeyi DONDUR, agirliklari bozmayalim
print(f"Govde: {govde.count_params():,} parametre (hepsi DONMUS)")

# 2) Ustune kendi kucuk siniflandiricini tak
model3 = keras.Sequential([
    keras.Input(shape=(160, 160, 3)),
    layers.RandomFlip("horizontal"),       # fotograflarda serbest (rakamda degil!)
    layers.RandomRotation(0.1),
    layers.Lambda(preprocess_input),       # MobileNet'in bekledigi olceklemeye cevir
    govde,
    layers.GlobalAveragePooling2D(),
    layers.Dropout(0.25),
    layers.Dense(1, activation="sigmoid"), # iki sinif: kedi mi kopek mi
])
model3.compile(optimizer=keras.optimizers.Adam(1e-3),
               loss="binary_crossentropy", metrics=["accuracy"])
model3.summary()

# 3) Egit: sadece 2.561 parametre ogreniliyor -> 500 goruntuyle bile calisir
# model3.fit(egitim_akisi, validation_data=dogrulama_akisi, epochs=10)

# 4) INCE AYAR (fine-tuning): govdenin UST katmanlarini da ac, AMA kucuk ogrenme hiziyla
govde.trainable = True
for katman in govde.layers[:-30]:
    katman.trainable = False
model3.compile(optimizer=keras.optimizers.Adam(1e-5),   # 100 KAT kucuk!
               loss="binary_crossentropy", metrics=["accuracy"])
Transfer öğrenmenin üç kuralı:
1. Önce gövdeyi dondur ve sadece yeni başı eğit. Baştaki rastgele ağırlıklar, gövdenin yıllarca öğrendiği bilgiyi ilk birkaç adımda bozabilir.
2. İnce ayara geçerken öğrenme hızını 10–100 kat küçült (1e-3 → 1e-5).
3. Girdiyi hazır modelin beklediği biçime çevirin (preprocess_input) ve boyutunu tutturun. Bunu atlamak sessizce kötü sonuç verir.

Ne zaman kullanılır? Veriniz birkaç bin örnekten azsa transfer öğrenme neredeyse her zaman sıfırdan eğitmekten iyidir. Ödevde kendi veri setinizle bunu deneyebilirsiniz.
19 · Uyarılar

Sık yapılan on hata

Bu listedeki hataların her biri derste birden fazla öğrencide görülüyor. Ödeve başlamadan bir kez okuyun; saatler kazandırır.

BGR ile RGB'yi karıştırmak. Renkler ters çıkıyorsa kod hatalı değil, sıra hatalı. plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)).
Belirti: gökyüzü turuncu, ten mavi. Kural: cv2.imread → BGR, skimage / PIL → RGB.
cv2.imshow kullanmak. Notebook'ta ekran yoktur; hücre sonsuza kadar çalışır ve çekirdeği yeniden başlatmak gerekir. Her zaman matplotlib.
imread'in None dönüşünü kontrol etmemek. Yol yanlışsa OpenCV hata atmaz, sessizce None döner ve hata beş hücre sonra anlaşılmaz bir biçimde çıkar. if img is None: raise ... yazın.
resize'da boyut sırasını ters vermek. shape → (yükseklik, genişlik); resize → (genişlik, yükseklik). Kare olmayan görüntülerde resim ezilir ve çoğu öğrenci bunu geç fark eder.
uint8 taşmasını hesaba katmamak. goruntu + 60 işlemi 255'i aşan değerleri başa döndürür: parlak alanlar simsiyah olur. cv2.add ya da cv2.convertScaleAbs kullanın.
Kenar bulmadan önce bulanıklaştırmamak. Canny'nin çıktısı “kar yağmış” gibi görünüyorsa sebebi neredeyse her zaman budur. GaussianBlur bir kayıp değil, zorunlu ön adımdır.
Konturları alana göre süzmemek. Süzmezseniz 3 piksellik gürültü lekeleri de “nesne” sayılır ve sayım saçmalar. if cv2.contourArea(k) > esik satırını yazın.
Normalleştirmeyi atlamak. CNN'e 0–255 aralığında veri verirseniz eğitim ya çok yavaşlar ya hiç yakınsamaz. X / 255.0 — tek satır, ama eğitimin kaderini belirler.
Belirti: doğruluk ilk epoch'tan sonra %10'da (taban çizgisinde) takılı kalıyor.
reshape'i atlayıp CNN'e düz 784 sütun vermek. Evrişim komşuluk üzerine kuruludur; girdi (n, 28, 28, 1) biçiminde olmazsa CNN'in bir anlamı kalmaz.
Eğitim doğruluğunu rapor etmek. Modelin kendi öğrendiği veride aldığı skorun hiçbir değeri yoktur. Raporunuza her zaman val_accuracy yazın — ve yanına taban çizgisini.

Kaggle'a özel üç ayrı tuzak

BelirtiSebepÇözüm
Eğitim çok yavaş, epoch başına dakikalarGPU kapalı Settings → Accelerator → GPU T4 x2, sonra hücreleri baştan çalıştırın
URLError / indirme hatasıİnternet kapalı Settings → Internet → On (telefon doğrulaması gerektirir). Ya da internet gerektirmeyen veri kullanın: skimage.data, yarışma CSV'leri
FileNotFoundError: /kaggle/input/...Veri eklenmemiş ya da klasör adı farklı Sol panelde dosyanın üstüne gelip yolu kopyalayın; elle yazmayın. Kontrol: import os; print(os.listdir("/kaggle/input"))
20 · Ödev

Ödev: kendi görüntü sınıflandırıcınız

Ödev iki parçalı: (A) klasik OpenCV ile bir ölçme/sayma işi, (B) kendi seçtiğiniz veri setiyle bir CNN. İkisi de tek bir Kaggle notebook'unda olacak.

Görev 1 · ısınma

Dersin OpenCV notebook'unu kendiniz çalıştırın

Yukarıdaki OpenCV notebook'unu indirip Kaggle'a aktarın (ya da kodları kendiniz yazın) ve baştan sona çalıştırın. Sonra şu üç değişikliği yapın:

  • Canny eşiklerini (20, 60) ve (120, 240) yapıp çıkan iki sonucu yan yana koyun. Hangisi daha iyi, neden? Bir cümleyle yazın.
  • Çekirdek tezgâhındaki keskinleştirme çekirdeğinin merkezini 5 yerine 9 yapın (komşuları da buna göre ayarlayın). Ne bozuldu?
  • Para sayma kodunda EN_AZ_ALAN değerini 20 ve 800 yapıp bulunan nesne sayısını not edin.

Teslim: notebook'ta bu üç karşılaştırmanın görselleri ve her birinin altında birer cümle yorum.

Görev 2

Kendi görüntü veri setinizi seçin

Kaggle Datasets'ten bir görüntü sınıflandırma veri seti seçin. Şartlar:

  • 2–10 sınıf olsun (ikili de olur).
  • Sınıf başına en az 150 görüntü bulunsun.
  • Lisansı yazıyor olsun (Unknown olmasın).
  • İçinde kimliklenebilir kişisel veri olmasın (yüz veri setleri bu ödevde kabul edilmiyor).
  • Toplam boyut 2 GB'ın altında olsun — Kaggle oturumunuz yetişsin.

Konu fikirleri: çöp türü ayrıştırma (geri dönüşüm), yaprak hastalığı tespiti, kahve çekirdeği kalitesi, trafik işareti, beyin MR'ında tümör var/yok, pirinç cinsi, X-ray'de pnömoni, moda ürün kategorisi, çiçek türü, para birimi tanıma, kumaş kusuru tespiti, meyve tazeliği.

Görev 3 · A bölümü

Klasik OpenCV ile veri setinizi inceleyin

Kendi veri setinizden en az 3 görüntü seçip şu zinciri uygulayın ve her adımın çıktısını gösterin:

  • Gri tonlama + histogram (grafik olarak). Görüntüler karanlık mı, yanmış mı, kontrastsız mı?
  • Üç eşikleme: elle, Otsu, uyarlamalı. Hangisi sizin verinizde çalıştı, neden?
  • Kenar: Sobel büyüklüğü ve Canny. Eşikleri kendi verinize göre ayarlayın.
  • Morfoloji: eşiklenmiş görüntüyü açma + kapama ile temizleyin.
  • Kontur: en az bir görüntüde nesne sayın ya da en büyük nesnenin alanını/çevresini ölçün. Sonucu görüntünün üstüne çizin.

Bir paragraf yazın: “Bu problem klasik yöntemle çözülebilir miydi?” Cevabınız ne olursa olsun gerekçelendirin.

Görev 4 · B bölümü

CNN eğitin ve en az iki modeli karşılaştırın

  • Taban çizgisi: en kalabalık sınıfın oranı. Bu sayı raporda olmak zorunda.
  • Veri hazırlığı: ortak boyuta getirme, /255 normalleştirme, eğitim/doğrulama ayrımı (stratify ile).
  • Sınıf başına örnek sayısını yazın ve her sınıftan en az 3 örnek görüntüyü ekrana basın.
  • Model 1: sıfırdan basit bir CNN (en az 2 evrişim bloğu). summary() çıktısı olsun.
  • Model 2: ya veri artırmalı hâli ya da transfer öğrenme. İkisini karşılaştırın.
  • Eğitim grafikleri: loss ve accuracy, eğitim + doğrulama birlikte, taban çizgisi çizili.
  • Karmaşıklık matrisi ve en çok karıştırılan iki sınıf.
  • En az 8 yanlış tahmini resim olarak gösterin ve bir cümleyle yorumlayın.
Görev 5

Teslim

  • Public Kaggle notebook bağlantısı (kaggle.com/code/...). Save & Run All ile baştan sona hatasız çalışmış olmalı.
  • İki sayfalık rapor (PDF): problem, veri seti + lisansı, taban çizgisi, A bölümünün bulguları, iki modelin skorları, modelin en çok yaptığı hata ve bir cümle öz değerlendirme.
ModelDoğrulama doğruluğuParametreTaban çizgisini ne kadar geçti?
Taban çizgisi…——
Model 1 — basit CNN………
Model 2 — artırma / transfer………

Değerlendirme (100 puan)

ÖlçütNe arıyorumPuan
Veri seti seçimiŞartlara uygun; kaynağı, lisansı ve sınıf dağılımı yazılmış.10
A bölümü — OpenCVBeş adım uygulanmış, çıktıları gösterilmiş, eşikler kendi verisine göre ayarlanmış.25
Taban çizgisiHesaplanmış, grafiğe çizilmiş, model skoruyla karşılaştırılmış.10
Veri hazırlığıNormalleştirme, boyutlandırma, eğitim/doğrulama ayrımı doğru yapılmış.10
İki model ve karşılaştırmaİkisi de eğitilmiş, summary() ve parametre sayıları verilmiş, fark yorumlanmış.20
DeğerlendirmeEğitim grafikleri, karmaşıklık matrisi ve yanlış tahminlerin resimleri var.15
YorumSonuç kendi cümlelerinizle açıklanmış; modelin nerede yanıldığı söylenmiş.5
DüzenNotebook baştan sona çalışıyor, public, Markdown başlıklarıyla bölünmüş.5
Kabul edilmeyecekler
  • MNIST, Fashion-MNIST, CIFAR-10 ve Digit Recognizer yasak. Dersin örneği bunlar; internette hazır çözümü de çok fazla.
  • Kedi/köpek veri seti yasak — aynı sebep.
  • Başkasının notebook'unu kaynak göstermeden teslim etmek. Yararlanmak serbesttir; bağlantısını yazın ve neyi değiştirdiğinizi anlatın.
  • Taban çizgisi hesaplanmamış ödev.
  • Sadece accuracy yazan, karmaşıklık matrisi olmayan ödev.
  • A bölümünü atlayıp doğrudan CNN'e geçen ödev. İki bölüm de zorunlu.
  • Çalışmayan notebook. Teslimden önce Save & Run All yapıp hata çıkmadığını görün.
Bir tavsiye: %99 alan ödev en yüksek notu almayacak. Puanın yarıdan fazlası skorla hiç ilgili değil. Taban çizgisini 20 puan geçip “modelim şu iki sınıfı karıştırıyor, çünkü veri setinde ikisi de bulanık fotoğraflardan oluşuyor” diyen bir ödev, %98 alıp hiçbir yorum yazmayan ödevden yüksek not alır.

Zorlanırsanız sıralama şu: önce veri setini seçin (bu en uzun süren adım), sonra 50 görüntüyle bütün hattı baştan sona çalıştırın, en son tam veriyle eğitin. Küçük veriyle çalışan bir hat, büyük veriyle de çalışır.
21 · Toparlama

Özet ve ders akışı

Bir görüntü işleme projesinin iki yolu
Görüntü
imread
→
Gri
cvtColor
→
Bulanıklaştır
GaussianBlur
→
Eşikle
threshold / adaptive
→
Temizle
OPEN + CLOSE
→
Kontur
findContours
→
Ölç / say
klasik yol
Görüntü
imread
→
Boyutlandır
resize
→
Normalleştir
/ 255
→
Artır
rotate / shift / zoom
→
Conv + ReLU + Pool
×N kez
→
Dense + Softmax
sınıflandırıcı
→
Sınıf tahmini
CNN yolu
Üstteki yol öğrenmez, alttaki yol öğrenir. İlk üç kutu neredeyse aynı — bu yüzden OpenCV bilmeden CNN eğitilmez.

Bu haftanın on cümlesi

Dersten sonra tek başınıza yapın

4 saatlik önerilen ders akışı

SüreBölümKonu
0–20 dk01–03Görüntü = sayı tablosu. Lab 1 projeksiyonda: satranç tahtasında kenara tıklanıp sayılardaki atlama birlikte görülür. BGR tuzağı.
20–45 dk04–05Kaggle'da notebook açılır, skimage.data görüntüleri yüklenir, goster() yardımcısı yazılır. Kırpma, resize, döndürme.
45–75 dk06–07Histogram ve eşikleme. Lab 4, taranmış sayfa ile. “Hangi eşik işe yarıyor?” diye sınıfa sorulur, kimse bulamaz, sonra uyarlamalıya geçilir.
75–100 dk08Lab 5 — çekirdek tezgâhı. Dersin kritik 25 dakikası. Dokuz sayı birlikte değiştirilir, toplam kuralı tahtaya yazılır.
100–110 dk—Ara
110–145 dk09–12Gürültü (medyan ↔ 2. haftanın ortancası), kenar, morfoloji, para sayma. Herkes 24 paradan kaçını bulabildiğini söyler.
145–160 dk13–15HSV, Haar, filtre galerisi. Alıştırma tahtada oylanarak çözülür: klasik mi CNN mi?
160–190 dk16–17Lab 11 ve 13. Evrişim animasyonu adım adım, sonra herkes tuvale bir rakam çizer ve öznitelik haritalarına bakar.
190–225 dk18CNN eğitimi. GPU açılır, hücreler birlikte yazılır. Eğitim koşarken grafikler ve summary() tartışılır. Hücre 8 ile öğrenilmiş çekirdekler ekrana basılır.
225–240 dk19–20On hata okunur, ödev anlatılır, veri seti seçimi sınıfta başlatılır.
Hoca notu: Bu dersin iki “aydınlanma anı” var ve ikisi de atlanmamalı.

(1) 75–100 dakika — çekirdek tezgâhı. Öğrenciye dokuz sayıyı kendi elleriyle değiştirtmek, “filtre” kelimesinin soyutluğunu tamamen yok ediyor. Özellikle ortalama çekirdeğinde “toplama böl” kutusunu kapatıp görüntünün bembeyaz yandığını göstermek etkili: parlaklığın neden korunması gerektiği o anda anlaşılıyor.

(2) Hücre 8 — ağın öğrendiği çekirdekler. Dersin başında elle yazdığımız [-1,0,1 / -1,0,1 / -1,0,1] ile ağın bulduğu [-0.21,0.04,0.29 / -0.34,-0.05,0.37 / ...] yan yana tahtaya yazıldığında sınıfta kısa bir sessizlik oluyor. “Kimse ona dikey kenar ara demedi” cümlesi, dönemin geri kalanında öğrenmenin ne demek olduğunu anlatmak için yeterli hâle geliyor.

Pratik uyarı: GPU'yu ders başında değil, 18. bölüme gelince açtırın. Erken açılırsa boşta bekleyen oturumlar haftalık GPU kotasını tüketiyor ve eğitim sırasında kota biten öğrenciler çıkıyor.
Gelecek hafta
Bu hafta modellerimiz “bu görüntü hangi sınıfa ait?” sorusunu cevapladı. 5. haftada sorunun kendisini sorgulayacağız: doğruluk neyi ölçüyor, neyi ölçmüyor? Precision, recall, karmaşıklık matrisinin derinlemesine okunması ve aşırı öğrenme.

Bu haftanın 36 hatalı rakamı oraya giriş olacak: o hatalardan hangisi “kabul edilebilir”, hangisi “pahalı”? Bir tıbbi görüntüde kaçırılan tümör ile yanlış alarm aynı şey değil — ve bu kararı model değil, biz veriyoruz.

Final soru: Bir arkadaşınız “CNN modelim %97 doğruluk aldı” diyor. Hangi üç soruyu sorarsınız?

1 · “Taban çizgisi kaçtı?” İki sınıflı bir problemde örneklerin %96'sı tek sınıftaysa %97 bir başarı değil, neredeyse hiçbir şey yapmamaktır.
2 · “Bu sayıyı hangi veriyle ölçtün?” Eğitim verisiyle ölçtüyse anlamı yok. val_accuracy olmalı — ve veri artırma uygulanmamış, temiz bir doğrulama parçasıyla.
3 · “Hangi hatayı yapıyor?” Karmaşıklık matrisi olmadan %97'nin nerede kaybedildiği bilinmez. Üç sınıftan birini hiç bulamıyorsa ortalama doğruluk bunu gizler.

Bonus dördüncü soru: “Kaç görüntüyle eğittin?” 200 görüntüyle %97 alan bir model genellikle ya ezberlemiştir ya da doğrulama parçası eğitim verisiyle kirlenmiştir (aynı fotoğrafın iki kopyası, biri eğitimde biri doğrulamada). Görüntü veri setlerinde tekrarlanan dosyalar şaşırtıcı derecede yaygındır.