feat: generate the filtering by manufacturer not complete

app.py

@@ -723,24 +723,114 @@ elif page == "🕵️ Análisis de Cliente":
                     # Mostrar el cliente y el fabricante seleccionados
                     st.write(f"**Cliente seleccionado:** {customer_code}")
                     st.write(f"**Fabricante seleccionado:** {fabricante_seleccionado}")
+                    
+                    # Obtener el código del fabricante seleccionado
                     codigo_fabricante_seleccionado = np.int64(nombres_proveedores[nombres_proveedores['nombre'] == fabricante_seleccionado]['codigo'].values[0])
-
-
                     st.write(f"**Código fabricante seleccionado:** {codigo_fabricante_seleccionado}")
                     
+                    # Verificar si el código está presente en el LabelEncoder y obtener su encoded
                     if codigo_fabricante_seleccionado in marca_id_mapping.classes_:
-                        # Si el código está en el LabelEncoder, hacer la transformación
                         codigo_fabricante_encoded = marca_id_mapping.transform([codigo_fabricante_seleccionado])[0]
                         st.write(f"**Código fabricante encoded (marca_id_encoded):** {codigo_fabricante_encoded}")
+                        
+                        # Filtrar datos solo para este fabricante
+                        with st.spinner("Preparando los datos..."):
+                            predict_data = pd.read_csv(f'predicts/predict_cluster_{cluster}.csv')
+                            predict_data['cliente_id'] = predict_data['cliente_id'].astype(str)
+                            customer_code_str = str(customer_code)
+                            customer_data = predict_data[(predict_data['cliente_id'] == customer_code_str) & 
+                                                        (predict_data['marca_id_encoded'] == codigo_fabricante_encoded)]
+
+                        with st.spinner("Generando predicciones de venta..."):
+                            if not customer_data.empty:
+                                # Preparar las características
+                                lag_features = [f'precio_total_lag_{lag}' for lag in range(1, 25)]
+                                features = lag_features + ['mes', 'marca_id_encoded', 'año', 'cluster_id']
+                                X_predict = customer_data[features]
+                                
+                                # Convertir las características categóricas a su dtype correspondiente
+                                categorical_features = ['mes', 'marca_id_encoded', 'cluster_id']
+                                for feature in categorical_features:
+                                    X_predict[feature] = X_predict[feature].astype('category')
+                                
+                                # Realizar la predicción
+                                y_pred = gbm.predict(X_predict, num_iteration=gbm.best_iteration)
+                                results = customer_data[['cliente_id', 'marca_id_encoded', 'fecha_mes']].copy()
+                                results['ventas_predichas'] = y_pred
+
+                                # Cargar datos reales para 2024
+                                actual_sales = df_agg_2024[(df_agg_2024['cliente_id'] == customer_code_str) & 
+                                                        (df_agg_2024['marca_id_encoded'] == codigo_fabricante_encoded)]
+                                
+                                if not actual_sales.empty:
+                                    results = results.merge(actual_sales[['cliente_id', 'marca_id_encoded', 'fecha_mes', 'precio_total']], 
+                                                            on=['cliente_id', 'marca_id_encoded', 'fecha_mes'], how='left')
+                                    results.rename(columns={'precio_total': 'ventas_reales'}, inplace=True)
+                                else:
+                                    results['ventas_reales'] = 0
+                                
+                                results['ventas_reales'].fillna(0, inplace=True)
+
+                                # Generar gráfica y métricas
+                                fecha_inicio_2023 = pd.to_datetime("2023-01-01")
+                                fecha_fin_2023 = pd.to_datetime("2023-12-31")
+                                datos_cliente_total = results.groupby('fecha_mes').agg({'ventas_reales': 'sum', 'ventas_predichas': 'sum'}).reset_index()
+
+                                # Crear la gráfica
+                                fig = go.Figure()
+                                fig.add_trace(go.Scatter(x=datos_cliente_total['fecha_mes'], y=datos_cliente_total['ventas_predichas'],
+                                                        mode='lines+markers', name='Ventas Predichas', line=dict(color='orange')))
+                                fig.add_trace(go.Scatter(x=datos_cliente_total['fecha_mes'], y=datos_cliente_total['ventas_reales'],
+                                                        mode='lines+markers', name='Ventas Reales', line=dict(color='green')))
+                                fig.update_layout(title=f"Ventas Predichas y Reales para Cliente {customer_code} y Fabricante {fabricante_seleccionado}",
+                                                xaxis_title="Fecha", yaxis_title="Ventas (€)", height=600)
+                                st.plotly_chart(fig)
+
+                                # Cálculo de métricas
+                                datos_2024 = datos_cliente_total[datos_cliente_total['fecha_mes'].dt.year == 2024]
+                                actual = datos_2024['ventas_reales']
+                                predicted = datos_2024['ventas_predichas']
+                                mae = mean_absolute_error(actual, predicted)
+                                mse = mean_squared_error(actual, predicted)
+                                rmse = np.sqrt(mse)
+                                mape = np.mean(np.abs((actual - predicted) / actual)) * 100 if not actual.empty else 0
+                                smape = np.mean(2 * np.abs(actual - predicted) / (np.abs(actual) + np.abs(predicted))) * 100 if not actual.empty else 0
+                                
+                                # Mostrar métricas
+                                st.subheader("Métricas de Predicción (2024)")
+                                col1, col2, col3, col4 = st.columns(4)
+                                col1.metric("MAE", f"{mae:.2f} €")
+                                col2.metric("MAPE", f"{mape:.2f}%")
+                                col3.metric("RMSE", f"{rmse:.2f} €")
+                                col4.metric("SMAPE", f"{smape:.2f}%")
+                            else:
+                                st.warning(f"No se encontraron datos para el cliente {customer_code} y el fabricante {fabricante_seleccionado}.")
                     else:
-                        # Si el código no se encuentra en el LabelEncoder, mostrar advertencia y los códigos disponibles
                         st.warning(f"El código de fabricante {codigo_fabricante_seleccionado} no se encuentra en el LabelEncoder.")
-                        st.write("Lista de códigos de fabricantes disponibles en el LabelEncoder:")
+
+            # else:
+            #     with st.spinner(f"Mostrando datos para el fabricante {fabricante_seleccionado}..."):
+            #         # Mostrar el cliente y el fabricante seleccionados
+            #         st.write(f"**Cliente seleccionado:** {customer_code}")
+            #         st.write(f"**Fabricante seleccionado:** {fabricante_seleccionado}")
+            #         codigo_fabricante_seleccionado = np.int64(nombres_proveedores[nombres_proveedores['nombre'] == fabricante_seleccionado]['codigo'].values[0])
+
+
+            #         st.write(f"**Código fabricante seleccionado:** {codigo_fabricante_seleccionado}")
+                    
+            #         if codigo_fabricante_seleccionado in marca_id_mapping.classes_:
+            #             # Si el código está en el LabelEncoder, hacer la transformación
+            #             codigo_fabricante_encoded = marca_id_mapping.transform([codigo_fabricante_seleccionado])[0]
+            #             st.write(f"**Código fabricante encoded (marca_id_encoded):** {codigo_fabricante_encoded}")
+            #         else:
+            #             # Si el código no se encuentra en el LabelEncoder, mostrar advertencia y los códigos disponibles
+            #             st.warning(f"El código de fabricante {codigo_fabricante_seleccionado} no se encuentra en el LabelEncoder.")
+            #             st.write("Lista de códigos de fabricantes disponibles en el LabelEncoder:")
                         
-                        # Imprimir los códigos disponibles y su tipo
-                        available_codes = marca_id_mapping.classes_
-                        st.write(f"**Códigos disponibles:** {available_codes}")
-                        st.write(f"**Tipo de los códigos disponibles:** {type(available_codes[0])}")
+            #             # Imprimir los códigos disponibles y su tipo
+            #             available_codes = marca_id_mapping.classes_
+            #             st.write(f"**Códigos disponibles:** {available_codes}")
+            #             st.write(f"**Tipo de los códigos disponibles:** {type(available_codes[0])}")