Update app.py

app.py

@@ -26,7 +26,7 @@ Construir um modelo de Inteligência Artificial capaz de classificar imagens
 considerando 10 categorias:
 - ✈️ Airplane
 - 🚗 Automobile
-- 🐦 Bird
+- 🦅 Bird
 - 🐱 Cat
 - 🦌 Deer
 - 🐕 Dog
@@ -55,7 +55,7 @@ nomes_classes = ['airplane', 'automobile', 'bird', 'cat', 'deer',
 emojis_classes = {
     'airplane': '✈️',
     'automobile': '🚗',
-    'bird': '🐦',
+    'bird': '🦅',
     'cat': '🐱',
     'deer': '🦌',
     'dog': '🐕',
@@ -65,17 +65,29 @@ emojis_classes = {
     'truck': '🚛'
 }
 
+# Inicializar session state no início
+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
+
 # 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)
+    try:
+        (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)
+    except Exception as e:
+        st.error(f"Erro ao carregar dados: {str(e)}")
+        return None
 
 # Função para visualizar imagens
 def visualiza_imagens(images, labels, num_imagens=25):
@@ -84,72 +96,89 @@ def visualiza_imagens(images, labels, num_imagens=25):
     fig.suptitle('Exemplos do Dataset CIFAR-10', fontsize=16)
     
     for i, ax in enumerate(axes.flat):
-        if i < num_imagens:
+        if i < num_imagens and i < len(images):
             ax.imshow(images[i])
             ax.set_title(nomes_classes[labels[i][0]], fontsize=8)
             ax.axis('off')
     
     plt.tight_layout()
+    plt.close('all')  # Prevenir memory leak
     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)),
+    try:
+        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(64, (3, 3), activation='relu'),
+            layers.MaxPooling2D((2, 2)),
+            
+            # Terceiro bloco convolucional
+            layers.Conv2D(64, (3, 3), activation='relu'),
+            
+            # Camadas de classificação
+            layers.Flatten(),
+            layers.Dense(64, activation='relu'),
+            layers.Dense(10, activation='softmax')
+        ])
         
-        # Terceiro bloco convolucional
-        layers.Conv2D(64, (3, 3), activation='relu'),
-        layers.MaxPooling2D((2, 2)),
+        modelo.compile(
+            optimizer='adam',
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
         
-        # 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
+        return modelo
+    except Exception as e:
+        st.error(f"Erro ao criar modelo: {str(e)}")
+        return None
 
 # 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
+    try:
+        history = modelo.fit(
+            imagens_treino,
+            labels_treino,
+            epochs=epochs,
+            validation_data=(imagens_teste, labels_teste),
+            verbose=0,
+            batch_size=64
+        )
+        return history
+    except Exception as e:
+        st.error(f"Erro durante o treinamento: {str(e)}")
+        return None
 
 # 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
+    try:
+        imagem = Image.open(imagem_file)
+        
+        # Converte para RGB se necessário
+        if imagem.mode != 'RGB':
+            imagem = imagem.convert('RGB')
+        
+        # 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
+    except Exception as e:
+        st.error(f"Erro ao processar imagem: {str(e)}")
+        return None, None
 
 # Função para criar gráficos de treinamento
 def plotar_historico(history):
@@ -163,7 +192,7 @@ def plotar_historico(history):
     ax1.set_xlabel('Época')
     ax1.set_ylabel('Acurácia')
     ax1.legend()
-    ax1.grid(True)
+    ax1.grid(True, alpha=0.3)
     
     # Gráfico de perda
     ax2.plot(history.history['loss'], label='Treino', marker='o')
@@ -172,9 +201,10 @@ def plotar_historico(history):
     ax2.set_xlabel('Época')
     ax2.set_ylabel('Perda')
     ax2.legend()
-    ax2.grid(True)
+    ax2.grid(True, alpha=0.3)
     
     plt.tight_layout()
+    plt.close('all')  # Prevenir memory leak
     return fig
 
 # Abas principais
@@ -202,24 +232,27 @@ with tab1:
     
     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
+            resultado = carregar_dados()
             
-        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))
+            if resultado is not None:
+                (imagens_treino, labels_treino), (imagens_teste, labels_teste) = resultado
+                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):
@@ -231,6 +264,7 @@ with tab1:
             st.session_state.labels_treino
         )
         st.pyplot(fig)
+        plt.clf()
         
         # Informações detalhadas
         with st.expander("📊 Informações Detalhadas dos Dados"):
@@ -266,10 +300,11 @@ with tab2:
     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 modelo is not None:
+                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("---")
@@ -277,7 +312,6 @@ with tab2:
         
         # 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'))
@@ -297,7 +331,7 @@ with tab2:
             - Reduz dimensionalidade pela metade
             - Mantém características mais importantes
             
-            **Camada 3 - Conv2D (128 filtros, 3x3):**
+            **Camada 3 - Conv2D (64 filtros, 3x3):**
             - Segunda camada convolucional
             - Extrai características mais complexas
             
@@ -308,17 +342,14 @@ with tab2:
             - Terceira camada convolucional
             - Refinamento de características
             
-            **Camada 6 - MaxPooling2D (2x2):**
-            - Terceira redução de dimensionalidade
-            
-            **Camada 7 - Flatten:**
+            **Camada 6 - Flatten:**
             - Converte matriz em vetor
             
-            **Camada 8 - Dense (64 neurônios):**
+            **Camada 7 - Dense (64 neurônios):**
             - Camada totalmente conectada
             - Ativação ReLU
             
-            **Camada 9 - Dense (10 neurônios):**
+            **Camada 8 - Dense (10 neurônios):**
             - Camada de saída
             - Ativação Softmax (probabilidades)
             - Uma saída para cada classe
@@ -364,8 +395,8 @@ with tab3:
             epochs = st.slider(
                 "Número de Épocas",
                 min_value=1,
-                max_value=20,
-                value=10,
+                max_value=15,
+                value=5,
                 help="Número de vezes que o modelo verá todos os dados de treino"
             )
         
@@ -380,9 +411,6 @@ with tab3:
             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
@@ -396,31 +424,32 @@ with tab3:
                     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}")
+                if history is not None:
+                    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):
@@ -429,6 +458,7 @@ with tab3:
         
         fig = plotar_historico(st.session_state.history)
         st.pyplot(fig)
+        plt.clf()
         
         with st.expander("💡 Interpretação dos Gráficos"):
             st.markdown("""
@@ -449,35 +479,38 @@ with tab3:
         
         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%}")
+                try:
+                    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%}")
+                except Exception as e:
+                    st.error(f"Erro ao avaliar modelo: {str(e)}")
 
 # ==================== ABA 4: PREDIÇÃO ====================
 with tab4:
@@ -512,7 +545,7 @@ with tab4:
             with col1:
                 st.subheader("🖼️ Imagem Original")
                 imagem_original = Image.open(uploaded_file)
-                st.image(imagem_original, use_container_width=True)
+                st.image(imagem_original, use_column_width=True)
                 
                 # Informações da imagem
                 st.markdown(f"""
@@ -527,120 +560,126 @@ with tab4:
                 
                 # 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.")
+                if imagem_processada is not None:
+                    st.image(imagem_processada, use_column_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)
-                    """)
+                if imagem_array is not None:
+                    with st.spinner("Analisando imagem..."):
+                        try:
+                            # 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)
+                            plt.clf()
+                            
+                            # 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)
+                                """)
+                        except Exception as e:
+                            st.error(f"Erro ao fazer predição: {str(e)}")
 
 # Footer
 st.markdown("---")
@@ -650,12 +689,4 @@ st.markdown("""
     <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
+""", unsafe_allow_html=True)