Crie o arquivo app.py

app.py

@@ -0,0 +1,661 @@
+import streamlit as st
+import tensorflow as tf
+from tensorflow.keras import datasets, layers, models
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+import time
+
+# Configuração da página
+st.set_page_config(
+    page_title="Classificador de Imagens CIFAR-10",
+    page_icon="🖼️",
+    layout="wide"
+)
+
+# Título principal
+st.title("🖼️ Classificador de Imagens com Deep Learning")
+st.markdown("---")
+
+# Sidebar com informações
+st.sidebar.title("📊 Informações do Projeto")
+st.sidebar.info("""
+**Problema de Negócio:**
+
+Construir um modelo de Inteligência Artificial capaz de classificar imagens 
+considerando 10 categorias:
+- ✈️ Airplane
+- 🚗 Automobile
+- 🐦 Bird
+- 🐱 Cat
+- 🦌 Deer
+- 🐕 Dog
+- 🐸 Frog
+- 🐴 Horse
+- 🚢 Ship
+- 🚛 Truck
+""")
+
+st.sidebar.markdown("---")
+st.sidebar.markdown("### 🔧 Tecnologias Utilizadas")
+st.sidebar.markdown("""
+- Python
+- TensorFlow/Keras
+- Streamlit
+- NumPy
+- Matplotlib
+- PIL
+""")
+
+# Classes das imagens
+nomes_classes = ['airplane', 'automobile', 'bird', 'cat', 'deer', 
+                 'dog', 'frog', 'horse', 'ship', 'truck']
+
+# Emojis para cada classe
+emojis_classes = {
+    'airplane': '✈️',
+    'automobile': '🚗',
+    'bird': '🐦',
+    'cat': '🐱',
+    'deer': '🦌',
+    'dog': '🐕',
+    'frog': '🐸',
+    'horse': '🐴',
+    'ship': '🚢',
+    'truck': '🚛'
+}
+
+# Função para carregar dados
+@st.cache_data
+def carregar_dados():
+    """Carrega e pré-processa o dataset CIFAR-10"""
+    (imagens_treino, labels_treino), (imagens_teste, labels_teste) = datasets.cifar10.load_data()
+    
+    # Normaliza os valores dos pixels
+    imagens_treino = imagens_treino / 255.0
+    imagens_teste = imagens_teste / 255.0
+    
+    return (imagens_treino, labels_treino), (imagens_teste, labels_teste)
+
+# Função para visualizar imagens
+def visualiza_imagens(images, labels, num_imagens=25):
+    """Cria uma figura com múltiplas imagens do dataset"""
+    fig, axes = plt.subplots(5, 5, figsize=(10, 10))
+    fig.suptitle('Exemplos do Dataset CIFAR-10', fontsize=16)
+    
+    for i, ax in enumerate(axes.flat):
+        if i < num_imagens:
+            ax.imshow(images[i])
+            ax.set_title(nomes_classes[labels[i][0]], fontsize=8)
+            ax.axis('off')
+    
+    plt.tight_layout()
+    return fig
+
+# Função para criar o modelo
+@st.cache_resource
+def criar_modelo():
+    """Cria a arquitetura da rede neural convolucional"""
+    modelo = models.Sequential([
+        # Primeiro bloco convolucional
+        layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
+        layers.MaxPooling2D((2, 2)),
+        
+        # Segundo bloco convolucional
+        layers.Conv2D(128, (3, 3), activation='relu'),
+        layers.MaxPooling2D((2, 2)),
+        
+        # Terceiro bloco convolucional
+        layers.Conv2D(64, (3, 3), activation='relu'),
+        layers.MaxPooling2D((2, 2)),
+        
+        # Camadas de classificação
+        layers.Flatten(),
+        layers.Dense(64, activation='relu'),
+        layers.Dense(10, activation='softmax')
+    ])
+    
+    modelo.compile(
+        optimizer='adam',
+        loss='sparse_categorical_crossentropy',
+        metrics=['accuracy']
+    )
+    
+    return modelo
+
+# Função para treinar o modelo
+def treinar_modelo(modelo, imagens_treino, labels_treino, imagens_teste, labels_teste, epochs=10):
+    """Treina o modelo com os dados fornecidos"""
+    history = modelo.fit(
+        imagens_treino,
+        labels_treino,
+        epochs=epochs,
+        validation_data=(imagens_teste, labels_teste),
+        verbose=0
+    )
+    return history
+
+# Função para processar imagem do usuário
+def processar_imagem_usuario(imagem_file):
+    """Processa a imagem enviada pelo usuário"""
+    imagem = Image.open(imagem_file)
+    
+    # Redimensiona para 32x32
+    imagem_redimensionada = imagem.resize((32, 32))
+    
+    # Converte para array e normaliza
+    imagem_array = np.array(imagem_redimensionada) / 255.0
+    
+    # Expande dimensão
+    imagem_array = np.expand_dims(imagem_array, axis=0)
+    
+    return imagem_redimensionada, imagem_array
+
+# Função para criar gráficos de treinamento
+def plotar_historico(history):
+    """Cria gráficos de acurácia e perda durante o treinamento"""
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
+    
+    # Gráfico de acurácia
+    ax1.plot(history.history['accuracy'], label='Treino', marker='o')
+    ax1.plot(history.history['val_accuracy'], label='Validação', marker='s')
+    ax1.set_title('Acurácia do Modelo')
+    ax1.set_xlabel('Época')
+    ax1.set_ylabel('Acurácia')
+    ax1.legend()
+    ax1.grid(True)
+    
+    # Gráfico de perda
+    ax2.plot(history.history['loss'], label='Treino', marker='o')
+    ax2.plot(history.history['val_loss'], label='Validação', marker='s')
+    ax2.set_title('Perda do Modelo')
+    ax2.set_xlabel('Época')
+    ax2.set_ylabel('Perda')
+    ax2.legend()
+    ax2.grid(True)
+    
+    plt.tight_layout()
+    return fig
+
+# Abas principais
+tab1, tab2, tab3, tab4 = st.tabs([
+    "📚 Dados", 
+    "🏗️ Modelo", 
+    "📈 Treinamento", 
+    "🎯 Predição"
+])
+
+# ==================== ABA 1: DADOS ====================
+with tab1:
+    st.header("📚 Exploração dos Dados")
+    
+    st.markdown("""
+    ### Dataset CIFAR-10
+    
+    O **CIFAR-10** é um dataset clássico de visão computacional que contém 60.000 imagens 
+    coloridas de 32x32 pixels em 10 classes diferentes, com 6.000 imagens por classe.
+    
+    - **50.000 imagens de treino**
+    - **10.000 imagens de teste**
+    - **10 classes balanceadas**
+    """)
+    
+    if st.button("🔄 Carregar Dataset CIFAR-10", key="carregar_dados"):
+        with st.spinner("Carregando dados..."):
+            (imagens_treino, labels_treino), (imagens_teste, labels_teste) = carregar_dados()
+            st.session_state.dados_carregados = True
+            st.session_state.imagens_treino = imagens_treino
+            st.session_state.labels_treino = labels_treino
+            st.session_state.imagens_teste = imagens_teste
+            st.session_state.labels_teste = labels_teste
+            
+        st.success("✅ Dados carregados com sucesso!")
+        
+        # Mostrar estatísticas
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Imagens de Treino", f"{len(imagens_treino):,}")
+        with col2:
+            st.metric("Imagens de Teste", f"{len(imagens_teste):,}")
+        with col3:
+            st.metric("Classes", len(nomes_classes))
+    
+    # Visualização das imagens
+    if st.session_state.get('dados_carregados', False):
+        st.markdown("---")
+        st.subheader("🖼️ Exemplos de Imagens do Dataset")
+        
+        fig = visualiza_imagens(
+            st.session_state.imagens_treino,
+            st.session_state.labels_treino
+        )
+        st.pyplot(fig)
+        
+        # Informações detalhadas
+        with st.expander("📊 Informações Detalhadas dos Dados"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown("**Dados de Treino:**")
+                st.write(f"- Shape: {st.session_state.imagens_treino.shape}")
+                st.write(f"- Tipo: {st.session_state.imagens_treino.dtype}")
+                st.write(f"- Valores min/max: {st.session_state.imagens_treino.min():.2f} / {st.session_state.imagens_treino.max():.2f}")
+            
+            with col2:
+                st.markdown("**Dados de Teste:**")
+                st.write(f"- Shape: {st.session_state.imagens_teste.shape}")
+                st.write(f"- Tipo: {st.session_state.imagens_teste.dtype}")
+                st.write(f"- Valores min/max: {st.session_state.imagens_teste.min():.2f} / {st.session_state.imagens_teste.max():.2f}")
+
+# ==================== ABA 2: MODELO ====================
+with tab2:
+    st.header("🏗️ Arquitetura do Modelo")
+    
+    st.markdown("""
+    ### Rede Neural Convolucional (CNN)
+    
+    O modelo utiliza uma arquitetura de **Rede Neural Convolucional**, 
+    ideal para processamento de imagens. A arquitetura consiste em:
+    
+    1. **Camadas Convolucionais**: Extraem características das imagens
+    2. **Camadas de Pooling**: Reduzem a dimensionalidade
+    3. **Camadas Densas**: Realizam a classificação final
+    """)
+    
+    if st.button("🔨 Criar Modelo", key="criar_modelo"):
+        with st.spinner("Criando modelo..."):
+            modelo = criar_modelo()
+            st.session_state.modelo = modelo
+            st.session_state.modelo_criado = True
+            
+        st.success("✅ Modelo criado com sucesso!")
+    
+    if st.session_state.get('modelo_criado', False):
+        st.markdown("---")
+        st.subheader("📋 Sumário da Arquitetura")
+        
+        # Captura o sumário do modelo
+        from io import StringIO
+        import sys
+        
+        buffer = StringIO()
+        st.session_state.modelo.summary(print_fn=lambda x: buffer.write(x + '\n'))
+        summary_string = buffer.getvalue()
+        
+        st.code(summary_string, language='text')
+        
+        # Visualização da arquitetura
+        with st.expander("🔍 Detalhes das Camadas"):
+            st.markdown("""
+            **Camada 1 - Conv2D (32 filtros, 3x3):**
+            - Primeira camada convolucional
+            - Extrai 32 características diferentes
+            - Ativação ReLU
+            
+            **Camada 2 - MaxPooling2D (2x2):**
+            - Reduz dimensionalidade pela metade
+            - Mantém características mais importantes
+            
+            **Camada 3 - Conv2D (128 filtros, 3x3):**
+            - Segunda camada convolucional
+            - Extrai características mais complexas
+            
+            **Camada 4 - MaxPooling2D (2x2):**
+            - Segunda redução de dimensionalidade
+            
+            **Camada 5 - Conv2D (64 filtros, 3x3):**
+            - Terceira camada convolucional
+            - Refinamento de características
+            
+            **Camada 6 - MaxPooling2D (2x2):**
+            - Terceira redução de dimensionalidade
+            
+            **Camada 7 - Flatten:**
+            - Converte matriz em vetor
+            
+            **Camada 8 - Dense (64 neurônios):**
+            - Camada totalmente conectada
+            - Ativação ReLU
+            
+            **Camada 9 - Dense (10 neurônios):**
+            - Camada de saída
+            - Ativação Softmax (probabilidades)
+            - Uma saída para cada classe
+            """)
+        
+        # Informações sobre parâmetros
+        trainable_params = np.sum([np.prod(v.shape) for v in st.session_state.modelo.trainable_weights])
+        
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("Parâmetros Treináveis", f"{trainable_params:,}")
+        with col2:
+            st.metric("Camadas", len(st.session_state.modelo.layers))
+        with col3:
+            st.metric("Tamanho Input", "32x32x3")
+
+# ==================== ABA 3: TREINAMENTO ====================
+with tab3:
+    st.header("📈 Treinamento do Modelo")
+    
+    st.markdown("""
+    ### Processo de Treinamento
+    
+    Durante o treinamento, o modelo aprende a identificar padrões nas imagens 
+    através de múltiplas iterações (épocas) sobre os dados de treino.
+    
+    **Métricas monitoradas:**
+    - **Acurácia**: Percentual de predições corretas
+    - **Perda (Loss)**: Medida de erro do modelo
+    """)
+    
+    # Verificar pré-requisitos
+    if not st.session_state.get('dados_carregados', False):
+        st.warning("⚠️ Por favor, carregue os dados primeiro na aba 'Dados'")
+    elif not st.session_state.get('modelo_criado', False):
+        st.warning("⚠️ Por favor, crie o modelo primeiro na aba 'Modelo'")
+    else:
+        st.markdown("---")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            epochs = st.slider(
+                "Número de Épocas",
+                min_value=1,
+                max_value=20,
+                value=10,
+                help="Número de vezes que o modelo verá todos os dados de treino"
+            )
+        
+        with col2:
+            st.markdown("### ⚙️ Configurações")
+            st.write(f"- **Otimizador**: Adam")
+            st.write(f"- **Função de Perda**: Sparse Categorical Crossentropy")
+            st.write(f"- **Métrica**: Accuracy")
+        
+        if st.button("🚀 Iniciar Treinamento", key="treinar"):
+            
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            
+            # Container para métricas em tempo real
+            metrics_container = st.empty()
+            
+            start_time = time.time()
+            
+            # Treinar o modelo
+            with st.spinner("Treinando modelo..."):
+                history = treinar_modelo(
+                    st.session_state.modelo,
+                    st.session_state.imagens_treino,
+                    st.session_state.labels_treino,
+                    st.session_state.imagens_teste,
+                    st.session_state.labels_teste,
+                    epochs=epochs
+                )
+                
+                st.session_state.history = history
+                st.session_state.modelo_treinado = True
+            
+            end_time = time.time()
+            training_time = end_time - start_time
+            
+            progress_bar.progress(100)
+            status_text.success(f"✅ Treinamento concluído em {training_time:.2f} segundos!")
+            
+            # Mostrar métricas finais
+            final_train_acc = history.history['accuracy'][-1]
+            final_val_acc = history.history['val_accuracy'][-1]
+            final_train_loss = history.history['loss'][-1]
+            final_val_loss = history.history['val_loss'][-1]
+            
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                st.metric("Acurácia Treino", f"{final_train_acc:.2%}")
+            with col2:
+                st.metric("Acurácia Validação", f"{final_val_acc:.2%}")
+            with col3:
+                st.metric("Perda Treino", f"{final_train_loss:.4f}")
+            with col4:
+                st.metric("Perda Validação", f"{final_val_loss:.4f}")
+    
+    # Mostrar gráficos se já treinado
+    if st.session_state.get('modelo_treinado', False):
+        st.markdown("---")
+        st.subheader("📊 Evolução do Treinamento")
+        
+        fig = plotar_historico(st.session_state.history)
+        st.pyplot(fig)
+        
+        with st.expander("💡 Interpretação dos Gráficos"):
+            st.markdown("""
+            **Gráfico de Acurácia:**
+            - Mostra como a precisão do modelo melhora ao longo das épocas
+            - Idealmente, ambas as curvas devem crescer juntas
+            - Se a curva de validação estagna ou cai, pode indicar overfitting
+            
+            **Gráfico de Perda:**
+            - Mostra como o erro do modelo diminui ao longo das épocas
+            - Valores menores indicam melhor desempenho
+            - A diferença entre treino e validação indica generalização
+            """)
+        
+        # Avaliação final
+        st.markdown("---")
+        st.subheader("🎯 Avaliação Final")
+        
+        if st.button("📊 Avaliar Modelo no Conjunto de Teste"):
+            with st.spinner("Avaliando modelo..."):
+                erro_teste, acc_teste = st.session_state.modelo.evaluate(
+                    st.session_state.imagens_teste,
+                    st.session_state.labels_teste,
+                    verbose=0
+                )
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.metric(
+                    "Acurácia no Teste",
+                    f"{acc_teste:.2%}",
+                    help="Percentual de imagens classificadas corretamente"
+                )
+            
+            with col2:
+                st.metric(
+                    "Erro no Teste",
+                    f"{erro_teste:.4f}",
+                    help="Medida de erro do modelo"
+                )
+            
+            # Interpretação do resultado
+            if acc_teste >= 0.70:
+                st.success(f"✅ Excelente! O modelo alcançou {acc_teste:.1%} de acurácia!")
+            elif acc_teste >= 0.60:
+                st.info(f"ℹ️ Bom resultado! O modelo alcançou {acc_teste:.1%} de acurácia.")
+            else:
+                st.warning(f"⚠️ O modelo pode melhorar. Acurácia atual: {acc_teste:.1%}")
+
+# ==================== ABA 4: PREDIÇÃO ====================
+with tab4:
+    st.header("🎯 Fazer Predições")
+    
+    st.markdown("""
+    ### Classificação de Novas Imagens
+    
+    Envie uma imagem para que o modelo treinado faça a classificação!
+    
+    **Dicas para melhores resultados:**
+    - Use imagens claras das categorias suportadas
+    - Evite imagens muito diferentes do dataset de treino
+    - Quanto mais simples a imagem, melhor
+    """)
+    
+    if not st.session_state.get('modelo_treinado', False):
+        st.warning("⚠️ Por favor, treine o modelo primeiro na aba 'Treinamento'")
+    else:
+        st.markdown("---")
+        
+        # Upload de imagem
+        uploaded_file = st.file_uploader(
+            "📤 Escolha uma imagem",
+            type=['png', 'jpg', 'jpeg'],
+            help="Formatos aceitos: PNG, JPG, JPEG"
+        )
+        
+        if uploaded_file is not None:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.subheader("🖼️ Imagem Original")
+                imagem_original = Image.open(uploaded_file)
+                st.image(imagem_original, use_container_width=True)
+                
+                # Informações da imagem
+                st.markdown(f"""
+                **Informações:**
+                - Tamanho: {imagem_original.size[0]} x {imagem_original.size[1]} pixels
+                - Formato: {imagem_original.format}
+                - Modo: {imagem_original.mode}
+                """)
+            
+            with col2:
+                st.subheader("🔍 Imagem Processada (32x32)")
+                
+                # Processar imagem
+                imagem_processada, imagem_array = processar_imagem_usuario(uploaded_file)
+                st.image(imagem_processada, use_container_width=True)
+                
+                st.info("A imagem foi redimensionada para 32x32 pixels para corresponder ao formato de entrada do modelo.")
+            
+            # Botão de predição
+            st.markdown("---")
+            
+            if st.button("🎲 Classificar Imagem", key="classificar", use_container_width=True):
+                with st.spinner("Analisando imagem..."):
+                    # Fazer predição
+                    previsoes = st.session_state.modelo.predict(imagem_array, verbose=0)
+                    classe_prevista = np.argmax(previsoes[0])
+                    confianca = previsoes[0][classe_prevista]
+                    nome_classe = nomes_classes[classe_prevista]
+                    emoji_classe = emojis_classes[nome_classe]
+                
+                # Resultado principal
+                st.markdown("---")
+                st.subheader("🎉 Resultado da Classificação")
+                
+                # Card de resultado
+                st.markdown(f"""
+                <div style="
+                    padding: 30px;
+                    border-radius: 10px;
+                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                    color: white;
+                    text-align: center;
+                    margin: 20px 0;
+                ">
+                    <h1 style="font-size: 4em; margin: 0;">{emoji_classe}</h1>
+                    <h2 style="margin: 10px 0;">{nome_classe.upper()}</h2>
+                    <p style="font-size: 1.5em; margin: 0;">Confiança: {confianca:.1%}</p>
+                </div>
+                """, unsafe_allow_html=True)
+                
+                # Barra de progresso da confiança
+                st.progress(float(confianca))
+                
+                # Mostrar todas as probabilidades
+                st.markdown("---")
+                st.subheader("📊 Probabilidades para Todas as Classes")
+                
+                # Criar DataFrame com resultados
+                import pandas as pd
+                
+                resultados = pd.DataFrame({
+                    'Classe': [f"{emojis_classes[nome]} {nome}" for nome in nomes_classes],
+                    'Probabilidade': previsoes[0],
+                    'Confiança (%)': previsoes[0] * 100
+                })
+                resultados = resultados.sort_values('Probabilidade', ascending=False)
+                
+                # Gráfico de barras
+                fig, ax = plt.subplots(figsize=(10, 6))
+                colors = ['#667eea' if i == classe_prevista else '#cccccc' 
+                         for i in range(len(nomes_classes))]
+                
+                bars = ax.barh(
+                    resultados['Classe'],
+                    resultados['Probabilidade'],
+                    color=[colors[nomes_classes.index(nome.split()[-1])] for nome in resultados['Classe']]
+                )
+                
+                ax.set_xlabel('Probabilidade', fontsize=12)
+                ax.set_title('Distribuição de Probabilidades', fontsize=14, fontweight='bold')
+                ax.set_xlim(0, 1)
+                
+                # Adicionar valores nas barras
+                for bar in bars:
+                    width = bar.get_width()
+                    ax.text(width, bar.get_y() + bar.get_height()/2, 
+                           f'{width:.1%}',
+                           ha='left', va='center', fontsize=9, 
+                           bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
+                
+                plt.tight_layout()
+                st.pyplot(fig)
+                
+                # Tabela detalhada
+                with st.expander("📋 Ver Tabela Detalhada"):
+                    st.dataframe(
+                        resultados.style.format({
+                            'Probabilidade': '{:.4f}',
+                            'Confiança (%)': '{:.2f}%'
+                        }).background_gradient(subset=['Probabilidade'], cmap='Blues'),
+                        use_container_width=True
+                    )
+                
+                # Interpretação
+                with st.expander("💡 Como Interpretar o Resultado"):
+                    st.markdown(f"""
+                    ### Análise da Predição:
+                    
+                    - **Classe Prevista**: {emoji_classe} **{nome_classe.upper()}**
+                    - **Confiança**: {confianca:.1%}
+                    
+                    #### O que significa a confiança?
+                    
+                    A confiança indica o quão "certo" o modelo está sobre sua predição:
+                    
+                    - **> 90%**: 🟢 Muito confiante - O modelo está muito seguro da classificação
+                    - **70-90%**: 🟡 Confiante - Boa certeza, mas com alguma margem de dúvida
+                    - **50-70%**: 🟠 Moderado - O modelo tem dúvidas significativas
+                    - **< 50%**: 🔴 Baixa confiança - O modelo está muito incerto
+                    
+                    #### Por que o modelo pode errar?
+                    
+                    - Imagem muito diferente das do dataset de treino
+                    - Objeto muito pequeno ou distante
+                    - Ângulo ou iluminação incomum
+                    - Múltiplos objetos na imagem
+                    - Qualidade da imagem (blur, pixelização)
+                    """)
+
+# Footer
+st.markdown("---")
+st.markdown("""
+<div style="text-align: center; color: #666; padding: 20px;">
+    <p><strong>🎓 Projeto Educacional - Deep Learning com TensorFlow</strong></p>
+    <p>Desenvolvido para fins de aprendizado e demonstração</p>
+    <p style="font-size: 0.8em;">Dataset: CIFAR-10 | Framework: TensorFlow/Keras | Interface: Streamlit</p>
+</div>
+""", unsafe_allow_html=True)
+
+# Inicializar session state
+if 'dados_carregados' not in st.session_state:
+    st.session_state.dados_carregados = False
+if 'modelo_criado' not in st.session_state:
+    st.session_state.modelo_criado = False
+if 'modelo_treinado' not in st.session_state:
+    st.session_state.modelo_treinado = False