Update src/streamlit_app.py

src/streamlit_app.py

@@ -18,16 +18,13 @@ import numpy as np
 import io
 from sklearn.feature_selection import RFE
 from sklearn.linear_model import LogisticRegression
+from sklearn.inspection import permutation_importance  # Importa Permutation Importance
 
 # Configuração da página do Streamlit
 st.set_page_config(layout="wide", page_title="Previsão de Reclamações de Clientes")
 
-st.markdown("""
-<div style='background-color: #f0f2f6; padding: 10px; border-radius: 8px; margin-bottom: 15px;'>
-    <b>Autor:</b> Vinicius Salgueiro Costa &nbsp;&nbsp; <b>Matrícula:</b> 180028880
-</div>
-""", unsafe_allow_html=True)
-
+st.markdown("""<div style='background-color: #f0f2f6; padding: 10px; border-radius: 8px; margin-bottom: 15px;'>
+    <b>Autor:</b> Vinicius Salgueiro Costa &nbsp;&nbsp; <b>Matrícula:</b> 180028880</div>""", unsafe_allow_html=True)
 st.title("📊 Previsão de Reclamações de Clientes com Modelos Supervisionados")
 st.markdown(
     "Este dashboard tem como objetivo identificar clientes com maior probabilidade de terem feito uma reclamação nos últimos 2 anos, utilizando modelos de Machine Learning.")
@@ -99,10 +96,9 @@ def train_and_evaluate_models(X_train_raw, X_test_raw, y_train, y_test, _scaler,
 
     results = {}
 
-    # --- NOVO: Se for uma chamada inicial, apenas retorna as chaves sem tentar treinar ---
+    # Se for uma chamada inicial, apenas retorna as chaves sem tentar treinar
     if st.session_state.get('is_initial_call', False):
         return {name: {} for name in models.keys()}
-    # --- FIM NOVO ---
 
     # Check if y_train has at least two classes before attempting to train (real training calls)
     if len(np.unique(y_train)) < 2:
@@ -177,8 +173,6 @@ def train_and_evaluate_models(X_train_raw, X_test_raw, y_train, y_test, _scaler,
                 "y_prob": y_prob
             }
         except Exception as e:
-            # Captura erros de treinamento, mas não os exibe para o usuário final durante a seleção inicial
-            # O warning será exibido APENAS se o treinamento real for solicitado (nos botões "Treinar" ou "Analisar")
             results[name] = {
                 "Model": None, "Accuracy": 0, "Precision": 0, "Recall": 0, "F1-score": 0,
                 "AUC": 0.5, "Confusion Matrix": np.array([[0, 0], [0, 0]]), "FPR": [0, 1], "TPR": [0, 1],
@@ -261,7 +255,7 @@ tab1, tab2, tab3, tab4, tab5 = st.tabs([
 ])
 
 with tab1:
-    st.header("Visão Geral dos Dados")
+    st.header("1. Visão Geral dos Dados")
     st.subheader("Primeiras 5 Linhas do Dataset")
     st.dataframe(df.head())
 
@@ -275,43 +269,64 @@ with tab1:
     st.text(s)
 
     # NOVO: Análise de valores ausentes
-    st.subheader("Valores Ausentes por Coluna")
+    st.subheader("Valores Ausentes por Coluna (Dataset Original)")
     missing = df.isnull().sum()
-    missing = missing[missing > 0]
+    missing = missing[missing > 0].sort_values(ascending=False)
     if not missing.empty:
         st.dataframe(missing.to_frame('Nulos'))
+        st.info("Valores ausentes foram tratados durante o pré-processamento.")
     else:
         st.info("Não há valores ausentes no dataset original.")
 
     # NOVO: Distribuição de variáveis numéricas
     num_cols = df_processed.select_dtypes(include=np.number).columns.tolist()
+    # Remover 'Complain' da lista de colunas numéricas para histograma, pois é o alvo
+    if 'Complain' in num_cols:
+        num_cols.remove('Complain')
+
     if num_cols:
-        st.subheader("Distribuição de Variáveis Numéricas")
+        st.subheader("Distribuição de Variáveis Numéricas (Após Pré-processamento)")
         selected_num = st.selectbox("Escolha uma variável numérica para visualizar:", num_cols, key="num_hist")
         fig, ax = plt.subplots()
         sns.histplot(df_processed[selected_num], kde=True, ax=ax)
         ax.set_title(f"Distribuição de {selected_num}")
+        ax.set_xlabel(selected_num)
+        ax.set_ylabel("Frequência")
         st.pyplot(fig)
 
-    # NOVO: Distribuição de variáveis categóricas
-    cat_cols = [col for col in df.columns if df[col].dtype == 'object']
-    if cat_cols:
-        st.subheader("Distribuição de Variáveis Categóricas")
-        selected_cat = st.selectbox("Escolha uma variável categórica para visualizar:", cat_cols, key="cat_bar")
+    # NOVO: Distribuição de variáveis categóricas (original para visualização)
+    # Pegamos as colunas originais antes do get_dummies para visualização
+    original_cat_cols = ['Education', 'Marital_Status']
+    # Filtra as colunas que realmente existem no df original
+    original_cat_cols = [col for col in original_cat_cols if col in df.columns]
+
+    if original_cat_cols:
+        st.subheader("Distribuição de Variáveis Categóricas (Dataset Original)")
+        selected_cat = st.selectbox("Escolha uma variável categórica para visualizar:", original_cat_cols,
+                                    key="cat_bar")
         fig, ax = plt.subplots()
-        df[selected_cat].value_counts().plot(kind='bar', ax=ax)
+        sns.countplot(x=df[selected_cat], ax=ax, palette='viridis')
         ax.set_title(f"Distribuição de {selected_cat}")
+        ax.set_xlabel(selected_cat)
+        ax.set_ylabel("Contagem")
+        plt.xticks(rotation=45, ha='right')
         st.pyplot(fig)
 
     # NOVO: Mapa de calor de correlação
-    st.subheader("Mapa de Calor das Correlações (variáveis numéricas)")
-    fig, ax = plt.subplots(figsize=(8, 5))
-    sns.heatmap(df_processed[num_cols].corr(), cmap='coolwarm', ax=ax, annot=False)
-    st.pyplot(fig)
+    st.subheader("Mapa de Calor das Correlações (Variáveis Numéricas Processadas)")
+    if num_cols:  # Garante que ainda há colunas numéricas após remoção de 'Complain'
+        fig, ax = plt.subplots(figsize=(12, 10))
+        corr_matrix = df_processed[num_cols].corr()
+        mask = np.triu(np.ones_like(corr_matrix, dtype=bool))  # Para não repetir a matriz
+        sns.heatmap(corr_matrix, cmap='coolwarm', annot=False, fmt=".2f", linewidths=.5, ax=ax, mask=mask)
+        ax.set_title('Mapa de Calor de Correlações')
+        st.pyplot(fig)
+    else:
+        st.info("Não há colunas numéricas suficientes para gerar o mapa de calor de correlação.")
 
     st.subheader("Distribuição da Variável Alvo ('Complain') Original")
     fig, ax = plt.subplots(figsize=(6, 4))
-    sns.countplot(x=y, ax=ax)
+    sns.countplot(x=y, ax=ax, palette='pastel')
     ax.set_title("Distribuição Original da Variável 'Complain'")
     ax.set_xlabel("Reclamou (0: Não, 1: Sim)")
     ax.set_ylabel("Contagem")
@@ -320,12 +335,18 @@ with tab1:
     st.warning("Observe o desbalanceamento da classe 'Complain' (poucas reclamações).")
 
     st.subheader("Comparação de Variáveis com a Variável Alvo (Complain)")
-    selected_bi = st.selectbox("Escolha uma variável para comparar com 'Complain':", num_cols)
-    fig, ax = plt.subplots()
-    sns.boxplot(x=df_processed['Complain'], y=df_processed[selected_bi], ax=ax)
-    st.pyplot(fig)
+    if num_cols:
+        selected_bi = st.selectbox("Escolha uma variável para comparar com 'Complain':", num_cols, key="bivariate_plot")
+        fig, ax = plt.subplots(figsize=(8, 6))
+        sns.boxplot(x=df_processed['Complain'], y=df_processed[selected_bi], ax=ax, palette='coolwarm')
+        ax.set_title(f"Distribuição de {selected_bi} por Classe de Reclamação")
+        ax.set_xlabel("Reclamou (0: Não, 1: Sim)")
+        ax.set_ylabel(selected_bi)
+        st.pyplot(fig)
+    else:
+        st.info("Não há colunas numéricas para comparação bivariada.")
 
-    st.subheader("Resumo Estatístico Customizado")
+    st.subheader("Resumo Estatístico Customizado (Dataset Processado)")
     st.dataframe(df_processed.describe(percentiles=[.01, .05, .25, .5, .75, .95, .99]).T)
 
 with tab2:
@@ -341,22 +362,23 @@ with tab2:
         smote = SMOTE(random_state=42)
         try:
             if len(np.unique(y_display)) < 2:
-                st.error("SMOTE não pode ser aplicado: A variável alvo contém apenas uma classe.")
+                st.error(
+                    "SMOTE não pode ser aplicado: A variável alvo contém apenas uma classe. Isso geralmente ocorre em datasets muito pequenos ou após uma filtragem intensa.")
                 X_res, y_res = X_display, y_display
             else:
                 X_res, y_res = smote.fit_resample(X_display, y_display)
                 st.success("Dados balanceados com sucesso!")
-                st.write(f"'Complain' variable distribution after SMOTE balancing: {Counter(y_res)}")
+                st.write(f"**Distribuição da variável 'Complain' depois do balanceamento com SMOTE:** {Counter(y_res)}")
 
                 fig, ax = plt.subplots(figsize=(6, 4))
-                sns.countplot(x=y_res, ax=ax)
+                sns.countplot(x=y_res, ax=ax, palette='pastel')
                 ax.set_title("Distribuição da Variável 'Complain' Após SMOTE")
                 ax.set_xlabel("Reclamou (0: Não, 1: Sim)")
                 ax.set_ylabel("Contagem")
                 st.pyplot(fig)
         except Exception as e:
             st.error(
-                f"Erro ao aplicar SMOTE: {e}. Isso pode acontecer se houver poucas amostras na classe minoritária ou muitas features.")
+                f"Erro ao aplicar SMOTE: {e}. Isso pode acontecer se houver poucas amostras na classe minoritária ou muitas features. Os dados não foram balanceados.")
             X_res, y_res = X_display, y_display
     else:
         st.info("SMOTE desabilitado. O balanceamento não será aplicado.")
@@ -376,16 +398,18 @@ with tab2:
                 "Não foi possível usar `stratify` no `train_test_split` pois o alvo tem apenas uma classe após o processamento. Dividindo sem estratificação.")
             X_train, X_test, y_train, y_test = train_test_split(X_res, y_res, test_size=test_size, random_state=42)
 
-    st.write(f"**Shape dos dados de treino:** {X_train.shape}")
-    st.write(f"**Shape dos dados de teste:** {X_test.shape}")
-    st.write(f"**Shape y_train:** {y_train.shape}")
-    st.write(f"**Shape y_test:** {y_test.shape}")
-    st.write(f"**Shape do DataFrame (após pré-processamento):** {df_processed.shape}")
-    st.write(f"**Tipos das colunas (após pré-processamento):**")
+    st.markdown("---")
+    st.subheader("Status dos Dados de Treino e Teste")
+    st.write(f"**Shape dos dados de treino (X_train):** {X_train.shape}")
+    st.write(f"**Shape dos dados de teste (X_test):** {X_test.shape}")
+    st.write(f"**Shape dos rótulos de treino (y_train):** {y_train.shape}")
+    st.write(f"**Shape dos rótulos de teste (y_test):** {y_test.shape}")
+    st.write(f"**Shape do DataFrame completo (após pré-processamento e antes do split):** {df_processed.shape}")
+    st.write(f"**Tipos de Dados das Colunas (após pré-processamento):**")
     st.dataframe(df_processed.dtypes.astype(str).reset_index().rename(columns={'index': 'Coluna', 0: 'Tipo de Dado'}))
-    st.write(f"**Primeiras 5 linhas (após pré-processamento):**")
+    st.write(f"**Primeiras 5 linhas do DataFrame (após pré-processamento):**")
     st.dataframe(df_processed.head())
-    st.write(f"**Classes em y_train:** {np.unique(y_train)}")
+    st.write(f"**Classes únicas em y_train:** {np.unique(y_train)}")
 
     if X_train.empty or y_train.empty:
         st.error("Os dados de treino estão vazios! Verifique o carregamento ou pré-processamento dos dados.")
@@ -449,7 +473,6 @@ with tab4:
         with st.spinner(f"Analisando {model_choice}..."):
             selected_model_results = train_and_evaluate_models(X_train, X_test, y_train, y_test, StandardScaler(),
                                                                model_selected=model_choice)
-
             if model_choice not in selected_model_results or selected_model_results[model_choice]['Model'] is None:
                 st.error(
                     f"Não foi possível analisar o modelo {model_choice}. Ele pode ter falhado no treinamento. Erro: {selected_model_results.get(model_choice, {}).get('Error', 'Desconhecido')}")
@@ -530,43 +553,135 @@ with tab5:
                 model_instance = selected_model_results[model_choice]["Model"]
 
                 st.subheader("Importância das Variáveis")
+                st.markdown(
+                    "A importância das variáveis indica o quanto cada atributo contribui para a capacidade preditiva do modelo. Entender esses fatores é crucial para a tomada de decisão estratégica.")
 
+                # Tenta obter feature_importances (para modelos de árvore)
                 if hasattr(model_instance, 'feature_importances_'):
                     feature_importances = model_instance.feature_importances_
                     feature_names = X.columns.tolist()
                     importance_df = pd.DataFrame(
                         {'Variável': feature_names, 'Importância Relativa': feature_importances})
                     importance_df = importance_df.sort_values(by='Importância Relativa', ascending=False)
+
+                    st.markdown("**Importância por Ganho de Informação / Gini (para modelos em árvore):**")
                     st.dataframe(importance_df.head(10).set_index('Variável'))
 
                     fig_imp, ax_imp = plt.subplots(figsize=(10, 6))
-                    sns.barplot(x='Importância Relativa', y='Variável', data=importance_df.head(10), ax=ax_imp)
-                    ax_imp.set_title('Top 10 Variáveis Mais Importantes')
+                    sns.barplot(x='Importância Relativa', y='Variável', data=importance_df.head(10), ax=ax_imp,
+                                palette='viridis')
+                    ax_imp.set_title('Top 10 Variáveis Mais Importantes (Feature Importance)')
+                    ax_imp.set_xlabel('Importância Relativa')
+                    ax_imp.set_ylabel('Variável')
+                    plt.tight_layout()
                     st.pyplot(fig_imp)
 
+                # Tenta obter coeficientes (para modelos lineares)
                 elif hasattr(model_instance, 'coef_'):
-                    st.info("Para modelos lineares, os coeficientes podem ser interpretados como importância.")
+                    # Para SVM, se for linear, ou Logistic Regression (se adicionado)
+                    # Certifique-se que X_train_raw é usado se o modelo não usa scaler
+                    # ou use X_train_processed se o modelo usou scaler
+
+                    # Para este dashboard, o X_train_raw tem as colunas originais (ou após RFE)
+                    # e é o que deve ser usado para mapear coeficientes
+
+                    # É crucial que o scaler usado aqui seja o mesmo que foi ajustado na função de treinamento
+                    # Reajustar o scaler para obter os coeficientes no espaço original das features,
+                    # se o modelo linear for treinado em dados escalados.
+
+                    # Vamos assumir que para SVM (que usa coef_), ele foi treinado em X_train_processed (escalado)
+                    # Para interpretar, seria ideal reverter o escalonamento ou entender os coeficientes no espaço escalado.
+                    # Para simplicidade e foco na interpretabilidade gerencial, permutation importance é mais direto aqui.
+
+                    st.markdown("**Coeficientes (para modelos lineares como SVM Linear):**")
+                    # Para simplificar, mostraremos os coeficientes, mas a interpretação direta é mais complexa com features escaladas
+                    if model_instance.coef_.ndim > 1:
+                        coefs = model_instance.coef_[0]
+                    else:
+                        coefs = model_instance.coef_
+
+                    coef_df = pd.DataFrame({'Variável': X_train.columns, 'Coeficiente': coefs})
+                    coef_df = coef_df.sort_values(by='Coeficiente', ascending=False)
+                    st.dataframe(coef_df)
+                    st.info(
+                        "Para coeficientes, o sinal indica a direção da relação (positiva/negativa) e a magnitude a força. Em modelos com dados escalados, a magnitude é relativa.")
+
+                # Importância por Permutação (geralmente aplicável a qualquer modelo)
+                # Esta é uma técnica robusta e interpretável.
+                st.markdown("---")
+                st.markdown("**Importância por Permutação (Mede o Impacto na Performance do Modelo):**")
+                st.info(
+                    "A importância por permutação embaralha uma variável e mede a queda no desempenho do modelo, indicando quão crucial ela é para as previsões. É robusta para diferentes tipos de modelos.")
+
+                # Certifica-se de que o modelo foi treinado e X_test/y_test não estão vazios
+                if model_instance and not X_test.empty and not y_test.empty:
+                    # Ajusta X_test para o modelo (escalado ou não)
+                    X_test_for_pi = StandardScaler().fit_transform(X_test) if model_choice in ["K-Nearest Neighbors",
+                                                                                               "Support Vector Machine"] else X_test
+
+                    try:
+                        perm_importance = permutation_importance(model_instance, X_test_for_pi, y_test, n_repeats=10,
+                                                                 random_state=42, n_jobs=-1)
+                        perm_df = pd.DataFrame({
+                            'Variável': X_test.columns[perm_importance.importances_mean.argsort()[::-1]],
+                            # Ordena pelo mean
+                            'Importância Média': perm_importance.importances_mean[
+                                perm_importance.importances_mean.argsort()[::-1]],
+                            'Desvio Padrão': perm_importance.importances_std[
+                                perm_importance.importances_mean.argsort()[::-1]]
+                        })
+                        st.dataframe(perm_df.head(10).set_index('Variável'))
+
+                        fig_pi, ax_pi = plt.subplots(figsize=(10, 6))
+                        sns.barplot(x='Importância Média', y='Variável', data=perm_df.head(10), ax=ax_pi,
+                                    palette='cividis')
+                        ax_pi.set_title('Top 10 Variáveis Mais Importantes (Permutation Importance)')
+                        ax_pi.set_xlabel('Importância Média (Queda na Performance)')
+                        ax_pi.set_ylabel('Variável')
+                        plt.tight_layout()
+                        st.pyplot(fig_pi)
+
+                    except Exception as e:
+                        st.warning(
+                            f"Não foi possível calcular a Importância por Permutação: {e}. Isso pode ocorrer com alguns modelos ou se os dados de teste forem muito pequenos.")
                 else:
                     st.info(
-                        "Não foi possível extrair a importância das variáveis para este tipo de modelo de forma direta.")
+                        "Dados de teste insuficientes ou modelo não treinado para calcular Importância por Permutação.")
 
-                st.subheader("Análise e Recomendações Gerenciais")
+                st.markdown("---")
+                st.subheader("Análise Estratégica e Recomendações Gerenciais")
+                st.markdown(f"""
+                Como analista de dados, sua missão é transformar os insights do modelo de **Análise de Personalidade do Cliente** em ações concretas para a empresa varejista. A capacidade de prever reclamações nos permite adotar uma abordagem proativa, em vez de reativa, melhorando a experiência do consumidor, priorizando suporte personalizado e antecipando insatisfações.
 
-                st.markdown("""
-                Com base nas variáveis mais importantes, podemos formular estratégias proativas:
+                O modelo **{model_choice}** nos forneceu as variáveis mais influentes na probabilidade de um cliente registrar uma reclamação. A partir da análise das "Importâncias de Variáveis" (seja por Ganho/Gini, Coeficientes ou Permutação), podemos identificar os **perfis de cliente de alto risco** e propor intervenções estratégicas.
+
+                **Interpretando os Fatores Chave :**
+
+                As variáveis que consistentemente aparecem no topo das listas de importância (Feature Importance e/ou Permutation Importance) são seus principais alvos. Por exemplo, se seu modelo destacar:
+
+                * **`Days_Since_Customer` (Dias Desde a Última Compra)**: Se essa variável tiver alta importância e uma correlação positiva com reclamações, indica que clientes inativos ou que não compram há muito tempo tendem a reclamar mais. Eles podem estar se sentindo negligenciados ou ter tido uma experiência negativa não resolvida.
+                * **`NumWebVisitsMonth` (Número de Visitas ao Site no Último Mês)**: Se importante e associado a reclamações, pode significar que clientes estão visitando o site com frequência, talvez buscando soluções para problemas ou informações que não encontram facilmente, levando à frustração.
+                * **`MntWines` (Gasto em Vinho)** ou outras categorias de produtos: Altos gastos em categorias específicas podem indicar clientes de alto valor. Se essa variável for importante para prever reclamações, pode sinalizar que esses clientes têm altas expectativas ou que problemas relacionados a esses produtos/serviços geram maior insatisfação.
+                * **`Kidhome` / `Teenhome` (Presença de Crianças/Adolescentes)**: Fatores demográficos podem revelar segmentos com necessidades específicas ou sensibilidades que, se não atendidas, resultam em reclamações.
+
+                **Recomendações Gerenciais Estratégicas:**
+
+                Com base nesses insights, a empresa pode adaptar suas estratégias de marketing e relacionamento, focando nos segmentos de maior risco:
 
-                **Exemplo de Cenário e Recomendação (Ajuste com base nos resultados reais das suas variáveis importantes):**
+                1.  **Priorização do Suporte Personalizado Proativo:**
+                    * Monitorar clientes que o modelo classifica com alta probabilidade de reclamação.
+                    * Para clientes com **longo tempo de inatividade** e/ou **altas visitas ao site sem conversão**, acione proativamente um contato (e-mail personalizado, ligação, ou pop-up de chat) oferecendo ajuda, coletando feedback ou reengajando com ofertas relevantes. Isso transforma uma potencial reclamação em uma oportunidade de fidelização.
 
-                Se, por exemplo, 'MntWines' (gasto com vinho), 'NumWebVisitsMonth' (visitas ao site) e 'Dt_Customer' (dias desde a última compra) forem as variáveis mais importantes:
+                2.  **Otimização da Jornada do Cliente e Conteúdo:**
+                    * Se o **número de visitas do site** for um fator chave para reclamações, investigue as páginas mais visitadas por esses clientes de alto risco. Há informações faltando? O processo de compra ou suporte é confuso? Use esses dados para otimizar a usabilidade do site e a clareza das informações.
+                    * Crie **conteúdo direcionado** para as necessidades específicas de segmentos identificados (ex: famílias com crianças/adolescentes) se `Kidhome` ou `Teenhome` forem relevantes.
 
-                * **Clientes com alto gasto em vinho (`MntWines`)** que apresentam **alta frequência de visitas ao site (`NumWebVisitsMonth`) mas baixo engajamento recente (`Dt_Customer` elevado)** podem estar enfrentando dificuldades para encontrar produtos, informações ou ter problemas não resolvidos.
+                3.  **Gestão da Satisfação para Clientes de Alto Valor:**
+                    * Para clientes que gastam muito em **categorias de produtos específicas** (como vinho), mas que têm alta propensão a reclamar, implemente um programa de "check-up" de satisfação pós-compra ou um canal de suporte VIP. A perda desses clientes tem um impacto financeiro maior.
 
-                **Recomendação Gerencial:**
+                **Exemplo de Recomendação Acionável (Ajuste com seus dados reais):**
 
-                Priorize esses clientes com **ações proativas de atendimento e retenção**. Por exemplo:
-                1.  **Suporte Proativo:** Monitore clientes com alto `NumWebVisitsMonth` que não resultam em compra ou que têm histórico de altos gastos e ofereça ajuda via chat ou contato telefônico personalizado.
-                2.  **Campanhas de Reengajamento:** Crie campanhas segmentadas para clientes com `Dt_Customer` elevado, oferecendo descontos em seus produtos preferidos (ex: vinhos) ou convidando-os a fornecer feedback sobre a experiência recente.
-                3.  **Melhoria na Experiência Online:** Analise as páginas mais visitadas por esses clientes com `NumWebVisitsMonth` alto para identificar gargalos ou informações ausentes que possam estar gerando frustração.
+                "Clientes que não realizam compras **há mais de 180 dias** e que registraram **mais de 5 visitas ao site no último mês** sem interações significativas, apresentam uma probabilidade de reclamação ** maior**. Estes clientes devem ser imediatamente incluídos em uma **campanha de 'reconexão proativa'**, por meio de comunicações como CRM ou Whatsapp oferecendo suporte personalizado para dúvidas não resolvidas e incentivos de reengajamento adaptados aos seus históricos de compra."
 
-                Ao antecipar e resolver proativamente as insatisfações, a empresa pode **melhorar a experiência do consumidor, reduzir as taxas de reclamação e aumentar a lealdade do cliente.**
+                Ao aplicar esses insights da **Análise de Personalidade do Cliente**, a empresa pode não apenas reduzir o volume de reclamações, mas também aprofundar o entendimento sobre seus clientes, construir lealdade e, em última análise, impulsionar o crescimento do negócio.
                 """)