Upload 3 files

src/run2.py

@@ -0,0 +1,136 @@
+import streamlit as st
+
+def run_app2():
+    st.title(" LLM Compatibility Advisor (Manual Spec Entry)")
+    st.markdown("Enter your CPU and GPU specs to get local LLM suggestions (Ollama-compatible)")
+
+    st.markdown("### 🔧 How to Find Your Device Configuration")
+    st.markdown("""
+    - **🪟 Windows**: Press `Win + R`, type `dxdiag`, and press Enter to view CPU, GPU, and RAM details.
+    - **🍎 macOS**: Click Apple  menu → `About This Mac` → `More Info...`
+    - **🐧 Linux**: Use terminal commands like `lscpu`, `free -h`, or `neofetch`
+    """)
+
+    st.markdown("#### 💡 Tip: You can use these tools to help find your processor and GPU names.")
+
+    cpu_name = st.text_input("🖥️ Enter your Processor Name", placeholder="e.g., Intel Core i5-10300H")
+    st.caption("ℹ️ Enter your exact CPU name to help identify its capability (found in system settings).")
+
+    with st.expander("💡 Suggested Processor Examples"):
+        st.markdown("""
+        - **Intel i3**: i3-10100U, i3-1115G4, i3-N305  
+        - **Intel i5**: i5-10300H, i5-1240P, i5-13400  
+        - **Intel i7**: i7-9750H, i7-11800H, i7-13700K  
+        - **Apple M Series**: M1, M1 Pro, M2, M3  
+        - **AMD Ryzen**: Ryzen 5 5600H, Ryzen 7 5800X, Ryzen 9 7945HX  
+        - **Snapdragon**: Snapdragon 8 Gen 1, Snapdragon 7c Gen 2
+        """)
+
+    cpu_category = st.selectbox(
+        "⚙️ Select your CPU Category",
+        ["Intel i3", "Intel i5", "Intel i7", "Apple M Series", "AMD Ryzen", "Qualcomm Snapdragon", "Other/Unknown"]
+    )
+    st.caption("ℹ️ If unsure, choose the closest matching category from the dropdown.")
+
+    gpu_name = st.text_input("🎮 GPU (Optional)", placeholder="e.g., NVIDIA GTX 1650 / None")
+    st.caption("ℹ️ GPU helps speed up models. If you're unsure or using only CPU, leave it blank or type 'None'.")
+
+    performance_score = {
+        "Intel i3": ("🔴 Low-end", "May only support 4-bit quantized models."),
+        "Intel i5": ("🟡 Moderate", "Can run most 4-bit and some 8-bit models."),
+        "Intel i7": ("🟢 High-end", "Handles 8-bit and some full FP16 models."),
+        "Apple M Series": ("🟢 High-end", "Great efficiency for quantized models."),
+        "AMD Ryzen": ("🟢 High-end", "Multi-core power suitable for larger models."),
+        "Qualcomm Snapdragon": ("🔴 Low-end", "Best for smallest on-device models."),
+        "Other/Unknown": ("🟡 Average", "Limited info—may vary by chip.")
+    }
+
+    llm_recommendations = {
+        "Intel i3": {
+            "Coding": ["Code Llama (7B - quantized)", "Phi-2"],
+            "Math & Logic": ["Mistral (7B - quantized)", "Gemma 2B"],
+            "General": ["Phi-2", "TinyLlama"]
+        },
+        "Intel i5": {
+            "Coding": ["Code Llama (7B)", "Deepseek Coder (6.7B)"],
+            "Math & Logic": ["Mistral 7B", "Gemma 7B"],
+            "General": ["Phi-2", "Mistral", "LLaMA 2 (7B)"]
+        },
+        "Intel i7": {
+            "Coding": ["Code Llama (13B - Q4)", "Deepseek Coder 6.7B"],
+            "Math & Logic": ["Mistral 7B", "LLaMA 2 13B (quantized)"],
+            "General": ["LLaMA 2 (13B)", "OpenChat 3.5"]
+        },
+        "Apple M Series": {
+            "Coding": ["Code Llama 7B (Q4)", "Phi-2"],
+            "Math & Logic": ["Gemma 7B", "Mistral (quantized)"],
+            "General": ["Mistral", "LLaMA 2 7B", "Phi-2"]
+        },
+        "AMD Ryzen": {
+            "Coding": ["Deepseek Coder", "Code Llama"],
+            "Math & Logic": ["Mistral", "LLaMA 2"],
+            "General": ["Phi-2", "Mistral", "LLaMA 2"]
+        },
+        "Qualcomm Snapdragon": {
+            "Coding": ["Phi-2 (on-device)"],
+            "Math & Logic": ["TinyLlama", "Phi-2"],
+            "General": ["TinyLlama", "Gemma 2B"]
+        },
+        "Other/Unknown": {
+            "Coding": ["Phi-2", "TinyLlama"],
+            "Math & Logic": ["Gemma 2B", "TinyLlama"],
+            "General": ["Phi-2", "TinyLlama"]
+        }
+    }
+
+    quantized_sizes = {
+        "TinyLlama": "FP16: 0.6GB, 8-bit: 0.3GB, 4-bit: 0.15GB",
+        "Phi-2": "FP16: 5.2GB, 8-bit: 2.6GB, 4-bit: 1.3GB",
+        "Mistral": "FP16: 13GB, 8-bit: 7GB, 4-bit: 3.5GB",
+        "Gemma 2B": "FP16: 4.2GB, 8-bit: 2.1GB, 4-bit: 1.1GB",
+        "Gemma 7B": "FP16: 13GB, 8-bit: 6.5GB, 4-bit: 3.2GB",
+        "Code Llama": "7B: FP16: 13GB, 8-bit: 6.5GB, 4-bit: 3.3GB | 13B: FP16: 26GB, 8-bit: 13GB, 4-bit: 6.5GB",
+        "Deepseek Coder": "6.7B: FP16: 12.8GB, 8-bit: 6.4GB, 4-bit: 3.2GB",
+        "LLaMA 2": "7B: FP16: 13GB, 8-bit: 6.7GB, 4-bit: 3.5GB | 13B: FP16: 26GB, 8-bit: 13GB, 4-bit: 6.5GB",
+        "OpenChat 3.5": "FP16: 7.1GB, 8-bit: 3.6GB, 4-bit: 1.8GB"
+    }
+
+    if cpu_name:
+        st.markdown("---")
+        st.subheader(" Your Hardware Configuration")
+        st.write(f"**Processor Name:** {cpu_name}")
+        st.write(f"**CPU Category:** {cpu_category}")
+        st.write(f"**GPU:** {gpu_name or 'Not specified'}")
+
+        score_label, score_note = performance_score.get(cpu_category, ("🟡 Unknown", "Estimate based on general category."))
+        st.success(f"💡 Performance Score: {score_label}")
+        st.caption(score_note)
+
+        st.markdown("---")
+        st.subheader("📋 Recommended LLMs for Local Use (Ollama Compatible)")
+
+        recommendations_text = f"Processor: {cpu_name} ({cpu_category})\\nGPU: {gpu_name or 'None'}\\nPerformance Score: {score_label}\\n\\nRecommended Models:\\n"
+
+        recs = llm_recommendations.get(cpu_category, llm_recommendations["Other/Unknown"])
+        for task in ["Coding", "Math & Logic", "General"]:
+            st.markdown(f"### 🔹 {task}")
+            recommendations_text += f"\\n{task}:\\n"
+            for model in recs[task]:
+                st.markdown(f"- ✅ **{model}**")
+                recommendations_text += f"- {model}"
+                for key in quantized_sizes:
+                    if key.lower() in model.lower():
+                        st.caption(f"💾 {quantized_sizes[key]}")
+                        recommendations_text += f" ({quantized_sizes[key]})"
+                        break
+                # Generate command
+                cmd = model.split("(")[0].strip().lower().replace(" ", "_").replace("-", "")
+                st.code(f"ollama pull {cmd}", language="bash")
+                recommendations_text += f"\\n  Command: ollama pull {cmd}\\n"
+
+        st.markdown("---")
+        st.markdown("💡 _Tip: Run these models using `ollama run <model>` or download with `ollama pull <model>`._")
+
+        st.download_button("📥 Download These Recommendations", recommendations_text, file_name="llm_suggestions.txt")
+    else:
+        st.info("Enter your processor details to see LLM recommendations.")

src/run3.py

@@ -0,0 +1,56 @@
+# llm_training_estimator.py
+
+def get_gpu_teraflops(gpu_type: str, exo_flops: float = None) -> float:
+    """
+    Returns TFLOPs/s based on GPU type or Exo input.
+    """
+    gpu_lookup = {
+        "A100": 312,   # FP16
+        "H100": 700,
+    }
+
+    if gpu_type == "Exo":
+        if exo_flops is None or exo_flops <= 0:
+            raise ValueError("Exo TFLOPs must be provided.")
+        return exo_flops
+
+    return gpu_lookup.get(gpu_type, 0)
+
+
+def get_gpu_cost_per_tflop_hour(gpu_type: str, manual_cost: float = None) -> float:
+    """
+    Returns ₹ cost per TFLOP-hour based on GPU type.
+    """
+    cost_lookup = {
+        "A100": 17.64 * 83,   # $17.64 × ₹83 (approx.) = ₹1464 per TFLOP/hr
+        "H100": 7.56 * 83     # ₹627 per TFLOP/hr
+    }
+
+    if gpu_type == "Exo" and manual_cost:
+        return manual_cost
+    return cost_lookup.get(gpu_type, 0)
+
+
+def estimate_training_time_and_cost(params_billion: float, tokens_billion: float, teraflops: float,
+                                    cost_per_tflop_hr: float = 0.0):
+    """
+    Estimate training time and cost.
+
+    Returns:
+    - FLOPs required
+    - Time (hours/days)
+    - Cost (₹)
+    """
+    total_flops_required = 6 * params_billion * 1e9 * tokens_billion * 1e9  # 6 × N × T
+    time_seconds = total_flops_required / (teraflops * 1e12)
+    time_hours = time_seconds / 3600
+    time_days = time_hours / 24
+
+    total_cost = (teraflops * time_hours) * cost_per_tflop_hr if cost_per_tflop_hr > 0 else 0
+
+    return {
+        "flops_required": total_flops_required,
+        "time_hours": time_hours,
+        "time_days": time_days,
+        "total_cost": total_cost
+    }

src/utils.py

@@ -0,0 +1,19 @@
+# utils.py
+
+def get_all_models_from_database(db):
+    models = []
+    for tier, categories in db.items():
+        for category, items in categories.items():
+            for model in items:
+                display_name = f"{model['name']} | {model['size']} | {category} | {tier}"
+                models.append({
+                    "display": display_name,
+                    "name": model["name"],
+                    "size": model["size"],
+                    "description": model["description"],
+                    "cost_a100": model.get("cost(A100)", "₹0"),
+                    "cost_h100": model.get("cost(H100)", "₹0"),
+                    "tier": tier,
+                    "category": category
+                })
+    return models