app.py

import streamlit as st
import pandas as pd
import subprocess
import time
import random
import numpy as np
import tensorflow as tf
from tensorflow.keras import layers, models
from transformers import BertTokenizer, TFBertModel
import requests
import matplotlib.pyplot as plt
from io import BytesIO
import base64

# ---------------------------- Helper Function for NER Data ----------------------------

def generate_ner_data():
    # Sample NER data for different entities
    data_person = [{"text": f"Person example {i}", "entities": [{"entity": "Person", "value": f"Person {i}"}]} for i in range(1, 21)]
    data_organization = [{"text": f"Organization example {i}", "entities": [{"entity": "Organization", "value": f"Organization {i}"}]} for i in range(1, 21)]
    data_location = [{"text": f"Location example {i}", "entities": [{"entity": "Location", "value": f"Location {i}"}]} for i in range(1, 21)]
    data_date = [{"text": f"Date example {i}", "entities": [{"entity": "Date", "value": f"Date {i}"}]} for i in range(1, 21)]
    data_product = [{"text": f"Product example {i}", "entities": [{"entity": "Product", "value": f"Product {i}"}]} for i in range(1, 21)]
    
    # Create a dictionary of all NER examples
    ner_data = {
        "Person": data_person,
        "Organization": data_organization,
        "Location": data_location,
        "Date": data_date,
        "Product": data_product
    }
    
    return ner_data

# ---------------------------- Fun NER Data Function ----------------------------

def ner_demo():
    st.header("🤖 LLM NER Model Demo 🕵️‍♀️")
    
    # Generate NER data
    ner_data = generate_ner_data()

    # Pick a random entity type to display
    entity_type = random.choice(list(ner_data.keys()))
    st.subheader(f"Here comes the {entity_type} entity recognition, ready to show its magic! 🎩✨")

    # Select a random record to display
    example = random.choice(ner_data[entity_type])
    st.write(f"Analyzing: *{example['text']}*")
    
    # Display recognized entity
    for entity in example["entities"]:
        st.success(f"🔍 Found a {entity['entity']}: **{entity['value']}**")
    
    # A bit of rhyme to lighten up the task
    st.write("There once was an AI so bright, 🎇")
    st.write("It could spot any name in sight, 👁️")
    st.write("With a click or a tap, it put on its cap, 🎩")
    st.write("And found entities day or night! 🌙")

# ---------------------------- Helper: Text Data Augmentation ----------------------------

def word_subtraction(text):
    """Subtract words at random positions."""
    words = text.split()
    if len(words) > 2:
        index = random.randint(0, len(words) - 1)
        words.pop(index)
    return " ".join(words)

def word_recombination(text):
    """Recombine words with random shuffling."""
    words = text.split()
    random.shuffle(words)
    return " ".join(words)

# ---------------------------- ML Model Building ----------------------------

def build_small_model(input_shape):
    model = models.Sequential()
    model.add(layers.Dense(64, activation='relu', input_shape=(input_shape,)))
    model.add(layers.Dense(32, activation='relu'))
    model.add(layers.Dense(1, activation='sigmoid'))
    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
    return model

# ---------------------------- TensorFlow and Keras Integration ----------------------------

def train_model_demo():
    st.header("🧪 Let's Build a Mini TensorFlow Model 🎓")

    # Generate random synthetic data for simplicity
    data_size = 100
    X_train = np.random.rand(data_size, 10)
    y_train = np.random.randint(0, 2, size=data_size)
    
    st.write(f"🚀 **Data Shape**: {X_train.shape}, with binary target labels.")
    
    # Build the model
    model = build_small_model(X_train.shape[1])
    
    st.write("🔧 **Model Summary**:")
    st.text(model.summary())

    # Train the model
    st.write("🚀 **Training the model...**")
    history = model.fit(X_train, y_train, epochs=5, batch_size=16, verbose=0)

    # Output training results humorously
    st.success("🎉 Training completed! The model now knows its ABCs... or 1s and 0s at least! 😂")

    st.write(f"Final training loss: **{history.history['loss'][-1]:.4f}**, accuracy: **{history.history['accuracy'][-1]:.4f}**")
    st.write("Fun fact: This model can make predictions on binary outcomes like whether a cat will sleep or not. 🐱💤")

# ---------------------------- Additional Useful Examples ----------------------------

def code_snippet_sharing():
    st.header("📤 Code Snippet Sharing with Syntax Highlighting 🖥️")

    code = '''def hello_world():
    print("Hello, world!")'''

    st.code(code, language='python')

    st.write("Developers often need to share code snippets. Here's how you can display code with syntax highlighting in Streamlit! 🌈")

def file_uploader_example():
    st.header("📁 File Uploader Example 📤")

    uploaded_file = st.file_uploader("Choose a CSV file", type="csv")
    if uploaded_file is not None:
        data = pd.read_csv(uploaded_file)
        st.write("🎉 File uploaded successfully!")
        st.dataframe(data.head())
        st.write("Use file uploaders to allow users to bring their own data into your app! 📊")

def matplotlib_plot_example():
    st.header("📈 Matplotlib Plot Example 📊")

    # Generate data
    x = np.linspace(0, 10, 100)
    y = np.sin(x)

    # Create plot
    fig, ax = plt.subplots()
    ax.plot(x, y)
    ax.set_title('Sine Wave')
    st.pyplot(fig)

    st.write("You can integrate Matplotlib plots directly into your Streamlit app! 🎨")

def cache_example():
    st.header("⚡ Streamlit Cache Example 🚀")

    @st.cache
    def expensive_computation(a, b):
        time.sleep(2)
        return a * b

    st.write("Let's compute something that takes time...")
    result = expensive_computation(2, 21)
    st.write(f"The result is {result}. But thanks to caching, it's faster the next time! ⚡")

# ---------------------------- Display Tweet ----------------------------

def display_tweet():
    st.header("🐦 Tweet Spotlight: TensorFlow and Transformers 🌟")

    tweet_html = '''
    <blockquote class="twitter-tweet">
    <p lang="en" dir="ltr">
    Just tried integrating TensorFlow with Transformers for my latest LLM project! 🚀
    The synergy between them is incredible. TensorFlow's flexibility combined with Transformers' power boosts Generative AI capabilities to new heights! 🔥 #TensorFlow #Transformers #AI #MachineLearning
    </p>&mdash; AI Enthusiast (@ai_enthusiast) <a href="https://twitter.com/ai_enthusiast/status/1234567890">September 30, 2024</a>
    </blockquote>
    <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
    '''

    st.components.v1.html(tweet_html, height=300)

    st.write("Tweets can be embedded to showcase social proof or updates. Isn't that neat? 🐤")

# ---------------------------- Header and Introduction ----------------------------

st.set_page_config(page_title="LLMs and Tiny ML Models", page_icon="🤖", layout="wide", initial_sidebar_state="expanded")
st.title("🤖📊 LLMs and Tiny ML Models with TensorFlow 📊🤖")
st.markdown("This app demonstrates how to build small TensorFlow models, solve common developer problems, and augment text data using word subtraction and recombination strategies.")
st.markdown("---")

# ---------------------------- Main Navigation ----------------------------

st.sidebar.title("Navigation")
options = st.sidebar.radio("Go to", ['NER Demo', 'TensorFlow Model', 'Text Augmentation', 'Code Sharing', 'File Uploader', 'Matplotlib Plot', 'Streamlit Cache', 'Tweet Spotlight'])

if options == 'NER Demo':
    if st.button('🧪 Run NER Model Demo'):
        ner_demo()
    else:
        st.write("Click the button above to start the AI NER magic! 🎩✨")

elif options == 'TensorFlow Model':
    if st.button('🚀 Build and Train a TensorFlow Model'):
        train_model_demo()

elif options == 'Text Augmentation':
    st.subheader("🎲 Fun Text Augmentation with Random Strategies 🎲")
    input_text = st.text_input("Enter a sentence to see some augmentation magic! ✨", "TensorFlow is awesome!")
    if st.button("Subtract Random Words"):
        st.write(f"Original: **{input_text}**")
        st.write(f"Augmented: **{word_subtraction(input_text)}**")
    if st.button("Recombine Words"):
        st.write(f"Original: **{input_text}**")
        st.write(f"Augmented: **{word_recombination(input_text)}**")
    st.write("Try both and see how the magic works! 🎩✨")

elif options == 'Code Sharing':
    code_snippet_sharing()

elif options == 'File Uploader':
    file_uploader_example()

elif options == 'Matplotlib Plot':
    matplotlib_plot_example()

elif options == 'Streamlit Cache':
    cache_example()

elif options == 'Tweet Spotlight':
    display_tweet()

st.markdown("---")

# ---------------------------- Footer and Additional Resources ----------------------------

st.subheader("📚 Additional Resources")
st.markdown("""
- [Official Streamlit Documentation](https://docs.streamlit.io/)
- [TensorFlow Documentation](https://www.tensorflow.org/api_docs)
- [Transformers Documentation](https://huggingface.co/docs/transformers/index)
- [Streamlit Cheat Sheet](https://docs.streamlit.io/library/cheatsheet)
- [Matplotlib Documentation](https://matplotlib.org/stable/contents.html)
""")

# ---------------------------- requirements.txt ----------------------------
st.markdown('''
Reference Libraries:
plaintext
streamlit
pandas
numpy
tensorflow
transformers
matplotlib
''')