Spaces:

awacke1
/

TransformersDiffusersNDatasets

Sleeping

File size: 8,915 Bytes

#!/usr/bin/env python3
import os
import re
import streamlit as st
import streamlit.components.v1 as components
from urllib.parse import quote
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import base64

# Page Configuration
st.set_page_config(
    page_title="AI Knowledge Tree Builder 📈🌿",
    page_icon="🌳✨",
    layout="wide",
    initial_sidebar_state="auto",
)

# Predefined Knowledge Trees
trees = {
    "ML Engineering": """
0. ML Engineering 🌐
1. Data Preparation
- Load Data 📊
- Preprocess Data 🛠️
2. Model Building
- Train Model 🤖
- Evaluate Model 📈
3. Deployment
- Deploy Model 🚀
    """,
    "Health": """
0. Health and Wellness 🌿
1. Physical Health
- Exercise 🏋️
- Nutrition 🍎
2. Mental Health
- Meditation 🧘
- Therapy 🛋️
    """,
}

# Project Seeds
project_seeds = {
    "Code Project": """
0. Code Project 📂
1. app.py 🐍
2. requirements.txt 📦
3. README.md 📄
    """,
    "Papers Project": """
0. Papers Project 📚
1. markdown 📝
2. mermaid 🖼️
3. huggingface.co 🤗
    """,
    "AI Project": """
0. AI Project 🤖
1. Streamlit Torch Transformers
- Streamlit 🌐
- Torch 🔥
- Transformers 🤖
2. DistillKit MergeKit Spectrum
- DistillKit 🧪
- MergeKit 🔄
- Spectrum 📊
3. Transformers Diffusers Datasets
- Transformers 🤖
- Diffusers 🎨
- Datasets 📊
    """,
}

# Utility Functions
def sanitize_label(label):
    """Remove invalid characters for Mermaid labels."""
    return re.sub(r'[^\w\s-]', '', label).replace(' ', '_')

def parse_outline_to_mermaid(outline_text, search_agent):
    """Convert tree outline to Mermaid syntax with clickable nodes."""
    lines = outline_text.strip().split('\n')
    nodes, edges, clicks, stack = [], [], [], []
    for line in lines:
        indent = len(line) - len(line.lstrip())
        level = indent // 4
        label = re.sub(r'^[#*\->\d\.\s]+', '', line.strip())
        if label:
            node_id = f"N{len(nodes)}"
            sanitized_label = sanitize_label(label)
            nodes.append(f'{node_id}["{label}"]')
            search_url = search_urls[search_agent](label)
            clicks.append(f'click {node_id} "{search_url}" _blank')
            if stack:
                parent_level = stack[-1][0]
                if level > parent_level:
                    edges.append(f"{stack[-1][1]} --> {node_id}")
                    stack.append((level, node_id))
                else:
                    while stack and stack[-1][0] >= level:
                        stack.pop()
                    if stack:
                        edges.append(f"{stack[-1][1]} --> {node_id}")
                    stack.append((level, node_id))
            else:
                stack.append((level, node_id))
    return "%%{init: {'themeVariables': {'fontSize': '18px'}}}%%\nflowchart LR\n" + "\n".join(nodes + edges + clicks)

def generate_mermaid_html(mermaid_code):
    """Generate HTML to display Mermaid diagram."""
    return f"""
    <html><head><script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
    <style>.centered-mermaid{{display:flex;justify-content:center;margin:20px auto;}}</style></head>
    <body><div class="mermaid centered-mermaid">{mermaid_code}</div>
    <script>mermaid.initialize({{startOnLoad:true}});</script></body></html>
    """

def grow_tree(base_tree, new_node_name, parent_node):
    """Add a new node to the tree under a specified parent."""
    lines = base_tree.strip().split('\n')
    new_lines = []
    added = False
    for line in lines:
        new_lines.append(line)
        if parent_node in line and not added:
            indent = len(line) - len(line.lstrip())
            new_lines.append(f"{' ' * (indent + 4)}- {new_node_name} 🌱")
            added = True
    return "\n".join(new_lines)

def get_download_link(file_path, mime_type="text/plain"):
    """Generate a download link for a file."""
    with open(file_path, 'rb') as f:
        data = f.read()
    b64 = base64.b64encode(data).decode()
    return f'<a href="data:{mime_type};base64,{b64}" download="{file_path}">Download {file_path}</a>'

# Search Agents (Highest resolution social network default: X)
search_urls = {
    "📚📖ArXiv": lambda k: f"/?q={quote(k)}",
    "🔮Google": lambda k: f"https://www.google.com/search?q={quote(k)}",
    "📺Youtube": lambda k: f"https://www.youtube.com/results?search_query={quote(k)}",
    "🔭Bing": lambda k: f"https://www.bing.com/search?q={quote(k)}",
    "💡Truth": lambda k: f"https://truthsocial.com/search?q={quote(k)}",
    "📱X": lambda k: f"https://twitter.com/search?q={quote(k)}",
}

# Main App
st.title("🌳 AI Knowledge Tree Builder 🌱")

# Select Project Type
project_type = st.selectbox("Select Project Type", ["Code Project", "Papers Project", "AI Project"])
if 'current_tree' not in st.session_state:
    st.session_state['current_tree'] = trees.get("ML Engineering", project_seeds[project_type])

# Select Search Agent for Node Links
search_agent = st.selectbox("Select Search Agent for Node Links", list(search_urls.keys()), index=5)  # Default to X

# Tree Growth
new_node = st.text_input("Add New Node")
parent_node = st.text_input("Parent Node")
if st.button("Grow Tree 🌱") and new_node and parent_node:
    st.session_state['current_tree'] = grow_tree(st.session_state['current_tree'], new_node, parent_node)
    with open("current_tree.md", "w") as f:
        f.write(st.session_state['current_tree'])
    st.success(f"Added '{new_node}' under '{parent_node}'!")

# Display Mermaid Diagram
st.markdown("### Knowledge Tree Visualization")
mermaid_code = parse_outline_to_mermaid(st.session_state['current_tree'], search_agent)
components.html(generate_mermaid_html(mermaid_code), height=600)

# Export Tree
if st.button("Export Tree as Markdown"):
    export_md = f"# Knowledge Tree\n\n## Outline\n{st.session_state['current_tree']}\n\n## Mermaid Diagram\n```mermaid\n{mermaid_code}\n```"
    with open("knowledge_tree.md", "w") as f:
        f.write(export_md)
    st.markdown(get_download_link("knowledge_tree.md", "text/markdown"), unsafe_allow_html=True)

# AI Project: Minimal ML Model Building
if project_type == "AI Project":
    st.subheader("Build Minimal ML Model from CSV")
    uploaded_file = st.file_uploader("Upload CSV", type="csv")
    if uploaded_file:
        df = pd.read_csv(uploaded_file)
        st.write("Columns:", df.columns.tolist())
        feature_cols = st.multiselect("Select feature columns", df.columns)
        target_col = st.selectbox("Select target column", df.columns)
        if st.button("Train Model"):
            X = df[feature_cols].values
            y = df[target_col].values
            X_tensor = torch.tensor(X, dtype=torch.float32)
            y_tensor = torch.tensor(y, dtype=torch.float32).view(-1, 1)
            dataset = TensorDataset(X_tensor, y_tensor)
            loader = DataLoader(dataset, batch_size=32, shuffle=True)
            model = nn.Linear(X.shape[1], 1)
            criterion = nn.MSELoss()
            optimizer = optim.Adam(model.parameters(), lr=0.01)
            for epoch in range(10):
                for batch_X, batch_y in loader:
                    optimizer.zero_grad()
                    outputs = model(batch_X)
                    loss = criterion(outputs, batch_y)
                    loss.backward()
                    optimizer.step()
            torch.save(model.state_dict(), "model.pth")
            app_code = f"""
import streamlit as st
import torch
import torch.nn as nn

model = nn.Linear({len(feature_cols)}, 1)
model.load_state_dict(torch.load("model.pth"))
model.eval()

st.title("ML Model Demo")
inputs = []
for col in {feature_cols}:
    inputs.append(st.number_input(col))
if st.button("Predict"):
    input_tensor = torch.tensor([inputs], dtype=torch.float32)
    prediction = model(input_tensor).item()
    st.write(f"Predicted {target_col}: {{prediction}}")
"""
            with open("app.py", "w") as f:
                f.write(app_code)
            reqs = "streamlit\ntorch\npandas\n"
            with open("requirements.txt", "w") as f:
                f.write(reqs)
            readme = """
# ML Model Demo

## How to run
1. Install requirements: `pip install -r requirements.txt`
2. Run the app: `streamlit run app.py`
3. Input feature values and click "Predict".
"""
            with open("README.md", "w") as f:
                f.write(readme)
            st.markdown(get_download_link("model.pth", "application/octet-stream"), unsafe_allow_html=True)
            st.markdown(get_download_link("app.py", "text/plain"), unsafe_allow_html=True)
            st.markdown(get_download_link("requirements.txt", "text/plain"), unsafe_allow_html=True)
            st.markdown(get_download_link("README.md", "text/markdown"), unsafe_allow_html=True)