Observação: Alguns desses códigos podem não funcionar perfeitamente. E o que você deve fazer quando isso acontecer? Ligar para o MIB? Para o Keanu Reeves? Desistir? Claro que não! Você vai corrigir o código e seguir em frente, pois é isso que acontece no dia a dia, tanto na criação do próprio código quanto na revisão do código feito por outros.
Projeto 1: Previsão de Inadimplência
Contexto
O Banco CDBr, uma instituição financeira tradicional com sede em São Paulo, enfrenta um desafio crescente: a inadimplência de empréstimos. Com um portfólio de crédito de R$ 10 bilhões, o banco observa um aumento constante da taxa de inadimplência nos últimos anos, impactando negativamente seus resultados e colocando em risco sua solidez financeira.
Problema: A inadimplência representa um custo significativo para o banco. Além das perdas diretas com a falta de pagamento dos empréstimos, o banco também arca com custos indiretos, como despesas com cobrança e processos jurídicos. A inadimplência também prejudica a reputação do banco e dificulta a captação de novos recursos.
Solução: O banco CDBr busca uma solução inovadora para reduzir a inadimplência e melhorar a qualidade de sua carteira de crédito. A implementação de um modelo de Machine Learning para prever a inadimplência de clientes surge como uma alternativa promissora. E procurando um profissional eficiente da área, ela acha sua empresa e te contrata
Objetivo: O objetivo do projeto é desenvolver um modelo de Machine Learning capaz de prever com alta acurácia a probabilidade de um cliente inadimplir com seu empréstimo. O modelo será utilizado para:
- Identificar clientes de alto risco: O banco poderá direcionar seus esforços de cobrança para os clientes com maior probabilidade de inadimplência, otimizando recursos e aumentando a eficiência da recuperação de crédito.
- Melhorar a análise de crédito: O modelo auxiliará na avaliação de novas solicitações de empréstimo, permitindo ao banco tomar decisões mais precisas sobre a concessão de crédito e reduzir o risco de inadimplência.
- Otimizar a gestão de risco: O banco poderá utilizar o modelo para monitorar sua carteira de crédito e identificar os fatores que contribuem para a inadimplência, permitindo a implementação de medidas preventivas e proativas.
Dados: O banco possui um extenso histórico de dados sobre seus clientes e operações de crédito, incluindo:
- Dados do cliente: informações pessoais, como idade, renda, profissão, histórico de crédito, etc.
- Dados do empréstimo: valor, prazo, taxa de juros, tipo de garantia, etc.
- Histórico de pagamentos: informações sobre o comportamento de pagamento do cliente, como atrasos, inadimplências, etc.
Metodologia: O projeto utilizará técnicas de Machine Learning para construir um modelo preditivo de inadimplência. O modelo será treinado com o histórico de dados do banco e será validado com um conjunto de dados de teste.
Resultados esperados: O projeto espera alcançar os seguintes resultados:
- Redução da taxa de inadimplência: O banco espera reduzir significativamente a taxa de inadimplência de sua carteira de crédito.
- Melhoria da qualidade da carteira de crédito: O banco espera aumentar a qualidade de sua carteira de crédito, reduzindo o risco de perdas.
- Otimização da gestão de risco: O banco espera otimizar sua gestão de risco, identificando e mitigando os fatores que contribuem para a inadimplência.
Conclusão: O desenvolvimento de um modelo de Machine Learning para prever a inadimplência de clientes é uma iniciativa estratégica que pode trazer benefícios significativos para o Banco CDBr . A implementação do modelo permitirá ao banco reduzir perdas, melhorar a qualidade de sua carteira de crédito e otimizar a gestão de risco, contribuindo para a solidez financeira da instituição.
A próxima etapa é criar uma base de dados fictícia que represente os dados do cliente, dados do empréstimo e histórico de pagamentos. Vou criar um conjunto de dados de exemplo utilizando a biblioteca pandas para criar um DataFrame com colunas representando essas informações.
import pandas as pd
import numpy as np
# Definindo os tamanhos dos conjuntos de dados
n_clientes = 1000
# Gerando dados dos clientes
clientes = pd.DataFrame({
'ID Cliente': range(1, n_clientes + 1),
'Idade': np.random.randint(20, 70, size=n_clientes),
'Renda': np.random.randint(1000, 10000, size=n_clientes),
'Profissão': np.random.choice(['Empresário', 'Funcionário Público', 'Autônomo', 'Estudante', 'Outros'], size=n_clientes),
'Histórico de Crédito': np.random.choice(['Bom', 'Regular', 'Ruim'], size=n_clientes)
})
# Gerando dados dos empréstimos
emprestimos = pd.DataFrame({
'ID Cliente': np.random.randint(1, n_clientes + 1, size=n_clientes*2),
'Valor Empréstimo (R$)': np.random.randint(1000, 50000, size=n_clientes*2),
'Prazo (meses)': np.random.randint(12, 60, size=n_clientes*2),
'Taxa de Juros': np.random.uniform(0.05, 0.2, size=n_clientes*2),
'Tipo de Garantia': np.random.choice(['Veículo', 'Imóvel', 'Sem garantia'], size=n_clientes*2)
})
# Gerando histórico de pagamentos
historico_pagamentos = pd.DataFrame({
'ID Cliente': np.random.randint(1, n_clientes + 1, size=n_clientes*5),
'Status Pagamento': np.random.choice(['Em dia', 'Atrasado', 'Inadimplente'], size=n_clientes*5),
'Valor Parcela (R$)': np.random.randint(100, 5000, size=n_clientes*5)
})
# Salvar os DataFrames em arquivos CSV
clientes.to_csv('clientes.csv', index=False)
emprestimos.to_csv('emprestimos.csv', index=False)
historico_pagamentos.to_csv('historico_pagamentos.csv', index=False)
Este código criará três conjuntos de dados CSV: clientes.csv, emprestimos.csv e historico_pagamentos.csv. Cada um desses arquivos contém informações simuladas sobre os clientes, empréstimos e histórico de pagamentos, respectivamente.
Agora, com os dados criados, podemos começar a trabalhar na construção do modelo de Machine Learning para prever a inadimplência dos clientes.
Os próximos passos envolvem a preparação dos dados, a construção e treinamento do modelo de Machine Learning e a avaliação de sua performance. Vou continuar com a preparação dos dados e a construção do modelo.
Preparação dos Dados:
Primeiro, precisamos carregar os dados que geramos anteriormente e combiná-los em um único DataFrame, unindo-os por meio da chave ID Cliente. Além disso, precisaremos fazer algum pré-processamento nos dados, como a codificação de variáveis categóricas e tratamento de valores faltantes.
# Carregar os dados
clientes = pd.read_csv('clientes.csv')
emprestimos = pd.read_csv('emprestimos.csv')
historico_pagamentos = pd.read_csv('historico_pagamentos.csv')
# Merge dos dataframes
dados = clientes.merge(emprestimos, on='ID Cliente').merge(historico_pagamentos, on='ID Cliente')
# Codificação de variáveis categóricas
dados = pd.get_dummies(dados, columns=['Profissão', 'Histórico de Crédito', 'Tipo de Garantia', 'Status Pagamento'])
# Tratamento de valores faltantes
dados.fillna(0, inplace=True)
# Separar features e target
X = dados.drop(['ID Cliente', 'Status Pagamento_Inadimplente'], axis=1) # Features
y = dados['Status Pagamento_Inadimplente'] # Target
Construção e Treinamento do Modelo:
Agora que os dados estão preparados, podemos prosseguir com a construção do modelo de Machine Learning. Vou usar um classificador de RandomForest como exemplo, mas você pode experimentar outros algoritmos também.
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
# Dividir os dados em conjunto de treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Inicializar e treinar o modelo
modelo = RandomForestClassifier(n_estimators=100, random_state=42)
modelo.fit(X_train, y_train)
# Prever os resultados no conjunto de teste
y_pred = modelo.predict(X_test)
# Avaliar a acurácia do modelo
acuracia = accuracy_score(y_test, y_pred)
print("Acurácia do modelo:", acuracia)
# Outras métricas de avaliação
print(classification_report(y_test, y_pred))
Com isso, construímos e treinamos um modelo de RandomForest para prever a inadimplência dos clientes. Agora, podemos avaliar a sua performance e iterar sobre o processo de construção do modelo para melhorar seus resultados.
Disclaimer 01:
Uma acurácia de 1.0 (ou 100%) em um modelo de previsão de inadimplência é altamente improvável na maioria dos casos, especialmente em situações reais onde os dados são mais complexos e ruidosos.
Uma acurácia tão alta geralmente indica algum tipo de problema, como vazamento de dados, sobreajuste (overfitting) do modelo aos dados de treinamento, ou algum erro na implementação.
Vamos investigar mais de perto a situação para identificar o problema. Aqui estão algumas sugestões de passos para solucionar o problema:
- Verificar os Dados de Treinamento e Teste: Certifique-se de que os conjuntos de dados de treinamento e teste estão sendo divididos corretamente. Pode ser útil mostrar o tamanho dos conjuntos de treino e teste para garantir que estão equilibrados.
- Verificar os Dados de Entrada: Dê uma olhada mais detalhada nos dados de entrada. Certifique-se de que não há erros nos dados, como valores ausentes ou valores que não fazem sentido.
- Analisar as Métricas Adicionais: Além da acurácia, é importante analisar outras métricas, como precisão, recall e F1-score, especialmente em problemas de classificação desbalanceada como a previsão de inadimplência.
- Experimentar Outros Modelos: Tente treinar outros modelos de Machine Learning para ver se o problema persiste. Às vezes, diferentes algoritmos se comportam melhor em diferentes tipos de dados.
- Tratamento de Desbalanceamento: Se os dados estiverem desbalanceados (ou seja, uma classe é muito mais prevalente do que a outra), é importante considerar técnicas de tratamento de desbalanceamento, como oversampling, undersampling ou o uso de algoritmos específicos para lidar com desbalanceamento.
Vamos começar verificando as proporções das classes na variável alvo (Status Pagamento_Inadimplente) nos conjuntos de treinamento e teste. Isso nos ajudará a determinar se há um desbalanceamento significativo entre as classes.
# Verificar proporção das classes nos conjuntos de treino e teste
print("Proporção das classes no conjunto de treino:")
print(y_train.value_counts(normalize=True))
print("\\\\nProporção das classes no conjunto de teste:")
print(y_test.value_counts(normalize=True))
Se as proporções das classes estiverem desbalanceadas, podemos considerar técnicas de balanceamento de classes, como oversampling, undersampling ou o uso de pesos de classe durante o treinamento do modelo. Vamos verificar isso primeiro e, se necessário, aplicar uma técnica de balanceamento.
Além disso, vamos examinar as outras métricas de avaliação do modelo, como precisão, recall e F1-score, para ter uma compreensão mais completa do desempenho do modelo. Isso nos ajudará a identificar se o problema está relacionado ao desbalanceamento de classes ou a outros problemas de modelagem.
Disclaimer 02:
Aqui os dados estão bonitinhos, perfeitinhos. Na vida real, isso aqui vem tudo errado, então tarefas anteriores de limpeza, tratamento, modelagem, exploração e etc.. dos dados, são essenciais.
Se você quiser saber mais dessa etapa, falamos muito disso no nosso podcast, na nossa série EDA, Analise Exploratória dos dados, que começa a partir do episódio 17.
Votlando ao caso
Agora, vamos simular no caso de um novo cliente aparecer e termos que analisar se ele tem chances ou não de ser inadimplente:
# Criar dados do novo cliente
novo_cliente = pd.DataFrame({
'Idade': [35],
'Renda': [5000],
'Profissão_Empresário': [0],
'Profissão_Funcionário Público': [0],
'Profissão_Autônomo': [1],
'Profissão_Estudante': [0],
'Profissão_Outros': [0],
'Histórico de Crédito_Bom': [1],
'Histórico de Crédito_Regular': [0],
'Histórico de Crédito_Ruim': [0],
'Valor Empréstimo (R$)': [20000],
'Prazo (meses)': [36],
'Taxa de Juros': [0.15],
'Tipo de Garantia_Veículo': [0],
'Tipo de Garantia_Imóvel': [1],
'Tipo de Garantia_Sem garantia': [0],
'Status Pagamento_Atrasado': [0],
'Status Pagamento_Em dia': [1],
'Valor Parcela (R$)': [2000]
})
# Realizar a previsão de inadimplência para o novo cliente
previsao_inadimplencia = modelo.predict(novo_cliente)
# Exibir a previsão
if previsao_inadimplencia[0] == 1:
print("O modelo prevê que o novo cliente será inadimplente.")
else:
print("O modelo prevê que o novo cliente será adimplente.")
Nesse caso, vimos que ele será adimplente, não representando risco para nossa companhia, vamos ver outro caso agora
# Criar dados do novo cliente adimplente
novo_cliente_adimplente = pd.DataFrame({
'Idade': [35],
'Renda': [10000],
'Profissão_Empresário': [0],
'Profissão_Funcionário Público': [0],
'Profissão_Autônomo': [1],
'Profissão_Estudante': [0],
'Profissão_Outros': [0],
'Histórico de Crédito_Bom': [1],
'Histórico de Crédito_Regular': [0],
'Histórico de Crédito_Ruim': [0],
'Valor Empréstimo (R$)': [20000],
'Prazo (meses)': [36],
'Taxa de Juros': [0.15],
'Tipo de Garantia_Veículo': [0],
'Tipo de Garantia_Imóvel': [1],
'Tipo de Garantia_Sem garantia': [0],
'Status Pagamento_Atrasado': [0],
'Status Pagamento_Em dia': [1],
'Valor Parcela (R$)': [2000]
})
# Realizar a previsão de adimplência para o novo cliente
previsao_adimplente = modelo.predict(novo_cliente_adimplente)
# Exibir a previsão
if previsao_adimplente[0] == 1:
print("O modelo prevê que o novo cliente será inadimplente.")
else:
print("O modelo prevê que o novo cliente será adimplente.")
Nesse caso, o modelo diz que ele será adimplente, também não representando risco para nossa companhia, o que nos leva a nosso 3º disclaimer:
Disclaimer 03:
Esse modelo, para se mostrar devidamente validado, deve passar por vários testes práticos, ou seja, deve ser colocado em campo real para provar sua eficiência ou não, e isso cabe à nós avaliarmos se ele está correto ou precisa ser melhorado, ou até mesmo trocar para outro modelo mais eficiente.
Outro ponto que deve ser levado em consideração é que eu inseri dados novos que estão de acordo com a tabela que modelo usa para fazer as previsões, não do jeito que nós criamos a tabela ali atrás.
Eu fiz isso para otimizar o tempo. Você, no seu dia a dia, NÃO PODE ESQUECER, que você deve aplicar as mesmas alterações nos dados novos assim como aplicou nos dados de treino e teste, caso contrário vai estar tudo errado.
Projeto 2: Diagnóstico de Doenças com Machine Learning
Contexto: Um hospital de uma cidade está sobrecarregado com o aumento no número de pacientes com suspeita de diferentes doenças. O processo de diagnóstico manual é demorado e sujeito a erros humanos. Para lidar com esse problema, o hospital está buscando uma solução automatizada que possa ajudar os médicos a fazer um diagnóstico preciso e rápido com o auxílio de Machine Learning.
Problema: O hospital enfrenta dificuldades no diagnóstico de diferentes doenças devido à carga de trabalho elevada e à complexidade dos casos. O diagnóstico incorreto ou tardio pode resultar em tratamento inadequado ou complicações para os pacientes. Portanto, é essencial desenvolver um sistema que possa auxiliar os médicos no diagnóstico precoce e preciso das doenças.
Solução: A implementação de um modelo de Machine Learning para classificação de doenças surge como uma solução viável para auxiliar os médicos no diagnóstico. Com um conjunto adequado de dados e algoritmos de classificação, é possível construir um sistema que possa analisar os sintomas dos pacientes e sugerir possíveis doenças.
Objetivo: O objetivo do projeto é desenvolver um modelo de Machine Learning capaz de classificar corretamente as doenças com base nos sintomas apresentados pelos pacientes. O modelo será utilizado para:
- Auxiliar os médicos no diagnóstico precoce e preciso de doenças.
- Reduzir o tempo necessário para o diagnóstico, permitindo um tratamento mais rápido e eficaz.
- Melhorar a precisão do diagnóstico, minimizando os erros humanos associados ao processo manual.
Dados: O hospital possui um banco de dados contendo informações sobre os pacientes e os sintomas relatados, além dos diagnósticos finais. Os dados incluem:
- Sintomas: informações sobre os sintomas apresentados pelos pacientes.
- Diagnósticos: diagnósticos finais fornecidos pelos médicos para cada paciente.
Metodologia: O projeto utilizará técnicas de Machine Learning para construir um modelo de classificação de doenças. O modelo será treinado com o histórico de dados do hospital e será validado com um conjunto de dados de teste. Serão explorados diferentes algoritmos de classificação para determinar o mais adequado para o problema em questão.
Resultados Esperados: O projeto espera alcançar os seguintes resultados:
- Melhoria na precisão do diagnóstico de doenças.
- Redução no tempo necessário para o diagnóstico, resultando em tratamento mais rápido e eficaz.
- Auxílio aos médicos no processo de tomada de decisão, proporcionando diagnósticos mais precisos e confiáveis.
Conclusão: O desenvolvimento de um modelo de Machine Learning para diagnóstico de doenças é uma iniciativa crucial que pode trazer benefícios significativos para o hospital e seus pacientes. A implementação do modelo permitirá diagnósticos mais precisos, reduzindo erros e melhorando a qualidade do atendimento médico.
Base de Dados: Para criar as bases de dados para o projeto de diagnóstico de doenças, vamos simular conjuntos de dados de pacientes com sintomas e seus diagnósticos correspondentes. Vou gerar conjuntos de dados fictícios para representar essa situação.
import pandas as pd
import numpy as np
# Definindo os tamanhos dos conjuntos de dados
n_pacientes = 10000
# Gerando dados dos pacientes
pacientes = pd.DataFrame({
'ID Paciente': range(1, n_pacientes + 1),
'Idade': np.random.randint(18, 90, size=n_pacientes),
'Sexo': np.random.choice(['Masculino', 'Feminino'], size=n_pacientes)
})
# Gerando dados dos sintomas
sintomas = pd.DataFrame({
'ID Paciente': np.random.randint(1, n_pacientes + 1, size=n_pacientes*3),
'Febre': np.random.choice([0, 1], size=n_pacientes*3),
'Dor de Cabeça': np.random.choice([0, 1], size=n_pacientes*3),
'Dor no Corpo': np.random.choice([0, 1], size=n_pacientes*3),
'Tosse': np.random.choice([0, 1], size=n_pacientes*3),
'Dor de Garganta': np.random.choice([0, 1], size=n_pacientes*3),
'Fadiga': np.random.choice([0, 1], size=n_pacientes*3),
'Náusea': np.random.choice([0, 1], size=n_pacientes*3)
})
# Gerando dados dos diagnósticos
diagnosticos = pd.DataFrame({
'ID Paciente': range(1, n_pacientes + 1),
'Diagnóstico': np.random.choice(['Resfriado Comum', 'Gripe', 'COVID-19', 'Dengue', 'Sinusite', 'Amigdalite'], size=n_pacientes)
})
# Salvar os DataFrames em arquivos CSV
pacientes.to_csv('Downloads/pacientes.csv', index=False)
sintomas.to_csv('Downloads/sintomas.csv', index=False)
diagnosticos.to_csv('Downloads/diagnosticos.csv', index=False)
Este código criará três conjuntos de dados CSV: pacientes.csv, sintomas.csv e diagnosticos.csv. Cada um desses arquivos contém informações simuladas sobre os pacientes, seus sintomas e os diagnósticos correspondentes.
Agora que os conjuntos de dados foram criados, cabe a você dar continuidade e evoluir em conhecimento
Projeto 3: Analisar sentimento
Projeto 3: Análise de Sentimento em Comentários de Redes Sociais
Contexto: Uma empresa de mídia social deseja entender o sentimento dos usuários em relação aos seus produtos e serviços. Com milhões de comentários sendo gerados diariamente, é impossível para a equipe de social media analisar manualmente cada comentário. Portanto, a empresa está buscando uma solução automatizada baseada em Machine Learning para realizar a análise de sentimento em tempo real.
Problema: A empresa enfrenta dificuldades em compreender o sentimento dos usuários em relação aos seus produtos e serviços devido ao grande volume de dados gerados nas redes sociais. O processo manual de análise de sentimento é lento, suscetível a erros humanos e não escalável para lidar com a enorme quantidade de dados gerados diariamente.
Solução: A implementação de um modelo de Machine Learning para análise de sentimento surge como uma solução eficaz para automatizar o processo de avaliação do sentimento dos usuários em relação aos produtos e serviços da empresa. Com um modelo treinado com dados históricos de comentários, a empresa poderá classificar automaticamente o sentimento dos usuários em positivo, negativo ou neutro.
Objetivo: O objetivo do projeto é desenvolver um modelo de Machine Learning capaz de analisar o sentimento dos usuários com base nos comentários postados nas redes sociais da empresa. O modelo será utilizado para:
- Identificar tendências de sentimento em relação aos produtos e serviços da empresa.
- Monitorar a satisfação do cliente e identificar problemas ou oportunidades de melhoria.
- Automatizar o processo de análise de sentimentos, permitindo uma análise em tempo real e escalável dos dados das redes sociais.
Dados: A empresa possui um banco de dados contendo comentários de usuários postados em suas páginas nas redes sociais. Os dados incluem:
- Comentários: texto dos comentários postados pelos usuários.
- Sentimento: classificação manual do sentimento de cada comentário em positivo, negativo ou neutro.
Metodologia: O projeto utilizará técnicas de Processamento de Linguagem Natural (NLP) e Machine Learning para construir um modelo de análise de sentimento. O modelo será treinado com o histórico de dados da empresa e será validado com um conjunto de dados de teste. Serão explorados diferentes algoritmos de classificação e técnicas de pré-processamento de texto para obter o melhor desempenho possível.
Resultados Esperados: O projeto espera alcançar os seguintes resultados:
- Melhoria na compreensão do sentimento dos usuários em relação aos produtos e serviços da empresa.
- Identificação de tendências e padrões de sentimento nas redes sociais.
- Automatização do processo de análise de sentimento, permitindo uma análise em tempo real e escalável dos dados das redes sociais.
Conclusão: A implementação de um modelo de Machine Learning para análise de sentimento é uma iniciativa estratégica que pode trazer benefícios significativos para a empresa de mídia social. A capacidade de compreender o sentimento dos usuários em tempo real e em grande escala permitirá à empresa tomar decisões mais informadas e proativas em relação aos seus produtos e serviços, melhorando assim a experiência do usuário e impulsionando o sucesso da empresa.
Base de dados: Para criar bases de dados para um projeto de análise de sentimento em comentários de redes sociais, precisamos de um conjunto diversificado de comentários que abordem uma variedade de tópicos e sentimentos. Vamos criar conjuntos de dados simulados que representam diferentes tipos de comentários com nuances do mundo real.
Primeiro, vamos criar um conjunto de dados de comentários simulados. Em seguida, adicionaremos um sentimento para cada comentário, classificando-os como positivos, negativos ou neutros. Vou usar uma biblioteca Python chamada Faker para gerar comentários fictícios.
pip install faker #caso não tenha o Faker instalado
import pandas as pd
from faker import Faker
import random
# Inicializar o Faker
fake = Faker()
# Definir o tamanho do conjunto de dados
n_comentarios = 10000
# Gerar comentários simulados
comentarios = [fake.text() for _ in range(n_comentarios)]
# Gerar sentimentos para os comentários
sentimentos = ['positivo', 'negativo', 'neutro']
sentimento_comentarios = [random.choice(sentimentos) for _ in range(n_comentarios)]
# Criar DataFrame
data = {'Comentário': comentarios, 'Sentimento': sentimento_comentarios}
df = pd.DataFrame(data)
# Salvar o DataFrame em um arquivo CSV
df.to_csv('Downloads/comentarios_sentimentos.csv', index=False)
Este código criará um conjunto de dados CSV chamado comentarios_sentimentos.csv, contendo comentários simulados e seus respectivos sentimentos (positivo, negativo ou neutro).
Agora, vamos adicionar nuances ao conjunto de dados, simulando variações nos sentimentos dentro de cada categoria. Faremos isso modificando aleatoriamente os comentários para incluir palavras ou frases que possam influenciar o sentimento percebido.
# Função para adicionar nuances aos comentários
def adicionar_nuances(comentario, sentimento):
if sentimento == 'positivo':
comentario += ' Ótimo produto! Altamente recomendado.'
elif sentimento == 'negativo':
comentario += ' Não funcionou como esperado. Péssima experiência.'
else: # neutro
comentario += ' Produto ok. Nada de especial.'
return comentario
# Aplicar a função aos comentários
df['Comentário'] = df.apply(lambda row: adicionar_nuances(row['Comentário'], row['Sentimento']), axis=1)
# Salvar o DataFrame atualizado em um arquivo CSV
df.to_csv('comentarios_sentimentos_nuances.csv', index=False)
Agora, o conjunto de dados comentarios_sentimentos_nuances.csv conterá comentários com nuances adicionadas, tornando-os mais realistas e representativos do mundo real.
Esses conjuntos de dados podem ser usados para treinar e testar modelos de análise de sentimento em comentários de redes sociais.
Conclusão
Espero, de verdade, que você aprenda muito sobre essa tecnologia fascinante e como ela pode ser aplicada em diversos setores da nossa vida.
Agora que você já tem uma base sólida em Machine Learning, é hora de colocar a mão na massa e começar a criar seus próprios projetos!
Muito obrigado por assistir!
Se você gostou desse episódio, não deixe de se inscrever no nosso podcast e compartilhar com seus amigos!
Até a próxima
