Initial deployment of Antique Authenticity API

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.10
+
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the entire project
+COPY . .
+
+# Expose port 7860 (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+
+# Run the app
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,13 @@
+# app.py - Main entry point for Hugging Face Spaces
+import sys
+import os
+
+# Add code directory to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'code'))
+
+# Import and run the FastAPI app
+from code.app import app
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

code/app.py

@@ -0,0 +1,271 @@
+# app.py
+from fastapi import FastAPI, UploadFile, Form, File
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import torch
+from PIL import Image
+import io
+from model import AuctionAuthenticityModel
+from torchvision import transforms
+import os
+import numpy as np
+
+
+app = FastAPI(
+    title="Antique Auction Authenticity API",
+    description="AI model do oceny autentyczności aukcji antyków",
+    version="1.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+DEVICE = torch.device('cpu')
+MODEL_PATH = '../weights/auction_model.pt'
+
+model = None
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225]
+    )
+])
+
+@app.on_event("startup")
+async def load_model():
+    global model
+    print("🚀 Ładowanie modelu...")
+    model = AuctionAuthenticityModel(num_classes=3, device=DEVICE).to(DEVICE)
+    if os.path.exists(MODEL_PATH):
+        model.load_state_dict(torch.load(MODEL_PATH, map_location=DEVICE))
+        print(f"✓ Model załadowany z {MODEL_PATH}")
+    else:
+        print("⚠️  Brak wag - pretrained")
+    model.eval()
+    print("✓ Model gotowy")
+
+@app.post("/predict")
+async def predict(
+    image: UploadFile = File(...),
+    title: str = Form(...),
+    description: str = Form(...)
+):
+    try:
+        img_data = await image.read()
+        img = Image.open(io.BytesIO(img_data)).convert('RGB')
+        img_tensor = transform(img).unsqueeze(0).to(DEVICE)
+        text = f"{title} {description}"
+        
+        with torch.no_grad():
+            logits = model(img_tensor, [text])
+            probs = torch.softmax(logits, dim=1)[0]
+        
+        orig_prob = float(probs[0])  # label 0
+        scam_prob = float(probs[1])  # label 1
+        repl_prob = float(probs[2])  # label 2
+        
+        probs_dict = {
+            "ORIGINAL": orig_prob,
+            "SCAM": scam_prob,
+            "REPLICA": repl_prob
+        }
+        best_label = max(probs_dict, key=probs_dict.get)
+        best_prob = probs_dict[best_label]
+        
+        # Niepewny: max prob < 0.6 LUB margin < 0.15
+        sorted_probs = sorted(probs_dict.values(), reverse=True)
+        margin = sorted_probs[0] - sorted_probs[1]
+        
+        if best_prob < 0.6 or margin < 0.15:
+            verdict = "UNCERTAIN"
+        else:
+            verdict = best_label
+        
+        return JSONResponse({
+            "status": "success",
+            "original_probability": round(orig_prob, 3),
+            "scam_probability": round(scam_prob, 3),
+            "replica_probability": round(repl_prob, 3),
+            "verdict": verdict,
+            "confidence": round(best_prob, 3),
+            "margin": round(margin, 3),
+            "message": f"Aukcja ma {best_prob*100:.1f}% pewności: {verdict}"
+        })
+    except Exception as e:
+        return JSONResponse(
+            {"status": "error", "error": str(e)},
+            status_code=400
+        )
+
+@app.post("/predict_ensemble")
+async def predict_ensemble(
+    images: list[UploadFile] = File(...),  # wiele plików!
+    title: str = Form(...),
+    description: str = Form(...)
+):
+    predictions = []
+    
+    for i, img_file in enumerate(images):
+        img_data = await img_file.read()
+        img = Image.open(io.BytesIO(img_data)).convert('RGB')
+        img_tensor = transform(img).unsqueeze(0).to(DEVICE)
+        text = f"{title} {description}"
+        
+        with torch.no_grad():
+            logits = model(img_tensor, [text])
+            probs = torch.softmax(logits, dim=1)[0].cpu().numpy()
+            predictions.append(probs)
+    
+    # Średnia z wszystkich zdjęć
+    avg_probs = np.mean(predictions, axis=0)
+    
+    orig_prob = float(avg_probs[0])
+    scam_prob = float(avg_probs[1])
+    repl_prob = float(avg_probs[2])
+    
+    probs_dict = {"ORIGINAL": orig_prob, "SCAM": scam_prob, "REPLICA": repl_prob}
+    best_label = max(probs_dict, key=probs_dict.get)
+    best_prob = probs_dict[best_label]
+    
+    sorted_probs = sorted(probs_dict.values(), reverse=True)
+    margin = sorted_probs[0] - sorted_probs[1]
+    
+    if best_prob < 0.6 or margin < 0.15:
+        verdict = "UNCERTAIN"
+    else:
+        verdict = best_label
+    
+    return JSONResponse({
+        "status": "success",
+        "image_count": len(images),
+        "original_probability": round(orig_prob, 3),
+        "scam_probability": round(scam_prob, 3),
+        "replica_probability": round(repl_prob, 3),
+        "verdict": verdict,
+        "confidence": round(best_prob, 3),
+        "margin": round(margin, 3),
+        "per_image_probs": [p.tolist() for p in predictions]  # dla debug
+    })
+
+@app.post("/validate_url")
+async def validate_url(
+    url: str = Form(...),
+    max_images: int = Form(3)
+):
+    try:
+        import numpy as np
+        from io import BytesIO
+        import requests
+        
+        max_images = max(1, min(max_images, 10))
+        
+        # 1. Scraper
+        if "allegro.pl" in url:
+            from web_scraper_allegro import scrape_allegro_offer
+            auction = scrape_allegro_offer(url)
+        elif "olx.pl" in url:
+            from web_scraper_olx import scrape_olx_offer
+            auction = scrape_olx_offer(url)
+        elif "ebay." in url:
+            from web_scraper_ebay import scrape_ebay_offer
+            auction = scrape_ebay_offer(url)
+        else:
+            return JSONResponse({"error": "Unsupported platform"}, status_code=400)
+        
+        if not auction.get("image_urls"):
+            return JSONResponse({"error": "No images"}, status_code=400)
+        
+        # 2. Ile zdjęć
+        total_available = len(auction["image_urls"])
+        images_to_use = min(max_images, total_available)
+        
+        # 3. Model BEZ HTTP (bezpośrednio!)
+        img_probs = []
+        text = auction["title"] + " " + auction["description"]
+        
+        for i, img_url in enumerate(auction["image_urls"][:images_to_use]):
+            print(f"📸 {i+1}/{images_to_use}")
+            
+            img_resp = requests.get(img_url, timeout=15)
+            img_resp.raise_for_status()
+            
+            img = Image.open(BytesIO(img_resp.content)).convert('RGB')
+            img_tensor = transform(img).unsqueeze(0).to(DEVICE)
+            
+            with torch.no_grad():
+                logits = model(img_tensor, [text])
+                probs = torch.softmax(logits, dim=1)[0]
+                
+            img_probs.append({
+                "original_probability": float(probs[0]),
+                "scam_probability": float(probs[1]),
+                "replica_probability": float(probs[2])
+            })
+        
+        # 4. Średnia
+        avg_orig = np.mean([p["original_probability"] for p in img_probs])
+        avg_scam = np.mean([p["scam_probability"] for p in img_probs])
+        avg_repl = np.mean([p["replica_probability"] for p in img_probs])
+        
+        probs_dict = {"ORIGINAL": avg_orig, "SCAM": avg_scam, "REPLICA": avg_repl}
+        best_label = max(probs_dict, key=probs_dict.get)
+        best_prob = float(probs_dict[best_label])
+        
+        sorted_probs = sorted(probs_dict.values(), reverse=True)
+        margin = float(sorted_probs[0] - sorted_probs[1])
+        
+        if best_prob < 0.6 or margin < 0.15:
+            verdict = "UNCERTAIN"
+        else:
+            verdict = best_label
+        
+        return {
+            "status": "success",
+            "url": url,
+            "title": auction["title"][:100] + "...",
+            "platform": auction["platform"],
+            "total_images_available": total_available,
+            "requested_max_images": max_images,
+            "image_count_used": images_to_use,
+            "original_probability": round(avg_orig, 3),
+            "scam_probability": round(avg_scam, 3),
+            "replica_probability": round(avg_repl, 3),
+            "verdict": verdict,
+            "confidence": round(best_prob, 3),
+            "margin": round(margin, 3)
+        }
+    
+    except Exception as e:
+        import traceback
+        return JSONResponse({
+            "status": "error", 
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        }, status_code=500)
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "message": "API running"}
+
+@app.get("/")
+def root():
+    return {
+        "name": "Antique Auction Authenticity API",
+        "version": "1.0.0",
+        "endpoints": {
+            "POST /predict": "Oceń aukcję",
+            "GET /health": "Health check"
+        }
+    }
+
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host='0.0.0.0', port=7860)

code/dataset_loader.py

@@ -0,0 +1,86 @@
+import json
+from pathlib import Path
+from PIL import Image
+import torch
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms
+
+class AuctionDatasetFromJSON(Dataset):
+    def __init__(self, json_path: str, root_dir: str, transform=None, max_samples=None):
+        """
+        json_path: dataset/dataset.json
+        root_dir: dataset/raw_data
+        """
+        with open(json_path, 'r', encoding='utf-8') as f:
+            self.data = json.load(f)
+        
+        if max_samples:
+            self.data = self.data[:max_samples]
+        
+        self.root_dir = Path(root_dir)
+        self.transform = transform
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        auction = self.data[idx]
+        
+        # Ścieżka do zdjęcia
+        img_path = self.root_dir / auction['folder_path'] / auction['images'][0]
+        
+        try:
+            img = Image.open(img_path).convert('RGB')
+        except Exception as e:
+            print(f"Błąd wczytywania {img_path}: {e}")
+            # Fallback: czarne zdjęcie
+            img = Image.new('RGB', (224, 224), color='black')
+        
+        if self.transform:
+            img = self.transform(img)
+        
+        # Tekst: title + opis
+        text = f"{auction.get('title', '')} {auction.get('description', '')}"
+        
+        return {
+            'image': img,
+            'text': text,
+            'platform': auction['platform'],
+            'title': auction['title'],
+            'id': auction['id'],
+            'label': torch.tensor(auction.get('label', 0), dtype=torch.long),
+            'folder_path': auction['folder_path']
+        }
+
+# Transformacje
+get_transforms = lambda: transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225]
+    )
+])
+
+if __name__ == '__main__':
+    print("Testowanie DataLoadera...")
+    
+    dataset = AuctionDatasetFromJSON(
+        json_path='../dataset/dataset.json',
+        root_dir='../dataset/raw_data',
+        transform=get_transforms(),
+        max_samples=5
+    )
+    
+    print(f"✓ Dataset załadowany: {len(dataset)} próbek")
+    
+    loader = DataLoader(dataset, batch_size=2, shuffle=True, num_workers=0)
+    
+    for batch in loader:
+        print(f"\nBatch:")
+        print(f"  - Image shape: {batch['image'].shape}")
+        print(f"  - Texts: {len(batch['text'])}")
+        print(f"  - Platforms: {batch['platform']}")
+        print(f"  - Labels: {batch['label']}")
+        print(f"  - Example text: {batch['text'][0][:100]}...")
+        break

code/evaluate_live.py

@@ -0,0 +1,74 @@
+# evaluate_live.py
+import requests
+from io import BytesIO
+
+# Import Twoich scraperów
+from web_scraper_allegro import scrape_allegro_offer
+from web_scraper_olx import scrape_olx_offer
+from web_scraper_ebay import scrape_ebay_offer
+
+API_URL = "http://localhost:7860/predict"
+
+def call_model(auction):
+    if not auction.get("image_urls"):
+        return {"error": "No images found"}
+    
+    img_url = auction["image_urls"][0]
+    print(f"📸 Pobieram zdjęcie: {img_url}")
+    
+    img_resp = requests.get(img_url, timeout=20)
+    img_resp.raise_for_status()
+    
+    files = {
+        "image": ("image.jpg", BytesIO(img_resp.content), "image/jpeg")
+    }
+    data = {
+        "title": auction.get("title", ""),
+        "description": auction.get("description", "")
+    }
+    
+    r = requests.post(API_URL, files=files, data=data, timeout=120)
+    r.raise_for_status()
+    return r.json()
+
+def scrape_offer(url: str):
+    """Automatycznie wybiera scraper na podstawie domeny"""
+    if "allegro.pl" in url:
+        return scrape_allegro_offer(url)
+    elif "olx.pl" in url:
+        return scrape_olx_offer(url)
+    elif "ebay." in url:
+        return scrape_ebay_offer(url)
+    else:
+        raise ValueError("Nieobsługiwana platforma")
+
+def evaluate_url(url: str):
+    """Pełny pipeline: scrape → model → wynik"""
+    print(f"🔍 Analizuję: {url}")
+    
+    auction = scrape_offer(url)
+    print(f"📋 Zebrane: {auction['title'][:50]}...")
+    
+    model_result = call_model(auction)
+    
+    return {
+        "url": url,
+        "platform": auction["platform"],
+        "title": auction["title"],
+        "model_result": model_result,
+    }
+
+if __name__ == "__main__":
+    while True:
+        url = input("\nPodaj link do aukcji (lub 'q' do wyjścia): ")
+        if url.lower() == 'q':
+            break
+        
+        try:
+            result = evaluate_url(url)
+            print("\n" + "="*80)
+            print(f"VERDICT: {result['model_result'].get('verdict')}")
+            print(f"CONFIDENCE: {result['model_result'].get('confidence')}")
+            print("="*80)
+        except Exception as e:
+            print(f"❌ Błąd: {e}")

code/labeling_app/labeling_app.py

@@ -0,0 +1,99 @@
+from flask import Flask, render_template, request, jsonify, send_file
+import json
+import os
+from pathlib import Path
+
+app = Flask(__name__)
+
+# WAŻNE: ustaw ścieżkę POPRAWNIE (zależy gdzie masz folder)
+DATASET_PATH = Path(__file__).parent.parent.parent / 'dataset' / 'dataset.json'
+RAW_DATA_PATH = Path(__file__).parent.parent.parent / 'dataset' / 'raw_data'
+
+print(f"Dataset path: {DATASET_PATH}")
+print(f"Raw data path: {RAW_DATA_PATH}")
+
+def load_dataset():
+    with open(DATASET_PATH, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+def save_dataset(data):
+    with open(DATASET_PATH, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+@app.route('/')
+def index():
+    dataset = load_dataset()
+    return render_template('labeling.html', total_auctions=len(dataset))
+
+@app.route('/image/<path:image_path>')
+def serve_image(image_path):
+    """Serwuj zdjęcie"""
+    full_path = RAW_DATA_PATH / image_path
+    print(f"Szukam: {full_path}")
+    if full_path.exists():
+        return send_file(full_path)
+    return "Not found", 404
+
+@app.route('/api/next_unlabeled')
+def next_unlabeled():
+    dataset = load_dataset()
+    
+    for i, auction in enumerate(dataset):
+        if auction.get('label_confidence', 0) == 0:
+            # Przygotuj WSZYSTKIE zdjęcia
+            images = []
+            for img_name in auction['images']:
+                img_path = f"{auction['folder_path']}/{img_name}"
+                images.append(f"/image/{img_path}")
+            
+            return jsonify({
+                'index': i,
+                'id': auction['id'],
+                'title': auction['title'],
+                'description': auction['description'][:300] + '...',
+                'platform': auction['platform'],
+                'link': auction['link'],
+                'parameters': auction.get('parameters', {}),
+                'images': images,
+                'total': len(dataset),
+                'current': i + 1
+            })
+    
+    return jsonify({'error': 'Wszystkie aukcje etykietowane!'})
+
+@app.route('/api/save_label', methods=['POST'])
+def save_label():
+    data = request.json
+    dataset = load_dataset()
+    
+    auction_index = data['auction_index']
+    dataset[auction_index]['label'] = data['label']
+    dataset[auction_index]['label_confidence'] = data['confidence']
+    
+    save_dataset(dataset)
+    return jsonify({'status': 'ok'})
+
+@app.route('/api/stats')
+def get_stats():
+    dataset = load_dataset()
+    
+    total = len(dataset)
+    labeled = len([a for a in dataset if a.get('label_confidence', 0) > 0])
+    unlabeled = total - labeled
+    
+    by_label = {
+        'ORIGINAL': len([a for a in dataset if a.get('label') == 0]),
+        'SCAM': len([a for a in dataset if a.get('label') == 1]),
+        'REPLICA': len([a for a in dataset if a.get('label') == 2])
+    }
+    
+    return jsonify({
+        'total': total,
+        'labeled': labeled,
+        'unlabeled': unlabeled,
+        'by_label': by_label,
+        'progress': round(labeled / total * 100, 1) if total > 0 else 0
+    })
+
+if __name__ == '__main__':
+    app.run(debug=True, port=5000)

code/labeling_app/templates/labeling.html

@@ -0,0 +1,660 @@
+<!DOCTYPE html>
+<html lang="pl">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Labeling Aukcji Antyków</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #f5f5f5;
+            padding: 20px;
+        }
+        
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        
+        header {
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            margin-bottom: 20px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        h1 {
+            font-size: 28px;
+            color: #333;
+        }
+        
+        .progress-bar {
+            width: 300px;
+            height: 8px;
+            background: #e0e0e0;
+            border-radius: 4px;
+            overflow: hidden;
+        }
+        
+        .progress-fill {
+            height: 100%;
+            background: #4CAF50;
+            transition: width 0.3s;
+        }
+        
+        .progress-text {
+            font-size: 14px;
+            color: #666;
+            margin-top: 8px;
+        }
+        
+        .main-content {
+            display: grid;
+            grid-template-columns: 2fr 1fr;
+            gap: 20px;
+        }
+        
+        .auction-card {
+            background: white;
+            border-radius: 8px;
+            padding: 20px;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        }
+        
+        .auction-header {
+            margin-bottom: 20px;
+            border-bottom: 1px solid #e0e0e0;
+            padding-bottom: 15px;
+        }
+        
+        .auction-title {
+            font-size: 20px;
+            font-weight: 600;
+            color: #333;
+            margin-bottom: 8px;
+        }
+        
+        .auction-meta {
+            display: flex;
+            gap: 15px;
+            font-size: 12px;
+            color: #888;
+        }
+        
+        .badge {
+            background: #f0f0f0;
+            padding: 4px 8px;
+            border-radius: 4px;
+        }
+        
+        .images-carousel {
+            margin-bottom: 20px;
+            border-radius: 8px;
+            overflow: hidden;
+            background: #f9f9f9;
+            max-height: 400px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+        
+        .images-carousel img {
+            max-width: 100%;
+            max-height: 400px;
+            object-fit: contain;
+        }
+        
+        .description {
+            background: #f9f9f9;
+            padding: 15px;
+            border-radius: 6px;
+            margin-bottom: 20px;
+            line-height: 1.6;
+            color: #555;
+            font-size: 14px;
+        }
+        
+        .parameters {
+            background: #f9f9f9;
+            padding: 15px;
+            border-radius: 6px;
+            margin-bottom: 20px;
+        }
+        
+        .parameters h3 {
+            font-size: 14px;
+            color: #333;
+            margin-bottom: 10px;
+        }
+        
+        .param-item {
+            display: flex;
+            justify-content: space-between;
+            padding: 8px 0;
+            border-bottom: 1px solid #e0e0e0;
+            font-size: 13px;
+        }
+        
+        .param-item:last-child {
+            border-bottom: none;
+        }
+        
+        .param-key {
+            color: #666;
+            font-weight: 500;
+        }
+        
+        .param-val {
+            color: #333;
+        }
+        
+        .sidebar {
+            display: flex;
+            flex-direction: column;
+            gap: 20px;
+        }
+        
+        .rating-section {
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        }
+        
+        .rating-section h2 {
+            font-size: 16px;
+            margin-bottom: 15px;
+            color: #333;
+        }
+        
+        .button-group {
+            display: flex;
+            flex-direction: column;
+            gap: 10px;
+            margin-bottom: 20px;
+        }
+        
+        .btn {
+            padding: 12px 16px;
+            border: none;
+            border-radius: 6px;
+            font-size: 14px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+        
+        .btn-original {
+            background: #4CAF50;
+            color: white;
+        }
+        
+        .btn-original:hover {
+            background: #45a049;
+            transform: translateY(-2px);
+        }
+        
+        .btn-original.active {
+            box-shadow: 0 4px 12px rgba(76, 175, 80, 0.4);
+        }
+        
+        .btn-scam {
+            background: #f44336;
+            color: white;
+        }
+        
+        .btn-scam:hover {
+            background: #da190b;
+            transform: translateY(-2px);
+        }
+        
+        .btn-scam.active {
+            box-shadow: 0 4px 12px rgba(244, 67, 54, 0.4);
+        }
+        
+        .btn-replica {
+            background: #FF9800;
+            color: white;
+        }
+        
+        .btn-replica:hover {
+            background: #e68900;
+            transform: translateY(-2px);
+        }
+        
+        .btn-replica.active {
+            box-shadow: 0 4px 12px rgba(255, 152, 0, 0.4);
+        }
+        
+        .confidence-section {
+            background: #f9f9f9;
+            padding: 15px;
+            border-radius: 6px;
+            margin-bottom: 15px;
+        }
+        
+        .confidence-label {
+            font-size: 13px;
+            color: #666;
+            margin-bottom: 10px;
+            display: flex;
+            justify-content: space-between;
+        }
+        
+        .confidence-value {
+            font-weight: 600;
+            color: #333;
+        }
+        
+        .confidence-slider {
+            width: 100%;
+        }
+        
+        .btn-save {
+            background: #2196F3;
+            color: white;
+            width: 100%;
+            padding: 14px;
+            font-size: 15px;
+            font-weight: 600;
+        }
+        
+        .btn-save:hover {
+            background: #0b7dda;
+        }
+        
+        .btn-save:disabled {
+            background: #ccc;
+            cursor: not-allowed;
+        }
+        
+        .stats-card {
+            background: white;
+            padding: 15px;
+            border-radius: 8px;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        }
+        
+        .stat-item {
+            display: flex;
+            justify-content: space-between;
+            padding: 10px 0;
+            border-bottom: 1px solid #e0e0e0;
+            font-size: 13px;
+        }
+        
+        .stat-item:last-child {
+            border-bottom: none;
+        }
+        
+        .stat-label {
+            color: #666;
+        }
+        
+        .stat-value {
+            font-weight: 600;
+            color: #333;
+        }
+        
+        .message {
+            padding: 15px;
+            border-radius: 6px;
+            margin-bottom: 20px;
+            text-align: center;
+            font-weight: 500;
+        }
+        
+        .message.success {
+            background: #d4edda;
+            color: #155724;
+        }
+        
+        .message.error {
+            background: #f8d7da;
+            color: #721c24;
+        }
+        .images-container {
+            margin-bottom: 20px;
+        }
+
+        .images-carousel {
+            margin-bottom: 10px;
+            border-radius: 8px;
+            overflow: hidden;
+            background: #f9f9f9;
+            max-height: 400px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .images-carousel img {
+            max-width: 100%;
+            max-height: 400px;
+            object-fit: contain;
+        }
+
+        .images-controls {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 10px;
+        }
+
+        .nav-btn {
+            background: #2196F3;
+            color: white;
+            border: none;
+            padding: 8px 12px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 13px;
+        }
+
+        .nav-btn:hover {
+            background: #0b7dda;
+        }
+
+        .nav-btn:disabled {
+            background: #ccc;
+            cursor: not-allowed;
+        }
+
+        .image-counter {
+            font-size: 12px;
+            color: #666;
+            font-weight: 600;
+        }
+
+        .thumbnails {
+            display: flex;
+            gap: 8px;
+            overflow-x: auto;
+            padding: 10px 0;
+        }
+
+        .thumbnail {
+            width: 60px;
+            height: 60px;
+            border: 2px solid #e0e0e0;
+            border-radius: 4px;
+            cursor: pointer;
+            overflow: hidden;
+            flex-shrink: 0;
+        }
+
+        .thumbnail img {
+            width: 100%;
+            height: 100%;
+            object-fit: cover;
+        }
+
+        .thumbnail.active {
+            border-color: #2196F3;
+        }
+
+        
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>🏺 Labeling Aukcji Antyków</h1>
+            <div>
+                <div class="progress-bar">
+                    <div class="progress-fill" id="progressFill"></div>
+                </div>
+                <div class="progress-text">
+                    <span id="progressText">0 / 0</span>
+                </div>
+            </div>
+        </header>
+        
+        <div class="main-content">
+            <div>
+                <div id="message"></div>
+                
+                <div class="auction-card">
+                    <div class="auction-header">
+                        <div class="auction-title" id="title">Ładowanie...</div>
+                        <div class="auction-meta">
+                            <span class="badge" id="platform">-</span>
+                            <span class="badge" id="position">-</span>
+                        </div>
+                    </div>
+                    
+                    <div class="images-container">
+                        <div class="images-carousel" id="imagesCarousel">
+                            <img id="currentImage" src="" alt="Zdjęcie aukcji">
+                        </div>
+                        <div class="images-controls">
+                            <button id="prevBtn" class="nav-btn">← Poprzednie</button>
+                            <span id="imageCounter" class="image-counter">1 / 1</span>
+                            <button id="nextBtn" class="nav-btn">Następne →</button>
+                        </div>
+                        <div class="thumbnails" id="thumbnails"></div>
+                    </div>
+                    
+                    <div class="description" id="description">-</div>
+                    
+                    <div class="parameters" id="parametersDiv">
+                        <h3>Parametry:</h3>
+                        <div id="paramsList"></div>
+                    </div>
+                    
+                    <a id="auctionLink" target="_blank" style="color: #2196F3; text-decoration: none;">
+                        → Otwórz aukcję
+                    </a>
+                </div>
+            </div>
+            
+            <div class="sidebar">
+                <div class="rating-section">
+                    <h2>Ocena autentyczności</h2>
+                    
+                    <div class="button-group">
+                        <button class="btn btn-original" data-label="0">✓ ORYGINAŁ</button>
+                        <button class="btn btn-scam" data-label="1">✗ SCAM</button>
+                        <button class="btn btn-replica" data-label="2">⚙ REPLIKA</button>
+                    </div>
+                    
+                    <div class="confidence-section">
+                        <div class="confidence-label">
+                            <span>Pewność oceny:</span>
+                            <span class="confidence-value" id="confidenceValue">0%</span>
+                        </div>
+                        <input type="range" min="0" max="5" value="0" class="confidence-slider" id="confidenceSlider">
+                        <div style="display: flex; justify-content: space-between; font-size: 11px; color: #999; margin-top: 5px;">
+                            <span>Niska</span>
+                            <span>Bardzo wysoka</span>
+                        </div>
+                    </div>
+                    
+                    <button class="btn btn-save" id="saveBtn" disabled>💾 Zapisz i Dalej</button>
+                </div>
+                
+                <div class="stats-card">
+                    <h3 style="margin-bottom: 15px; color: #333;">Statystyki</h3>
+                    <div class="stat-item">
+                        <span class="stat-label">Razem:</span>
+                        <span class="stat-value" id="statTotal">0</span>
+                    </div>
+                    <div class="stat-item">
+                        <span class="stat-label">Etykietowane:</span>
+                        <span class="stat-value" id="statLabeled">0</span>
+                    </div>
+                    <div class="stat-item">
+                        <span class="stat-label">Do zrobienia:</span>
+                        <span class="stat-value" id="statUnlabeled">0</span>
+                    </div>
+                    <div class="stat-item">
+                        <span class="stat-label">🏛 Oryginały:</span>
+                        <span class="stat-value" id="statOriginal">0</span>
+                    </div>
+                    <div class="stat-item">
+                        <span class="stat-label">🚫 Scamy:</span>
+                        <span class="stat-value" id="statScam">0</span>
+                    </div>
+                    <div class="stat-item">
+                        <span class="stat-label">⚙ Repliki:</span>
+                        <span class="stat-value" id="statReplica">0</span>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        let currentAuction = null;
+        let selectedLabel = null;
+        let selectedConfidence = 0;
+        let currentImageIndex = 0;
+
+        async function loadNextAuction() {
+            const res = await fetch('/api/next_unlabeled');
+            const data = await res.json();
+            
+            if (data.error) {
+                showMessage(data.error, 'success');
+                document.querySelector('.auction-card').style.display = 'none';
+                return;
+            }
+            
+            currentAuction = data;
+            currentImageIndex = 0;
+            selectedLabel = null;
+            selectedConfidence = 0;
+            
+            // Pokaż dane
+            document.getElementById('title').textContent = data.title;
+            document.getElementById('platform').textContent = data.platform.toUpperCase();
+            document.getElementById('position').textContent = `${data.current} / ${data.total}`;
+            document.getElementById('description').textContent = data.description;
+            document.getElementById('auctionLink').href = data.link;
+            
+            // Parametry
+            const paramsList = document.getElementById('paramsList');
+            paramsList.innerHTML = '';
+            Object.entries(data.parameters).forEach(([key, val]) => {
+                const item = document.createElement('div');
+                item.className = 'param-item';
+                item.innerHTML = `<span class="param-key">${key}:</span><span class="param-val">${val}</span>`;
+                paramsList.appendChild(item);
+            });
+            
+            // Thumbnails
+            const thumbnails = document.getElementById('thumbnails');
+            thumbnails.innerHTML = '';
+            data.images.forEach((imgUrl, idx) => {
+                const thumb = document.createElement('div');
+                thumb.className = 'thumbnail' + (idx === 0 ? ' active' : '');
+                thumb.innerHTML = `<img src="${imgUrl}" alt="Thumbnail ${idx+1}">`;
+                thumb.addEventListener('click', () => showImage(idx));
+                thumbnails.appendChild(thumb);
+            });
+            
+            showImage(0);
+            updateSaveButton();
+            updateStats();
+        }
+
+        function showImage(index) {
+            if (index < 0 || index >= currentAuction.images.length) return;
+            
+            currentImageIndex = index;
+            document.getElementById('currentImage').src = currentAuction.images[index];
+            document.getElementById('imageCounter').textContent = `${index + 1} / ${currentAuction.images.length}`;
+            
+            // Zaznacz thumbnail
+            document.querySelectorAll('.thumbnail').forEach((t, i) => {
+                t.classList.toggle('active', i === index);
+            });
+            
+            // Włącz/wyłącz przyciski
+            document.getElementById('prevBtn').disabled = index === 0;
+            document.getElementById('nextBtn').disabled = index === currentAuction.images.length - 1;
+        }
+
+        document.getElementById('prevBtn').addEventListener('click', () => {
+            showImage(currentImageIndex - 1);
+        });
+
+        document.getElementById('nextBtn').addEventListener('click', () => {
+            showImage(currentImageIndex + 1);
+        });
+
+        document.querySelectorAll('.btn-original, .btn-scam, .btn-replica').forEach(btn => {
+            btn.addEventListener('click', function() {
+                selectedLabel = parseInt(this.dataset.label);
+                document.querySelectorAll('.btn-original, .btn-scam, .btn-replica').forEach(b => b.classList.remove('active'));
+                this.classList.add('active');
+                updateSaveButton();
+            });
+        });
+
+        document.getElementById('confidenceSlider').addEventListener('input', function() {
+            selectedConfidence = parseInt(this.value);
+            const labels = ['0%', '20%', '40%', '60%', '80%', '100%'];
+            document.getElementById('confidenceValue').textContent = labels[selectedConfidence];
+            updateSaveButton();
+        });
+
+        function updateSaveButton() {
+            const canSave = selectedLabel !== null && selectedConfidence > 0;
+            document.getElementById('saveBtn').disabled = !canSave;
+        }
+
+        document.getElementById('saveBtn').addEventListener('click', async function() {
+            const res = await fetch('/api/save_label', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({
+                    auction_index: currentAuction.index,
+                    label: selectedLabel,
+                    confidence: selectedConfidence
+                })
+            });
+            
+            if (res.ok) {
+                loadNextAuction();
+            }
+        });
+
+        async function updateStats() {
+            const res = await fetch('/api/stats');
+            const stats = await res.json();
+            
+            document.getElementById('progressText').textContent = `${stats.labeled} / ${stats.total}`;
+            document.getElementById('progressFill').style.width = stats.progress + '%';
+            
+            document.getElementById('statTotal').textContent = stats.total;
+            document.getElementById('statLabeled').textContent = stats.labeled;
+            document.getElementById('statUnlabeled').textContent = stats.unlabeled;
+            document.getElementById('statOriginal').textContent = stats.by_label.ORIGINAL;
+            document.getElementById('statScam').textContent = stats.by_label.SCAM;
+            document.getElementById('statReplica').textContent = stats.by_label.REPLICA;
+        }
+
+        function showMessage(text, type) {
+            const msgDiv = document.getElementById('message');
+            msgDiv.textContent = text;
+            msgDiv.className = `message ${type}`;
+            msgDiv.style.display = 'block';
+            setTimeout(() => msgDiv.style.display = 'none', 3000);
+        }
+
+        loadNextAuction();
+
+    </script>
+</body>
+</html>

code/model.py

@@ -0,0 +1,80 @@
+# model.py
+import torch
+import torch.nn as nn
+from transformers import DistilBertTokenizer, DistilBertModel
+from torchvision.models import efficientnet_b0
+
+class AuctionAuthenticityModel(nn.Module):
+    def __init__(self, num_classes=3, device='cpu'):  # 3 klasy!
+        super().__init__()
+        self.device = device
+        
+        # Vision
+        self.vision_model = efficientnet_b0(pretrained=True)
+        self.vision_model.classifier = nn.Identity()
+        vision_out_dim = 1280
+        
+        # Text
+        self.text_model = DistilBertModel.from_pretrained(
+            'distilbert-base-multilingual-cased'
+        )
+        text_out_dim = 768
+        
+        self.tokenizer = DistilBertTokenizer.from_pretrained(
+            'distilbert-base-multilingual-cased'
+        )
+        
+        # Fusion (bez BatchNorm!)
+        hidden_dim = 256
+        self.fusion = nn.Sequential(
+            nn.Linear(vision_out_dim + text_out_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(hidden_dim, 128),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(128, num_classes)
+        )
+    
+    def forward(self, images, texts):
+        vision_features = self.vision_model(images)
+        tokens = self.tokenizer(
+            texts, padding=True, truncation=True, max_length=512, return_tensors='pt'
+        ).to(self.device)
+        text_outputs = self.text_model(**tokens)
+        text_features = text_outputs.last_hidden_state[:, 0, :]
+        
+        combined = torch.cat([vision_features, text_features], dim=1)
+        logits = self.fusion(combined)
+        return logits
+    
+    def count_parameters(self):
+        return sum(p.numel() for p in self.parameters() if p.requires_grad)
+
+
+if __name__ == '__main__':
+    print("Testowanie modelu...")
+    
+    device = torch.device('cpu')
+    model = AuctionAuthenticityModel(device=device).to(device)
+    
+    print(f"✓ Model stworzony")
+    print(f"  - Parametrów: {model.count_parameters():,}")
+    
+    # Dummy test
+    dummy_img = torch.randn(2, 3, 224, 224).to(device)
+    dummy_texts = ["Silver spoon antique", "Polish silverware 19th century"]
+    
+    with torch.no_grad():
+        output = model(dummy_img, dummy_texts)
+    
+    print(f"✓ Forward pass: {output.shape}")
+    print(f"  - Output: {output}")
+    
+    # Estimate model size
+    print(f"\n📊 Rozmiar modelu:")
+    torch.save(model.state_dict(), 'temp_model.pt')
+    import os
+    size_mb = os.path.getsize('temp_model.pt') / (1024*1024)
+    print(f"  - {size_mb:.1f} MB")
+    os.remove('temp_model.pt')

code/parse_auction_data.py

@@ -0,0 +1,131 @@
+import os
+import json
+from pathlib import Path
+from typing import Dict, List
+
+def parse_info_txt(info_path: str) -> Dict:
+    """
+    Parsuje info.txt z aukcji
+    """
+    with open(info_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    metadata = {}
+    
+    # TITLE
+    if 'TITLE:' in content:
+        title_start = content.find('TITLE:') + len('TITLE:')
+        title_end = content.find('\n', title_start)
+        metadata['title'] = content[title_start:title_end].strip()
+    else:
+        metadata['title'] = 'Unknown'
+    
+    # LINK
+    if 'LINK:' in content:
+        link_start = content.find('LINK:') + len('LINK:')
+        link_end = content.find('\n', link_start)
+        metadata['link'] = content[link_start:link_end].strip()
+    else:
+        metadata['link'] = ''
+    
+    # PARAMETERS
+    metadata['parameters'] = {}
+    if 'PARAMETERS:' in content:
+        params_start = content.find('PARAMETERS:') + len('PARAMETERS:')
+        params_end = content.find('----', params_start)
+        if params_end == -1:
+            params_end = content.find('DESCRIPTION:', params_start)
+        
+        params_text = content[params_start:params_end]
+        
+        for line in params_text.split('\n'):
+            if line.strip().startswith('*'):
+                line_clean = line.strip()[2:]
+                if ':' in line_clean:
+                    key, value = line_clean.split(':', 1)
+                    metadata['parameters'][key.strip()] = value.strip()
+    
+    # DESCRIPTION
+    if 'DESCRIPTION:' in content:
+        desc_start = content.find('DESCRIPTION:') + len('DESCRIPTION:')
+        metadata['description'] = content[desc_start:].strip()
+    else:
+        metadata['description'] = ''
+    
+    return metadata
+
+def organize_dataset(root_dir: str, output_json: str = 'dataset/dataset.json'):
+    """
+    Skanuje strukturę i tworzy dataset.json
+    """
+    root = Path(root_dir)
+    dataset = []
+    
+    for platform_dir in sorted(root.iterdir()):
+        if not platform_dir.is_dir():
+            continue
+        
+        platform_name = platform_dir.name
+        print(f"\n📁 Platform: {platform_name}")
+        
+        for auction_dir in sorted(platform_dir.iterdir()):
+            if not auction_dir.is_dir():
+                continue
+            
+            auction_id = auction_dir.name
+            info_txt = auction_dir / 'info.txt'
+            
+            if not info_txt.exists():
+                print(f"  ⚠️  {auction_id} - brak info.txt")
+                continue
+            
+            try:
+                metadata = parse_info_txt(str(info_txt))
+            except Exception as e:
+                print(f"  ❌ {auction_id} - błąd: {e}")
+                continue
+            
+            # Zbierz zdjęcia
+            images = sorted([
+                img.name for img in auction_dir.glob('*.jpg')
+            ])
+            images += sorted([
+                img.name for img in auction_dir.glob('*.png')
+            ])
+            
+            if not images:
+                print(f"  ⚠️  {auction_id} - brak zdjęć")
+                continue
+            
+            entry = {
+                'id': f"{platform_name}_{auction_id}",
+                'platform': platform_name,
+                'folder_path': str(auction_dir.relative_to(root)),
+                'image_count': len(images),
+                'images': images,
+                'label': 0,  # Default: authentic
+                'label_confidence': 0.0,  # Do ręcznego wypełnienia
+                **metadata
+            }
+            
+            dataset.append(entry)
+            print(f"  ✓ {auction_id} ({len(images)} zdjęć)")
+    
+    # Zapis
+    os.makedirs(os.path.dirname(output_json), exist_ok=True)
+    with open(output_json, 'w', encoding='utf-8') as f:
+        json.dump(dataset, f, ensure_ascii=False, indent=2)
+    
+    print(f"\n✅ Dataset wczytany: {len(dataset)} aukcji")
+    print(f"💾 Zapisano: {output_json}")
+    
+    return dataset
+
+if __name__ == '__main__':
+    dataset = organize_dataset('dataset/raw_data')
+    
+    if dataset:
+        print("\n" + "="*60)
+        print("PRZYKŁAD PIERWSZEJ AUKCJI:")
+        print("="*60)
+        print(json.dumps(dataset[0], indent=2, ensure_ascii=False)[:800])

code/train.py

@@ -0,0 +1,156 @@
+import torch
+import torch.nn.functional as F
+from torch.optim import AdamW
+from torch.utils.data import DataLoader, random_split
+from tqdm import tqdm
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+from model import AuctionAuthenticityModel
+from dataset_loader import AuctionDatasetFromJSON, get_transforms
+import json
+
+def train_epoch(model, loader, optimizer, device, epoch):
+    model.train()
+    total_loss = 0
+    progress_bar = tqdm(loader, desc=f"Epoch {epoch} [TRAIN]")
+    
+    for batch in progress_bar:
+        images = batch['image'].to(device)
+        texts = batch['text']
+        labels = batch['label'].to(device)
+        
+        optimizer.zero_grad()
+        
+        logits = model(images, texts)
+        loss = F.cross_entropy(logits, labels)
+        
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+        optimizer.step()
+        
+        total_loss += loss.item()
+        progress_bar.set_postfix(loss=f'{loss.item():.4f}')
+    
+    return total_loss / len(loader)
+
+def validate(model, loader, device, epoch):
+    model.eval()
+    all_preds = []
+    all_labels = []
+    total_loss = 0
+    
+    with torch.no_grad():
+        progress_bar = tqdm(loader, desc=f"Epoch {epoch} [VAL]")
+        for batch in progress_bar:
+            images = batch['image'].to(device)
+            texts = batch['text']
+            labels = batch['label'].to(device)
+            
+            logits = model(images, texts)
+            loss = F.cross_entropy(logits, labels)
+            total_loss += loss.item()
+            
+            preds = torch.argmax(logits, dim=1).cpu().numpy()
+            
+            all_preds.extend(preds)
+            all_labels.extend(labels.cpu().numpy())
+    
+    acc = accuracy_score(all_labels, all_preds)
+    prec = precision_score(all_labels, all_preds, zero_division=0)
+    rec = recall_score(all_labels, all_preds, zero_division=0)
+    f1 = f1_score(all_labels, all_preds, zero_division=0)
+    
+    return {
+        'loss': total_loss / len(loader),
+        'accuracy': acc,
+        'precision': prec,
+        'recall': rec,
+        'f1': f1
+    }
+
+def main():
+    # Konfiguracja
+    BATCH_SIZE = 4
+    EPOCHS = 5
+    LEARNING_RATE = 2e-5
+    DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    
+    print(f"🖥️  Device: {DEVICE}")
+    print(f"📦 Batch size: {BATCH_SIZE}")
+    print(f"📚 Epochs: {EPOCHS}")
+    
+    # Załaduj dataset
+    print("\n📥 Ładowanie datasetu...")
+    dataset = AuctionDatasetFromJSON(
+        json_path='../dataset/dataset.json',
+        root_dir='../dataset/raw_data',
+        transform=get_transforms()
+    )
+    
+    print(f"✓ {len(dataset)} aukcji załadowanych")
+    
+    # Split: 80% train, 20% val
+    train_size = int(0.8 * len(dataset))
+    val_size = len(dataset) - train_size
+    train_dataset, val_dataset = random_split(dataset, [train_size, val_size])
+    
+    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=0)
+    val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=0)
+    
+    print(f"  - Train: {len(train_dataset)}")
+    print(f"  - Val: {len(val_dataset)}")
+    
+    # Model
+    print("\n🧠 Inicjalizacja modelu...")
+    model = AuctionAuthenticityModel(device=DEVICE).to(DEVICE)
+    print(f"✓ Model gotowy ({model.count_parameters():,} parametrów)")
+    
+    # Optimizer
+    optimizer = AdamW(model.parameters(), lr=LEARNING_RATE)
+    
+    # Training loop
+    print("\n🚀 Rozpoczynam trening...\n")
+    
+    history = {
+        'train_loss': [],
+        'val_loss': [],
+        'val_accuracy': [],
+        'val_f1': []
+    }
+    
+    for epoch in range(EPOCHS):
+        # Train
+        train_loss = train_epoch(model, train_loader, optimizer, DEVICE, epoch+1)
+        
+        # Validate
+        val_metrics = validate(model, val_loader, DEVICE, epoch+1)
+        
+        # Log
+        history['train_loss'].append(train_loss)
+        history['val_loss'].append(val_metrics['loss'])
+        history['val_accuracy'].append(val_metrics['accuracy'])
+        history['val_f1'].append(val_metrics['f1'])
+        
+        print(f"\n{'='*60}")
+        print(f"Epoch {epoch+1}/{EPOCHS}")
+        print(f"  Train Loss: {train_loss:.4f}")
+        print(f"  Val Loss:   {val_metrics['loss']:.4f}")
+        print(f"  Val Acc:    {val_metrics['accuracy']:.4f}")
+        print(f"  Val Prec:   {val_metrics['precision']:.4f}")
+        print(f"  Val Rec:    {val_metrics['recall']:.4f}")
+        print(f"  Val F1:     {val_metrics['f1']:.4f}")
+        print(f"{'='*60}\n")
+    
+    # Zapis modelu
+    print("\n💾 Zapis modelu...")
+    torch.save(model.state_dict(), '../weights/auction_model.pt')
+    print("✓ Zapisano: weights/auction_model.pt")
+    
+    # Zapis historii
+    with open('../weights/training_history.json', 'w') as f:
+        json.dump(history, f, indent=2)
+    print("✓ Zapisano: weights/training_history.json")
+    
+    print("\n✅ Trening ukończony!")
+
+if __name__ == '__main__':
+    main()

code/web_scraper_allegro.py

@@ -0,0 +1,95 @@
+# scrape_allegro_offer.py
+import undetected_chromedriver as uc
+from selenium.webdriver.common.by import By
+import time
+import requests
+
+def sanitize_folder_name(text):  # helper function
+    polish_chars = {
+        "ą": "a", "ć": "c", "ę": "e", "ł": "l", "ń": "n",
+        "ó": "o", "ś": "s", "ź": "z", "ż": "z"
+    }
+    text = text.lower()
+    result = ""
+    for char in text:
+        if char in polish_chars:
+            result += polish_chars[char]
+        elif char.isalnum():
+            result += char
+        else:
+            result += "_"
+    while "__" in result:
+        result = result.replace("__", "_")
+    return result.strip("_")
+
+def scrape_allegro_offer(url: str):
+    """Zwraca dane aukcji bez zapisywania na dysk"""
+    options = uc.ChromeOptions()
+    options.add_argument("--window-position=-3000,0")
+    driver = uc.Chrome(use_subprocess=True, options=options)
+    
+    try:
+        print(f"🔍 Allegro: {url}")
+        driver.get(url)
+        time.sleep(10)
+        
+        # TITLE
+        try:
+            title_element = driver.find_element(By.TAG_NAME, "h1")
+            title_str = title_element.text.strip()
+        except:
+            title_str = "untitled"
+        
+        # PARAMETERS
+        parameter_list = []
+        try:
+            rows = driver.find_elements(By.CSS_SELECTOR, "tr")
+            for row in rows:
+                cells = row.find_elements(By.TAG_NAME, "td")
+                if len(cells) == 2:
+                    name = cells[0].text.strip()
+                    value = cells[1].text.strip()
+                    if name and value:
+                        parameter_list.append(f"{name}: {value}")
+        except:
+            pass
+        
+        # DESCRIPTION
+        try:
+            description_element = driver.find_element(By.CSS_SELECTOR, "div._0d3bd_am0a-")
+            description_content = description_element.text
+        except:
+            description_content = "No description"
+        
+        # IMAGES
+        unique_links = set()
+        try:
+            images = driver.find_elements(By.CSS_SELECTOR, ".msub_80.m9tr_5r._07951_IOf8s")
+            allowed_sizes = ["/s128/", "/s360/", "/s512/", "/s720/", "/s1024/", "/s1440/", "/original/"]
+            for img in images:
+                src = img.get_attribute("src")
+                if src and "allegroimg.com" in src:
+                    if not any(size in src for size in allowed_sizes):
+                        continue
+                    for size in allowed_sizes:
+                        src = src.replace(size, "/original/")
+                    unique_links.add(src)
+        except Exception as e:
+            print(f"Image error: {e}")
+        
+        return {
+            "platform": "allegro",
+            "url": url,
+            "title": title_str,
+            "description": description_content,
+            "parameters": parameter_list,
+            "image_urls": list(unique_links)
+        }
+    
+    finally:
+        driver.quit()
+
+if __name__ == "__main__":
+    url = input("Allegro URL: ")
+    result = scrape_allegro_offer(url)
+    print(result)

code/web_scraper_ebay.py

@@ -0,0 +1,78 @@
+# scrape_ebay_offer.py
+import undetected_chromedriver as uc
+from selenium.webdriver.common.by import By
+import time
+import requests
+
+def scrape_ebay_offer(url: str):
+    """Zwraca dane aukcji bez zapisywania na dysk"""
+    print(f"🔍 eBay: {url}")
+    options = uc.ChromeOptions()
+    options.add_argument("--window-position=-3000,0")
+    driver = uc.Chrome(use_subprocess=True, options=options)
+    
+    try:
+        driver.get(url)
+        time.sleep(4)
+        
+        # TITLE
+        try:
+            title_element = driver.find_element(By.CSS_SELECTOR, "h1.x-item-title__mainTitle")
+            title_str = title_element.text.strip()
+        except:
+            title_str = "untitled_ebay"
+        
+        # PARAMETERS
+        parameter_list = []
+        try:
+            rows = driver.find_elements(By.CSS_SELECTOR, ".ux-labels-values")
+            for row in rows:
+                try:
+                    label = row.find_element(By.CSS_SELECTOR, ".ux-labels-values__labels").text.strip()
+                    value = row.find_element(By.CSS_SELECTOR, ".ux-labels-values__values").text.strip()
+                    if label and value:
+                        parameter_list.append(f"{label}: {value}")
+                except:
+                    continue
+        except:
+            pass
+        
+        # DESCRIPTION
+        description_content = "No description"
+        try:
+            frame = driver.find_element(By.ID, "desc_ifr")
+            driver.switch_to.frame(frame)
+            description_content = driver.find_element(By.TAG_NAME, "body").text.strip()
+            driver.switch_to.default_content()
+        except:
+            pass
+        
+        # IMAGES
+        unique_links = set()
+        try:
+            thumbnails = driver.find_elements(By.CSS_SELECTOR, ".ux-image-grid-item img")
+            for img in thumbnails:
+                src = img.get_attribute("src") or img.get_attribute("data-src")
+                if src and "ebayimg.com" in src:
+                    # Zamień na HD
+                    hd_link = src.replace("/s-l64/", "/s-l1600").replace("/s-l140/", "/s-l1600")
+                    unique_links.add(hd_link)
+        except:
+            pass
+        
+        return {
+            "platform": "ebay",
+            "url": url,
+            "title": title_str,
+            "description": description_content,
+            "parameters": parameter_list,
+            "image_urls": list(unique_links)
+        }
+    
+    finally:
+        driver.quit()
+
+if __name__ == "__main__":
+    url = input("eBay URL: ")
+    result = scrape_ebay_offer(url)
+    print(result)

code/web_scraper_olx.py

@@ -0,0 +1,55 @@
+# scrape_olx_offer.py
+import requests
+from bs4 import BeautifulSoup
+
+def scrape_olx_offer(url: str):
+    """Zwraca dane aukcji bez zapisywania na dysk"""
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36"
+    }
+    
+    print(f"🔍 OLX: {url}")
+    response = requests.get(url, headers=headers)
+    
+    if response.status_code != 200:
+        raise ValueError(f"OLX error: {response.status_code}")
+    
+    soup = BeautifulSoup(response.content, "html.parser")
+    
+    # TITLE
+    title_element = soup.find("h4", class_="css-1au435n")
+    title = title_element.get_text().strip() if title_element else "untitled"
+    
+    # DESCRIPTION
+    description_element = soup.find("div", class_="css-19duwlz")
+    description = description_element.get_text(separator="\n").strip() if description_element else "No description"
+    
+    # PARAMETERS
+    parameter_list = []
+    parameters_container = soup.find("div", attrs={"data-testid": "ad-parameters-container"})
+    if parameters_container:
+        params = parameters_container.find_all("p", class_="css-13x8d99")
+        for p in params:
+            parameter_list.append(p.get_text().strip())
+    
+    # IMAGES
+    images = soup.select('img[data-testid^="swiper-image"]')
+    unique_links = set()
+    for img in images:
+        link = img.get("src")
+        if link:
+            unique_links.add(link)
+    
+    return {
+        "platform": "olx",
+        "url": url,
+        "title": title,
+        "description": description,
+        "parameters": parameter_list,
+        "image_urls": list(unique_links)
+    }
+
+if __name__ == "__main__":
+    url = input("OLX URL: ")
+    result = scrape_olx_offer(url)
+    print(result)

requirements.txt

@@ -0,0 +1,14 @@
+torch
+torchvision
+transformers
+pillow
+numpy
+scikit-learn
+tqdm
+fastapi
+uvicorn
+python-multipart
+undetected_chromedriver
+bs4
+requests
+flask

weights/auction_model.pt

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

weights/training_history.json

@@ -0,0 +1,30 @@
+{
+  "train_loss": [
+    0.8840779519081116,
+    0.4452889025211334,
+    0.24018713772296907,
+    0.12335345685482026,
+    0.05679535768926144
+  ],
+  "val_loss": [
+    0.6094270433698382,
+    0.30430711592946735,
+    0.15748658563409532,
+    0.07173337734171323,
+    0.03333232658249991
+  ],
+  "val_accuracy": [
+    1.0,
+    1.0,
+    1.0,
+    1.0,
+    1.0
+  ],
+  "val_f1": [
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0
+  ]
+}