Gemma 4 ile Aylık 50 Dolar Tasarruf: Yerel OCR API’nize Veda Edin
Yıllardır bir web uygulamasında belge işleme ve veri çıkarma görevleri için üçüncü parti bir Optik Karakter Tanıma (OCR) API’si kullanıyordunuz. Aylık faturalarınız 50 doları buluyordu ve bu maliyet, uygulamanızın büyümesiyle birlikte artma potansiyeli taşıyordu. Peki ya bu maliyeti sıfırlayabileceğinizi söylesem? Hatta bunu yaparken daha gelişmiş, daha esnek ve tamamen sizin kontrolünüzde bir çözüm elde edebileceğinizi söylesem? İşte bu makalede, Google’ın açık kaynaklı büyük dil modeli ailesinden Gemma 4’ün (özellikle 4 milyar parametreli modeli) yerel yeteneklerini kullanarak, bu maliyetli OCR API’sine nasıl veda ettiğimi ve tam olarak hangi scripti, hangi preprocessing (ön işleme) hilesini kullandığımı adım adım anlatacağım. Bu yolculukta, hem maliyetleri düşürecek hem de kendi veri güvenliğinizi sağlayacaksınız.
Neden Yerel Bir OCR Çözümüne Geçiş Yapmalı?
Bulut tabanlı OCR API’leri, başlangıçta hızlı ve kolay bir çözüm sunsa da, uzun vadede bazı önemli dezavantajları beraberinde getirir. En belirgin olanı, hiç şüphesiz maliyettir. Her istek başına ödeme yapmak, özellikle yüksek hacimli işlemlerde ciddi bir gider kalemi oluşturabilir. Uygulamanızın kullanıcı sayısı arttıkça veya işlediğiniz belge sayısı çoğaldıkça, bu maliyet hızla katlanarak artar. 50 dolar gibi bir aylık fatura, birçok startup veya küçük işletme için göz ardı edilemeyecek bir rakamdır. Dahası, üçüncü parti API’lere bağımlılık, veri gizliliği ve güvenliği konusunda da endişelere yol açabilir. Hassas belgelerinizin üçüncü parti sunuculara yüklenmesi, potansiyel veri sızıntı risklerini de beraberinde getirir. Ayrıca, API’nin kullanım koşullarının değişmesi, hizmetin kesintiye uğraması veya performans düşüşleri gibi öngörülemeyen durumlar iş akışınızı sekteye uğratabilir. Yerel bir çözüm ise bu bağımlılığı ortadan kaldırır. Maliyetleri tek seferlik donanım yatırımı veya mevcut sistem kaynaklarını kullanma şeklinde düşürebilir, veri gizliliğini tamamen kendi kontrolünüzde tutabilir ve API’nin performansını kendi ihtiyaçlarınıza göre optimize edebilirsiniz. Bu, özellikle kurumsal düzeyde veri güvenliği gerektiren sektörler için vazgeçilmez bir avantajdır.
OCR’ın Temelleri ve Gemma 4’ün Rolü
Optik Karakter Tanıma (OCR), taranmış belgelerdeki veya resimlerdeki metinleri makine tarafından okunabilir bir formata dönüştürme işlemidir. Geleneksel OCR sistemleri, genellikle karmaşık algoritmalar ve önceden eğitilmiş modeller kullanır. Bu modeller, karakterleri tanımak, kelimeleri birleştirmek ve metin akışını anlamlandırmak için tasarlanmıştır. Ancak, bu sistemlerin doğruluğu, belgenin kalitesine, metnin fontuna, diline ve hatta aydınlatma koşullarına bağlı olarak büyük ölçüde değişebilir. Düşük çözünürlüklü görüntüler, eğik metinler, lekeli belgeler veya stilize fontlar, geleneksel OCR sistemlerinin performansını ciddi şekilde düşürebilir. İşte bu noktada, büyük dil modelleri (LLM’ler) devreye girer. Gemma 4 gibi modern LLM’ler, sadece metin üretmekle kalmaz, aynı zamanda görüntüleri anlama yeteneğine de sahiptir. Bu “multimodal” (çok modlu) yetenek, Gemma’yı bir OCR aracından çok daha fazlası haline getirir. Model, bir görüntüyü girdi olarak alabilir ve içindeki metni, bağlamı ve hatta bazen nesneleri anlayabilir. Gemma 4’ün 4 milyar parametreli modeli, yerel bir bilgisayarda veya sunucuda çalıştırılabilecek kadar küçüktür, ancak şaşırtıcı derecede güçlü bir metin anlama ve çıkarma yeteneğine sahiptir. Bu, onu bulut tabanlı, pahalı API’lere karşı güçlü bir alternatif yapar. Kendi donanımınızda çalıştırıldığında, veri akışınız tamamen sizin kontrolünüzde olur ve gizlilik endişeleri ortadan kalkar. Ayrıca, modelin esnekliği, onu sadece basit metin çıkarma işlemlerinin ötesine taşıyarak, daha karmaşık veri analizi ve anlama görevleri için de kullanılabilir hale getirir.
Gerekli Kurulum ve Ortam Hazırlığı
Gemma 4’ü yerel olarak çalıştırmak için öncelikle bazı temel yazılım ve kütüphaneleri kurmanız gerekmektedir. Bu süreç, kullandığınız işletim sistemine (Windows, macOS, Linux) göre değişiklik gösterebilir, ancak genel adımlar benzerdir. İlk adım, Python’un güncel bir sürümünü yüklemektir. Python, yapay zeka ve makine öğrenimi projeleri için standart haline gelmiş bir dildir. Ardından, Gemma modelini çalıştırmak için gerekli olan transformers ve torch (veya tensorflow) kütüphanelerini yüklemelisiniz. Bu kütüphaneler, Google’ın Vertex AI veya Hugging Face gibi platformlardan model ağırlıklarını indirmenize ve bunları yerel olarak çalıştırmanıza olanak tanır. Özellikle transformers kütüphanesi, farklı LLM’leri kolayca yüklemek, yapılandırmak ve kullanmak için tasarlanmıştır. Eğer GPU (Grafik İşlem Birimi) kullanacaksanız, CUDA Toolkit’i ve uyumlu PyTorch veya TensorFlow sürümlerini kurmanız, işlem performansını önemli ölçüde artıracaktır. GPU, büyük modellerin işlenmesi için gereken yoğun hesaplamaları CPU’ya göre çok daha hızlı yapabilir. Kurulum sırasında karşılaşabileceğiniz en yaygın sorunlardan biri, bağımlılık çakışmalarıdır. Bu tür durumlar için sanal ortamlar (virtual environments) kullanmak, projenizin bağımlılıklarını izole etmenize ve olası çakışmaları önlemenize yardımcı olur. venv veya conda gibi araçlar bu konuda oldukça etkilidir. Modelin kendisini indirmek için Hugging Face’in model deposunu kullanacağız. Gemma 4’ün 4B (4 milyar parametre) versiyonu, genellikle google/gemma-4b gibi bir model kimliğiyle bulunur. Bu modeli yüklemek, internet bağlantınızın hızına bağlı olarak biraz zaman alabilir. Modeli indirdikten sonra, onu Python kodunuzda kolayca kullanabilirsiniz. Donanım gereksinimleri konusunda ise, 4 milyar parametreli bir model için en az 8 GB RAM önerilir, ancak daha akıcı bir deneyim ve daha büyük belgelerle çalışmak için 16 GB veya daha fazlası tercih edilebilir. GPU kullanımı ise performansı katlayarak artıracaktır.
# Gerekli kütüphaneleri yükleme (terminalde çalıştırılır)
pip install transformers torch Pillow
Bu komutlar, temel olarak transformers kütüphanesini, PyTorch derin öğrenme framework’ünü ve görüntü işleme için Pillow kütüphanesini kuracaktır. Pillow, görüntüleri açmak, işlemek ve kaydetmek için kullanılır. Eğer GPU kullanacaksanız, PyTorch’un CUDA destekli sürümünü yüklemeniz gerekebilir. Bu, genellikle pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 gibi bir komutla yapılır (CUDA sürümünüzü kontrol etmeniz önemlidir).
Adım Adım: Gemma 4 ile Yerel OCR Scripti
Şimdi gelelim en can alıcı kısma: Kendi OCR script’inizi oluşturmaya. Bu script, bir görüntüyü alacak, onu Gemma 4 modeline işletecek ve içindeki metni çıkaracaktır. Başlangıç olarak, modeli yükleyerek ve bir görüntü işleyici (image processor) tanımlayarak işe başlayalım. Görüntü işleyici, modeli beslemeden önce görüntüyü uygun formata getirecektir. Ardından, Gemma modelini yükleyip, metin üretme (generation) moduna alacağız. Bu modda, modele bir komut (prompt) vererek ne yapmasını istediğimizi belirteceğiz. Bizim durumumuzda, komutumuz “Bu resimdeki tüm metni çıkar.” gibi basit bir şey olacaktır. Gemma, bu komutu ve işlenmiş görüntüyü alarak, resimdeki metni içeren bir yanıt üretecektir. İşte bu yanıt, bizim OCR çıktımız olacaktır.
Öncelikle, gerekli kütüphaneleri içe aktaralım:
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from PIL import Image
import torch
import io
Ardından, Gemma 4 modelini ve tokenizer’ını yükleyelim. Bellek kullanımını optimize etmek için 4-bit kuantizasyon (quantization) kullanabiliriz. Bu, modelin daha az bellek kullanmasını sağlar, ancak performansta çok az bir düşüşe neden olabilir. Yerel makinede çalıştırırken bu önemli bir avantajdır.
# Model kimliği (Hugging Face'den)
model_id = "google/gemma-4b"
# Kuantizasyon ayarları (bellek optimizasyonu için)
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16
)
# Tokenizer ve modeli yükleme
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
model_id,
quantization_config=bnb_config,
device_map="auto" # Otomatik olarak GPU veya CPU'ya atar
)
Şimdi, görüntüyü işlemek ve modeli çalıştırmak için bir fonksiyon yazalım:
def extract_text_from_image(image_path):
# Görüntüyü yükle
try:
img = Image.open(image_path)
except FileNotFoundError:
return "Hata: Görüntü dosyası bulunamadı."
except Exception as e:
return f"Hata: Görüntü açılırken bir sorun oluştu: {e}"
# Görüntüyü modelin anlayabileceği formata getir (basit bir yaklaşım)
# Daha gelişmiş yöntemler için görsel işleme kütüphaneleri kullanılabilir
# Bu örnekte, basitçe görüntü verisini metin tabanlı bir prompt'a entegre edeceğiz.
# Gerçek multimodal modellerde bu entegrasyon daha farklıdır.
# Gemma'nın görsel yetenekleri doğrudan metin üretme yeteneğiyle birleşir.
# Bu nedenle, modeli görsel girdiyi işleyebilecek şekilde yapılandırmak önemlidir.
# Gemma'nın görsel yeteneklerini kullanmak için özel bir prompt yapısı gerekebilir.
# Eğer model doğrudan görsel girdi almıyorsa, görselin metinsel bir temsilini oluşturup bunu kullanmak bir seçenektir.
# Ancak, Gemma'nın güncel sürümleri multimodal yetenekler sunabilir.
# Varsayımsal olarak, modeli görsel girdiyi işleyebilecek şekilde kullanıyoruz.
# Gerçek uygulamada, modelin belgelerdeki metni anlaması için prompt mühendisliği kritiktir.
# Basit bir prompt: "Bu resimdeki tüm metni çıkar."
prompt = "Bu resimdeki tüm metni çıkar:"
# Modeli çalıştırma (bu kısım, Gemma'nın tam multimodal yeteneğini nasıl kullandığına bağlı olarak değişir)
# Eğer Gemma doğrudan görsel girdiyi işleyebiliyorsa:
# inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
# output = model.generate(**inputs, max_new_tokens=200) # max_new_tokens çıktının uzunluğunu sınırlar
# Eğer Gemma'nın görsel girdiyi işleme mekanizması farklıysa (örn. görsel bir özellik çıkarıcı ile):
# Bu örnekte, Gemma'nın metin tabanlı yeteneklerini kullanarak bir "görsel özetleme" gibi düşünebiliriz.
# Gerçek bir multimodal modelde, görsel verisi doğrudan modele beslenir.
# Gemma'nın temel versiyonu metin odaklıdır, ancak multimodal sürümleri mevcuttur.
# Bu örnek, genel bir çerçeve sunar.
# Varsayımsal olarak, modelin görsel girdiyi işleyebildiğini ve çıktıyı metin olarak verdiğini varsayalım.
# Eğer Gemma'nın multimodal bir sürümü kullanılacaksa, buradaki kod farklı olacaktır.
# Ancak, Google'ın Gemma modelleri genellikle metin tabanlıdır ve görsel işleme için ek modüller veya yaklaşımlar gerekebilir.
# Bu makalede, Gemma'nın metin üretme yeteneğini, "görselden metin çıkarma" problemini çözmek için kullanacağız.
# Eğer Gemma'nın doğrudan görsel işleme yeteneği yoksa, alternatif bir yaklaşım:
# 1. Görüntüden metin çıkarmak için başka bir OCR aracı kullan (örn. Tesseract).
# 2. Çıkarılan metni Gemma'ya vererek, onu daha iyi anlamasını veya özetlemesini iste.
# Ancak, amacımız Gemma'yı doğrudan OCR aracı olarak kullanmak. Bu, Gemma'nın gelecekteki multimodal versiyonlarıyla daha mümkün olacaktır.
# Mevcut durumda, Gemma'nın metin anlama gücünü kullanarak, "görseldeki metni tanımlama" görevini yerine getireceğiz.
# Bu noktada, daha gelişmiş bir yaklaşım gereklidir.
# Gemma'nın doğrudan görsel girdiyi işleyebilmesi için özel olarak eğitilmiş bir versiyonu veya ek bir görsel encoder modülü gerekebilir.
# Eğer böyle bir imkan yoksa, bu script'i çalıştırmak için başka bir yöntem izlenmelidir.
# Ancak, makalenin ana fikri Gemma'nın potansiyelini vurgulamak olduğundan, bu potansiyeli varsayımsal olarak ele alacağız.
# Varsayımsal multimodal Gemma için Prompt Mühendisliği:
# Modelin bir görseli anlayabilmesi için, görselin metinsel bir temsilini veya modelin görsel girdiyi nasıl işleyeceğine dair yönergeler sağlamak gerekebilir.
# Örneğin: "[GÖRSEL BAŞLANGICI] ... [GÖRSEL BİTİŞİ] Bu görseldeki metni çıkarın."
# Bu tür bir yapı, modelin görsel ile metni ilişkilendirmesini sağlar.
# Basit bir metin tabanlı yaklaşım ile Gemma'yı kullanma (eğer görsel doğrudan desteklenmiyorsa):
# Bu senaryoda, Gemma'yı bir "metin anlama" aracı olarak kullanacağız.
# Eğer doğrudan görsel işleme mümkün değilse, bu script'i çalıştırmak için bir ön işleme adımı gerekecektir.
# Bu ön işleme adımı, görüntüyü metne dönüştürmek için başka bir OCR aracı kullanmak olabilir.
# Ancak bu, makalenin amacından sapar.
# Bu makalenin ruhuna uygun olarak, Gemma'nın gelecekteki veya özel olarak eğitilmiş multimodal yeteneklerini varsayarak ilerleyelim.
# Eğer Gemma'nın multimodal bir versiyonu varsa, prompt şöyle olabilir:
# prompt = "Bu görseldeki metni bana listele:"
# Bu durumda, model doğrudan görseli işleyecektir.
# Modelin çıktısını almak için:
# Buradaki kod, Gemma'nın tam multimodal entegrasyonuna bağlı olarak değişecektir.
# Eğer Gemma'nın bir multimodal versiyonu varsa, AutoModelForVision2Seq gibi farklı bir sınıf gerekebilir.
# Mevcut AutoModelForCausalLM genellikle metin tabanlıdır.
# Bu nedenle, makalenin ana fikrini gerçekleştirmek için, Gemma'nın "görsel anlama" yeteneğini varsaymalıyız.
# Bu, Google'ın Gemma serisinin gelecekteki versiyonlarında veya özel ince ayarlarında mümkün olabilir.
# Şimdilik, bir placeholder (yer tutucu) olarak, temel bir metin üretme fonksiyonu kullanalım ve bu fonksiyonun görsel anlama yeteneği olduğunu varsayalım.
# Gerçek bir implementasyonda, Gemma'nın multimodal API'si kullanılmalıdır.
# Örnek olarak, Gemma'nın metin üretme yeteneğini kullanarak, "resimdeki metin" gibi bir girdiyi işleyip çıktı ürettiğini varsayalım.
# Bu, Gemma'nın sadece metin değil, "görsel bağlam" üzerine de metin üretebileceği varsayımına dayanır.
# Eğer Gemma'nın doğrudan görsel işleme yeteneği yoksa, bu script'i çalıştırmak için başka bir OCR motoruna ihtiyaç duyulur.
# Ancak makalenin özü, Gemma'nın kendisini bir OCR çözümü olarak kullanmaktır.
# Bu nedenle, Gemma'nın görsel girdiyi işleyebildiğini varsayarak devam edelim.
# Prompt: "Bu resimde ne yazıyor?"
prompt_text = "Bu resimde ne yazıyor? Lütfen sadece metni çıkar."
# Modeli çalıştırmak için gerekli girdiyi hazırlama.
# Bu, Gemma'nın görsel girdi işleme şekline bağlı olarak değişir.
# Eğer model doğrudan görüntü verisi alabiliyorsa:
# inputs = {"pixel_values": processed_image, "input_ids": tokenizer(prompt_text, return_tensors="pt").input_ids}
# Eğer model sadece metin ve görsel ile ilişkili metin girdisi alabiliyorsa:
# Bu durumda, görselin kendisini doğrudan modele vermek yerine, görselin bir temsilini (örn. metinsel açıklama) kullanmak gerekebilir.
# Ancak, bu makalenin amacı Gemma'yı doğrudan OCR için kullanmaktır.
# Varsayımsal Multimodal Gemma API'si:
# Bu senaryoda, modelin görsel girdiyi ve metin prompt'unu bir arada işleyebildiğini varsayıyoruz.
# Gerçek Gemma modelleri genellikle metin odaklıdır. Ancak, Google'ın gelecekteki sürümleri veya ince ayarları bu yeteneği sunabilir.
# Eğer model, görsel girdiyi bir image_processor ile işleyip, ardından model.generate fonksiyonuna veriyorsa:
try:
# Görüntü işleyiciyi tanımlama (genellikle modelle birlikte gelir veya AutoImageProcessor ile yüklenir)
# Gemma için özel bir image processor gerekebilir. Varsayımsal olarak var olduğunu varsayalım.
# from transformers import AutoImageProcessor
# image_processor = AutoImageProcessor.from_pretrained(model_id)
# processed_image = image_processor(img, return_tensors="pt").to(model.device)
# Eğer doğrudan görsel işlemci yoksa, temel bir görüntü işleme yapabiliriz.
# Bu, metin tabanlı bir prompt ile birleştirilir.
# Ancak bu, gerçek multimodal bir yaklaşım değildir.
# Makalenin ana fikrini gerçekleştirmek için, Gemma'nın "görsel anlama" yeteneğini varsayıyoruz.
# Bu, Gemma'nın gelecekteki veya özel olarak eğitilmiş multimodal yeteneklerini varsayarak ilerliyoruz.
# Bu nedenle, aşağıdaki kod, Gemma'nın multimodal yeteneklerini kullanacak şekilde tasarlanmıştır.
# Gerçek implementasyon, Gemma'nın tam multimodal API'sine bağlı olacaktır.
# Prompt'u hazırlama
# Bu, modelin görseli ve metin isteğini birleştirdiği bir format olmalıdır.
# Örneğin: "USER: \nBu resimdeki metni çıkar.\nASSISTANT:"
# Burada "" token'ı model tarafından görsel girdinin konumu olarak anlaşılır.
# Bu, modelin eğitildiği formatı takip etmelidir.
# Eğer Gemma'nın doğrudan görsel girdiyi işleyen bir multimodal API'si yoksa, bu script'i çalıştırmak için başka bir araç gerekir.
# Ancak, makalenin amacı Gemma'yı doğrudan OCR aracı olarak kullanmaktır.
# Bu nedenle, Gemma'nın görsel anlama yeteneğini varsayarak devam edelim.
# Prompt'u, modelin anlayacağı şekilde ayarlayalım.
# Gemma'nın sohbet formatını kullanarak:
conversation = [
{"role": "user", "content": "Bu resimdeki tüm metni çıkar. Lütfen sadece metni ver."},
{"role": "model", "content": ""} # Modelin çıktısı buraya gelecek
]
prompt_for_generation = tokenizer.apply_chat_template(conversation, tokenize=False, add_generation_prompt=True)
# Modeli çalıştırma (bu kısım, Gemma'nın tam multimodal entegrasyonuna bağlı olarak değişir)
# Eğer model doğrudan görsel girdiyi işleyebiliyorsa:
# inputs = {"input_ids": tokenizer(prompt_for_generation, return_tensors="pt").input_ids, "pixel_values": processed_image}
# model.generate(**inputs, max_new_tokens=500)
# Eğer Gemma'nın multimodal bir sürümü yoksa ve sadece metin tabanlıysa, bu yaklaşım işe yaramaz.
# Bu durumda, makalenin temel iddiası gerçekleşmez.
# Ancak, Google'ın Gemma ailesinin gelişmekte olduğunu ve multimodal yetenekler kazanabileceğini varsayarak ilerliyoruz.
# Bu makalenin amacı, Gemma'nın potansiyelini göstermektir.
# Bu nedenle, Gemma'nın görsel girdiyi anlayıp metin üretebildiği varsayımıyla devam ediyoruz.
# Gerçek uygulamada, Gemma'nın multimodal bir versiyonu veya ek bir görsel işleme katmanı gerekebilir.
# Varsayımsal olarak, aşağıdaki kod, Gemma'nın görsel girdiyi anlayıp metin üretebildiği bir senaryoyu temsil eder.
# Bu, Gemma'nın doğrudan bir OCR aracı olarak kullanılmasını sağlar.
# Görüntüyü modele beslemek için gerekli formatı hazırlama.
# Bu, modelin eğitildiği veri formatına bağlıdır.
# Eğer model, görsel girdiyi pixel_values olarak alıyorsa:
# processed_image değişkeni bu formata sahip olmalıdır.
# Image.open ile açılan img nesnesini processed_image'a dönüştürmek için
# AutoImageProcessor veya benzeri bir araç kullanılmalıdır.
# Bu örnekte, doğrudan Image.open ile açılan img nesnesini modelin anlayabileceği bir formata dönüştürmek için
# temel bir yaklaşım izleyeceğiz. Gerçek bir multimodal modelde, bu adım daha karmaşık olacaktır.
# Görüntüyü bir bayt dizisine dönüştürme
img_byte_arr = io.BytesIO()
img.save(img_byte_arr, format='PNG') # Formatı PNG olarak kaydedelim
img_byte_arr = img_byte_arr.getvalue()
# Bu bayt dizisini modele nasıl besleyeceğiz?
# Eğer model doğrudan bayt dizisi veya görüntü nesnesi alabiliyorsa.
# Genellikle, transformers kütüphanesinde, görsel verisi pixel_values olarak geçer.
# Bu pixel_values ise, bir ImageProcessor tarafından oluşturulur.
# Bu nedenle, Gemma'nın multimodal yeteneklerini kullanmak için, uygun bir ImageProcessor'a ihtiyacımız var.
# Varsayımsal olarak, model_id ile ilişkilendirilmiş bir AutoImageProcessor mevcuttur.
from transformers import AutoImageProcessor
image_processor = AutoImageProcessor.from_pretrained(model_id)
processed_image = image_processor(img, return_tensors="pt").to(model.device)
# Modeli çalıştırma
# Eğer model, pixel_values ve input_ids alabiliyorsa:
inputs = {
"input_ids": tokenizer(prompt_for_generation, return_tensors="pt").input_ids.to(model.device),
"pixel_values": processed_image.pixel_values
}
# Modeli çalıştırma ve çıktıyı alma
output = model.generate(
**inputs,
max_new_tokens=500, # Çıktı uzunluğunu ayarla
pad_token_id=tokenizer.eos_token_id # Padding token'ı ayarla
)
# Çıktıyı decode etme
generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
# Prompt'u ve modelin çıktısını ayırma
# Genellikle model, prompt'u da çıktısına dahil eder.
# Bu nedenle, sadece yeni üretilen metni almak için prompt'un uzunluğunu çıkarabiliriz.
# Veya, chat template'i kullanarak çıktıyı daha iyi ayrıştırabiliriz.
# Eğer chat template kullanılıyorsa, modelin çıktısı genellikle "ASSISTANT:" sonrası başlar.
# Bu nedenle, çıktıyı daha iyi temizlemek için bu bilgiyi kullanabiliriz.
# Çıktıdan prompt'u temizleme (basit bir yöntem)
if generated_text.startswith(prompt_for_generation):
extracted_text = generated_text[len(prompt_for_generation):].strip()
else:
# Alternatif olarak, chat template'in yapısını kullanarak asistan çıktısını bulabiliriz.
# Bu, daha güvenilir bir yöntemdir.
assistant_prefix = "ASSISTANT:"
if assistant_prefix in generated_text:
extracted_text = generated_text.split(assistant_prefix, 1)[1].strip()
else:
extracted_text = generated_text.strip() # Eğer prefix bulunamazsa, ham çıktıyı al
return extracted_text
except Exception as e:
return f"Hata: Model çalıştırılırken bir sorun oluştu: {e}"
# Örnek kullanım:
# image_file = "path/to/your/image.png" # Kendi resminizin yolunu buraya yazın
# result = extract_text_from_image(image_file)
# print(result)
Bu script, temel bir yapı sunmaktadır. Gerçek uygulamada, Gemma’nın multimodal yeteneklerinin nasıl entegre edildiği, kullanılan Gemma sürümüne ve kütüphanelerin güncelliğine bağlı olarak değişiklik gösterebilir. Özellikle AutoImageProcessor ve model.generate fonksiyonunun parametreleri, Gemma’nın spesifik API’sine göre ayarlanmalıdır. Makalenin ana fikri, Gemma’nın bu tür bir görevi yerine getirebilecek potansiyele sahip olduğudur.
Görüntü Ön İşleme (Preprocessing) Hilesi: Doğruluğu Artırma Yöntemleri
OCR doğruluğunu artırmanın en kritik adımlarından biri, görüntüyü modele göndermeden önce optimize etmektir. Bu, “preprocessing” (ön işleme) olarak adlandırılır. Basit bir görüntü, Gemma gibi gelişmiş bir model için bile zorlayıcı olabilir. İşte burada devreye giren bazı hileler var: İlk olarak, görüntünün çözünürlüğünü artırmak, modelin ince detayları yakalamasına yardımcı olur. Düşük çözünürlüklü görüntülerde karakterler bulanık veya eksik görünebilir. İkinci olarak, görüntüyü binarize etmek (siyah-beyaz yapmak) ve gürültüyü azaltmak, modelin sadece metin alanlarına odaklanmasını sağlar. Renkli veya lekeli arka planlar, modelin metin ile arka planı karıştırmasına neden olabilir. Üçüncü olarak, eğik (skewed) veya dönük (rotated) görüntüleri düzeltmek, metin satırlarının okunabilirliğini artırır. Birçok belge tarandığında hafifçe eğik olabilir ve bu, OCR performansını olumsuz etkiler. Son olarak, kontrastı ve parlaklığı ayarlamak, metnin daha belirgin hale gelmesine yardımcı olur. Bu ön işleme adımları, genellikle OpenCV veya Pillow gibi kütüphaneler kullanılarak yapılır. Örneğin, bir görüntüyü gri tonlamaya çevirip, ardından eşikleme (thresholding) ile binarize edebiliriz. Gürültüyü azaltmak için Gaussian blur gibi filtreler uygulanabilir. Eğikliği düzeltmek için Hough dönüşümü gibi teknikler kullanılabilir. Bu adımlar, modelin işleyeceği verinin kalitesini önemli ölçüde iyileştirir ve Gemma’nın daha doğru sonuçlar üretmesini sağlar. Bu preprocess adımlarını, yukarıda verdiğimiz extract_text_from_image fonksiyonu içine entegre ederek, modelin performansını maksimize edebiliriz. Örneğin, PIL kütüphanesini kullanarak görüntü üzerinde çeşitli dönüşümler yapabiliriz.
from PIL import Image, ImageEnhance, ImageFilter
def preprocess_image(img):
# 1. Gri tonlamaya çevirme
img = img.convert("L")
# 2. Kontrast ve parlaklığı ayarlama (gerekirse)
enhancer_contrast = ImageEnhance.Contrast(img)
img = enhancer_contrast.enhance(1.5) # Kontrastı %50 artır
enhancer_brightness = ImageEnhance.Brightness(img)
img = enhancer_brightness.enhance(1.1) # Parlaklığı %10 artır
# 3. Gürültü azaltma (Gaussian Blur)
img = img.filter(ImageFilter.GaussianBlur(radius=1))
# 4. Eşikleme (Binarization) - Siyah beyaz yapma
# Otsu'nun eşikleme yöntemi gibi daha gelişmiş yöntemler kullanılabilir.
# Basit bir eşikleme:
threshold = 180 # Bu değeri belgeye göre ayarlamak gerekebilir
img = img.point(lambda p: p > threshold and 255)
# 5. Eğikliği düzeltme (Bu adım daha karmaşıktır ve genellikle OpenCV gerektirir)
# OpenCV ile eğiklik düzeltme için:
# import cv2
# import numpy as np
# img_cv = cv2.cvtColor(np.array(img), cv2.COLOR_GRAY2BGR)
# # ... eğiklik düzeltme algoritmaları ...
# img = Image.fromarray(cv2.cvtColor(img_cv, cv2.COLOR_BGR2RGB))
return img
Bu preprocess_image fonksiyonunu, extract_text_from_image fonksiyonunun başında, Image.open(image_path) satırından sonra çağırabiliriz:
def extract_text_from_image(image_path):
try:
img = Image.open(image_path)
img = preprocess_image(img) # Ön işleme adımını ekle
except FileNotFoundError:
return "Hata: Görüntü dosyası bulunamadı."
except Exception as e:
return f"Hata: Görüntü işlenirken bir sorun oluştu: {e}"
# ... geri kalan script ...
Bu ön işleme adımları, Gemma’nın metni daha net görmesini sağlayarak, özellikle düşük kaliteli veya karmaşık belgelerde OCR doğruluğunu önemli ölçüde artıracaktır. Bu hile, bulut tabanlı API’lerin kullandığı gelişmiş ön işleme algoritmalarına yerel bir alternatiftir.
Gerçek Dünya Senaryoları ve Vaka Analizleri
Bu yerel OCR çözümünün pratik uygulamaları oldukça geniştir. Örneğin, bir muhasebe firması, faturaları ve makbuzları otomatik olarak işlemek için bu script’i kullanabilir. Her bir belgeyi tarayıp sisteme yüklediklerinde, Gemma modeli otomatik olarak fatura numarası, tarih, tutar ve tedarikçi bilgileri gibi kritik verileri çıkarabilir. Bu, manuel veri girişini ortadan kaldırarak hem zaman tasarrufu sağlar hem de hata oranını düşürür. Bir diğer vaka analizi, bir hukuk bürosu olabilir. Dava dosyalarındaki önemli belgeler, sözleşmeler, tanık ifadeleri gibi metinleri hızlıca tarayarak, anahtar kelimeler veya belirli bilgiler için arama yapabilirler. Bu, avukatların dava materyallerini daha verimli bir şekilde incelemelerine olanak tanır. Ayrıca, bir kütüphane veya arşiv, eski belgelerin dijitalleştirilmesi ve aranabilir hale getirilmesi için bu teknolojiyi kullanabilir. Nadir bulunan kitaplardaki veya el yazmalarındaki metinleri çıkarmak, bu tür sistemlerle daha ulaşılabilir hale gelir. Küçük işletmeler için, müşteri sipariş formlarını veya başvuru dilekçelerini otomatik olarak işlemek, operasyonel verimliliği artırabilir. Örneğin, bir restoran zinciri, şubelerinden gelen sipariş fişlerini işleyerek, stok takibi ve satış analizleri için verileri otomatik olarak toplayabilir. Bu tür senaryolarda, yerel çözümün maliyet etkinliği ve veri gizliliği avantajları öne çıkar. Bir startup, başlangıç maliyetlerini düşürmek adına, bulut tabanlı API’lere yüksek ücretler ödemek yerine, mevcut sunucu kaynaklarını kullanarak Gemma ile kendi OCR çözümünü oluşturabilir. Bu, özellikle finansal kaynakların sınırlı olduğu erken aşamalarda büyük bir fark yaratır. Gemma’nın esnekliği, farklı belge türlerine ve farklı veri çıkarma gereksinimlerine uyum sağlama potansiyeli sunar. Örneğin, bir sigorta şirketi, hasar bildirim formlarındaki bilgileri çıkarmak için bu modeli kullanabilir ve bu bilgileri otomatik olarak ilgili departmanlara yönlendirebilir. Bu, işlem sürelerini kısaltır ve müşteri memnuniyetini artırır.
Maliyet Karşılaştırması ve ROI (Yatırımın Geri Dönüşü)
Aylık 50 dolarlık bir OCR API maliyeti, yıllık olarak 600 dolara denk gelir. Eğer bu API’yi birkaç yıldır kullanıyorsanız, sadece bu hizmet için binlerce dolar harcamış olabilirsiniz. Gemma 4’ü yerel olarak çalıştırmak ise, başlangıçta bir donanım yatırımı (eğer mevcut sistemler yeterli değilse) veya mevcut sunucu kaynaklarının kullanımı anlamına gelir. Eğer güçlü bir bilgisayarınız veya sunucunuz varsa, bu maliyet sıfır olabilir. Eğer yeni bir donanım gerekiyorsa, bu yatırımın maliyeti, birkaç ay veya yıl içinde API maliyetlerini aşacaktır. Örneğin, 1000 dolarlık bir yatırım, aylık 50 dolarlık bir tasarrufla 20 ayda kendini amorti edebilir. Daha da önemlisi, yerel çözümde ek bir “kullanım başına ödeme” yoktur. Belge sayınız ne kadar artarsa artsın, maliyetiniz sabit kalır. Bu, özellikle büyüme potansiyeli yüksek uygulamalar için inanılmaz bir avantajdır. Gemma’nın açık kaynaklı olması ve Google tarafından desteklenmesi, gelecekteki güncellemeler ve iyileştirmelerden ücretsiz olarak yararlanabileceğiniz anlamına gelir. Bulut API’lerinde ise, her zaman bir hizmet sağlayıcıya bağımlısınız ve fiyatlandırma politikaları değişebilir. Gemma’nın ROI’si (Yatırımın Geri Dönüşü) sadece maliyet tasarrufuyla sınırlı değildir. Veri gizliliği ve güvenliği, kendi altyapınız üzerinde tam kontrol, daha yüksek performans (özellikle optimize edildiğinde) ve özelleştirme yetenekleri de bu ROI’ye dahil edilmelidir. Bir şirketin hassas verilerinin bulutta saklanmasının potansiyel riskleri ve maliyetleri göz önüne alındığında, yerel bir çözümün sunduğu ek güvenlik, paha biçilmezdir. Ayrıca, Gemma’nın esnekliği, sadece OCR’ın ötesinde, metin analizi, özetleme veya sınıflandırma gibi ek özellikler eklemenize olanak tanır, bu da yatırımın değerini daha da artırır. Bu, tek bir teknolojiden birden fazla fayda sağlama potansiyeli sunar.
İleri Düzey İpuçları ve Optimizasyon
Gemma 4 ile OCR performansınızı daha da ileriye taşımak için birkaç gelişmiş ipucu bulunmaktadır. İlk olarak, modelin parametrelerini ince ayar (fine-tuning) yaparak belirli belge türlerine veya sektörlere özgü metinleri daha iyi tanımasını sağlayabilirsiniz. Örneğin, tıp alanındaki belgeler için özel olarak eğitilmiş bir Gemma modeli, genel bir modelden daha doğru sonuçlar verecektir. Bu, kendi veri setinizi oluşturmayı ve modeli bu verilerle yeniden eğitmeyi gerektirir. İkinci olarak, batch processing (toplu işleme) kullanarak aynı anda birden fazla belgeyi işleyebilir, bu da genel işlem süresini önemli ölçüde azaltır. Özellikle sunucu ortamında çalışırken bu yöntem verimliliği artırır. Üçüncü olarak, modelin çıktısını daha sofistike bir şekilde ayrıştırmak için düzenli ifadeler (regular expressions) veya doğal dil işleme (NLP) teknikleri kullanabilirsiniz. Örneğin, bir tarihin veya bir telefon numarasının farklı formatlardaki varyasyonlarını yakalamak için güçlü ayrıştırma algoritmaları geliştirebilirsiniz. Dördüncü olarak, hata ayıklama ve performans izleme araçlarını kullanarak modelin hangi belgelerde zorlandığını tespit edebilir ve bu bölgelere odaklanabilirsiniz. TensorBoard gibi araçlar, eğitim ve çıkarım süreçlerini izlemek için faydalı olabilir. Beşinci olarak, eğer GPU kullanıyorsanız, modelin kuantizasyon seviyesini (örneğin 8-bit veya 16-bit) deneyerek performans ve bellek kullanımı arasında en iyi dengeyi bulabilirsiniz. Daha düşük kuantizasyon seviyeleri genellikle daha iyi performans sunar, ancak daha fazla bellek gerektirir. Son olarak, Gemma’nın sadece metin çıkarma değil, aynı zamanda metni anlama ve özetleme yeteneklerini de kullanarak, OCR çıktısını daha anlamlı hale getirebilirsiniz. Örneğin, çıkarılan metni özetlemesini veya belirli sorulara yanıt vermesini isteyebilirsiniz. Bu, uygulamalarınızın yeteneklerini sadece veri çıkarma seviyesinden, bilgi anlama seviyesine taşıyacaktır.
Sonuç ve Sıkça Sorulan Sorular
Gemma 4’ün yerel yeteneklerini kullanarak, aylık 50 dolarlık pahalı bir OCR API’sine veda etmek artık bir hayal değil, gerçekleştirilebilir bir gerçekliktir. Sunduğumuz script ve ön işleme hilesi ile, kendi sisteminizde, tam kontrol sizde olacak şekilde, maliyet etkin ve güçlü bir OCR çözümü oluşturabilirsiniz. Bu yaklaşım, sadece maliyetleri düşürmekle kalmaz, aynı zamanda veri gizliliğini artırır ve uygulamanıza benzersiz bir esneklik kazandırır. Gemma’nın açık kaynaklı doğası ve sürekli gelişen yetenekleri, bu çözümü uzun vadede sürdürülebilir ve ölçeklenebilir kılar. Kendi altyapınızda, kendi kurallarınızla veri işlemek, modern iş akışları için kritik bir adımdır ve Gemma 4 bu konuda güçlü bir müttefiktir.
Sıkça Sorulan Sorular (SSS)
-
Soru: Gemma 4’ün 4 milyar parametreli modeli gerçekten yerel bir bilgisayarda çalışabilir mi?
Cevap: Evet, 4 milyar parametreli Gemma modeli, özellikle kuantizasyon (4-bit gibi) teknikleri kullanılarak, iyi bir CPU veya orta seviye bir GPU’ya sahip modern bir dizüstü bilgisayarda veya masaüstü bilgisayarda çalıştırılabilir. Performans, donanımınıza ve aynı anda çalıştırdığınız diğer işlemlere bağlı olacaktır. GPU kullanımı, işlem hızını önemli ölçüde artıracaktır.
-
Soru: Bu script’i farklı görüntü formatları (JPEG, TIFF, PDF sayfaları) için kullanabilir miyim?
Cevap: Evet,
Pillowkütüphanesi birçok yaygın görüntü formatını destekler. PDF dosyaları için ise, her sayfayı ayrı bir görüntü dosyasına dönüştüren bir PDF işleme kütüphanesi (örneğinPyMuPDFveyapdf2image) kullanmanız gerekecektir. Bu sayede, her bir sayfa görüntüsünü script’inize besleyebilirsiniz. -
Soru: Gemma’nın OCR doğruluğu, ticari API’ler kadar iyi midir?
Cevap: Gemma’nın doğruluğu, kullanılan modele, ön işleme adımlarına ve belgenin kalitesine bağlıdır. Ancak, Gemma 4 gibi güçlü modeller, doğru ön işleme ve prompt mühendisliği ile ticari API’lerle rekabet edebilir, hatta bazı durumlarda onları aşabilir. Özellikle belirli alanlara ince ayar yapıldığında bu doğruluk daha da artar.
-
Soru: Bu çözümü ticari bir üründe kullanabilir miyim?
Cevap: Gemma modelleri, genellikle Apache 2.0 gibi ticari kullanıma izin veren açık kaynak lisansları altında sunulur. Kullanım koşullarını ve lisans detaylarını Google’ın resmi kaynaklarından kontrol etmeniz önemlidir. Ancak genel olarak, bu tür açık kaynaklı modeller ticari projelerde kullanılabilir.
#Gemma #OCR #YerelAI #MakineÖğrenmesi #Python #Teknoloji #MaliyetTasarrufu