Sıfır Maliyetle Güçlü Bir Yapay Zeka Yığını Oluşturmak: MindsEye x Google AI Mimarisi

Yapay zeka projeleri geliştirirken bütçe engeline takılmak kaderiniz mi? Özellikle başlangıç aşamasında, bulut servislerinin ve API maliyetlerinin yüksekliği, birçok geliştiriciyi ve küçük ölçekli işletmeyi caydırabiliyor. Ancak endişelenmeyin! Bu kapsamlı rehberde, MindsEye konseptiyle Google AI yeteneklerini harmanlayan, tamamen yerel ve maliyet etkin bir yapay zeka yığını oluşturmanın inceliklerini adım adım öğreneceksiniz. Sıfır bulut kredisi veya API bütçesiyle dahi, altı ayrı depoyu kullanarak nasıl güçlü ve ölçeklenebilir bir AI altyapısı kurabileceğinizi keşfedin. Bu yaklaşım, hem inovasyonunuzu destekleyecek hem de başlangıç maliyetlerinizi minimumda tutmanıza yardımcı olacak.

Modern yapay zeka projeleri, genellikle yüksek performanslı GPU’lara, geniş veri depolama alanlarına ve karmaşık bulut altyapılarına ihtiyaç duyar. Ne var ki, bu kaynakların maliyeti, özellikle proje başlangıcında veya kısıtlı bütçelerle çalışan ekipler için ciddi bir engel teşkil edebilir. MindsEye x Google AI Stack yaklaşımı, tam da bu noktada devreye girerek, bulut servislerine bağımlılığı azaltıp yerel kaynakları optimize ederek güçlü yapay zeka çözümleri geliştirmenin yolunu açar. Peki, bu kavramlar ne anlama geliyor ve neden bu kadar kritik?

MindsEye, bu mimaride, bir projenin “algı” veya “anlama” yeteneğini temsil eden bir metafor olarak kullanılmaktadır. Görüntü işleme, doğal dil işleme veya ses analizi gibi alanlarda, karmaşık verileri yerel olarak işleyerek anlamlı çıkarımlar yapabilen bir sistem hayal edin. Bu, MindsEye’ın temelini oluşturur. Öte yandan, “Google AI Stack” ifadesi, Google’ın yapay zeka alanındaki geniş deneyiminden ve geliştirdiği modellerden ilham alan yetenek setini ifade eder. Bu, Gemini gibi büyük dil modellerini doğrudan kullanmak yerine, onların temel aldığı prensipleri veya açık kaynaklı muadillerini yerel sistemlere entegre etme fikrini içerir. Yani, Google’ın sunduğu yüksek kaliteli AI çözümlerinin sunduğu yetenekleri, maliyet etkin ve yerel bir yaklaşımla kendi altyapımızda yeniden yaratmaya çalışırız. Bu bir nevi, Google’ın inovasyonundan ilham alarak kendi özelleştirilmiş ve bağımsız çözümümüzü geliştirmektir.

Bu yığını oluşturan temel bileşenler genellikle açık kaynaklı kütüphaneler (örneğin, TensorFlow Lite, PyTorch Mobile, ONNX Runtime, Hugging Face Transformers kütüphanesi) ve yerel donanım üzerinde çalışan optimizasyon teknikleridir. Bu yaklaşımın en büyük avantajlarından biri, veri gizliliği ve güvenliği konusunda sunduğu ek güvencedir. Veriler, buluta gönderilmeden yerel olarak işlendiği için, hassas bilgilerinizin kontrolü tamamen sizde kalır. Ayrıca, internet bağlantısı gereksinimi azalır veya tamamen ortadan kalkar, bu da çevrimdışı çalışabilen veya düşük bant genişliğine sahip ortamlarda kritik uygulamalar geliştirmek için idealdir. Örneğin, bir güvenlik kamerası sisteminin, hareket algılama ve yüz tanıma gibi işlemlerini tamamen yerel bir Raspberry Pi üzerinde yapabildiğini düşünün. Bu, hem anlık tepki süresi sağlar hem de sürekli buluta veri gönderme maliyetini ortadan kaldırır. Özetle, MindsEye x Google AI Stack, esneklik, maliyet etkinliği, veri gizliliği ve performansı bir araya getiren güçlü bir yerel yapay zeka geliştirme paradigması sunar.

Maliyet Etkinliği Neden Bu Kadar Kritik? Bulut Kredi Bağımlılığından Nasıl Kurtuluruz?

Yapay zeka projeleri büyüdükçe, bulut servislerinin ve API kullanımlarının faturası da hızla şişebilir. Özellikle prototipleme, eğitim veya deneme aşamalarında, öngörülemeyen maliyetler projeleri durma noktasına getirebilir. Bu durum, özellikle kısıtlı bütçelere sahip bireysel geliştiriciler, startup’lar ve küçük işletmeler için büyük bir problem teşkil eder. Bulut kredi bağımlılığı, sadece finansal bir yük olmakla kalmaz, aynı zamanda projenin esnekliğini ve gelecekteki ölçeklenebilirliğini de kısıtlayabilir. Örneğin, büyük bir dil modeli API’si kullanarak her metin çevirisi veya özetleme isteği için ödeme yapmak, yoğun kullanımlarda astronomik rakamlara ulaşabilir. Bu yüzden, başlangıçta maliyet etkin bir strateji benimsemek, projenin sürdürülebilirliği açısından hayati öneme sahiptir.

Peki, bu bağımlılıktan nasıl kurtuluruz? Cevap, akıllıca yerel kaynak kullanımı ve açık kaynaklı araçların gücünden faydalanmaktır. İlk adım, projenin hangi kısımlarının mutlaka bulut gerektirdiğini, hangilerinin yerel olarak çözülebileceğini net bir şekilde analiz etmektir. Çoğu zaman, veri ön işleme, model eğitimi (daha küçük ölçekli modellerle), çıkarım (inference) ve sonuçların sunumu gibi süreçler yerel olarak yönetilebilir. Örneğin, görüntü tanıma için, büyük bir bulut tabanlı API yerine, önceden eğitilmiş, optimize edilmiş bir modelin (TensorFlow Lite veya ONNX formatında) yerel bir cihazda çalıştırılması hem maliyeti sıfırlar hem de gecikmeyi önemli ölçüde azaltır. Bu, özellikle kenar bilişim (edge computing) senaryolarında, yani verilerin toplandığı yerde işlendiği durumlarda paha biçilmezdir.

İkinci olarak, açık kaynak topluluğunun sunduğu zenginlikten faydalanmak çok önemlidir. Hugging Face’in Transformers kütüphanesi veya spaCy gibi doğal dil işleme araçları, birçok dil modelini ve NLP yeteneğini yerel olarak çalıştırma imkanı sunar. Görüntü işleme için OpenCV, makine öğrenimi için Scikit-learn veya daha derin öğrenme modelleri için PyTorch/TensorFlow’un hafifleştirilmiş versiyonları bu stratejinin temel taşlarıdır. Docker ve konteynerizasyon teknolojileri ise, farklı yapay zeka bileşenlerini izole edilmiş ortamlarda çalıştırarak bağımlılık sorunlarını minimize eder ve dağıtımı kolaylaştırır. Bu sayede, geliştirme ortamınızı bir kez kurup, farklı cihazlarda veya sistemlerde tutarlı bir şekilde çalıştırabilirsiniz. Böylece, projenizin erken aşamalarında yüzbinlerce dolarlık bulut faturalarından kaçınarak, kaynaklarınızı daha stratejik alanlara yönlendirebilirsiniz. Bu, sadece bir maliyet avantajı değil, aynı zamanda projenize daha fazla kontrol ve esneklik sağlayan bir yaklaşımdır.

Uzman İpucu: Bulut kredilerinden tamamen kaçınmak yerine, bunları stratejik olarak kullanmayı düşünün. Örneğin, başlangıçta çok büyük modelleri eğitmek için kısa süreliğine bulut GPU’larından faydalanıp, ardından bu modelleri optimize ederek yerel çıkarım için kullanabilirsiniz. Bu, “hibrit” bir yaklaşım olup, her iki dünyanın da en iyi yanlarını birleştirir.

Mimariyi Tasarlamak: 6 Ayrı Depo Neden Gerekli ve Ne İşlev Görüyor?

Büyük ve karmaşık bir yapay zeka projesini tek bir monolitik kod tabanında yönetmek, sürdürülebilirlik ve ekip iş birliği açısından birçok zorluk yaratır. İşte bu nedenle, MindsEye x Google AI Stack mimarimizde, projemizi altı ayrı depoya (repository) bölmek hem modülerliği artırır hem de her bir bileşenin bağımsız olarak geliştirilmesini, test edilmesini ve sürdürülmesini kolaylaştırır. Bu dağıtık yapı, aynı zamanda farklı ekiplerin eş zamanlı olarak farklı modüller üzerinde çalışabilmesine olanak tanır ve böylece geliştirme sürecini hızlandırır. Peki, bu altı depo ne işlev görüyor ve neden bu ayrım bu kadar önemli?

1. Veri Alımı ve Ön İşleme (Data Ingestion & Preprocessing) Deposu:

   Bu depo, projenizin “duyusal” organı gibidir. Görüntüler, metinler, sensör verileri veya ses kayıtları gibi ham verileri farklı kaynaklardan (yerel dosya sistemi, web kazıma, cihaz sensörleri) toplar. Daha sonra bu verileri, makine öğrenimi modellerinin anlayabileceği ve işleyebileceği bir formata dönüştürür. Bu, gürültü azaltma, yeniden boyutlandırma, normalizasyon, etiketleme ve veri artırma gibi adımları içerir. Bu ayrım, veri kaynaklarının değişmesi veya yeni ön işleme tekniklerinin eklenmesi durumunda, ana model depolarını etkilemeden hızlıca adapte olabilmenizi sağlar. Veri kalitesi ve tutarlılığı, tüm yapay zeka projesinin başarısı için temeldir, bu yüzden bu aşamayı ayrı bir depo olarak ele almak mantıklıdır.

2. Model Eğitimi ve Optimizasyonu (Model Training & Optimization) Deposu:

   Adından da anlaşılacağı gibi, bu depo yapay zeka modellerinizin kalbinin attığı yerdir. Seçilen mimarilere (örneğin, evrişimli sinir ağları, tekrarlayan sinir ağları, transformatörler) uygun olarak modelleri tanımlar, eğitir ve hiperparametreleri optimize eder. Önemli olarak, bu depo aynı zamanda modelleri yerel ve kaynak kısıtlı ortamlarda çalışacak şekilde optimize etme (quantization, pruning, knowledge distillation) süreçlerini de içerir. Örneğin, TensorFlow Lite veya ONNX Runtime için model dönüşümleri burada gerçekleştirilir. Bu optimizasyonlar, modeli daha küçük, daha hızlı ve daha az bellek tüketen bir hale getirerek, bulut yerine yerel cihazlarda etkin bir şekilde çalışmasını sağlar.

3. Çıkarım Motoru (Inference Engine) Deposu:

   Eğitilmiş ve optimize edilmiş modellerin gerçek dünya verileri üzerinde tahminler yapmasını sağlayan depodur. Bu, genellikle Flask veya FastAPI gibi hafif bir web çerçevesi kullanılarak oluşturulan bir mikro servis veya Python tabanlı bir CLI aracı olabilir. Bu depo, ön işlenmiş verileri alır, modeli yükler, çıkarım yapar ve sonuçları uygun bir formatta (örneğin, JSON) dışarı aktarır. Performans kritik olduğu için, bu depoda modelin yüklenme hızı, çıkarım süresi ve kaynak tüketimi ön plandadır. Modellerin güncellenmesi veya farklı modellerin kullanılması durumunda, Inference Engine deposunu bağımsız olarak güncelleyebilir veya ölçekleyebiliriz.

4. Kullanıcı Arayüzü/Uygulama (UI/Application) Deposu:

   Son kullanıcıların yapay zeka sisteminizle etkileşim kurduğu arayüzü barındırır. Bu bir web uygulaması (React, Vue), bir masaüstü uygulaması (Electron) veya mobil uygulama (Flutter, React Native) olabilir. Bu depo, Inference Engine ile iletişim kurarak kullanıcıdan gelen girdileri alır, Inference Engine’e gönderir ve oradan gelen sonuçları anlaşılır bir şekilde görselleştirir. Bu ayrım, arayüz tasarımcılarının ve frontend geliştiricilerinin backend yapay zeka bileşenlerinden bağımsız olarak çalışmasına olanak tanır.

5. Paylaşılan Yardımcı Araçlar ve Kütüphaneler (Shared Utilities & Libraries) Deposu:

   Birden fazla depo tarafından kullanılan ortak kodları, fonksiyonları, sabitleri ve temel yapılandırmaları içeren bir depodur. Örneğin, veri modelleme sınıfları, özel hata işleme mekanizmaları, loglama yardımcıları veya ortak ağ istekleri bu depoda yer alabilir. Bu, kod tekrarını önler, tutarlılığı artırır ve tüm yığını daha yönetilebilir hale getirir. Herhangi bir ortak bileşende yapılan bir değişiklik, tek bir yerde yapılıp tüm yığına kolayca yayılabilir.

6. Dağıtım ve Orkestrasyon (Deployment & Orchestration) Deposu:

   Bu depo, tüm bu bağımsız bileşenlerin bir araya getirilip çalıştırılmasından sorumludur. Docker Compose dosyaları, Kubernetes yapılandırmaları (ileride buluta geçiş durumunda), dağıtım betikleri (deployment scripts) veya CI/CD boru hatları bu depoda saklanır. Bu depo sayesinde, projenin farklı ortamlara (geliştirme, test, üretim) kolayca dağıtılması ve bağımsız servislerin bir arada uyumlu bir şekilde çalışması sağlanır. Başlangıçta, bu bir Docker Compose dosyası ile tüm servisleri yerel olarak ayağa kaldırma işlevini görebilir.

Bu altı depo yapısı, projenin karmaşıklığını yönetmek, her bir bileşenin sorumluluğunu net bir şekilde tanımlamak ve gelecekteki ölçeklenebilirlik için sağlam bir temel oluşturmak adına kritik öneme sahiptir. Her depo, kendi bağımsız yaşam döngüsüne sahip olabilir ve farklı teknolojilerle (örneğin, bir depo Python ile, diğeri Node.js ile) geliştirilebilir, bu da takımınıza büyük esneklik sağlar.

Adım Adım Uygulama: MindsEye x Google AI Stack Nasıl Oluşturulur?

Şimdi teoriden pratiğe geçme zamanı. MindsEye x Google AI Stack’ı yerel olarak, sıfır bulut kredisi veya API bütçesiyle nasıl oluşturabileceğimize dair adım adım bir rehber sunacağız. Bu rehberde, Python tabanlı bir yaklaşım benimseyecek ve açık kaynak araçlarından faydalanacağız. Amacımız, basit bir görüntü tanıma servisini bu mimari üzerinde çalıştırmak olsun.

1. Ortak Altyapı Hazırlığı (Ortak Yardımcılar ve Dağıtım Depoları)

Öncelikle, tüm depoların kullanacağı temel yapıyı kuralım. Ortak araçlar ve dağıtım betikleri için iki ayrı depo oluşturacağız. İlk olarak, bir shared_utilities deposu ile başlıyoruz. Bu depo, loglama ayarlarını ve bazı temel veri modellerini içerebilir.

# shared_utilities/logger_config.py
import logging
import sys

def setup_logger(name, level=logging.INFO):
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(formatter)
    logger = logging.getLogger(name)
    logger.setLevel(level)
    if not logger.handlers:
        logger.addHandler(handler)
    return logger

# shared_utilities/models.py
from pydantic import BaseModel
from typing import List, Dict, Any

class ImagePrediction(BaseModel):
    label: str
    confidence: float

class InferenceResult(BaseModel):
    predictions: List[ImagePrediction]
    processed_time_ms: float
    image_id: str

Daha sonra, bu servisleri ayağa kaldıracak bir deployment deposu oluşturacağız. Başlangıç için bir docker-compose.yml dosyası idealdir. Bu dosya, ilerleyen adımlarda oluşturacağımız servisleri bir arada çalıştıracaktır.

# deployment/docker-compose.yml
version: '3.8'
services:
  inference-engine:
    build: ../inference_engine
    ports:
      - "8000:8000"
    volumes:
      - ./models:/app/models # Modelleri Inference Engine'e mount ediyoruz
    environment:
      - MODEL_PATH=/app/models/optimized_model.tflite
    depends_on:
      - data-preprocessing
  data-preprocessing:
    build: ../data_preprocessing
    ports:
      - "8001:8001"
  ui-application:
    build: ../ui_application
    ports:
      - "3000:3000"
    environment:
      - INFERENCE_API_URL=http://inference-engine:8000

2. Veri Alımı ve Ön İşleme Deposu Oluşturma (data_preprocessing)

Bu depo, raw görüntüleri alacak ve modelimizin beklediği formata dönüştürecek bir mikro servis içerecek. FastAPI ve Pillow kütüphanelerini kullanacağız.

# data_preprocessing/main.py
from fastapi import FastAPI, UploadFile, File
from PIL import Image
import io
import numpy as np
from shared_utilities.logger_config import setup_logger # shared_utilities'dan loglayıcıyı içe aktar
import uvicorn

logger = setup_logger(__name__)
app = FastAPI()

@app.post("/preprocess_image/")
async def preprocess_image(file: UploadFile = File(...)):
    try:
        image_bytes = await file.read()
        image = Image.open(io.BytesIO(image_bytes))
        
        # Örnek ön işleme: Boyutlandırma ve gri tonlama
        image = image.resize((224, 224)) # Modelin beklediği boyuta getir
        image = image.convert("RGB") # RGB'ye dönüştür (eğer değilse)
        
        # NumPy dizisine çevir ve normalleştir
        img_array = np.array(image).astype(np.float32)
        img_array = img_array / 255.0 # 0-1 arasına normalleştir
        img_array = np.expand_dims(img_array, axis=0) # Batch boyutu ekle (1, 224, 224, 3)

        logger.info(f"Image {file.filename} preprocessed successfully. Shape: {img_array.shape}")
        return {"message": "Image preprocessed", "shape": img_array.shape.tolist(), "data": img_array.tobytes().hex()}
    except Exception as e:
        logger.error(f"Error during image preprocessing: {e}")
        return {"message": "Error processing image", "error": str(e)}, 500

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8001)

# data_preprocessing/Dockerfile
FROM python:3.9-slim-buster
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
# shared_utilities deposunu buraya kopyalamamız gerekiyor
COPY ../shared_utilities /app/shared_utilities
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8001"]

# data_preprocessing/requirements.txt
fastapi
uvicorn
Pillow
numpy
pydantic # Shared utilities'daki modeller için

3. Model Eğitimi ve Optimizasyonu Deposu Oluşturma (model_training_optimization)

Bu depo, basit bir görüntü sınıflandırma modeli eğitecek ve onu TensorFlow Lite formatına dönüştürecektir. Model dosyası daha sonra deployment/models klasörüne kopyalanacaktır.

# model_training_optimization/train_and_optimize.py
import tensorflow as tf
from tensorflow import keras
import numpy as np
from shared_utilities.logger_config import setup_logger # shared_utilities'dan loglayıcıyı içe aktar
import os

logger = setup_logger(__name__)

def create_and_train_model():
    # Basit bir model oluşturalım: MobileNetV2 üzerine kurulu
    base_model = keras.applications.MobileNetV2(input_shape=(224, 224, 3), include_top=False, weights='imagenet')
    base_model.trainable = False # Önceden eğitilmiş katmanları dondur

    inputs = keras.Input(shape=(224, 224, 3))
    x = base_model(inputs, training=False)
    x = keras.layers.GlobalAveragePooling2D()(x)
    outputs = keras.layers.Dense(10, activation='softmax')(x) # Örnek olarak 10 sınıf
    
    model = keras.Model(inputs, outputs)
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
    
    # Basit bir dummy veri seti oluşturalım (gerçek uygulamada kendi verinizi kullanın)
    dummy_x = np.random.rand(100, 224, 224, 3).astype(np.float32)
    dummy_y = np.random.randint(0, 10, 100)

    logger.info("Starting model training with dummy data...")
    model.fit(dummy_x, dummy_y, epochs=3, verbose=1)
    logger.info("Model training finished.")
    
    return model

def optimize_model(model, output_path="deployment/models/optimized_model.tflite"):
    converter = tf.lite.TFLiteConverter.from_keras_model(model)
    # Varsayılan optimizasyon (quantization)
    converter.optimizations = [tf.lite.Optimize.DEFAULT]
    tflite_model = converter.convert()

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    with open(output_path, 'wb') as f:
        f.write(tflite_model)
    logger.info(f"Optimized TFLite model saved to {output_path}")

if __name__ == "__main__":
    trained_model = create_and_train_model()
    optimize_model(trained_model)

# model_training_optimization/requirements.txt
tensorflow==2.x # Yüklü TensorFlow sürümünüze göre ayarlayın
numpy

Uzman İpucu: Model eğitiminde GPU kullanmak için TensorFlow kurulumunuzu ve Docker konfigürasyonunuzu (nvidia-docker) buna göre ayarlamanız gerekir. Ancak başlangıç için CPU'da küçük modellerle denemeler yapmak maliyet açısından daha uygun olacaktır.

4. Çıkarım Motoru Deposu Oluşturma (inference_engine)

Bu depo, optimize edilmiş TFLite modelini yükleyecek ve ön işlenmiş verileri alıp tahminler yapacak bir FastAPI servisi içerecek.

# inference_engine/main.py
from fastapi import FastAPI, HTTPException
import tensorflow as tf
import numpy as np
import os
import time
from shared_utilities.logger_config import setup_logger
from shared_utilities.models import InferenceResult, ImagePrediction # Paylaşılan modelleri içe aktar
import uvicorn

logger = setup_logger(__name__)
app = FastAPI()

interpreter = None
input_details = None
output_details = None

# Örnek etiketler (modelin eğitildiği sınıflara göre güncelleyin)
LABELS = [f"class_{i}" for i in range(10)] 

@app.on_event("startup")
async def load_model():
    global interpreter, input_details, output_details
    model_path = os.getenv("MODEL_PATH", "/app/models/optimized_model.tflite")
    if not os.path.exists(model_path):
        logger.error(f"Model file not found at {model_path}")
        raise FileNotFoundError(f"Model file not found at {model_path}")

    logger.info(f"Loading TFLite model from {model_path}")
    interpreter = tf.lite.Interpreter(model_path=model_path)
    interpreter.allocate_tensors()
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()
    logger.info("TFLite model loaded successfully.")

@app.post("/predict/", response_model=InferenceResult)
async def predict_image(image_data: dict):
    if interpreter is None:
        raise HTTPException(status_code=500, detail="Model not loaded. Server starting up.")

    try:
        # Ön işlenmiş veriyi hex string'den numpy dizisine çevir
        # image_data.get("data") preprocessor'dan gelen hex string olmalı
        img_array_bytes = bytes.fromhex(image_data["data"])
        img_array = np.frombuffer(img_array_bytes, dtype=np.float32).reshape(image_data["shape"])

        input_tensor = input_details[0]['index']
        output_tensor = output_details[0]['index']

        interpreter.set_tensor(input_tensor, img_array)
        
        start_time = time.time()
        interpreter.invoke()
        end_time = time.time()
        
        predictions = interpreter.get_tensor(output_tensor)[0]
        
        processed_time_ms = (end_time - start_time) * 1000
        logger.info(f"Inference completed in {processed_time_ms:.2f} ms.")

        # Tahminleri ImagePrediction listesine çevir
        results = []
        for i, score in enumerate(predictions):
            results.append(ImagePrediction(label=LABELS[i], confidence=float(score)))
        
        return InferenceResult(
            predictions=sorted(results, key=lambda x: x.confidence, reverse=True),
            processed_time_ms=processed_time_ms,
            image_id=image_data.get("image_id", "N/A")
        )

    except Exception as e:
        logger.error(f"Error during inference: {e}")
        raise HTTPException(status_code=500, detail=f"Inference error: {e}")

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

# inference_engine/Dockerfile
FROM python:3.9-slim-buster
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
COPY ../shared_utilities /app/shared_utilities # shared_utilities deposunu buraya da kopyalıyoruz
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# inference_engine/requirements.txt
fastapi
uvicorn
tensorflow # TFLite interpreter için
numpy
pydantic

5. Kullanıcı Arayüzü/Uygulama Deposu Oluşturma (ui_application)

Basit bir web arayüzü oluşturmak için JavaScript (Fetch API) ve HTML kullanacağız. Bu depo, ön işleme servisine bir görüntü gönderecek, ardından gelen veriyi çıkarım servisine aktaracak ve sonuçları gösterecektir.

    

        
MindsEye Yerel Görüntü Sınıflandırıcı
        
        Görüntüyü Sınıflandır
        

        

            
Sonuçlar:
            

            

        
    

    

# ui_application/Dockerfile
FROM nginx:alpine
COPY ./index.html /usr/share/nginx/html/index.html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Bu, basit bir Nginx sunucusu ile HTML dosyamızı servis edecek. index.html dosyasındaki JavaScript kodunda, Docker Compose servis isimleri (inference-engine, data-preprocessing) yerine localhost kullandığımıza dikkat edin. Bu, tarayıcıdan doğrudan erişimde ve Docker'da local network üzerinden servislerin birbirine erişiminde farklılık gösterebilir. Docker Compose ortamında, servisler birbirini isimleriyle tanır ancak tarayıcıdan erişim için localhost ve port numaralarını kullanırız. docker-compose.yml içinde INFERENCE_API_URL ve PREPROCESSING_API_URL ortam değişkenlerini tanımlayarak bu adresleri dinamik hale getirebiliriz.

Tüm bu adımları tamamladıktan sonra, deployment dizinine giderek:

docker-compose up --build

komutu ile tüm yığını ayağa kaldırabilirsiniz. Artık http://localhost:3000 adresinden arayüzünüze erişebilir, bir görüntü yükleyebilir ve yerel yapay zeka yığınlarınızın nasıl çalıştığını görebilirsiniz!

Performans ve Optimizasyon: Kısıtlı Kaynaklarla En İyi Sonuçları Nasıl Elde Ederiz?

Yerel bir MindsEye x Google AI Stack oluşturmanın en büyük zorluklarından biri, kısıtlı donanım kaynaklarıyla (CPU, RAM, belki entegre GPU) yüksek performans elde etmektir. Bulutun aksine, burada güçlü donanım kiralamak gibi bir seçeneğimiz yoktur. Dolayısıyla, her bileşeni titizlikle optimize etmek, projenin başarısı için kritik öneme sahiptir. İşte kısıtlı kaynaklarla en iyi sonuçları elde etmek için bazı stratejiler:

1. Model Optimizasyonu: Daha Küçük, Daha Hızlı Modeller

• Niceleme (Quantization): Modellerdeki kayan nokta (float32) değerlerini daha düşük hassasiyetli tam sayılara (int8) dönüştürme işlemidir. Bu, model boyutunu önemli ölçüde küçültür ve çıkarım hızını artırır. TensorFlow Lite ve ONNX Runtime gibi kütüphaneler niceleme için güçlü araçlar sunar. Küçük bir doğruluk kaybına neden olsa da, çoğu kenar bilişim senaryosu için kabul edilebilir bir ödünleşmedir.
• Budama (Pruning): Modeldeki daha az önemli ağırlıkları veya bağlantıları kaldırarak modelin seyreltik hale getirilmesidir. Bu da model boyutunu küçültür ve hızlandırır.
• Bilgi Damıtma (Knowledge Distillation): Büyük, karmaşık bir "öğretmen" modelin bilgisini, daha küçük ve daha az karmaşık bir "öğrenci" modele aktarma tekniğidir. Öğrenci model, öğretmen modelin performansına yakın sonuçlar verirken, çok daha az kaynak tüketir.
• Mimari Seçimi: Küçük ve verimli model mimarilerini tercih edin. MobileNet, EfficientNet, SqueezeNet gibi modeller, mobil ve kenar cihazlar için özel olarak tasarlanmıştır ve iyi bir başlangıç noktası sunar.

2. Veri Ön İşleme Optimizasyonu

• Veri Boyutu ve Kalitesi: Gereksiz yere yüksek çözünürlüklü veya fazla detaylı verilerle çalışmaktan kaçının. Modelinizin ihtiyaç duyduğu en düşük kabul edilebilir boyuta ve karmaşıklığa indirin. Gürültülü veya eksik veriler, modelin performansını düşüreceği için ön işleme aşamasında dikkatle temizlenmelidir.
• Veri Formatı: Verileri mümkün olan en verimli formatlarda depolayın ve aktarın. Örneğin, görüntüler için JPEG/PNG yerine WebP gibi modern formatlar veya sıkıştırılmış NumPy dizileri kullanmak faydalı olabilir.
• Toplu İşleme (Batch Processing): Eğer mümkünse, tek tek veri noktalarını işlemek yerine, birkaç veri noktasını bir araya getirerek toplu bir şekilde işleyin. Bu, CPU/GPU kullanımını daha verimli hale getirir.

3. Yazılım ve Altyapı Optimizasyonu

• Doğru Kütüphaneler: Kaynak kısıtlı ortamlar için özel olarak tasarlanmış kütüphaneleri (örneğin, TensorFlow Lite, PyTorch Mobile, ONNX Runtime) kullanın. Bu kütüphaneler, optimizasyonlar ve donanım hızlandırma için özel API'lar sunar.
• Asenkron İşleme: G/Ç (input/output) operasyonları (dosya okuma, ağ istekleri) yoğun olan yerlerde asenkron programlama kullanın. Python'da asyncio, FastAPI ile birlikte iyi çalışır ve uygulamanızın aynı anda birden fazla isteği işlemesini sağlar.
• Konteynerizasyon ve Hafif Ortamlar: Docker gibi araçlar, bağımlılıkları yönetmede harikadır ancak her bir konteynerin kendisi de belirli bir kaynak tüketimine sahiptir. Alpine Linux tabanlı Docker imajları gibi hafif işletim sistemlerini kullanarak konteyner boyutlarını küçültün ve kaynak tüketimini azaltın.
• Caching: Sıkça kullanılan verileri veya model yüklemelerini bellekte önbelleğe alarak disk G/Ç'sini azaltın. Model yüklemesi, genellikle bir uygulamanın başlangıcında bir kez yapılır ve bellekte tutulur.
• Profil Oluşturma (Profiling): Uygulamanızın nerede zaman harcadığını anlamak için profil oluşturma araçlarını kullanın. Python'da cProfile veya line_profiler gibi araçlar, performans darboğazlarını tespit etmenize yardımcı olabilir.
• Minimal API Tasarımı: Servislerinizin API'lerini mümkün olduğunca basit tutun. Gereksiz veri transferinden kaçının ve yalnızca ihtiyaç duyulan bilgiyi gönderip alın.

Uzman İpucu: Kısıtlı bellekli cihazlar için, modelleri yüklemeden önce "swapping" veya dinamik model yükleme/boşaltma stratejileri geliştirebilirsiniz. Bu, aktif olarak kullanılan modelleri bellekte tutarken, diğerlerini gerektiğinde diske aktarmanıza olanak tanır, ancak bu da gecikmeyi artırabilir.

Bu optimizasyon tekniklerini birleştirerek, MindsEye x Google AI Stack'ınızı kısıtlı kaynaklara sahip yerel donanımlarda bile şaşırtıcı derecede verimli hale getirebilirsiniz. Unutmayın, her proje farklıdır ve en iyi optimizasyon stratejisi, uygulamanızın özel gereksinimlerine ve mevcut donanımınıza bağlı olacaktır.

Gerçek Dünya Senaryoları: Bu Mimari Hangi Projelerde Kullanılabilir?

Maliyet etkin ve yerel MindsEye x Google AI Stack mimarisi, sadece teorik bir konsept değil, aynı zamanda birçok gerçek dünya problemine pratik çözümler sunabilir. İşte bu mimarinin kullanılabileceği bazı senaryolar:

1. Akıllı Ev Otomasyonu ve Güvenlik Sistemleri

• Senaryo: Evinizdeki güvenlik kamerası sisteminin, tanınmayan bir yüz veya anormal bir hareket algıladığında sizi anında uyarması. Tüm görüntü işleme ve analiz süreçleri, verilerin gizliliğini korumak amacıyla tamamen yerel bir Raspberry Pi veya benzeri bir düşük güçlü cihaz üzerinde gerçekleşir.
• MindsEye Uygulaması: Kamera verilerini toplayan bir data_preprocessing servisi, optimize edilmiş bir yüz tanıma veya hareket algılama modelini çalıştıran bir inference_engine servisi. UI/Application katmanı, anlık bildirimleri mobil uygulamanıza veya bir web paneline gönderir.
• Fayda: Buluta görüntü gönderme maliyeti ve gecikmesi ortadan kalkar. Veri gizliliği maksimum düzeyde korunur. İnternet kesintilerinde bile güvenlik sistemi çalışmaya devam eder.

2. Endüstriyel Kalite Kontrol ve Hata Tespiti

• Senaryo: Üretim hattındaki ürünlerin görsel denetimi. Bir konveyör bandı üzerinde ilerleyen ürünlerin fotoğrafları çekilir ve hatalı ürünler (çizik, eksik parça, yanlış renk) anında tespit edilir.
• MindsEye Uygulaması: Görüntüleri alan ve ön işleyen bir data_preprocessing modülü. Önceden eğitilmiş bir anomali tespiti veya sınıflandırma modelini barındıran ve çalıştıran inference_engine. UI/Application modülü, üretim hattındaki operatörlere gerçek zamanlı geri bildirim sağlar ve hatalı ürünlerin ayrılmasını tetikler.
• Fayda: Üretim maliyetlerini düşürür, kaliteyi artırır ve insan hatasını minimize eder. Bulut bağımlılığı olmadığı için fabrikanın ağ altyapısına olan yük azalır.

3. Çevrimdışı Doğal Dil İşleme (NLP) Asistanları

• Senaryo: İnternet erişimi olmayan veya kısıtlı olan bir ortamda (örneğin bir şantiye, uzak bir saha araştırması, uçak içi eğlence sistemi) çalışan bir sesli asistan veya metin özetleyici.
• MindsEye Uygulaması: Sesli komutları veya metin girdilerini alan ve ön işleyen bir data_preprocessing modülü. Küçük, optimize edilmiş bir dil modelini (örneğin, BERT'in hafifletilmiş bir versiyonu veya DistilBERT) çalıştıran bir inference_engine modülü. Bu model, yerel olarak metin sınıflandırma, varlık tanıma veya özetleme yapar. UI/Application ise kullanıcıya sesli veya yazılı geri bildirim sağlar.
• Fayda: İnternet bağımsızlığı sağlar. Hassas konuşma verilerinin buluta gönderilmesini engeller. Gecikme süresini önemli ölçüde azaltarak daha akıcı bir kullanıcı deneyimi sunar.

4. Kişisel Veri Analizi ve Önerici Sistemler

• Senaryo: Kullanıcının kişisel bilgisayarında veya mobil cihazında depolanan verileri (fotoğraflar, belgeler, okuma alışkanlıkları) analiz ederek kişiselleştirilmiş öneriler veya düzenlemeler sunan bir uygulama. Tüm analiz yerel olarak yapılır ve hiçbir veri dışarıya çıkmaz.
• MindsEye Uygulaması: Yerel dosya sisteminden veri çeken ve ön işleyen bir data_preprocessing modülü. Kullanıcının ilgi alanlarını veya davranışlarını öğrenen ve öneriler üreten yerel bir inference_engine. UI/Application, kullanıcının verilerini güvenli bir şekilde sunar ve önerileri gösterir.
• Fayda: Kullanıcıların veri gizliliği ve güvenliği konusundaki endişelerini giderir. Veri egemenliğini kullanıcılara geri verir. Bulut maliyetlerini ortadan kaldırır.

5. Eğitim ve Araştırma Projeleri

• Senaryo: Öğrencilerin veya araştırmacıların yapay zeka modellerini keşfetmeleri ve uygulamaları için maliyet etkin bir platform. Cloud kredileri olmadan deneyler yapma imkanı sunar.
• MindsEye Uygulaması: Öğrencilerin kendi veri setlerini ve modellerini sisteme entegre edebilecekleri esnek bir yapı. Farklı model türlerini (görüntü, metin, ses) destekleyen genel bir inference_engine ve data_preprocessing katmanları. UI/Application ise sonuçları görselleştirmek ve deneyleri yönetmek için bir arayüz sunar.
• Fayda: Öğrenciler ve araştırmacılar için yapay zeka öğrenimini daha erişilebilir kılar. Prototipleme ve deneme maliyetlerini düşürür.

Bu senaryolar, MindsEye x Google AI Stack mimarisinin ne kadar çok yönlü ve güçlü olduğunu göstermektedir. Anahtar nokta, projenizin gereksinimlerini dikkatlice analiz etmek ve bulut servislerinin sunduğu avantajları (ölçeklenebilirlik, yönetim kolaylığı) ne zaman feda edip yerel çözümlerin getirdiği maliyet etkinliği ve veri egemenliğini tercih edeceğinize karar vermektir.

Geleceğe Bakış: Bulut Entegrasyonu ve API Bütçesi Planlaması

MindsEye x Google AI Stack'ı yerel ve maliyet etkin bir şekilde inşa etmek, projenizin başlangıç aşamaları için harika bir stratejidir. Ancak her proje büyüdükçe ve karmaşıklığı arttıkça, bazı noktada bulut servislerinin sunduğu avantajlara (ölçeklenebilirlik, yönetilebilirlik, global dağıtım) ihtiyaç duyulabilir. Bu, "bulut kredisi veya API bütçesi olmadan... henüz" ifadesinin ana fikridir. Önemli olan, bu geçişi bilinçli, stratejik ve kontrollü bir şekilde yapmaktır.

Ne Zaman Buluta Geçmeli veya API Kullanımını Düşünmeli?

• Yoğun Trafik ve Yüksek Ölçeklenebilirlik İhtiyacı: Yerel donanımınız belirli bir eşiğe kadar performans sunar. Eğer uygulamanız yüz binlerce eş zamanlı istek alacaksa veya coğrafi olarak geniş bir kullanıcı tabanına hizmet verecekse, bulutun elastikliği ve dağıtım yetenekleri vazgeçilmez hale gelir.
• Büyük Ölçekli Model Eğitimi: Kendi yerel sunucularınızda terabaytlarca veri ile saatler süren model eğitimleri yapmak yerine, bulutun sunduğu güçlü GPU'lar ve veri işleme hizmetleri çok daha verimli olabilir.
• Özel ve Karmaşık AI Hizmetleri: Belirli bir alanda çok uzmanlaşmış, önceden eğitilmiş, sürekli güncellenen ve kendi başınıza geliştirmenin çok maliyetli olacağı Google Vision API, Natural Language API veya Gemini gibi servisler, belirli görevler için oldukça cazip olabilir.
• Yönetilebilirlik ve Bakım Yükü: Kendi sunucularınızı yönetmek, yazılım güncellemeleri, güvenlik yamaları ve donanım arızalarıyla ilgilenmek zaman ve kaynak gerektirir. Bulut, bu operasyonel yükü büyük ölçüde üzerinizden alır.

Akıllı API Bütçesi Planlaması Nasıl Yapılır?

1. İhtiyaçları Belirleyin: Hangi görevler için bulut API'lerine gerçekten ihtiyaç duyuyorsunuz? Her şeyi buluta taşımak yerine, sadece yerel olarak verimli bir şekilde çözülemeyen veya özel yetenek gerektiren kısımları hedefleyin. Örneğin, temel görüntü tanıma yerel olarak yapılabilirken, çok dilli ve çok modlu büyük bir dil modeli (Gemini gibi) buluttan çağrılabilir.
2. Fiyatlandırma Modellerini Anlayın: Her bulut servis sağlayıcısının ve API'nin farklı fiyatlandırma modelleri vardır (kullanım başına, veri hacmi başına, zaman başına). Hangi modelin sizin için en uygun olduğunu ve maliyetleri nasıl etkileyeceğini iyi araştırın.
3. Kullanım Kotaları ve Uyarılar: Bulut platformlarının sunduğu bütçe uyarıları ve kullanım kotalarını mutlaka ayarlayın. Bu, beklenmedik maliyetlerden kaçınmanızı sağlar.
4. Hibrid Yaklaşım: Yerel ve bulut çözümlerini bir arada kullanın. Düşük gecikme süresi ve veri gizliliği gerektiren işlemler yerel olarak çalışırken, yüksek performans veya karmaşık AI yetenekleri gerektiren işlemler buluttan sağlanabilir.
5. Optimize Edilmiş Veri Transferi: Buluta sadece gerekli olan veriyi gönderin. Ön işleme ve özetleme işlemleri mümkün olduğunca yerel olarak yapılarak veri transfer maliyetleri düşürülebilir.
6. Model Optimizasyonu ve Önbellekleme: Bulut API'si kullanıyorsanız bile, isteklerinizi ve yanıtlarınızı önbelleğe alarak tekrarlayan çağrıları azaltabilirsiniz. Ayrıca, bulutta çalışan modelleri de optimize ederek daha az kaynak tüketmelerini sağlayabilirsiniz.

Kısacası, bulut entegrasyonu ve API kullanımı, projenizin büyümesinin doğal bir parçası olabilir, ancak bu geçişi "varsayılan" bir seçenek olarak değil, "stratejik" bir karar olarak ele almak önemlidir. Yerel olarak inşa ettiğiniz sağlam temel, bu geçişi daha kontrollü ve maliyet etkin bir şekilde yapmanızı sağlayacaktır.

Sonuç ve Sıkça Sorulan Sorular

Bu makalede, MindsEye x Google AI Stack mimarisini kullanarak sıfır bulut kredisi veya API bütçesiyle nasıl güçlü ve maliyet etkin bir yapay zeka çözümü oluşturulabileceğini detaylı bir şekilde inceledik. Altı ayrı depo kullanarak modüler, ölçeklenebilir ve yönetilebilir bir yapı inşa etmenin önemini vurguladık. Veri alımından model optimizasyonuna, çıkarım motorundan kullanıcı arayüzüne kadar her bir bileşenin rolünü ele aldık ve pratik kod örnekleriyle adım adım bir uygulama gösterdik. Kısıtlı kaynaklarla performans elde etmek için model niceleme, budama gibi optimizasyon tekniklerinin yanı sıra, gerçek dünya senaryolarında bu mimarinin nasıl kullanılabileceğini keşfettik. Son olarak, projeniz büyüdükçe buluta geçişin nasıl stratejik bir karar olarak ele alınması gerektiğini ve API bütçesi planlamasının inceliklerini aktardık. Bu yaklaşım, yapay zeka dünyasına giriş yapmak veya maliyetlerini kontrol altında tutmak isteyen herkes için güçlü bir başlangıç noktası sunmaktadır.

Sıkça Sorulan Sorular

S1: Bu MindsEye x Google AI Stack mimarisini kullanmak için hangi donanımlara ihtiyacım var?

C1: Minimumda, Python ve Docker çalıştırabilecek, yeterli RAM'e (genellikle 8GB+) ve CPU çekirdeğine sahip ortalama bir dizüstü bilgisayar veya masaüstü bilgisayar yeterlidir. Eğer görüntü işleme veya daha büyük modellerle çalışacaksanız, harici bir GPU (NVIDIA veya AMD) veya entegre bir GPU (Intel Iris Xe gibi) performansı artıracaktır. Raspberry Pi gibi tek kartlı bilgisayarlar da kenar bilişim projeleri için ideal başlangıç noktaları olabilir.

S2: Tüm bu depoları tek bir sunucuda mı çalıştırmalıyım?

C2: Başlangıçta ve geliştirme aşamasında, evet, hepsi aynı yerel makinede Docker Compose ile çalıştırılabilir. Ancak projeniz büyüdükçe, her bir depoyu ayrı ayrı mikro servisler olarak farklı sunucularda veya konteyner orkestrasyon platformlarında (örneğin Kubernetes) dağıtabilirsiniz. Bu, mimarinin ölçeklenebilirliğini ve esnekliğini artırır.

S3: TensorFlow Lite yerine başka hangi optimizasyon araçlarını kullanabilirim?

C3: TensorFlow Lite'ın yanı sıra, PyTorch Mobile (PyTorch modelleri için), ONNX Runtime (birçok farklı framework'ten model dışa aktarımı için), OpenVINO (Intel donanımları için) ve NVIDIA TensorRT (NVIDIA GPU'ları için) gibi birçok başka optimizasyon aracı mevcuttur. Seçiminiz, kullandığınız ana makine öğrenimi çerçevesine ve hedef donanımınıza bağlı olacaktır.

S4: Projemde hassas veriler kullanılıyorsa, bu yerel yaklaşım güvenli midir?

C4: Evet, aslında yerel yaklaşım, veri gizliliği ve güvenliği açısından bulut tabanlı çözümlere göre genellikle daha avantajlıdır. Verileriniz sunucularınızdan veya cihazlarınızdan asla ayrılmadığı için, üçüncü taraf bulut sağlayıcılarının veri gizliliği politikalarına güvenmek zorunda kalmazsınız. Ancak yine de kendi sistemlerinizin fiziksel güvenliğini ve yazılım güvenlik önlemlerini (şifreleme, erişim kontrolü vb.) sağlamanız önemlidir.

S5: "Google AI" ifadesi tam olarak neyi temsil ediyor bu mimaride, doğrudan Google API'leri kullanılmıyorsa?

C5: Bu bağlamda "Google AI", Google'ın yapay zeka alanındaki yeniliklerinden, geliştirdiği model mimarilerinden (örneğin, Transformer mimarisi, MobileNet gibi verimli modeller) ve genel olarak yapay zeka teknolojilerine olan katkılarından ilham almayı temsil eder. Doğrudan Google'ın ücretli API'lerini kullanmak yerine, bu prensipleri ve benzer açık kaynaklı uygulamaları (örneğin, Hugging Face'teki açık kaynaklı dil modelleri veya TensorFlow'daki modeller) kendi yerel yığınımızda uygulayarak Google'ın sunduğu "türden" yetenekleri maliyet etkin bir şekilde elde etmeye odaklanırız. Yani, Google'ın vizyonundan ve teknik bilgisinden faydalanırken, kendi bağımsız çözümümüzü inşa ederiz.