Upload 10 files

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Sistem bağımlılıklarını yükle
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libsndfile1 \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python bağımlılıklarını yükle
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Uygulama kodunu kopyala
+COPY . /app
+
+# Ortam değişkenleri
+ENV PYTHONPATH=/app
+ENV ENVIRONMENT=production
+
+# Uygulamayı başlat
+CMD ["python", "app_ui.py"] 

app.py

@@ -0,0 +1 @@
+ 

asr.py

@@ -0,0 +1,93 @@
+import torch
+import whisper
+from ..config import settings
+from typing import Dict, Any, Optional
+import os
+
+_model = whisper.load_model(settings.ASR_MODEL)
+
+class MedicalASR:
+    def __init__(self, config: Dict[str, Any]):
+        """
+        Tıbbi konuşma tanıma için ASR modülü
+        
+        Args:
+            config: Yapılandırma parametreleri
+                - language: Dil kodu (örn. "tr")
+                - model: Kullanılacak model adı
+                - domain: Alan adı (tıp için "medical")
+        """
+        self.config = config
+        self.language = config.get("language", "tr")
+        self.model_name = config.get("model", "whisper-large-v3")
+        
+        # CUDA kullanılabilirse tercih et
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+        # Modeli yükle
+        self.model = whisper.load_model(self.model_name, device=self.device)
+        
+        # Türkçe tıbbi terim sözlüğü - gerçek bir uygulama için genişletilebilir
+        self.medical_terms = self._load_medical_terms()
+    
+    def _load_medical_terms(self) -> Dict[str, str]:
+        """Türkçe tıbbi terim sözlüğünü yükler"""
+        # Örnek: Bu fonksiyon bir dosyadan ya da veritabanından tıbbi terimleri yükleyebilir
+        return {
+            "ateş": "ateş",
+            "hipertansiyon": "hipertansiyon",
+            "miyokard infarktüsü": "miyokard infarktüsü",
+            # ... daha fazla tıbbi terim
+        }
+    
+    def transcribe(self, audio_file: str, speaker_diarization: bool = True) -> Dict[str, Any]:
+        """
+        Ses dosyasını transkribe eder
+        
+        Args:
+            audio_file: Ses dosyasının yolu
+            speaker_diarization: Konuşmacı diyarizasyonu yapılsın mı
+            
+        Returns:
+            Transkripsiyon sonuçları
+        """
+        # Transkripsiyon için Whisper modelini kullan
+        transcribe_options = {
+            "language": self.language,
+            "task": "transcribe",
+        }
+        
+        result = self.model.transcribe(audio_file, **transcribe_options)
+        
+        # Tıbbi terimleri düzelt
+        corrected_text = self._correct_medical_terms(result["text"])
+        result["text"] = corrected_text
+        
+        # Diyarizasyon isteniyorsa ekle
+        if speaker_diarization:
+            # Burada bir diyarizasyon kütüphanesi kullanılabilir (pyannote.audio gibi)
+            # Bu örnekte yapmıyoruz
+            pass
+        
+        return result
+    
+    def _correct_medical_terms(self, text: str) -> str:
+        """
+        Transkribe edilmiş metindeki tıbbi terimleri düzeltir
+        
+        Args:
+            text: Düzeltilecek metin
+            
+        Returns:
+            Düzeltilmiş metin
+        """
+        # Bu basit bir örnek - daha gelişmiş NLP teknikleri kullanılabilir
+        for term, correct_form in self.medical_terms.items():
+            # Basit string değiştirme - gerçek uygulamada daha sofistike olmalı
+            text = text.replace(term, correct_form)
+        
+        return text
+
+def transcribe_file(file_path: str) -> str:
+    result = _model.transcribe(file_path)
+    return result.get('text', '').strip()

config.py

@@ -0,0 +1,10 @@
+import os
+
+class Settings:
+    ASR_MODEL = os.getenv("ASR_MODEL", "openai/whisper-small")
+    UPLOAD_DIR = os.getenv("UPLOAD_DIR", "./data/uploads")
+    OUTPUT_DIR = os.getenv("OUTPUT_DIR", "./data/outputs")
+    SAMPLE_RATE = int(os.getenv("SAMPLE_RATE", 16000))
+    DIAR_MODEL = os.getenv("DIAR_MODEL", "pyannote/speaker-diarization")
+
+settings = Settings()

diarization.py

@@ -0,0 +1,11 @@
+from pyannote.audio import Pipeline
+from ..config import settings
+
+_diar_pipeline = Pipeline.from_pretrained(settings.DIAR_MODEL)
+
+def diarize_segments(file_path: str) -> list:
+    diarization = _diar_pipeline(file_path)
+    segments = []
+    for turn, _, speaker in diarization.itertracks(yield_label=True):
+        segments.append((turn.start, turn.end, speaker))
+    return segments

main.py

@@ -0,0 +1,157 @@
+from fastapi import FastAPI, Depends, HTTPException, Security, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from fastapi.middleware.cors import CORSMiddleware
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any
+import os
+from pydantic import BaseModel
+from .routes import router
+
+# Güvenlik yapılandırması
+SECRET_KEY = os.environ.get("SECRET_KEY", "güvenli_bir_anahtar_oluşturun")
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+# Şifre hashleme
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# Token doğrulama
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+# Kullanıcı modeli
+class User(BaseModel):
+    username: str
+    full_name: str
+    email: str
+    role: str  # "admin", "doctor", "specialist"
+    disabled: bool = False
+
+# Token modeli
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+# Örnek kullanıcı veritabanı (gerçek uygulamada güvenli bir veritabanı kullanın)
+fake_users_db = {
+    "doktor": {
+        "username": "doktor",
+        "full_name": "Doktor Kullanıcı",
+        "email": "doktor@example.com",
+        "hashed_password": pwd_context.hash("gizlisifre"),
+        "role": "doctor",
+        "disabled": False
+    },
+    "bölüm_başkanı": {
+        "username": "bölüm_başkanı",
+        "full_name": "Bölüm Başkanı",
+        "email": "bolum@example.com",
+        "hashed_password": pwd_context.hash("gizlisifre2"),
+        "role": "specialist",
+        "disabled": False
+    }
+}
+
+# Uygulama
+app = FastAPI(
+    title="Tıbbi Konuşma Transkripsiyon Servisi",
+    description="Doktor viziteleri sırasında konuşmaları transkribe eden ve diyarize eden API",
+    version="0.1.0"
+)
+
+# CORS ayarları - sadece güvenilir kaynaklar
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["https://sizin-guvenli-web-siteniz.com"],  # Üretimde belirli bir domain listesi kullanın
+    allow_credentials=True,
+    allow_methods=["GET", "POST"],
+    allow_headers=["Authorization", "Content-Type"],
+)
+
+# Yetkilendirme fonksiyonları
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_user(db, username: str):
+    if username in db:
+        user_dict = db[username]
+        return User(**user_dict)
+
+def authenticate_user(db, username: str, password: str):
+    user = get_user(db, username)
+    if not user:
+        return False
+    if not verify_password(password, db[username]["hashed_password"]):
+        return False
+    return user
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+async def get_current_user(token: str = Depends(oauth2_scheme)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Geçersiz kimlik bilgileri",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    user = get_user(fake_users_db, username)
+    if user is None:
+        raise credentials_exception
+    return user
+
+async def get_current_active_user(current_user: User = Depends(get_current_user)):
+    if current_user.disabled:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return current_user
+
+# Doktor yetkisi kontrolü
+def doctor_required(current_user: User = Depends(get_current_active_user)):
+    if current_user.role not in ["doctor", "specialist"]:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Bu işlem için doktor yetkisi gereklidir"
+        )
+    return current_user
+
+# Token endpoint
+@app.post("/token", response_model=Token)
+async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
+    user = authenticate_user(fake_users_db, form_data.username, form_data.password)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Kullanıcı adı veya şifre hatalı",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_access_token(
+        data={"sub": user.username}, expires_delta=access_token_expires
+    )
+    return {"access_token": access_token, "token_type": "bearer"}
+
+# Türkçe dil desteği yapılandırması
+app.state.asr_config = {
+    "language": "tr",
+    "model": "whisper-large-v3",
+    "domain": "medical",
+    # Güvenlik ayarları
+    "anonymize_data": True  # Varsayılan olarak veri anonimleştirme aktif
+}
+
+# Router'ı ekle - doktor yetkisi gerektir
+app.include_router(router, prefix="/api", dependencies=[Depends(doctor_required)])

preprocessing.py

@@ -0,0 +1,41 @@
+import os
+from pydub import AudioSegment
+import noisereduce as nr
+import webrtcvad
+from ..config import settings
+
+def clean_audio(input_path: str) -> str:
+    audio = AudioSegment.from_file(input_path)
+    samples = audio.get_array_of_samples()
+    reduced = nr.reduce_noise(
+        y=samples, sr=settings.SAMPLE_RATE
+    )
+    cleaned = AudioSegment(
+        reduced.tobytes(),
+        frame_rate=settings.SAMPLE_RATE,
+        sample_width=audio.sample_width,
+        channels=audio.channels
+    )
+    vad = webrtcvad.Vad(2)
+    trimmed = _apply_vad(cleaned, vad)
+    clean_path = input_path.replace('.wav', '_clean.wav')
+    trimmed.export(clean_path, format='wav')
+    return clean_path
+
+def _apply_vad(audio: AudioSegment, vad: webrtcvad.Vad) -> AudioSegment:
+    frame_duration = 30
+    frames = []
+    samples = audio.get_array_of_samples()
+    for i in range(0, len(samples), int(settings.SAMPLE_RATE * frame_duration / 1000)):
+        frame = samples[i:i + int(settings.SAMPLE_RATE * frame_duration / 1000)]
+        is_speech = vad.is_speech(
+            frame.tobytes(), sample_rate=settings.SAMPLE_RATE
+        )
+        if is_speech:
+            frames.extend(frame)
+    return AudioSegment(
+        data=bytes(frames),
+        sample_width=audio.sample_width,
+        frame_rate=settings.SAMPLE_RATE,
+        channels=audio.channels
+    )

requirements.txt

@@ -0,0 +1,19 @@
+fastapi==0.103.1
+uvicorn==0.23.2
+pydantic==2.3.0
+python-multipart==0.0.6
+numpy==1.26.0
+librosa==0.10.1
+noisereduce==2.0.1
+soundfile==0.12.1
+pyannote.audio==3.0.0
+torch==2.0.1
+whisper==1.1.10
+spacy==3.6.1
+fuzzywuzzy==0.18.0
+python-Levenshtein==0.21.1
+python-jose==3.3.0
+passlib==1.7.4
+cryptography==41.0.4
+python-dotenv==1.0.0
+gradio==3.50.2 

routes.py

@@ -0,0 +1,85 @@
+from fastapi import APIRouter, UploadFile, File, Depends, HTTPException, Query
+from fastapi.responses import JSONResponse
+from .services.preprocessing import clean_audio
+from .services.asr import transcribe_file, MedicalASR
+from .services.diarization import diarize_segments
+from .services.privacy import MedicalPrivacyProcessor
+from .config import settings
+from typing import Optional
+import tempfile, os, uuid
+from fastapi.concurrency import run_in_threadpool
+
+router = APIRouter()
+
+# Gizlilik işlemcisi
+privacy_processor = MedicalPrivacyProcessor()
+
+def get_asr_model():
+    """ASR modelini oluşturur ve döndürür"""
+    from .main import app
+    # Ana uygulamadan konfigürasyonu al
+    config = app.state.asr_config
+    return MedicalASR(config)
+
+@router.post("/transcribe")
+async def transcribe_audio(
+    file: UploadFile = File(...),
+    diarize: bool = True,
+    enhance_audio: bool = True,
+    anonymize: Optional[bool] = Query(None, description="Kişisel verileri anonimleştir"),
+    asr_model: MedicalASR = Depends(get_asr_model)
+):
+    """Ses dosyasını transkribe eder"""
+    try:
+        # Geçici dosya oluştur
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_file:
+            temp_file.write(await file.read())
+            temp_file_path = temp_file.name
+        
+        # CPU/GPU yoğun işlemi thread pool'da çalıştır
+        result = await run_in_threadpool(
+            asr_model.transcribe,
+            temp_file_path, 
+            speaker_diarization=diarize,
+            enhance_audio=enhance_audio
+        )
+        
+        # Geçici dosyayı temizle
+        os.unlink(temp_file_path)
+        
+        # Kişisel veri anonimleştirme
+        # Eğer açıkça belirtilmediyse uygulama konfigürasyonuna göre davran
+        from .main import app
+        should_anonymize = anonymize if anonymize is not None else app.state.asr_config.get("anonymize_data", True)
+        
+        identified_data = {}
+        if should_anonymize:
+            # Ana metni anonimleştir
+            anonymized_text, main_data = privacy_processor.anonymize_text(result["text"])
+            result["text"] = anonymized_text
+            identified_data.update(main_data)
+            
+            # Diyarizasyon segmentlerini anonimleştir
+            if "diarization" in result:
+                for segment in result["diarization"]:
+                    if segment["text"]:
+                        anonymized_segment, segment_data = privacy_processor.anonymize_text(segment["text"])
+                        segment["text"] = anonymized_segment
+                        # Her segment için tespit edilen verileri güncelle
+                        for key, values in segment_data.items():
+                            identified_data.setdefault(key, []).extend(values)
+            
+            # Tespit edilen verileri güvenli şekilde sakla
+            # NOT: Gerçek uygulamada bu verileri şifreli bir veritabanında saklayın
+            session_id = str(uuid.uuid4())
+            # Burada verileri güvenli bir şekilde saklama kodunuz olacak
+            
+            # Yanıtta tespit edilen veri tipleri hakkında bilgi ver
+            result["anonymized"] = True
+            result["identified_data_types"] = {k: len(v) for k, v in identified_data.items() if v}
+            result["session_id"] = session_id
+        
+        return JSONResponse(content=result)
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Transkripsiyon hatası: {str(e)}")

test_asr.py

@@ -0,0 +1,29 @@
+from app.services.asr import MedicalASR
+import os
+
+# Test yapılandırması
+config = {
+    "language": "tr",
+    "model": "whisper-base",  # Daha hızlı test için daha küçük model
+    "domain": "medical"
+}
+
+# MedicalASR sınıfını başlat
+asr = MedicalASR(config)
+
+# Test ses dosyası (örnek bir wav dosyası yolu verin)
+test_file = "test_audio.wav"
+
+# Transkripsiyon yap
+result = asr.transcribe(
+    test_file, 
+    speaker_diarization=True,
+    enhance_audio=True
+)
+
+# Sonuçları yazdır
+print("Tam Transkripsiyon:")
+print(result["text"])
+print("\nKonuşmacı Ayrımı:")
+for segment in result.get("diarization", []):
+    print(f"{segment['speaker']} ({segment['start']:.1f}s - {segment['end']:.1f}s): {segment['text']}")