seven

app.py

@@ -1,222 +1,266 @@
 import streamlit as st
-import pandas as pd
 import pickle
+import pandas as pd
 import numpy as np
-import os
-from datetime import datetime
+from sklearn.feature_extraction.text import TfidfVectorizer
+import warnings
+warnings.filterwarnings('ignore')
 
 # Konfigurasi halaman
 st.set_page_config(
-    page_title="Prediksi Alergen Makanan",
+    page_title="🍽️ Deteksi Alergen Makanan",
     page_icon="🍽️",
-    layout="wide"
+    layout="wide",
+    initial_sidebar_state="expanded"
 )
 
-# Judul aplikasi
-st.title("🍽️ Sistem Prediksi Alergen Makanan")
-st.markdown("---")
+# CSS untuk styling
+st.markdown("""
+<style>
+    .main-header {
+        text-align: center;
+        color: #2E86AB;
+        font-size: 3rem;
+        font-weight: bold;
+        margin-bottom: 1rem;
+    }
+    .sub-header {
+        text-align: center;
+        color: #A23B72;
+        font-size: 1.2rem;
+        margin-bottom: 2rem;
+    }
+    .allergen-box {
+        background-color: #f0f2f6;
+        border-radius: 10px;
+        padding: 15px;
+        margin: 10px 0;
+        border-left: 5px solid #FF6B6B;
+    }
+    .safe-box {
+        background-color: #e8f5e8;
+        border-radius: 10px;
+        padding: 15px;
+        margin: 10px 0;
+        border-left: 5px solid #4CAF50;
+    }
+    .model-info {
+        background-color: #e3f2fd;
+        border-radius: 10px;
+        padding: 15px;
+        margin: 10px 0;
+        border-left: 5px solid #2196F3;
+    }
+</style>
+""", unsafe_allow_html=True)
 
-# Cache untuk memuat model
-@st.cache_data
+@st.cache_resource
 def load_models():
-    """Memuat semua model dan vectorizer yang tersimpan"""
-    models = {}
-    model_files = {
-        "XGBoost": "models/XGBoost_model.pkl",
-        "KNN": "models/KNN_model.pkl", 
-        "Random Forest": "models/Random Forest_model.pkl"
-    }
-    
-    # Load TF-IDF vectorizer
+    """Load semua model dan vectorizer"""
     try:
-        with open('models/tfidf_vectorizer.pkl', 'rb') as f:
-            tfidf_vectorizer = pickle.load(f)
-    except FileNotFoundError:
-        st.error("❌ TF-IDF vectorizer tidak ditemukan! Pastikan file 'models/tfidf_vectorizer.pkl' ada.")
-        return None, None
-    
-    # Load models
-    for name, path in model_files.items():
-        try:
-            with open(path, 'rb') as f:
-                models[name] = pickle.load(f)
-        except FileNotFoundError:
-            st.warning(f"⚠️ Model {name} tidak ditemukan di {path}")
-    
-    return models, tfidf_vectorizer
+        models = {}
+        
+        # Load TF-IDF Vectorizer
+        with open('saved_models/tfidf_vectorizer.pkl', 'rb') as f:
+            tfidf = pickle.load(f)
+        
+        # Load Models
+        model_names = ['XGBoost', 'KNN', 'Random Forest']
+        for name in model_names:
+            try:
+                with open(f'saved_models/{name}_model.pkl', 'rb') as f:
+                    models[name] = pickle.load(f)
+            except FileNotFoundError:
+                st.warning(f"Model {name} tidak ditemukan!")
+                continue
+        
+        return tfidf, models
+    except Exception as e:
+        st.error(f"Error loading models: {str(e)}")
+        return None, {}
 
-# Fungsi prediksi
-def predict_allergens(text, model, vectorizer):
-    """Melakukan prediksi alergen dari teks input"""
-    # Transform text menggunakan TF-IDF vectorizer
-    text_vector = vectorizer.transform([text])
+def predict_allergens(text, model, tfidf):
+    """Prediksi alergen dari teks"""
+    try:
+        # Transform teks menggunakan TF-IDF
+        X = tfidf.transform([text])
+        
+        # Prediksi
+        prediction = model.predict(X)[0]
+        prediction_proba = model.predict_proba(X)
+        
+        # Nama alergen
+        allergen_names = ['Susu', 'Kacang', 'Telur', 'Makanan Laut', 'Gandum']
+        
+        results = {}
+        for i, allergen in enumerate(allergen_names):
+            results[allergen] = {
+                'predicted': bool(prediction[i]),
+                'probability': float(prediction_proba[i][0][1]) if len(prediction_proba[i][0]) > 1 else 0.0
+            }
+        
+        return results
+    except Exception as e:
+        st.error(f"Error dalam prediksi: {str(e)}")
+        return {}
+
+def main():
+    # Header
+    st.markdown('<h1 class="main-header">🍽️ Deteksi Alergen Makanan</h1>', unsafe_allow_html=True)
+    st.markdown('<p class="sub-header">Aplikasi AI untuk mendeteksi kandungan alergen dalam makanan berdasarkan deskripsi teks</p>', unsafe_allow_html=True)
     
-    # Prediksi
-    prediction = model.predict(text_vector)
-    prediction_proba = model.predict_proba(text_vector)
+    # Load models
+    tfidf, models = load_models()
     
-    return prediction[0], prediction_proba
-
-# Load models
-models, tfidf_vectorizer = load_models()
-
-if models is None or tfidf_vectorizer is None:
-    st.stop()
-
-# Sidebar untuk pemilihan model
-st.sidebar.header("⚙️ Pengaturan")
-selected_model = st.sidebar.selectbox(
-    "Pilih Model:",
-    list(models.keys()),
-    help="Pilih model machine learning untuk prediksi"
-)
-
-# Label alergen
-allergen_labels = ['Susu', 'Kacang', 'Telur', 'Makanan Laut', 'Gandum']
-allergen_emojis = ['🥛', '🥜', '🥚', '🦐', '🌾']
-
-# Main interface
-col1, col2 = st.columns([2, 1])
-
-with col1:
-    st.header("📝 Input Teks Makanan")
+    if not models:
+        st.error("❌ Tidak ada model yang berhasil dimuat. Pastikan file model ada di folder 'saved_models/'")
+        st.info("📁 File yang dibutuhkan:")
+        st.code("""
+saved_models/
+├── tfidf_vectorizer.pkl
+├── XGBoost_model.pkl
+├── KNN_model.pkl
+└── Random Forest_model.pkl
+        """)
+        return
     
-    # Text input
-    user_input = st.text_area(
-        "Masukkan deskripsi makanan atau ingredients:",
-        placeholder="Contoh: nasi goreng dengan telur, udang, dan kacang tanah",
-        height=100
-    )
+    # Sidebar - Model Selection
+    with st.sidebar:
+        st.markdown("### ⚙️ Pengaturan Model")
+        selected_model = st.selectbox(
+            "Pilih Model:",
+            list(models.keys()),
+            help="Pilih model machine learning untuk prediksi"
+        )
+        
+        st.markdown("### 📊 Info Model")
+        st.markdown(f"""
+        <div class="model-info">
+        <strong>Model Aktif:</strong> {selected_model}<br>
+        <strong>Alergen yang Dideteksi:</strong><br>
+        • 🥛 Susu<br>
+        • 🥜 Kacang<br>
+        • 🥚 Telur<br>
+        • 🦐 Makanan Laut<br>
+        • 🌾 Gandum
+        </div>
+        """, unsafe_allow_html=True)
     
-    # Contoh input
-    st.subheader("💡 Contoh Input:")
-    examples = [
-        "pizza dengan keju mozzarella dan seafood",
-        "roti gandum dengan selai kacang",
-        "cake coklat dengan butter dan telur",
-        "sup tom yum dengan udang dan cumi",
-        "mie instan rasa ayam"
-    ]
+    # Main content
+    col1, col2 = st.columns([2, 1])
     
-    example_cols = st.columns(len(examples))
-    for i, example in enumerate(examples):
-        if example_cols[i].button(f"Contoh {i+1}", help=example):
-            user_input = example
+    with col1:
+        st.markdown("### 📝 Input Deskripsi Makanan")
+        
+        # Text input
+        user_input = st.text_area(
+            "Masukkan deskripsi makanan atau bahan-bahan:",
+            placeholder="Contoh: Kue coklat dengan krim susu, ditaburi kacang almond dan remah biskuit gandum...",
+            height=150,
+            help="Masukkan deskripsi makanan dalam bahasa Indonesia"
+        )
+        
+        # Contoh input
+        st.markdown("#### 💡 Contoh Input:")
+        examples = [
+            "Kue coklat dengan krim susu dan kacang almond",
+            "Nasi goreng seafood dengan udang dan cumi",
+            "Roti gandum dengan selai kacang",
+            "Es krim vanilla dengan topping biskuit",
+            "Salad sayuran segar tanpa dressing"
+        ]
+        
+        selected_example = st.selectbox("Pilih contoh atau tulis sendiri:", [""] + examples)
+        if selected_example and st.button("📋 Gunakan Contoh"):
+            user_input = selected_example
             st.rerun()
-
-with col2:
-    st.header("ℹ️ Informasi Model")
-    if selected_model in models:
-        st.success(f"✅ Model {selected_model} siap digunakan")
-        st.info(f"📊 Jumlah label: {len(allergen_labels)}")
+    
+    with col2:
+        st.markdown("### 🎯 Hasil Prediksi")
         
-        # Model info
-        model_info = {
-            "XGBoost": "Gradient Boosting yang efisien",
-            "KNN": "K-Nearest Neighbors",
-            "Random Forest": "Ensemble dari decision trees"
-        }
-        st.write(f"**Deskripsi:** {model_info.get(selected_model, 'Model machine learning')}")
-
-# Prediksi
-if st.button("🔍 Prediksi Alergen", type="primary", use_container_width=True):
-    if user_input.strip():
-        with st.spinner("Sedang melakukan prediksi..."):
-            try:
-                # Prediksi
-                prediction, prediction_proba = predict_allergens(
-                    user_input, 
-                    models[selected_model], 
-                    tfidf_vectorizer
-                )
+        if user_input and st.button("🔍 Analisis Alergen", type="primary"):
+            with st.spinner("Menganalisis..."):
+                results = predict_allergens(user_input, models[selected_model], tfidf)
+            
+            if results:
+                # Tampilkan hasil
+                allergens_detected = []
+                safe_allergens = []
                 
-                st.markdown("---")
-                st.header("📊 Hasil Prediksi")
+                for allergen, result in results.items():
+                    if result['predicted']:
+                        allergens_detected.append((allergen, result['probability']))
+                    else:
+                        safe_allergens.append((allergen, result['probability']))
                 
-                # Hasil prediksi dalam bentuk metrics
-                st.subheader("🎯 Deteksi Alergen")
-                
-                # Buat columns untuk menampilkan hasil
-                cols = st.columns(len(allergen_labels))
-                
-                detected_allergens = []
-                for i, (label, emoji) in enumerate(zip(allergen_labels, allergen_emojis)):
-                    with cols[i]:
-                        if prediction[i] == 1:
-                            st.success(f"{emoji} **{label}**\n\n✅ **TERDETEKSI**")
-                            detected_allergens.append(label)
-                        else:
-                            st.info(f"{emoji} **{label}**\n\n❌ Tidak terdeteksi")
-                
-                # Ringkasan
-                st.subheader("📋 Ringkasan")
-                if detected_allergens:
-                    st.warning(f"⚠️ **Alergen terdeteksi:** {', '.join(detected_allergens)}")
-                    st.write("**Rekomendasi:** Harap berhati-hati jika Anda memiliki alergi terhadap bahan-bahan tersebut.")
+                # Alergen terdeteksi
+                if allergens_detected:
+                    st.markdown("#### ⚠️ Alergen Terdeteksi:")
+                    for allergen, prob in allergens_detected:
+                        emoji_map = {'Susu': '🥛', 'Kacang': '🥜', 'Telur': '🥚', 'Makanan Laut': '🦐', 'Gandum': '🌾'}
+                        st.markdown(f"""
+                        <div class="allergen-box">
+                        <strong>{emoji_map.get(allergen, '🚨')} {allergen}</strong><br>
+                        Confidence: {prob:.2%}
+                        </div>
+                        """, unsafe_allow_html=True)
                 else:
-                    st.success("✅ **Tidak ada alergen utama yang terdeteksi**")
-                    st.write("**Catatan:** Selalu periksa label produk untuk memastikan keamanan.")
-                
-                # Probability scores (jika tersedia)
-                try:
-                    st.subheader("📈 Tingkat Kepercayaan")
-                    prob_data = []
-                    
-                    for i, (label, emoji) in enumerate(zip(allergen_labels, allergen_emojis)):
-                        # Ambil probabilitas untuk kelas positif (indeks 1)
-                        if hasattr(prediction_proba[i], 'shape') and len(prediction_proba[i][0]) > 1:
-                            prob = prediction_proba[i][0][1]  # Probabilitas kelas 1 (positif)
-                        else:
-                            prob = 0.5  # Default jika tidak ada probabilitas
-                        
-                        prob_data.append({
-                            'Alergen': f"{emoji} {label}",
-                            'Probabilitas': prob,
-                            'Persentase': f"{prob*100:.1f}%"
-                        })
-                    
-                    prob_df = pd.DataFrame(prob_data)
-                    
-                    # Progress bars
-                    for _, row in prob_df.iterrows():
-                        st.write(f"**{row['Alergen']}**")
-                        st.progress(row['Probabilitas'])
-                        st.write(f"Kepercayaan: {row['Persentase']}")
-                        st.write("")
+                    st.markdown("""
+                    <div class="safe-box">
+                    <strong>✅ Aman</strong><br>
+                    Tidak ada alergen yang terdeteksi
+                    </div>
+                    """, unsafe_allow_html=True)
                 
-                except Exception as e:
-                    st.info("💡 Tingkat kepercayaan tidak tersedia untuk model ini")
+                # Detail semua hasil
+                st.markdown("#### 📊 Detail Lengkap:")
                 
-                # Timestamp
-                st.markdown("---")
-                st.caption(f"Prediksi dilakukan pada: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+                # Buat DataFrame untuk hasil
+                df_results = pd.DataFrame([
+                    {
+                        'Alergen': allergen,
+                        'Status': '⚠️ Terdeteksi' if result['predicted'] else '✅ Aman',
+                        'Confidence': f"{result['probability']:.2%}"
+                    }
+                    for allergen, result in results.items()
+                ])
                 
-            except Exception as e:
-                st.error(f"❌ Terjadi kesalahan saat prediksi: {str(e)}")
-                st.write("Pastikan semua file model sudah tersedia dan format input benar.")
-    else:
-        st.warning("⚠️ Silakan masukkan teks untuk prediksi!")
-
-# Footer
-st.markdown("---")
-st.markdown("""
-### 📌 Catatan Penting:
-- Sistem ini adalah alat bantu dan tidak menggantikan konsultasi medis profesional
-- Selalu periksa label produk dan konsultasikan dengan dokter untuk alergi yang serius
-- Akurasi prediksi tergantung pada kualitas data training dan input yang diberikan
-""")
-
-# Informasi tambahan di sidebar
-st.sidebar.markdown("---")
-st.sidebar.header("📋 Informasi Alergen")
-st.sidebar.markdown("""
-**Alergen yang dideteksi:**
-- 🥛 **Susu**: Produk dairy, keju, yogurt
-- 🥜 **Kacang**: Kacang tanah, almond, dll
-- 🥚 **Telur**: Telur ayam dan produk turunannya
-- 🦐 **Makanan Laut**: Udang, ikan, kerang
-- 🌾 **Gandum**: Tepung terigu, roti, pasta
-""")
+                st.dataframe(df_results, use_container_width=True, hide_index=True)
+        
+        elif user_input:
+            st.info("👆 Klik tombol 'Analisis Alergen' untuk memulai prediksi")
+        else:
+            st.info("📝 Masukkan deskripsi makanan terlebih dahulu")
+    
+    # Footer information
+    st.markdown("---")
+    st.markdown("### ℹ️ Informasi Aplikasi")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("""
+        **🎯 Tujuan:**
+        - Deteksi otomatis alergen dalam makanan
+        - Membantu penderita alergi makanan
+        - Analisis berbasis AI/ML
+        """)
+    
+    with col2:
+        st.markdown("""
+        **🔬 Teknologi:**
+        - TF-IDF Vectorization
+        - Multi-output Classification
+        - XGBoost, KNN, Random Forest
+        """)
+    
+    with col3:
+        st.markdown("""
+        **⚠️ Disclaimer:**
+        - Hasil prediksi tidak 100% akurat
+        - Selalu konsultasi dengan ahli
+        - Untuk referensi saja
+        """)
 
-st.sidebar.markdown("---")
-st.sidebar.info("💡 **Tips:** Semakin detail deskripsi makanan yang Anda berikan, semakin akurat hasil prediksinya.")
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,6 +1,7 @@
-streamlit
-pandas
-scikit-learn
-xgboost
-numpy
-pickle
+streamlit==1.28.1
+pandas==2.0.3
+numpy==1.24.3
+scikit-learn==1.3.0
+xgboost==1.7.6
+tqdm==4.65.0
+pickle-mixin==1.0.2