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.
Filtre uygulamak, her pikseli komşularıyla birlikte yeni bir sayıya çevirmektir. CNN'in yaptığı tek yenilik, o filtreyi kendisinin bulmasıdır.
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.
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.
Gri görüntü
Her piksel için tek sayı: parlaklık. (yükseklik, genişlik) boyutunda bir tablo.
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).
Her şey aritmetik
Resmi parlatmak = her sayıya 30 eklemek. Negatifini almak = 255 − sayı. Sihir yok, toplama çıkarma var.
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.
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
• 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.
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.
- 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)
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
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.
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.
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ı.
Öğrenmez
OpenCV'nin filtrelerini siz seçersiniz. “Kedi bul” diyemezsiniz. Öğrenme kısmı 16. bölümden itibaren CNN'in işi.
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.
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.
Koyu zeminde sekiz parlak nesne; ikisi birbirine değiyor. Eşikleme, morfoloji ve kontur ile sayma için.
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.
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.
Düzgün kareler ve çapraz bir ışık geçişi. Piksel değerlerini okumak, kenar ve köşe bulmak için.
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
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)
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.
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__)
OpenCV surumu: 4.10.0 NumPy surumu: 1.26.4
Örnek görüntüleri yükleyin ve bir bakın
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}")
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
• 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.
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"])
Kendi dosyanızı okumak: imread ve sessiz hata
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.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
| Ayar | Nereden | Ne zaman gerekir? |
|---|---|---|
| Internet | Sağ 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. |
| Accelerator | Sağ 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 Input | Sağ üst → Add Input | Kendi veri setinizi ya da bir yarışmayı eklemek için. CNN bölümünde Digit Recognizer ekleyeceğiz. |
| Save Version | Sağ ü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. |
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.
# 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)"])
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)
• 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.
# 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)"])
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).
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.
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.
α (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.
# --- 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)
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.
Ö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.
# 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)
Otsu'nun buldugu esik: 126.0
• 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.
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.
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).
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.
Bu dokuz sayı neden böyle? Çekirdek okuma rehberi
| Çekirdek | Toplamı | 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. |
• 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.
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"])
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.
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.
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.
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.
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ı.
| Filtre | Nasıl çalışır | Ne zaman kullanılır | Hız |
|---|---|---|---|
| blur (kutu) | Komşuların düz ortalaması. | Kaba ve hızlı yumuşatma. Kenarları en çok bozan yöntem. | Çok hızlı |
| GaussianBlur | Merkeze yakın komşu daha ağır sayılır. | Varsayılan seçiminiz bu olsun. Kenar bulmadan önceki standart adım. | Hızlı |
| medianBlur | Komşuların ortancası. Ortalama değil! | Tuz-biber gürültüsünün ilacı. Tek bir uç değer ortancayı hiç etkilemez. | Orta |
| bilateralFilter | Hem 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ş |
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.
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}")
--- 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
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.
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.
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.
Üçünün farkı nedir?
| Sobel | Laplacian | Canny | |
|---|---|---|---|
| Ne verir? | Yönlü türev (x ve y ayrı) | Yönsüz ikinci türev | İkili (0/255) ince kenar haritası |
| Çıktı tipi | Gri tonlu, 0–255 arası | Gri tonlu | Sadece 0 veya 255 |
| Kalınlık | Kalın, bulanık bantlar | Kalın, çift çizgili | Tek piksel kalınlığında |
| Gürültü | Orta duyarlı | Çok duyarlı | En dayanıklı (içinde bulanıklaştırma var) |
| Parametre | ksize | ksize | İ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. |
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.
# --- 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)
• 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.
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.
Hatırlama yolu: Açma = beyazı azaltır (beyaz lekeleri siler). Kapama = siyahı kapatır (siyah delikleri doldurur).
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.
# 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"])
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?
cvtColor
GaussianBlur
threshold + OTSU
OPEN + CLOSE
findContours
contourArea
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ığı.
# 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))
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 ...
Çö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.
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}")
• Ç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.
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.
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.
Doygunluk
“Ne kadar canlı?” 0 = gri, 255 = en canlı hâli. Beyaz, siyah ve grinin doygunluğu düşüktür.
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.
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]))
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.
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)
• 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.
# 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)
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.
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?
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.
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.
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.
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.
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.
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.
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.
• Ç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).
Her 2×2 kareden tek bir sayı seçiyoruz. İleri ▶ ile tek tek ilerleyin, sonra Ortalama'ya geçip farkı görün.
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.
784 sayı
320 parametre
0 parametre
18.496 parametre
0 parametre
0 parametre
401.536 parametre
1.290 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.
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.
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.
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.
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.
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.
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.
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)
TensorFlow: 3.5.0 Egitim: (42000, 785) Test : (28000, 784) Goruntu hali: (42000, 28, 28, 1)
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.
# 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))
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
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
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)
Egitim : (37800, 28, 28, 1) Dogrulama : (4200, 28, 28, 1)
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
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()
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
• 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”.
Eğitin
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,
)
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.
• 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 — 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
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.")
• İ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
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()
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
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.
# --- 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()
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)
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.
Aynı görüntünün dokuz varyasyonu. Ağ bunların hepsine aynı cevabı vermeyi öğrenmek zorunda — işte genellemeyi sağlayan şey bu.
# 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}")
Total params: 48,586 <- Flatten yerine GlobalAveragePooling: 421.642 -> 48.586 Model 1 (artirmasiz) : 0.9914 Model 2 (artirmali) : 0.9945
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.
• 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
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()
ImageId Label 0 1 2 1 2 0 2 3 9 3 4 9 4 5 3 Satir sayisi: 28000 (28000 olmali)
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.
# --- 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")
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
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.
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"])
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.
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.
Belirti: gökyüzü turuncu, ten mavi. Kural: cv2.imread → BGR, skimage / PIL → RGB.
Belirti: doğruluk ilk epoch'tan sonra %10'da (taban çizgisinde) takılı kalıyor.
Kaggle'a özel üç ayrı tuzak
| Belirti | Sebep | Çözüm |
|---|---|---|
| Eğitim çok yavaş, epoch başına dakikalar | GPU 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")) |
Ö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.
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.
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.
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.
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.
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.
| Model | Doğrulama doğruluğu | Parametre | Taban çizgisini ne kadar geçti? |
|---|---|---|---|
| Taban çizgisi | … | — | — |
| Model 1 — basit CNN | … | … | … |
| Model 2 — artırma / transfer | … | … | … |
Değerlendirme (100 puan)
| Ölçüt | Ne arıyorum | Puan |
|---|---|---|
| Veri seti seçimi | Şartlara uygun; kaynağı, lisansı ve sınıf dağılımı yazılmış. | 10 |
| A bölümü — OpenCV | Beş adım uygulanmış, çıktıları gösterilmiş, eşikler kendi verisine göre ayarlanmış. | 25 |
| Taban çizgisi | Hesaplanmış, 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ğerlendirme | Eğitim grafikleri, karmaşıklık matrisi ve yanlış tahminlerin resimleri var. | 15 |
| Yorum | Sonuç kendi cümlelerinizle açıklanmış; modelin nerede yanıldığı söylenmiş. | 5 |
| Düzen | Notebook baştan sona çalışıyor, public, Markdown başlıklarıyla bölünmüş. | 5 |
- 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.
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.
Özet ve ders akışı
imread
cvtColor
GaussianBlur
threshold / adaptive
OPEN + CLOSE
findContours
klasik yol
imread
resize
/ 255
rotate / shift / zoom
×N kez
sınıflandırıcı
CNN yolu
Bu haftanın on cümlesi
Dersten sonra tek başınıza yapın
4 saatlik önerilen ders akışı
| Süre | Bölüm | Konu |
|---|---|---|
| 0–20 dk | 01–03 | Gö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 dk | 04–05 | Kaggle'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 dk | 06–07 | Histogram 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 dk | 08 | Lab 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 dk | 09–12 | Gürültü (medyan ↔ 2. haftanın ortancası), kenar, morfoloji, para sayma. Herkes 24 paradan kaçını bulabildiğini söyler. |
| 145–160 dk | 13–15 | HSV, Haar, filtre galerisi. Alıştırma tahtada oylanarak çözülür: klasik mi CNN mi? |
| 160–190 dk | 16–17 | Lab 11 ve 13. Evrişim animasyonu adım adım, sonra herkes tuvale bir rakam çizer ve öznitelik haritalarına bakar. |
| 190–225 dk | 18 | CNN 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 dk | 19–20 | On hata okunur, ödev anlatılır, veri seti seçimi sınıfta başlatılır. |
(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.
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?
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.