Upload 3 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/best_plate_model.pdparams filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,137 @@
+import os
+import cv2
+import numpy as np
+import paddle
+import paddle.nn as nn
+import gradio as gr
+from ultralytics import YOLO
+from PIL import Image
+
+# ─── 1) PlateOCR Sınıfı (fine-tuned model mimarinizle birebir aynı) ───
+MAX_SEQ_LEN = 15
+LABEL_MAP   = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ "
+NUM_CLASSES = len(LABEL_MAP)
+
+class OCRHead(nn.Layer):
+    def __init__(self, flatten_size):
+        super().__init__()
+        self.dropout = nn.Dropout(0.5)
+        self.fc      = nn.Linear(flatten_size, MAX_SEQ_LEN * NUM_CLASSES)
+
+    def forward(self, x):
+        x = self.dropout(x)
+        x = self.fc(x)
+        return x.reshape([-1, MAX_SEQ_LEN, NUM_CLASSES])
+
+class PlateOCR(nn.Layer):
+    def __init__(self):
+        super().__init__()
+        self.backbone = nn.Sequential(
+            nn.Conv2D(3, 32, 3, padding=1), nn.BatchNorm2D(32), nn.ReLU(),
+            nn.MaxPool2D(2,2),
+            nn.Conv2D(32, 64, 3, padding=1), nn.BatchNorm2D(64), nn.ReLU(),
+            nn.MaxPool2D(2,2),
+            nn.Conv2D(64,128,3, padding=1), nn.BatchNorm2D(128),nn.ReLU(),
+            nn.MaxPool2D(2,2), nn.Dropout(0.25)
+        )
+        # dummy tensor ile flatten boyutunu hesapla
+        dummy = paddle.randn([1,3,32,128])
+        flat_size = paddle.flatten(self.backbone(dummy),1).shape[1]
+        self.head = OCRHead(flat_size)
+
+    def forward(self, x):
+        x = self.backbone(x)
+        x = paddle.flatten(x,1)
+        return self.head(x)
+
+# ─── 2) Greedy Decode ───
+def greedy_decode(logits):
+    # logits: [B, T, C]
+    preds = logits.numpy().argmax(axis=2)  # [B, T]
+    texts = []
+    for seq in preds:
+        prev = -1
+        chars = []
+        for idx in seq:
+            if idx != prev and idx < NUM_CLASSES:
+                chars.append(LABEL_MAP[idx])
+            prev = idx
+        texts.append("".join(chars).strip())
+    return texts
+
+# ─── 3) Modelleri Yükle ───
+# YOLO
+yolo = YOLO("models/best.pt")
+
+# PlateOCR
+plate_ocr = PlateOCR()
+plate_ocr.set_state_dict(paddle.load("models/best_plate_model.pdparams"))
+plate_ocr.eval()
+
+# ─── 4) Pipeline Fonksiyonu ───
+def detect_and_read(image, conf_thresh):
+    """ YOLO ile plakayı kes, PlateOCR ile oku, görselleştir. """
+    if image is None:
+        return None, "❌ Upload an image."
+
+    # 1) BGR→RGB
+    img = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+    # 2) YOLO predict
+    results = yolo.predict(source=img, conf=conf_thresh)[0]
+    boxes   = results.boxes.xyxy.cpu().numpy()  # [N,4]
+    scores  = results.boxes.conf.cpu().numpy()
+    classes = results.boxes.cls.cpu().numpy()
+
+    annotated = img.copy()
+    ocr_texts = []
+
+    for (x1,y1,x2,y2), conf in zip(boxes, scores):
+        x1,y1,x2,y2 = map(int,(x1,y1,x2,y2))
+        crop = annotated[y1:y2, x1:x2]
+        if crop.size==0: 
+            continue
+
+        # 3) PlateOCR için preprocess
+        plate = cv2.resize(crop, (128,32))
+        arr   = plate.astype("float32")/255.0
+        arr   = arr.transpose(2,0,1)[None,:,:,:]  # [1,3,32,128]
+        inp   = paddle.to_tensor(arr)
+
+        # 4) OCR inference
+        with paddle.no_grad():
+            out = plate_ocr(inp)                # [1, T, C]
+        text = greedy_decode(out)[0]
+
+        # 5) Draw box + text + confidences
+        label = f"{text} ({conf:.2f})"
+        # kutu
+        cv2.rectangle(annotated,(x1,y1),(x2,y2),(0,255,0),2)
+        # label arka plan
+        (tw,th),baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.8,2)
+        ty = y1 - 10 if y1 -10 > th+baseline else y1+th+10
+        cv2.rectangle(annotated,(x1,ty-th-baseline),(x1+tw,ty+baseline),(0,255,0),cv2.FILLED)
+        cv2.putText(annotated,label,(x1,ty),cv2.FONT_HERSHEY_SIMPLEX,0.8,(0,0,0),2)
+
+        ocr_texts.append(text)
+
+    # BGR→RGB döndür
+    out_img = cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)
+    status  = f"Detected {len(boxes)} plates, OCR: {ocr_texts}"
+    return out_img, status
+
+# ─── 5) Gradio Arayüzü ───
+with gr.Blocks() as demo:
+    gr.Markdown("## 🚗 Plate Detection + Recognition")
+    with gr.Row():
+        with gr.Column():
+            inp  = gr.Image(type="numpy", label="Upload Image")
+            conf = gr.Slider(0,1,0.25,0.01, label="YOLO Confidence")
+            btn  = gr.Button("Run")
+        with gr.Column():
+            out_img  = gr.Image(type="numpy", label="Annotated")
+            out_text = gr.Textbox(label="Status", interactive=False)
+    btn.click(detect_and_read, [inp, conf], [out_img, out_text])
+    gr.Markdown("---\n**How it works:** YOLO finds plate boxes; your PaddleOCR-fine-tuned PlateOCR reads them.")
+
+if __name__=="__main__":
+    demo.launch()

models/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f25d12d95518dd762f3365e7c3a1fffd87c9e4a2b7a4c61623384c2ecc84f62
+size 6250979

models/best_plate_model.pdparams

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2eb1aef4e213469bd6d6d62dcfa6a0ddda6ba7b8a1339ef84625b2839cc3b2bc
+size 18566687