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: