Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,269 @@
+import gradio as st
+import torch
+import json
+import requests
+from transformers import (
+    AutoTokenizer, 
+    AutoModelForSequenceClassification,
+    TrainingArguments, 
+    Trainer,
+    DataCollatorWithPadding
+)
+from datasets import Dataset, DatasetDict
+import numpy as np
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+import os
+
+# Sayfa ayarları
+st.set_page_config(page_title="Code Security Trainer", page_icon="🎓", layout="wide")
+
+st.title("🎓 Code Security Model Trainer")
+st.markdown("Interaktif model eğitim arayüzü - Kontrol sende!")
+
+# Session state
+if 'model' not in st.session_state:
+    st.session_state.model = None
+if 'tokenizer' not in st.session_state:
+    st.session_state.tokenizer = None
+if 'dataset' not in st.session_state:
+    st.session_state.dataset = None
+if 'training_logs' not in st.session_state:
+    st.session_state.training_logs = []
+
+# Sidebar kontroller
+with st.sidebar:
+    st.header("⚙️ Eğitim Ayarları")
+    
+    epochs = st.slider("Epoch sayısı", 5, 50, 20)
+    learning_rate = st.select_slider("Learning rate", options=[1e-5, 2e-5, 5e-5, 1e-4], value=2e-5)
+    batch_size = st.selectbox("Batch size", [2, 4, 8], index=1)
+    
+    st.markdown("---")
+    st.header("📊 Durum")
+    if st.session_state.model:
+        st.success("Model yüklendi")
+    else:
+        st.info("Model yüklenmedi")
+
+# Ana bölüm
+tab1, tab2, tab3, tab4 = st.tabs(["📥 Veri Seti", "🏋️ Eğitim", "🧪 Test", "💾 Kaydet"])
+
+# Tab 1: Veri Seti
+with tab1:
+    st.header("Veri Seti Yükle")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("HF'den İndir")
+        if st.button("📥 HF Veri Setini İndir"):
+            with st.spinner("İndiriliyor..."):
+                try:
+                    url = "https://huggingface.co/datasets/omernet/code-security-dataset/resolve/main/python_sql_20.jsonl"
+                    response = requests.get(url)
+                    
+                    data = []
+                    for line in response.text.strip().split('\n'):
+                        if line.strip():
+                            data.append(json.loads(line))
+                    
+                    st.session_state.raw_data = data
+                    
+                    # Göster
+                    st.success(f"{len(data)} örnek yüklendi!")
+                    st.write(f"- Zafiyetli: {sum(1 for d in data if d['label'] == 1)}")
+                    st.write(f"- Güvenli: {sum(1 for d in data if d['label'] == 0)}")
+                    
+                    # Veri setini hazırla
+                    train_data = data[:14]
+                    val_data = data[14:17]
+                    test_data = data[17:]
+                    
+                    def create_dataset(examples):
+                        return Dataset.from_dict({
+                            'code': [e['code'] for e in examples],
+                            'label': [e['label'] for e in examples]
+                        })
+                    
+                    st.session_state.dataset = DatasetDict({
+                        'train': create_dataset(train_data),
+                        'validation': create_dataset(val_data),
+                        'test': create_dataset(test_data)
+                    })
+                    
+                    st.success("Veri seti hazır!")
+                    
+                except Exception as e:
+                    st.error(f"Hata: {e}")
+    
+    with col2:
+        st.subheader("Örnekleri Gör")
+        if st.session_state.get('raw_data'):
+            sample_type = st.radio("Tür", ["Zafiyetli", "Güvenli"])
+            label = 1 if sample_type == "Zafiyetli" else 0
+            samples = [d for d in st.session_state.raw_data if d['label'] == label]
+            
+            if samples:
+                selected = st.selectbox("Örnek seç", range(len(samples)), format_func=lambda i: f"Örnek {i+1}")
+                st.code(samples[selected]['code'], language='python')
+
+# Tab 2: Eğitim
+with tab2:
+    st.header("Model Eğitimi")
+    
+    col1, col2 = st.columns([1, 2])
+    
+    with col1:
+        st.subheader("Başlat")
+        
+        if st.button("🚀 Eğitimi Başlat", type="primary"):
+            if not st.session_state.get('dataset'):
+                st.error("Önce veri setini indir!")
+            else:
+                with st.spinner("Model yükleniyor..."):
+                    # Model yükle
+                    MODEL_NAME = "microsoft/codebert-base"
+                    st.session_state.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+                    st.session_state.model = AutoModelForSequenceClassification.from_pretrained(
+                        MODEL_NAME, num_labels=2
+                    )
+                    
+                    # Tokenize
+                    def tokenize_function(examples):
+                        return st.session_state.tokenizer(
+                            examples['code'],
+                            padding='max_length',
+                            truncation=True,
+                            max_length=512
+                        )
+                    
+                    tokenized = st.session_state.dataset.map(tokenize_function, batched=True)
+                    tokenized = tokenized.remove_columns(['code'])
+                    tokenized = tokenized.rename_column('label', 'labels')
+                    tokenized.set_format('torch')
+                    
+                    st.session_state.tokenized_dataset = tokenized
+                
+                # Eğitim
+                with st.spinner(f"Eğitim başlıyor ({epochs} epoch)..."):
+                    def compute_metrics(eval_pred):
+                        logits, labels = eval_pred
+                        predictions = np.argmax(logits, axis=-1)
+                        precision, recall, f1, _ = precision_recall_fscore_support(
+                            labels, predictions, average='binary'
+                        )
+                        acc = accuracy_score(labels, predictions)
+                        return {'accuracy': acc, 'f1': f1, 'precision': precision, 'recall': recall}
+                    
+                    training_args = TrainingArguments(
+                        output_dir="./results",
+                        learning_rate=learning_rate,
+                        per_device_train_batch_size=batch_size,
+                        per_device_eval_batch_size=batch_size,
+                        num_train_epochs=epochs,
+                        weight_decay=0.01,
+                        evaluation_strategy="epoch",
+                        save_strategy="epoch",
+                        load_best_model_at_end=True,
+                        metric_for_best_model="f1",
+                        logging_dir='./logs',
+                        logging_steps=1,
+                        report_to="none"
+                    )
+                    
+                    trainer = Trainer(
+                        model=st.session_state.model,
+                        args=training_args,
+                        train_dataset=tokenized['train'],
+                        eval_dataset=tokenized['validation'],
+                        tokenizer=st.session_state.tokenizer,
+                        data_collator=DataCollatorWithPadding(st.session_state.tokenizer),
+                        compute_metrics=compute_metrics,
+                    )
+                    
+                    # Eğit
+                    trainer.train()
+                    
+                    # Test
+                    results = trainer.evaluate(tokenized['test'])
+                    st.session_state.test_results = results
+                    
+                    st.success("Eğitim tamamlandı!")
+    
+    with col2:
+        st.subheader("Sonuçlar")
+        if st.session_state.get('test_results'):
+            results = st.session_state.test_results
+            
+            col_m1, col_m2, col_m3, col_m4 = st.columns(4)
+            with col_m1:
+                st.metric("Accuracy", f"{results['eval_accuracy']:.2%}")
+            with col_m2:
+                st.metric("F1 Score", f"{results['eval_f1']:.2%}")
+            with col_m3:
+                st.metric("Precision", f"{results['eval_precision']:.2%}")
+            with col_m4:
+                st.metric("Recall", f"{results['eval_recall']:.2%}")
+        else:
+            st.info("Eğitim sonrası sonuçlar burada görünecek")
+
+# Tab 3: Test
+with tab3:
+    st.header("Model Testi")
+    
+    if not st.session_state.get('model'):
+        st.warning("Önce modeli eğit!")
+    else:
+        test_code = st.text_area("Test kodu", height=150, value="def login(u, p):\n    query = f\"SELECT * FROM users WHERE name='{u}'\"\n    return db.execute(query)")
+        
+        if st.button("🔍 Tahmin Et"):
+            with st.spinner("Tahmin yapılıyor..."):
+                inputs = st.session_state.tokenizer(
+                    test_code,
+                    return_tensors="pt",
+                    truncation=True,
+                    max_length=512
+                )
+                
+                with torch.no_grad():
+                    outputs = st.session_state.model(**inputs)
+                    probabilities = torch.softmax(outputs.logits, dim=-1)
+                    prediction = torch.argmax(probabilities, dim=-1).item()
+                    confidence = probabilities[0][prediction].item()
+                
+                if prediction == 1:
+                    st.error(f"🔴 ZAFİYET TESPİT EDİLDİ (Güven: {confidence:.2%})")
+                else:
+                    st.success(f"🟢 GÜVENLİ (Güven: {confidence:.2%})")
+
+# Tab 4: Kaydet
+with tab4:
+    st.header("Modeli Kaydet")
+    
+    if not st.session_state.get('model'):
+        st.warning("Önce modeli eğit!")
+    else:
+        if st.button("💾 Local Kaydet"):
+            with st.spinner("Kaydediliyor..."):
+                st.session_state.model.save_pretrained("./code-security-model")
+                st.session_state.tokenizer.save_pretrained("./code-security-model")
+                st.success("Model kaydedildi!")
+        
+        st.markdown("---")
+        
+        hf_token = st.text_input("HF Token (opsiyonel)", type="password")
+        if st.button("☁️ Hugging Face'e Yükle"):
+            if hf_token:
+                with st.spinner("Yükleniyor..."):
+                    from huggingface_hub import login, HfApi
+                    login(token=hf_token)
+                    api = HfApi()
+                    
+                    api.create_repo(repo_id="omernet/code-security-trained", exist_ok=True)
+                    api.upload_folder(
+                        folder_path="./code-security-model",
+                        repo_id="omernet/code-security-trained"
+                    )
+                    st.success("HF'e yüklendi!")
+            else:
+                st.error("HF token gerekli!")