Dashboard de IA - Visualizando Insights Inteligentes

import streamlit as st
import plotly.graph_objects as go
import plotly.express as px
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import sqlite3
import json
import requests
from transformers import pipeline
import time
import threading
from PIL import Image
import io
import base64

# Configuração da página
st.set_page_config(
    page_title="Dashboard de IA Inteligente",
    page_icon="🤖",
    layout="wide",
    initial_sidebar_state="expanded"
)

class AIAnalyticsEngine:
    def __init__(self):
        """Motor de análise de IA para dashboard"""
        self.setup_database()
        self.load_ai_models()
        self.cache_data = {}
        self.last_update = datetime.now()
    
    @st.cache_resource
    def load_ai_models(_self):
        """Carrega modelos de IA com cache"""
        try:
            sentiment_analyzer = pipeline(
                "sentiment-analysis",
                model="cardiffnlp/twitter-roberta-base-sentiment-latest"
            )
            text_classifier = pipeline("zero-shot-classification")
            return sentiment_analyzer, text_classifier
        except Exception as e:
            st.error(f"Erro ao carregar modelos: {e}")
            return None, None
    
    def setup_database(self):
        """Configura banco de dados para métricas"""
        self.conn = sqlite3.connect('ai_dashboard_data.db', check_same_thread=False)
        cursor = self.conn.cursor()
        
        # Tabela de métricas de IA
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS ai_metrics (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
                metric_name TEXT,
                value REAL,
                category TEXT,
                metadata TEXT
            )
        ''')
        
        # Tabela de insights
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS ai_insights (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
                insight_type TEXT,
                title TEXT,
                description TEXT,
                confidence REAL,
                impact_score REAL
            )
        ''')
        
        # Tabela de predições
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS predictions (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
                model_name TEXT,
                input_data TEXT,
                prediction TEXT,
                confidence REAL,
                actual_outcome TEXT
            )
        ''')
        
        self.conn.commit()
    
    def generate_sample_data(self):
        """Gera dados de exemplo para demonstração"""
        cursor = self.conn.cursor()
        
        # Gerar métricas de exemplo
        metrics_data = [
            ('model_accuracy', np.random.uniform(0.85, 0.95), 'performance'),
            ('processing_speed', np.random.uniform(100, 500), 'performance'),
            ('user_satisfaction', np.random.uniform(4.0, 5.0), 'satisfaction'),
            ('cost_savings', np.random.uniform(1000, 5000), 'business'),
            ('automation_rate', np.random.uniform(60, 85), 'automation'),
            ('error_rate', np.random.uniform(0.01, 0.05), 'quality'),
        ]
        
        for metric_name, value, category in metrics_data:
            cursor.execute(
                "INSERT INTO ai_metrics (metric_name, value, category) VALUES (?, ?, ?)",
                (metric_name, value, category)
            )
        
        # Gerar insights de exemplo
        insights_data = [
            ('trend', 'Aumento na Produtividade', 
             'Sistema de automação aumentou produtividade em 35%', 0.92, 8.5),
            ('anomaly', 'Pico de Processamento Detectado', 
             'Aumento inusual no volume de dados às 14h', 0.78, 6.2),
            ('optimization', 'Oportunidade de Melhoria', 
             'Modelo pode ser otimizado para reduzir latência', 0.85, 7.8),
            ('prediction', 'Tendência Positiva', 
             'Previsão indica crescimento de 15% no próximo mês', 0.89, 9.1),
        ]
        
        for insight_type, title, description, confidence, impact in insights_data:
            cursor.execute(
                "INSERT INTO ai_insights (insight_type, title, description, confidence, impact_score) VALUES (?, ?, ?, ?, ?)",
                (insight_type, title, description, confidence, impact)
            )
        
        self.conn.commit()
    
    def get_real_time_metrics(self):
        """Simula métricas em tempo real"""
        return {
            'active_models': np.random.randint(5, 12),
            'predictions_today': np.random.randint(150, 500),
            'accuracy_avg': np.random.uniform(0.87, 0.94),
            'processing_time': np.random.uniform(0.1, 0.8),
            'api_calls': np.random.randint(1000, 3000),
            'cost_today': np.random.uniform(25, 85)
        }
    
    def get_performance_data(self, days=30):
        """Gera dados de performance dos últimos dias"""
        dates = pd.date_range(end=datetime.now(), periods=days, freq='D')
        
        # Tendência crescente com ruído
        base_accuracy = 0.85
        trend = np.linspace(0, 0.08, days)
        noise = np.random.normal(0, 0.02, days)
        accuracy = base_accuracy + trend + noise
        accuracy = np.clip(accuracy, 0.8, 0.95)
        
        # Dados de processamento
        processing_times = np.random.exponential(0.3, days)
        error_rates = np.random.exponential(0.02, days)
        throughput = np.random.normal(1000, 200, days)
        
        return pd.DataFrame({
            'date': dates,
            'accuracy': accuracy,
            'processing_time': processing_times,
            'error_rate': error_rates,
            'throughput': throughput
        })
    
    def get_insights_data(self):
        """Busca insights do banco de dados"""
        cursor = self.conn.cursor()
        cursor.execute("""
            SELECT insight_type, title, description, confidence, impact_score, timestamp
            FROM ai_insights
            ORDER BY impact_score DESC, timestamp DESC
            LIMIT 10
        """)
        
        results = cursor.fetchall()
        return pd.DataFrame(results, columns=[
            'type', 'title', 'description', 'confidence', 'impact', 'timestamp'
        ])

# Inicializar engine
@st.cache_resource
def get_analytics_engine():
    engine = AIAnalyticsEngine()
    # Gerar dados de exemplo na primeira execução
    engine.generate_sample_data()
    return engine

def create_kpi_card(title, value, delta=None, format_str="{}", icon="📊"):
    """Cria card de KPI personalizado"""
    delta_color = "normal"
    delta_symbol = ""
    
    if delta:
        if delta > 0:
            delta_symbol = "↗️ +"
            delta_color = "normal"
        else:
            delta_symbol = "↘️ "
            delta_color = "inverse"
    
    col1, col2 = st.columns([1, 4])
    with col1:
        st.markdown(f"## {icon}")
    with col2:
        st.metric(
            label=title,
            value=format_str.format(value),
            delta=f"{delta_symbol}{abs(delta):.1f}%" if delta else None
        )

def create_gauge_chart(value, title, max_value=100, color_threshold=[70, 90]):
    """Cria gráfico gauge personalizado"""
    fig = go.Figure(go.Indicator(
        mode = "gauge+number+delta",
        value = value,
        domain = {'x': [0, 1], 'y': [0, 1]},
        title = {'text': title},
        delta = {'reference': 80},
        gauge = {
            'axis': {'range': [None, max_value]},
            'bar': {'color': "darkblue"},
            'steps': [
                {'range': [0, color_threshold[0]], 'color': "lightgray"},
                {'range': [color_threshold[0], color_threshold[1]], 'color': "yellow"},
                {'range': [color_threshold[1], max_value], 'color': "green"}
            ],
            'threshold': {
                'line': {'color': "red", 'width': 4},
                'thickness': 0.75,
                'value': 90
            }
        }
    ))
    
    fig.update_layout(height=300)
    return fig

def create_ai_performance_chart(data):
    """Cria gráfico de performance de IA"""
    fig = px.line(data, x='date', y='accuracy', 
                  title='Evolução da Precisão dos Modelos',
                  labels={'accuracy': 'Precisão (%)', 'date': 'Data'})
    
    fig.add_hline(y=0.9, line_dash="dash", line_color="green",
                  annotation_text="Meta: 90%")
    
    fig.update_layout(
        xaxis_title="Data",
        yaxis_title="Precisão",
        hovermode='x unified'
    )
    
    return fig

def create_insights_visualization(insights_df):
    """Cria visualização de insights"""
    if insights_df.empty:
        return None
    
    fig = px.scatter(insights_df, 
                     x='confidence', 
                     y='impact',
                     size='impact',
                     color='type',
                     hover_data=['title'],
                     title='Mapa de Insights: Confiança vs Impacto')
    
    fig.update_layout(
        xaxis_title="Confiança",
        yaxis_title="Impacto",
        showlegend=True
    )
    
    return fig

def create_prediction_accuracy_chart():
    """Cria gráfico de precisão de predições"""
    models = ['Modelo A', 'Modelo B', 'Modelo C', 'Modelo D', 'Modelo E']
    accuracy = np.random.uniform(0.75, 0.95, len(models))
    
    fig = px.bar(x=models, y=accuracy,
                 title='Precisão por Modelo de IA',
                 labels={'x': 'Modelos', 'y': 'Precisão'})
    
    fig.add_hline(y=0.85, line_dash="dash", line_color="red",
                  annotation_text="Mínimo Aceitável: 85%")
    
    return fig

# Interface Principal do Dashboard
def main():
    st.title("🤖 Dashboard de IA Inteligente")
    st.markdown("### Monitoramento e Análise em Tempo Real")
    
    # Inicializar engine
    engine = get_analytics_engine()
    
    # Sidebar para controles
    st.sidebar.title("⚙️ Controles")
    
    # Seletor de período
    period = st.sidebar.selectbox(
        "Período de Análise",
        ["Últimas 24h", "Última Semana", "Último Mês", "Últimos 3 Meses"]
    )
    
    # Seletor de métricas
    show_advanced = st.sidebar.checkbox("Mostrar Métricas Avançadas")
    auto_refresh = st.sidebar.checkbox("Atualização Automática (30s)")
    
    # Refresh automático
    if auto_refresh:
        time.sleep(30)
        st.rerun()
    
    # Seção 1: KPIs Principais
    st.header("📈 KPIs Principais")
    
    # Buscar métricas em tempo real
    metrics = engine.get_real_time_metrics()
    
    col1, col2, col3, col4 = st.columns(4)
    
    with col1:
        create_kpi_card("Modelos Ativos", metrics['active_models'], 
                       delta=2.5, format_str="{:.0f}", icon="🤖")
    
    with col2:
        create_kpi_card("Predições Hoje", metrics['predictions_today'], 
                       delta=15.2, format_str="{:.0f}", icon="🎯")
    
    with col3:
        create_kpi_card("Precisão Média", metrics['accuracy_avg'] * 100, 
                       delta=1.8, format_str="{:.1f}%", icon="✅")
    
    with col4:
        create_kpi_card("Tempo Proc.", metrics['processing_time'], 
                       delta=-12.5, format_str="{:.2f}s", icon="⚡")
    
    # Seção 2: Gráficos de Performance
    st.header("📊 Performance dos Modelos")
    
    col1, col2 = st.columns([2, 1])
    
    with col1:
        # Gráfico de evolução da precisão
        performance_data = engine.get_performance_data()
        perf_chart = create_ai_performance_chart(performance_data)
        st.plotly_chart(perf_chart, use_container_width=True)
    
    with col2:
        # Gauge de performance geral
        overall_performance = metrics['accuracy_avg'] * 100
        gauge_fig = create_gauge_chart(
            overall_performance, 
            "Performance Geral",
            max_value=100,
            color_threshold=[85, 92]
        )
        st.plotly_chart(gauge_fig, use_container_width=True)
    
    # Seção 3: Análise de Modelos
    st.header("🔍 Análise Detalhada dos Modelos")
    
    col1, col2 = st.columns(2)
    
    with col1:
        # Gráfico de precisão por modelo
        accuracy_chart = create_prediction_accuracy_chart()
        st.plotly_chart(accuracy_chart, use_container_width=True)
    
    with col2:
        # Distribuição de tipos de predição
        prediction_types = ['Classificação', 'Regressão', 'Clustering', 'NLP', 'Visão']
        prediction_counts = np.random.randint(10, 100, len(prediction_types))
        
        fig = px.pie(values=prediction_counts, names=prediction_types,
                     title='Distribuição de Tipos de Predição')
        st.plotly_chart(fig, use_container_width=True)
    
    # Seção 4: Insights e Alertas
    st.header("💡 Insights e Alertas Inteligentes")
    
    insights_data = engine.get_insights_data()
    
    if not insights_data.empty:
        col1, col2 = st.columns([1, 1])
        
        with col1:
            # Lista de insights
            st.subheader("🎯 Principais Insights")
            for _, insight in insights_data.head(5).iterrows():
                with st.expander(f"{insight['title']} (Impacto: {insight['impact']:.1f})"):
                    st.write(insight['description'])
                    st.write(f"**Confiança:** {insight['confidence']:.1%}")
                    st.write(f"**Tipo:** {insight['type']}")
        
        with col2:
            # Gráfico de insights
            insights_chart = create_insights_visualization(insights_data)
            if insights_chart:
                st.plotly_chart(insights_chart, use_container_width=True)
    
    # Seção 5: Métricas Avançadas (se habilitado)
    if show_advanced:
        st.header("🔬 Métricas Avançadas")
        
        col1, col2, col3 = st.columns(3)
        
        with col1:
            st.subheader("💰 Custos")
            st.metric("Custo Hoje", f"${metrics['cost_today']:.2f}", delta=-8.5)
            st.metric("Chamadas API", f"{metrics['api_calls']:,}", delta=12.3)
        
        with col2:
            st.subheader("⚡ Performance")
            st.metric("Latência Média", f"{metrics['processing_time']:.3f}s", delta=-15.2)
            st.metric("Throughput", f"{np.random.randint(800, 1200)}/min", delta=5.7)
        
        with col3:
            st.subheader("🛡️ Qualidade")
            st.metric("Taxa de Erro", f"{np.random.uniform(0.01, 0.03):.2%}", delta=-2.1)
            st.metric("Disponibilidade", f"{np.random.uniform(0.995, 0.999):.2%}", delta=0.1)
    
    # Seção 6: Alertas em Tempo Real
    st.header("🚨 Alertas em Tempo Real")
    
    # Simular alertas
    alerts = [
        {"type": "warning", "message": "Latência acima do normal no Modelo B", "time": "2 min atrás"},
        {"type": "info", "message": "Novo modelo implantado com sucesso", "time": "15 min atrás"},
        {"type": "success", "message": "Meta de precisão atingida", "time": "1h atrás"},
    ]
    
    for alert in alerts:
        icon = {"warning": "⚠️", "info": "ℹ️", "success": "✅"}[alert["type"]]
        color = {"warning": "orange", "info": "blue", "success": "green"}[alert["type"]]
        
        st.markdown(f"""
        

            {icon} {alert['message']}

            {alert['time']}
        
        """, unsafe_allow_html=True)
    
    # Seção 7: Ferramentas de Análise Interativa
    st.header("🛠️ Ferramentas de Análise")
    
    tab1, tab2, tab3 = st.tabs(["📊 Análise de Dados", "🔮 Simulador", "📄 Relatórios"])
    
    with tab1:
        st.subheader("Análise Personalizada")
        
        # Upload de dados
        uploaded_file = st.file_uploader("Carregar dados para análise", type=['csv', 'json'])
        if uploaded_file:
            if uploaded_file.name.endswith('.csv'):
                df = pd.read_csv(uploaded_file)
                st.write("### Visualização dos Dados")
                st.dataframe(df.head())
                
                # Análise automática com IA
                if st.button("Analisar com IA"):
                    st.success("Análise concluída!")
                    st.write("**Insights Detectados:**")
                    st.write("- Tendência crescente nos últimos 30 dias")
                    st.write("- Correlação forte entre variáveis A e B")
                    st.write("- Anomalia detectada no período X")
    
    with tab2:
        st.subheader("Simulador de Cenários")
        
        scenario_type = st.selectbox("Tipo de Simulação", 
                                   ["Aumento de Volume", "Mudança de Precisão", "Novo Modelo"])
        
        if scenario_type == "Aumento de Volume":
            volume_increase = st.slider("Aumento de Volume (%)", 0, 500, 100)
            if st.button("Simular"):
                st.write(f"**Impacto de {volume_increase}% de aumento:**")
                st.write(f"- Custo estimado: +${volume_increase * 0.5:.2f}")
                st.write(f"- Latência: +{volume_increase * 0.01:.2f}s")
                st.write(f"- Recursos necessários: +{volume_increase * 0.8:.1f}%")
    
    with tab3:
        st.subheader("Gerador de Relatórios")
        
        report_type = st.selectbox("Tipo de Relatório", 
                                 ["Performance Semanal", "Análise de Custos", "Relatório Executivo"])
        
        if st.button("Gerar Relatório"):
            st.success("Relatório gerado com sucesso!")
            st.download_button(
                label="📥 Download Relatório PDF",
                data=b"PDF content here",  # Em produção, gerar PDF real
                file_name=f"{report_type.lower().replace(' ', '_')}.pdf",
                mime="application/pdf"
            )
    
    # Footer com informações
    st.markdown("---")
    st.markdown("**Dashboard de IA Inteligente** | Atualizado automaticamente | Dados em tempo real")

if __name__ == "__main__":
    main()