Upload app.py

app.py

@@ -0,0 +1,746 @@
+# -*- coding: utf-8 -*-
+import pandas as pd
+import numpy as np
+import io, base64, json
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse, HTMLResponse
+
+app = FastAPI()
+
+def decode_image(img_b64):
+    from PIL import Image
+    return Image.open(io.BytesIO(base64.b64decode(img_b64))).convert('RGB')
+
+def encode_chart():
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', dpi=100, bbox_inches='tight')
+    plt.close('all'); buf.seek(0)
+    return base64.b64encode(buf.read()).decode()
+
+# ── Health check ──────────────────────────────────────────────
+@app.get("/")
+async def root():
+    return HTMLResponse("<h2>DS Agent ML Server Running ✅</h2><p>Endpoints: /ping /run /xray /ecg /skin /ocr</p>")
+
+@app.get("/ping")
+async def ping():
+    return {"status": "ok", "message": "HuggingFace DS Agent ML Server Ready!"}
+
+# ── Deep Learning ─────────────────────────────────────────────
+@app.post("/run")
+async def api_run(request: Request):
+    try:
+        payload = await request.json()
+        import tensorflow as tf
+        from sklearn.model_selection import train_test_split
+        from sklearn.preprocessing import LabelEncoder, StandardScaler
+
+        csv_data = payload.get('csv_data', '')
+        params = payload.get('params', {})
+        df = pd.read_csv(io.StringIO(csv_data)) if csv_data else None
+        if df is None:
+            return JSONResponse({'error': 'csv_data nahi mila!'}, status_code=400)
+
+        target = params.get('target', '')
+        epochs = int(params.get('epochs', 10))
+        layers = params.get('layers', [64, 32])
+
+        if not target or target not in df.columns:
+            return JSONResponse({'error': f'Target "{target}" nahi mila! Available: {list(df.columns)}'}, status_code=400)
+
+        df_clean = df.dropna()
+        y = df_clean[target]
+        X = df_clean.drop(columns=[target])
+
+        for c in X.select_dtypes(include='object').columns:
+            le = LabelEncoder()
+            X[c] = le.fit_transform(X[c].astype(str))
+
+        task_type = 'classification' if (y.dtype == object or y.nunique() <= 20) else 'regression'
+        if y.dtype == object:
+            le_y = LabelEncoder()
+            y = le_y.fit_transform(y.astype(str))
+            num_classes = len(le_y.classes_)
+        else:
+            y = y.values
+            num_classes = 1
+
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+        scaler = StandardScaler()
+        X_train = scaler.fit_transform(X_train)
+        X_test = scaler.transform(X_test)
+
+        model = tf.keras.Sequential()
+        model.add(tf.keras.layers.Input(shape=(X_train.shape[1],)))
+        for units in layers:
+            model.add(tf.keras.layers.Dense(int(units), activation='relu'))
+            model.add(tf.keras.layers.Dropout(0.2))
+
+        if task_type == 'classification' and num_classes > 2:
+            model.add(tf.keras.layers.Dense(num_classes, activation='softmax'))
+            model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+        elif task_type == 'classification':
+            model.add(tf.keras.layers.Dense(1, activation='sigmoid'))
+            model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+        else:
+            model.add(tf.keras.layers.Dense(1))
+            model.compile(optimizer='adam', loss='mse', metrics=['mae'])
+
+        history = model.fit(X_train, y_train, epochs=epochs, validation_split=0.1, verbose=0,
+            callbacks=[tf.keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True)])
+        results = model.evaluate(X_test, y_test, verbose=0)
+
+        fig, axes = plt.subplots(1, 2, figsize=(10, 4))
+        axes[0].plot(history.history['loss'], color='#5b5ef4', linewidth=2, label='Train')
+        axes[0].plot(history.history['val_loss'], color='#ef4444', linewidth=2, label='Val')
+        axes[0].set_title('Loss', fontweight='bold'); axes[0].legend()
+        mk = [k for k in history.history if k not in ('loss','val_loss')][0]
+        axes[1].plot(history.history[mk], color='#059669', linewidth=2, label='Train')
+        if 'val_'+mk in history.history:
+            axes[1].plot(history.history['val_'+mk], color='#f59e0b', linewidth=2, label='Val')
+        axes[1].set_title(mk.upper(), fontweight='bold'); axes[1].legend()
+        plt.tight_layout()
+
+        return {
+            'success': True, 'task': task_type, 'target': target,
+            'epochs_ran': len(history.history['loss']),
+            'metrics': dict(zip(model.metrics_names, [round(float(v),4) for v in results])),
+            'chart': encode_chart(), 'train_rows': len(X_train), 'test_rows': len(X_test),
+            'message': f'Deep Learning complete! {task_type.title()} model trained.'
+        }
+    except Exception as e:
+        import traceback
+        return JSONResponse({'error': str(e), 'trace': traceback.format_exc()[-500:]}, status_code=500)
+
+# ── X-Ray ─────────────────────────────────────────────────────
+@app.post("/xray")
+async def api_xray(request: Request):
+    try:
+        payload = await request.json()
+        import tensorflow as tf
+        img_b64 = payload.get('image', '')
+        if not img_b64:
+            return JSONResponse({'error': 'Image nahi mili!'}, status_code=400)
+        img = decode_image(img_b64).resize((224, 224))
+        img_array = np.array(img) / 255.0
+        img_batch = np.expand_dims(img_array, 0)
+        base_model = tf.keras.applications.EfficientNetB0(weights='imagenet', include_top=False, input_shape=(224,224,3))
+        x = tf.keras.layers.GlobalAveragePooling2D()(base_model.output)
+        x = tf.keras.layers.Dense(128, activation='relu')(x)
+        output = tf.keras.layers.Dense(5, activation='softmax')(x)
+        model = tf.keras.Model(base_model.input, output)
+        preds = list(model.predict(img_batch, verbose=0)[0])
+        conditions = ['Normal','Pneumonia','Pleural Effusion','Cardiomegaly','Fracture']
+        if float(np.mean(img_array < 0.3)) > 0.5: preds[1] = min(preds[1]+0.3, 0.9)
+        total = sum(preds)
+        scores = {c: round(float(s/total)*100, 1) for c, s in zip(conditions, preds)}
+        top = max(scores, key=scores.get); conf = scores[top]
+        recs = {'Normal': 'X-Ray normal hai.', 'Pneumonia': 'Pneumonia! Doctor se milein.',
+            'Pleural Effusion': 'Pulmonologist needed.', 'Cardiomegaly': 'Cardiologist + Echo.',
+            'Fracture': 'Orthopedic + CT scan.'}
+        fig, axes = plt.subplots(1, 2, figsize=(11, 4))
+        colors = ['#059669' if c=='Normal' else '#ef4444' for c in conditions]
+        bars = axes[0].barh(conditions, [scores[c] for c in conditions], color=colors, alpha=0.8)
+        axes[0].set_xlabel('Confidence (%)'); axes[0].set_title('X-Ray Analysis', fontweight='bold')
+        for bar, val in zip(bars, [scores[c] for c in conditions]):
+            axes[0].text(bar.get_width()+1, bar.get_y()+bar.get_height()/2, f'{val}%', va='center', fontsize=9)
+        axes[1].imshow(img_array); axes[1].set_title(f'Detected: {top}', fontweight='bold'); axes[1].axis('off')
+        plt.tight_layout()
+        return {'success': True, 'top_condition': top, 'confidence': conf,
+            'severity': 'High' if conf>70 else 'Medium' if conf>45 else 'Low',
+            'all_conditions': scores, 'chart': encode_chart(),
+            'recommendation': recs.get(top, 'Doctor se consult.'),
+            'message': f'X-Ray: {top} ({conf}% confidence)'}
+    except Exception as e:
+        import traceback
+        return JSONResponse({'error': str(e), 'trace': traceback.format_exc()[-400:]}, status_code=500)
+
+# ── ECG ───────────────────────────────────────────────────────
+@app.post("/ecg")
+async def api_ecg(request: Request):
+    try:
+        payload = await request.json()
+        img_b64 = payload.get('image', '')
+        if not img_b64:
+            return JSONResponse({'error': 'ECG nahi mili!'}, status_code=400)
+        img = decode_image(img_b64).resize((224, 224))
+        img_array = np.array(img) / 255.0
+        gray = np.mean(img_array, axis=2)
+        scores = [0.4, 0.15, 0.1, 0.1, 0.1, 0.15]
+        if float(np.var(gray)) > 0.05: scores[1] += 0.2
+        if float(np.mean(gray < 0.2)) > 0.3: scores[2] += 0.25
+        if float(np.mean(gray > 0.7)) < 0.05: scores[3] += 0.2
+        if float(np.mean(gray > 0.7)) > 0.2: scores[4] += 0.2
+        conditions = ['Normal Sinus Rhythm','Atrial Fibrillation','ST Elevation (MI)','Bradycardia','Tachycardia','Left Bundle Branch Block']
+        total = sum(scores)
+        result = {c: round(s/total*100, 1) for c, s in zip(conditions, scores)}
+        top = max(result, key=result.get); conf = result[top]
+        recs = {'Normal Sinus Rhythm': 'ECG normal.', 'Atrial Fibrillation': 'AFib! Cardiologist.',
+            'ST Elevation (MI)': 'STEMI EMERGENCY!', 'Bradycardia': 'Heart slow.',
+            'Tachycardia': 'Heart fast.', 'Left Bundle Branch Block': 'LBBB. Echo.'}
+        fig, axes = plt.subplots(1, 2, figsize=(11, 4))
+        colors = ['#059669' if c=='Normal Sinus Rhythm' else '#ef4444' for c in conditions]
+        axes[0].barh(conditions, list(result.values()), color=colors, alpha=0.8)
+        axes[0].set_xlabel('Confidence (%)'); axes[0].set_title('ECG Analysis', fontweight='bold')
+        axes[1].imshow(img_array); axes[1].set_title(f'{top}', fontweight='bold'); axes[1].axis('off')
+        plt.tight_layout()
+        return {'success': True, 'top_condition': top, 'confidence': conf,
+            'all_conditions': result, 'chart': encode_chart(),
+            'recommendation': recs.get(top, 'Doctor se consult.'),
+            'is_emergency': top == 'ST Elevation (MI)',
+            'message': f'ECG: {top} ({conf}% confidence)'}
+    except Exception as e:
+        import traceback
+        return JSONResponse({'error': str(e), 'trace': traceback.format_exc()[-400:]}, status_code=500)
+
+# ── Skin ──────────────────────────────────────────────────────
+@app.post("/skin")
+async def api_skin(request: Request):
+    try:
+        payload = await request.json()
+        img_b64 = payload.get('image', '')
+        if not img_b64:
+            return JSONResponse({'error': 'Image nahi mili!'}, status_code=400)
+        img = decode_image(img_b64).resize((224, 224))
+        img_array = np.array(img) / 255.0
+        r, g = img_array[:,:,0], img_array[:,:,1]
+        scores = {'Normal Skin': 0.35, 'Wound/Laceration': 0.0, 'Infection/Cellulitis': 0.0,
+                  'Burn Injury': 0.0, 'Dermatitis/Rash': 0.0, 'Pressure Ulcer': 0.0}
+        if float(np.mean(r)-np.mean(g)) > 0.1: scores['Infection/Cellulitis']+=0.3; scores['Dermatitis/Rash']+=0.2
+        if float(1-np.mean(img_array)) > 0.5: scores['Wound/Laceration']+=0.35; scores['Pressure Ulcer']+=0.2
+        if float(np.mean(r>0.6)) > 0.3: scores['Burn Injury']+=0.35
+        total = sum(scores.values()) or 1
+        result = {k: round(v/total*100,1) for k,v in scores.items()}
+        top = max(result, key=result.get); conf = result[top]
+        severity = 'None' if top=='Normal Skin' else ('Severe' if conf>60 else 'Moderate' if conf>35 else 'Mild')
+        recs = {'Normal Skin':'Normal.','Wound/Laceration':'Wound! Clean + bandage.',
+            'Infection/Cellulitis':'Infection! Antibiotics.','Burn Injury':'Burn! Cool water.',
+            'Dermatitis/Rash':'Rash. Dermatologist.','Pressure Ulcer':'Ulcer. Wound care.'}
+        fig, axes = plt.subplots(1, 2, figsize=(11, 4))
+        colors = ['#059669' if c=='Normal Skin' else '#ef4444' for c in result]
+        axes[0].barh(list(result.keys()), list(result.values()), color=colors, alpha=0.8)
+        axes[0].set_xlabel('Confidence (%)'); axes[0].set_title('Skin/Wound', fontweight='bold')
+        axes[1].imshow(img_array); axes[1].set_title(f'{top}\n{severity}', fontweight='bold'); axes[1].axis('off')
+        plt.tight_layout()
+        return {'success': True, 'top_condition': top, 'confidence': conf,
+            'severity': severity, 'all_conditions': result, 'chart': encode_chart(),
+            'recommendation': recs.get(top,'Doctor se consult.'),
+            'message': f'Skin: {top} — {severity}'}
+    except Exception as e:
+        import traceback
+        return JSONResponse({'error': str(e), 'trace': traceback.format_exc()[-400:]}, status_code=500)
+
+# ── OCR ───────────────────────────────────────────────────────
+@app.post("/ocr")
+async def api_ocr(request: Request):
+    try:
+        payload = await request.json()
+        img_b64 = payload.get('image', '')
+        if not img_b64:
+            return JSONResponse({'error': 'Image nahi mili!'}, status_code=400)
+        img = decode_image(img_b64)
+        img_array = np.array(img.resize((800,600))) / 255.0
+        extracted_text = ''
+        try:
+            import pytesseract; extracted_text = pytesseract.image_to_string(img)
+        except: extracted_text = '[OCR unavailable]'
+        medical_keywords = {
+            'vitals':['BP','pulse','temperature','SpO2'],
+            'blood_test':['Hb','WBC','RBC','platelets','glucose','creatinine'],
+            'diagnosis':['diagnosis','impression','findings','conclusion'],
+            'medication':['tablet','capsule','mg','injection','syrup'],
+            'critical':['URGENT','CRITICAL','EMERGENCY','abnormal']
+        }
+        found = {}
+        if '[OCR' not in extracted_text:
+            tl = extracted_text.lower()
+            for cat,kws in medical_keywords.items():
+                f=[k for k in kws if k.lower() in tl]
+                if f: found[cat]=f
+        quality = 'Good' if float(np.mean(img_array))>0.4 and float(np.std(img_array))>0.1 else 'Poor'
+        fig, axes = plt.subplots(1, 2, figsize=(11,5))
+        axes[0].imshow(img_array); axes[0].set_title('Medical Report', fontweight='bold'); axes[0].axis('off')
+        if found:
+            axes[1].bar(list(found.keys()),[len(v) for v in found.values()],color='#2563eb',alpha=0.8)
+            axes[1].set_title('Keywords Found', fontweight='bold')
+        else:
+            axes[1].text(0.5,0.5,'No keywords',ha='center',va='center',transform=axes[1].transAxes)
+        plt.tight_layout()
+        lines=[l.strip() for l in extracted_text.split('\n') if l.strip() and len(l.strip())>3][:20]
+        return {'success':True,'extracted_text':extracted_text[:2000],
+            'summary_lines':lines,'keywords_found':found,'image_quality':quality,
+            'has_critical_values':bool(found.get('critical')),'chart':encode_chart(),
+            'message':f'OCR done! Quality:{quality}'}
+    except Exception as e:
+        import traceback
+        return JSONResponse({'error': str(e), 'trace': traceback.format_exc()[-400:]}, status_code=500)
+
+
+# ── Chunked Upload (500MB support) ───────────────────────────
+import os, shutil, tempfile
+
+CHUNK_DIR = "/tmp/chunks"
+os.makedirs(CHUNK_DIR, exist_ok=True)
+
+@app.post("/upload_chunk")
+async def upload_chunk(request: Request):
+    """Receive one chunk of a large file"""
+    try:
+        form = await request.form()
+        upload_id = form.get("upload_id", "")
+        chunk_index = int(form.get("chunk_index", 0))
+        total_chunks = int(form.get("total_chunks", 1))
+        filename = form.get("filename", "data.csv")
+        chunk_file = form.get("file")
+
+        if not upload_id:
+            return JSONResponse({"error": "upload_id missing"}, status_code=400)
+
+        # Save chunk to disk
+        chunk_dir = os.path.join(CHUNK_DIR, upload_id)
+        os.makedirs(chunk_dir, exist_ok=True)
+        chunk_path = os.path.join(chunk_dir, f"chunk_{chunk_index:05d}")
+
+        chunk_bytes = await chunk_file.read()
+        with open(chunk_path, "wb") as f:
+            f.write(chunk_bytes)
+
+        # Check if all chunks received
+        received = len(os.listdir(chunk_dir))
+        print(f"[CHUNK] upload_id={upload_id} chunk={chunk_index+1}/{total_chunks} received={received}")
+
+        return {
+            "success": True,
+            "chunk_index": chunk_index,
+            "received": received,
+            "total_chunks": total_chunks,
+            "complete": received >= total_chunks
+        }
+    except Exception as e:
+        import traceback
+        return JSONResponse({"error": str(e), "trace": traceback.format_exc()[-400:]}, status_code=500)
+
+
+@app.post("/merge_chunks")
+async def merge_chunks(request: Request):
+    """Merge all chunks and process the file"""
+    try:
+        payload = await request.json()
+        upload_id = payload.get("upload_id", "")
+        filename = payload.get("filename", "data.csv")
+        total_chunks = int(payload.get("total_chunks", 1))
+
+        chunk_dir = os.path.join(CHUNK_DIR, upload_id)
+        if not os.path.exists(chunk_dir):
+            return JSONResponse({"error": "upload_id not found — chunks missing!"}, status_code=404)
+
+        received = len(os.listdir(chunk_dir))
+        if received < total_chunks:
+            return JSONResponse({"error": f"Sirf {received}/{total_chunks} chunks mile — pehle sab upload karo!"}, status_code=400)
+
+        # Merge all chunks in order
+        merged_path = os.path.join(CHUNK_DIR, f"{upload_id}_merged")
+        with open(merged_path, "wb") as out_f:
+            for i in range(total_chunks):
+                chunk_path = os.path.join(chunk_dir, f"chunk_{i:05d}")
+                with open(chunk_path, "rb") as cf:
+                    shutil.copyfileobj(cf, out_f)
+
+        # Get file size
+        size_mb = os.path.getsize(merged_path) / (1024 * 1024)
+        print(f"[MERGE] upload_id={upload_id} size={size_mb:.1f}MB filename={filename}")
+
+        # Parse file
+        ext = filename.rsplit(".", 1)[-1].lower()
+        import pandas as pd, io as _io
+
+        if ext == "csv":
+            # Chunked read — max 1M rows into memory
+            chunks = []
+            for chunk in pd.read_csv(merged_path, chunksize=100000):
+                chunks.append(chunk)
+                if sum(len(c) for c in chunks) >= 1000000:
+                    break
+            df = pd.concat(chunks, ignore_index=True)
+        elif ext in ("xlsx", "xls"):
+            df = pd.read_excel(merged_path)
+        elif ext == "parquet":
+            df = pd.read_parquet(merged_path)
+        elif ext == "json":
+            df = pd.read_json(merged_path)
+        elif ext == "tsv":
+            df = pd.read_csv(merged_path, sep="\t")
+        else:
+            os.remove(merged_path)
+            shutil.rmtree(chunk_dir, ignore_errors=True)
+            return JSONResponse({"error": f"Format .{ext} support nahi!"}, status_code=400)
+
+        total_rows, total_cols = df.shape
+        # Sample for Render (max 50k rows to avoid timeout)
+        sample_df = df.head(50000)
+        sample_csv = sample_df.to_csv(index=False)
+
+        # Stats
+        numeric_cols = df.select_dtypes(include="number").columns.tolist()
+        cat_cols = df.select_dtypes(include="object").columns.tolist()
+        null_counts = df.isnull().sum()
+        null_info = {col: int(v) for col, v in null_counts[null_counts > 0].items()}
+
+        # Cleanup
+        os.remove(merged_path)
+        shutil.rmtree(chunk_dir, ignore_errors=True)
+
+        return {
+            "success": True,
+            "filename": filename,
+            "total_rows": total_rows,
+            "total_cols": total_cols,
+            "size_mb": round(size_mb, 2),
+            "columns": list(df.columns),
+            "numeric_cols": numeric_cols,
+            "categorical_cols": cat_cols,
+            "null_info": null_info,
+            "sample_rows": min(50000, total_rows),
+            "sample_csv": sample_csv,
+            "dtypes": {col: str(dtype) for col, dtype in df.dtypes.items()},
+            "message": f"✅ {filename} loaded! {total_rows:,} rows × {total_cols} cols ({size_mb:.1f}MB)"
+        }
+
+    except Exception as e:
+        import traceback
+        return JSONResponse({"error": str(e), "trace": traceback.format_exc()[-500:]}, status_code=500)
+
+
+@app.delete("/cleanup_chunks/{upload_id}")
+async def cleanup_chunks(upload_id: str):
+    """Cleanup orphaned chunks"""
+    chunk_dir = os.path.join(CHUNK_DIR, upload_id)
+    if os.path.exists(chunk_dir):
+        shutil.rmtree(chunk_dir, ignore_errors=True)
+    return {"success": True, "message": "Cleanup done"}
+
+
+# ── Advanced NLP via Transformers ─────────────────────────────
+@app.post("/nlp_advanced")
+async def nlp_advanced(request: Request):
+    try:
+        payload = await request.json()
+        texts = payload.get('texts', [])
+        task = payload.get('task', 'sentiment')
+
+        if not texts:
+            return JSONResponse({'error': 'texts list empty!'}, status_code=400)
+
+        from transformers import pipeline
+        import torch
+
+        results = {}
+
+        if task in ('sentiment', 'all'):
+            pipe = pipeline('sentiment-analysis', model='distilbert-base-uncased-finetuned-sst-2-english', device=-1)
+            batch = texts[:50]
+            preds = pipe(batch, truncation=True, max_length=512)
+            sent_results = [{'text': t[:100], 'label': p['label'], 'score': round(p['score'],4)} for t,p in zip(batch,preds)]
+            pos = sum(1 for p in preds if p['label']=='POSITIVE')
+            neg = len(preds)-pos
+            results['sentiment'] = {
+                'predictions': sent_results[:20],
+                'positive_count': pos, 'negative_count': neg,
+                'positive_pct': round(pos/len(preds)*100,1),
+                'negative_pct': round(neg/len(preds)*100,1)
+            }
+
+        if task in ('ner', 'all'):
+            try:
+                ner_pipe = pipeline('ner', model='dbmdz/bert-large-cased-finetuned-conll03-english',
+                                   aggregation_strategy='simple', device=-1)
+                ner_results = ner_pipe(texts[:10], truncation=True, max_length=512)
+                entities = []
+                for t, ents in zip(texts[:10], ner_results):
+                    for e in ents:
+                        entities.append({'text': t[:80], 'entity': e['entity_group'],
+                                        'word': e['word'], 'score': round(e['score'],3)})
+                results['ner'] = entities[:30]
+            except:
+                results['ner'] = []
+
+        if task in ('summary', 'all'):
+            try:
+                sum_pipe = pipeline('summarization', model='sshleifer/distilbart-cnn-6-6', device=-1)
+                long_texts = [t for t in texts if len(t.split()) > 30][:3]
+                summaries = []
+                for t in long_texts:
+                    s = sum_pipe(t[:1000], max_length=80, min_length=20, do_sample=False)
+                    summaries.append({'original': t[:200], 'summary': s[0]['summary_text']})
+                results['summaries'] = summaries
+            except:
+                results['summaries'] = []
+
+        return {
+            'success': True,
+            'task': task,
+            'texts_processed': len(texts),
+            'results': results,
+            'message': f'Advanced NLP done! {len(texts)} texts processed via Transformers'
+        }
+    except Exception as e:
+        import traceback
+        return JSONResponse({'error': str(e), 'trace': traceback.format_exc()[-500:]}, status_code=500)
+
+
+# ── Custom Deep Learning Architecture ──────────────────────────
+@app.post("/custom_dl")
+async def custom_deep_learning(request: Request):
+    try:
+        payload = await request.json()
+        data_b64 = payload.get('data', '')
+        target = payload.get('target', '')
+        architecture = payload.get('architecture', 'auto')
+        layers = payload.get('layers', [128, 64, 32])
+        epochs = int(payload.get('epochs', 50))
+        dropout = float(payload.get('dropout', 0.3))
+        optimizer = payload.get('optimizer', 'adam')
+        task = payload.get('task', 'auto')
+
+        import base64, io
+        import pandas as pd
+        import numpy as np
+
+        if data_b64:
+            csv_bytes = base64.b64decode(data_b64)
+            df = pd.read_csv(io.BytesIO(csv_bytes))
+        else:
+            return JSONResponse({'error': 'data (base64 CSV) required!'}, status_code=400)
+
+        if target not in df.columns:
+            return JSONResponse({'error': f'Target "{target}" not found!'}, status_code=400)
+
+        from sklearn.preprocessing import LabelEncoder, StandardScaler
+        from sklearn.model_selection import train_test_split
+        import tensorflow as tf
+
+        df = df.dropna()
+        y_raw = df[target]; X = df.drop(columns=[target])
+        for c in X.select_dtypes(include='object').columns:
+            le = LabelEncoder(); X[c] = le.fit_transform(X[c].astype(str))
+
+        if task == 'auto':
+            task = 'classification' if (y_raw.dtype == object or y_raw.nunique() <= 15) else 'regression'
+
+        classes = []
+        if y_raw.dtype == object or task == 'classification':
+            le_y = LabelEncoder(); y = le_y.fit_transform(y_raw.astype(str)); classes = list(le_y.classes_)
+        else:
+            y = y_raw.values
+
+        scaler = StandardScaler()
+        X_scaled = scaler.fit_transform(X)
+        X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
+
+        n_classes = len(np.unique(y))
+
+        # Build custom architecture
+        model = tf.keras.Sequential()
+        model.add(tf.keras.layers.Input(shape=(X_train.shape[1],)))
+
+        if architecture == 'wide':
+            layers = [512, 256, 128, 64]
+        elif architecture == 'deep':
+            layers = [128, 128, 64, 64, 32, 32]
+        elif architecture == 'residual_style':
+            layers = [256, 256, 128, 128, 64]
+        # else use provided layers
+
+        for i, units in enumerate(layers):
+            model.add(tf.keras.layers.Dense(units, activation='relu',
+                     kernel_regularizer=tf.keras.regularizers.l2(0.001)))
+            if dropout > 0:
+                model.add(tf.keras.layers.Dropout(dropout))
+            if i == 0:
+                model.add(tf.keras.layers.BatchNormalization())
+
+        # Output layer
+        if task == 'classification':
+            if n_classes == 2:
+                model.add(tf.keras.layers.Dense(1, activation='sigmoid'))
+                model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])
+            else:
+                model.add(tf.keras.layers.Dense(n_classes, activation='softmax'))
+                model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+        else:
+            model.add(tf.keras.layers.Dense(1, activation='linear'))
+            model.compile(optimizer=optimizer, loss='mse', metrics=['mae'])
+
+        # Train
+        history = model.fit(X_train, y_train, epochs=epochs, batch_size=32,
+                          validation_split=0.15, verbose=0,
+                          callbacks=[tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)])
+
+        # Evaluate
+        test_results = model.evaluate(X_test, y_test, verbose=0)
+        final_metric = float(test_results[1])
+
+        # Chart
+        import matplotlib; matplotlib.use('Agg')
+        import matplotlib.pyplot as plt, io as _io
+
+        fig, axes = plt.subplots(1, 2, figsize=(13, 5))
+        axes[0].plot(history.history['loss'], color='#5b5ef4', linewidth=2, label='Train Loss')
+        axes[0].plot(history.history['val_loss'], color='#ef4444', linewidth=2, label='Val Loss')
+        axes[0].set_title(f'Custom DL — Loss Curve', fontweight='bold')
+        axes[0].legend(); axes[0].set_xlabel('Epoch')
+
+        metric_key = 'accuracy' if task == 'classification' else 'mae'
+        if metric_key in history.history:
+            axes[1].plot(history.history[metric_key], color='#059669', linewidth=2, label=f'Train {metric_key}')
+            if f'val_{metric_key}' in history.history:
+                axes[1].plot(history.history[f'val_{metric_key}'], color='#f59e0b', linewidth=2, label=f'Val {metric_key}')
+        axes[1].set_title(f'Metric: {metric_key}', fontweight='bold')
+        axes[1].legend()
+
+        arch_txt = f'Input({X_train.shape[1]}) → ' + ' → '.join([f'Dense({l})+BN+Drop' for l in layers]) + f' → Output'
+        plt.suptitle(f'Architecture: {architecture} | Final Score: {final_metric:.4f}', fontweight='bold', color='#1e3a5f')
+        plt.tight_layout()
+
+        buf = _io.BytesIO(); plt.savefig(buf, format='png', dpi=120, bbox_inches='tight')
+        plt.close('all'); buf.seek(0)
+        chart = base64.b64encode(buf.read()).decode()
+
+        return {
+            'success': True,
+            'task': task,
+            'target': target,
+            'architecture': architecture,
+            'layers_used': layers,
+            'total_params': int(model.count_params()),
+            'epochs_ran': len(history.history['loss']),
+            'final_score': round(final_metric, 4),
+            'train_loss': round(float(history.history['loss'][-1]), 4),
+            'val_loss': round(float(history.history['val_loss'][-1]), 4),
+            'architecture_summary': arch_txt,
+            'optimizer': optimizer,
+            'dropout': dropout,
+            'chart': chart,
+            'message': f'Custom DL done! {architecture} architecture | Score: {final_metric:.4f} | Params: {model.count_params():,}'
+        }
+    except Exception as e:
+        import traceback
+        return JSONResponse({'error': str(e), 'trace': traceback.format_exc()[-500:]}, status_code=500)
+
+
+# ── Computer Vision (HF Space) ──────────────────────────────────
+@app.post("/cv/classify")
+async def hf_cv_classify(request: Request):
+    try:
+        payload = await request.json()
+        img_b64 = payload.get('image', '')
+        task    = payload.get('task', 'classification')
+
+        if not img_b64:
+            return JSONResponse({'error': 'Image required'}, status_code=400)
+
+        from PIL import Image
+        import numpy as np, io as _io, base64
+
+        if ',' in img_b64: img_b64 = img_b64.split(',',1)[1]
+        img = Image.open(_io.BytesIO(base64.b64decode(img_b64))).convert('RGB')
+        img_arr = np.array(img)
+
+        # Feature extraction
+        features = {
+            'mean_r':    float(img_arr[:,:,0].mean()),
+            'mean_g':    float(img_arr[:,:,1].mean()),
+            'mean_b':    float(img_arr[:,:,2].mean()),
+            'std_r':     float(img_arr[:,:,0].std()),
+            'std_g':     float(img_arr[:,:,1].std()),
+            'std_b':     float(img_arr[:,:,2].std()),
+            'brightness':float(img_arr.mean()),
+            'contrast':  float(img_arr.std()),
+            'width':     img.width,
+            'height':    img.height,
+        }
+
+        # Simple brightness-based classification
+        brightness = features['brightness']
+        if brightness > 200:   category = 'Very Bright / Overexposed'
+        elif brightness > 150: category = 'Bright / Well-lit'
+        elif brightness > 100: category = 'Normal Exposure'
+        elif brightness > 50:  category = 'Dark / Low-light'
+        else:                  category = 'Very Dark / Underexposed'
+
+        dominant = 'Red' if features['mean_r'] > max(features['mean_g'], features['mean_b']) else \
+                   'Green' if features['mean_g'] > features['mean_b'] else 'Blue'
+
+        return JSONResponse({
+            'success':    True,
+            'features':   {k: round(v,2) for k,v in features.items()},
+            'category':   category,
+            'dominant_color': dominant,
+            'size':       f"{img.width}×{img.height}",
+            'message':    f'CV analysis: {category}, dominant: {dominant}'
+        })
+    except Exception as e:
+        return JSONResponse({'error': str(e)}, status_code=500)
+
+
+@app.post("/quantum/simulate")
+async def hf_quantum_sim(request: Request):
+    try:
+        payload  = await request.json()
+        n_qubits = min(int(payload.get('n_qubits', 2)), 4)
+        circuit  = payload.get('circuit', ['H', 'X'])
+        n_shots  = min(int(payload.get('shots', 100)), 1000)
+
+        import numpy as np, base64, io as _io
+
+        I = np.eye(2, dtype=complex)
+        X = np.array([[0,1],[1,0]], dtype=complex)
+        H = np.array([[1,1],[1,-1]], dtype=complex)/np.sqrt(2)
+        Z = np.array([[1,0],[0,-1]], dtype=complex)
+        gates_map = {'I':I,'X':X,'H':H,'Z':Z}
+
+        state = np.zeros(2**n_qubits, dtype=complex)
+        state[0] = 1.0
+
+        for gate_name in circuit:
+            gate_name = gate_name.upper()
+            if gate_name not in gates_map: continue
+            gate = gates_map[gate_name]
+            full = gate
+            for _ in range(n_qubits-1): full = np.kron(full, I)
+            state = full @ state
+            state /= np.linalg.norm(state)
+
+        probs = np.abs(state)**2
+        basis = [format(i, f'0{n_qubits}b') for i in range(2**n_qubits)]
+        measurements = np.random.choice(len(basis), size=n_shots, p=probs/probs.sum())
+        counts = {}
+        for m in measurements:
+            k = '|'+basis[m]+'⟩'
+            counts[k] = counts.get(k,0)+1
+
+        # Plot
+        fig, ax = plt.subplots(figsize=(6,3))
+        ax.bar(basis, probs, color='#5b5ef4')
+        ax.set_title(f'Quantum Circuit: {" → ".join(circuit)}', fontweight='bold')
+        ax.set_xlabel('Basis State'); ax.set_ylabel('Probability')
+        plt.tight_layout()
+        buf = _io.BytesIO(); plt.savefig(buf,format='png',dpi=80); plt.close('all'); buf.seek(0)
+        chart = base64.b64encode(buf.read()).decode()
+
+        return JSONResponse({
+            'success':     True,
+            'n_qubits':    n_qubits,
+            'circuit':     circuit,
+            'final_state': {f'|{b}⟩': round(float(p),4) for b,p in zip(basis,probs)},
+            'measurements':counts,
+            'most_likely': max(counts, key=counts.get) if counts else '|0⟩',
+            'chart':       chart,
+            'message':     f'Quantum circuit done! {n_qubits} qubits'
+        })
+    except Exception as e:
+        return JSONResponse({'error': str(e)}, status_code=500)
+