def tratar_dados(data_treino, data_teste, teste):
tratamentoDados(data_treino.copy(), "OHE")
tratamentoDados(data_treino.copy(), "tfidf")
# Carregar os dados tratados
data_treino = pickles.carregarPickle("data")
label_treino = pickles.carregarPickle("label")
tfidf_treino = pickles.carregarPickle("tfidf")
# Retirando naturezas com numero de empenhos menor que X depois da limpesa
label_treino, index_label_x_empenhos = tratar_label.label_elemento(
label_treino["natureza_despesa_cod"], 2)
label_treino = pd.DataFrame(label_treino)["natureza_despesa_cod"]
data_treino.drop(index_label_x_empenhos, inplace=True, axis=0)
data_treino.reset_index(drop=True, inplace=True)
tfidf_treino.drop(index_label_x_empenhos, inplace=True, axis=0)
tfidf_treino.reset_index(drop=True, inplace=True)
del index_label_x_empenhos
# Tamanhos dos dados de treino tratados
print("OHE_treino", data_treino.shape)
print("TF-IDF_treino", tfidf_treino.shape)
visao_dupla_treino = csr_matrix(
sparse.hstack((csr_matrix(data_treino), csr_matrix(tfidf_treino))))
print("Visao dupla, dados combinados do treino", visao_dupla_treino.shape)
if (teste):
# Aplicar o tratamento no teste
tfidf_teste, label_teste = tratarDados(data_teste.copy(), 'tfidf')
data_teste, label_teste = tratarDados(data_teste.copy(), 'OHE')
# Retirando naturezas com numero de empenhos menor que X depois da limpesa
label_teste, index_label_x_empenhos = tratar_label.label_elemento(
label_teste["natureza_despesa_cod"], 2)
label_teste = pd.DataFrame(label_teste)["natureza_despesa_cod"]
data_teste.drop(index_label_x_empenhos, inplace=True, axis=0)
data_teste.reset_index(drop=True, inplace=True)
tfidf_teste.drop(index_label_x_empenhos, inplace=True, axis=0)
tfidf_teste.reset_index(drop=True, inplace=True)
# Tamanhos dos dados de treino tratados
print("OHE_teste", data_teste.shape)
print("TF-IDF_teste", tfidf_teste.shape)
visao_dupla_teste = csr_matrix(
sparse.hstack((csr_matrix(data_teste), csr_matrix(tfidf_teste))))
print("Visao dupla, dados combinados do testes",
visao_dupla_teste.shape)
return data_treino, label_treino, data_teste, label_teste, tfidf_treino, tfidf_teste, visao_dupla_treino, visao_dupla_teste
else:
return data_treino, label_treino, tfidf_treino, visao_dupla_treino
data = pd.read_excel("dados_analisados.xlsx")
print(data.shape)
label = data["ANÁLISE"]
data.drop("ANÁLISE", axis=1, inplace=True)
data_treino, data_teste, label_treino, label_teste = train_test_split(
data, label, test_size=0.1, stratify=label, random_state=10)
data_treino.reset_index(drop=True, inplace=True)
data_teste.reset_index(drop=True, inplace=True)
label_treino.reset_index(drop=True, inplace=True)
label_teste.reset_index(drop=True, inplace=True)
del data, label
# Tratando os dados de treino
tratamentoDados(data_treino.copy(), 'tfidf')
tratamentoDados(data_treino.copy(), 'Modelo 2')
data_treino = pickles.carregarPickle("data")
label_treino = pickles.carregarPickle("label")
tfidf_treino = pickles.carregarPickle("tfidf")
data_treino = sparse.hstack(
(csr_matrix(data_treino), csr_matrix(tfidf_treino)))
del tfidf_treino
print("Treino: ", data_treino.shape)
# Aplicando o tratamento nos dados de teste
data_teste, label_teste = tratarDados(data_teste, "Modelo 2")
print("Teste: ", data_teste.shape)
# Modelo
valor_c = 1.3
modelo = SVC(kernel="linear", random_state=0, C=valor_c)
modelo.fit(data_treino, label_treino.values.ravel())
y_predito = modelo.predict(data_teste)
micro = f1_score(label_teste, y_predito, average='micro')
def tratarDados(data, opcao = "visao dupla"):
# Trata o nome das colunas para trabalhar melhor com os dados
data.columns = [c.lower().replace(' ', '_') for c in data.columns]
data.columns = [tratar_texto.removerCaracteresEspeciais(c)for c in data.columns]
data.columns = [tratar_texto.tratarnomecolunas(c)for c in data.columns]
identificador_empenho = pd.DataFrame(data['empenho_sequencial_empenho'])
pickles.criarPickle(identificador_empenho,"modelos_tratamentos/identificador_empenho")
# Deleta colunas que atraves de analise foram identificadas como nao uteis
data = data.drop(['exercicio_do_orcamento_ano','classificacao_orcamentaria_descricao',
'natureza_despesa_nome',
'valor_estorno_anulacao_empenho','valor_anulacao_cancelamento_empenho',
'fonte_recurso_cod','elemento_despesa','grupo_despesa',
'empenho_sequencial_empenho'], axis='columns')
# rotulo
label = data['natureza_despesa_cod']
label = pd.DataFrame(label)
if(opcao == "Modelo 2"):
opcao = "OHE"
else:
data = data.drop('natureza_despesa_cod',axis = 1)
# tfidf
textoTratado = tratar_texto.cleanTextData(data["empenho_historico"])
# Função que gera o TF-IDF do texto tratado
with open('pickles/modelos_tratamentos/tfidf_modelo'+'.pk', 'rb') as pickle_file:
tfidf_modelo = pickle.load(pickle_file)
tfidf = pd.DataFrame.sparse.from_spmatrix(tfidf_modelo.transform(textoTratado))
del textoTratado
data = data.drop('empenho_historico',axis = 1)
# Tratamento dos dados
data = tratamento_especifico(data.copy())
# Tratando o beneficiario nome
nome = [""]*data.shape[0]
for i in range(data.shape[0]):
if(data['pessoa_juridica'].iloc[i]):
nome[i] = data["beneficiario_nome"].iloc[i]
else:
nome[i] = "pessoafisica"
data["beneficiario_nome"] = nome
# Tratando o campo beneficiario nome como texto livre e fazendo TFIDF
texto_beneficiario = tratar_texto.cleanTextData(data["beneficiario_nome"])
with open('pickles/modelos_tratamentos/tfidf_beneficiario'+'.pk', 'rb') as pickle_file:
tfidf_beneficiario = pickle.load(pickle_file)
data_cv = tfidf_beneficiario.transform(texto_beneficiario)
tfidf_beneficiario = pd.DataFrame.sparse.from_spmatrix(data_cv, columns = tfidf_beneficiario.get_feature_names())
data = data.drop("beneficiario_nome", axis='columns')
pickles.criarPickle(tfidf_beneficiario,"dados_tfidf_beneficiario")
# Normalizando colunas numéricas
colunas = data.columns
for col in colunas:
if(data[col].dtype != "O"):
with open('pickles/modelos_tratamentos/'+"normalization_"+col+'.pk', 'rb') as pickle_file:
min_max_scaler = pickle.load(pickle_file)
data[col] = pd.DataFrame(min_max_scaler.transform(data[col].values.reshape(-1,1)))
# OHE
if(opcao == "OHE"):
data = one_hot_encoding.aplyOHE(data)
tfidf_beneficiario = pickles.carregarPickle("dados_tfidf_beneficiario")
data = pd.concat([data, tfidf_beneficiario], axis = 1)
return data, label
elif(opcao == "tfidf"):
return tfidf, label
else:
data = one_hot_encoding.aplyOHE(data)
tfidf_beneficiario = pickles.carregarPickle("dados_tfidf_beneficiario")
data = pd.concat([data, tfidf_beneficiario], axis = 1)
data = sparse.hstack((csr_matrix(data),csr_matrix(tfidf) ))
data = pd.DataFrame.sparse.from_spmatrix(data)
return data, label
resultadoOHE = pd.DataFrame([])
resultadoTFIDF = pd.DataFrame([])
rotulo = pd.DataFrame([])
kf = StratifiedKFold(n_splits = 3, shuffle = True, random_state = 10)
for train_index, test_index in kf.split(data, label):
# =============================================================================
# Primeira parte
# =============================================================================
data_train, data_test = data.iloc[train_index], data.iloc[test_index]
data_train.reset_index(drop = True, inplace = True)
data_test.reset_index(drop = True, inplace = True)
# Tratando os dados de treino
tratamentoDados(data_train.copy(),'tfidf')
tratamentoDados(data_train.copy(),'OHE')
# Carregando os dados tratados
X_train = csr_matrix(pickles.carregarPickle("data"))
X_train_text = csr_matrix(pickles.carregarPickle("tfidf"))
y_train = pickles.carregarPickle("label")
# Aplicando o tratamento nos dados de teste
X_test, y_test = tratarDados(data_test.copy(),'OHE')
X_test = csr_matrix(X_test)
X_test_text, y_test = tratarDados(data_test.copy(),'tfidf')
X_test_text = csr_matrix(X_test_text)
y_test.reset_index(drop = True, inplace = True)
# Algoritmo 1
y_prob_predito = pd.DataFrame(randomforest.randomForest(X_train, X_test, y_train, y_test,"prob",1020))
y_prob_predito.index = test_index
resultadoOHE = pd.concat([resultadoOHE,y_prob_predito],axis=0)
# =============================================================================
# Segunda parte
# =============================================================================
data, data_teste, label, label_teste = train_test_split(data,
label,
test_size=0.3,
stratify=label,
random_state=10)
print("Tamanho dos dados de treino", data.shape)
print("Tamanho dos dados de teste", data_teste.shape)
# Tratando os documentos de treino e salvando os modelos para serem aplicados no teste
data.reset_index(drop=True, inplace=True)
data_teste.reset_index(drop=True, inplace=True)
label.reset_index(drop=True, inplace=True)
label_teste.reset_index(drop=True, inplace=True)
tratamentoDados(data.copy(), "tfidf")
tratamentoDados(data.copy(), "OHE")
# Carregar os dados tratados
data = pickles.carregarPickle("data")
label = pickles.carregarPickle("label")
label.reset_index(drop=True, inplace=True)
tfidf = pickles.carregarPickle("tfidf")
data = sparse.hstack((csr_matrix(data), csr_matrix(tfidf)))
#data = pd.DataFrame.sparse.from_spmatrix(data)
# Tratando os dados de teste
data_teste, label_teste = tratarDados(data_teste, "visao dupla")
# =============================================================================
# RF
# =============================================================================
modelo = RandomForestClassifier(n_jobs=-1,
random_state=10,
max_samples=int(data.shape[0] * 0.3))
scores = cross_validate(modelo,
data,
# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
from scipy import sparse
from sklearn.svm import SVC
from tratamentos import pickles
from scipy.sparse import csr_matrix
from tratarDados import tratarDados
from sklearn.metrics import f1_score
from preparacaoDados import tratamentoDados
from sklearn.ensemble import RandomForestClassifier
#def modelo_validacao(dados_tce):
# Carregando os dados validados
dados_tce = pickles.carregarPickle("dados_tce_limpos")[:1000] # 265246
dados_juliete = pd.read_excel("dados_analisados.xlsx")
dados_juliete.insert (25, "Empenho (Sequencial Empenho)(EOF).1", dados_juliete["Empenho (Sequencial Empenho)(EOF)"])
# Definindo a label como a avaliacao da validacao ( correto, incorreto, inconclusivo )
label_juliete = pd.DataFrame(tratamentoDados(dados_juliete.copy(),"dropar"))
dados_juliete.drop("ANÁLISE",axis = 1, inplace = True)
#
tratamentoDados(dados_juliete.copy(),"tfidf")
tratamentoDados(dados_juliete.copy(),"OHE")
dados_juliete = pickles.carregarPickle("data")
tfidf_juliete = pickles.carregarPickle("tfidf")
dados_juliete = sparse.hstack((csr_matrix(dados_juliete),csr_matrix(tfidf_juliete) ))
del tfidf_juliete
print(dados_juliete.shape)
# tratando os dados de teste
dados_teste, label_teste = tratarDados(dados_tce)
from scipy.sparse import csr_matrix
from modelos import supportVectorMachine
from modelos import feature_importance
from preparacaoDados import tratamentoDados
from modelos import xboosting
from modelos import xboost
from tratamentos import pickles
from modelos import sgd
from modelos import naive_bayes
from sklearn import preprocessing
#from preparacaoDados2 import tratamentoDados
from sklearn.model_selection import train_test_split
#tratamentoDados("OHE")
#tratamentoDados("tfidf")
data = pickles.carregarPickle("data")[:1000]
label = pickles.carregarPickle("label")[:1000]
tfidf = pickles.carregarPickle("tfidf")[:1000]
dados = sparse.hstack((csr_matrix(data), csr_matrix(tfidf)))
dados = pd.DataFrame.sparse.from_spmatrix(dados)
#dados = csr_matrix(dados)
del data
print(dados.shape)
#X_train, X_test, y_train, y_test = train_test_split(dados, label,test_size=0.3,stratify = label,random_state =5)
le = preprocessing.LabelEncoder()
label['natureza_despesa_cod'] = le.fit_transform(
label['natureza_despesa_cod']) #LABEL ENCODER
X_train, X_test, y_train, y_test = train_test_split(dados,
label,
test_size=0.3,
indexes = [0] * dados_validados.shape[0]
for i in range(dados_validados.shape[0]):
indexes[i] = data['Empenho (Sequencial Empenho)'][
data['Empenho (Sequencial Empenho)'] ==
dados_validados['Empenho (Sequencial Empenho)(EOF)'].
iloc[i]].index[0]
data.drop(indexes, inplace=True)
data.reset_index(drop=True, inplace=True)
del indexes
#
#data = data[:10000]
#dados_validados = dados_validados[:100]
print(data.shape)
tratamentoDados(data.copy(), 'tfidf')
tratamentoDados(data.copy(), 'OHE')
data = pickles.carregarPickle("data")
label = pickles.carregarPickle("label")
tfidf = pickles.carregarPickle("tfidf")
data = sparse.hstack((csr_matrix(data), csr_matrix(tfidf)))
del tfidf
print(data.shape)
# Separando 40% dos dados para selecao de hiperparametros
data_treino, data_teste, label_treino, label_teste = train_test_split(
data, label, test_size=0.6, stratify=label, random_state=10)
del data_teste, label_teste
label_treino.reset_index(drop=True, inplace=True)
# Acha o melhor conjunto de hiperparametros para o algoritmo
modelo = SVC(kernel="linear", random_state=0)
hiperparametros = {'C': [0.1, 1, 10, 100]}
espalhamento = 3
melhor_c = refinamento_hiperparametros(data_treino, label_treino, modelo,
# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
from scipy import sparse
from sklearn.svm import SVC
from tratamentos import pickles
from scipy.sparse import csr_matrix
from tratarDados import tratarDados
from sklearn.metrics import f1_score
from preparacaoDados import tratamentoDados
from sklearn.ensemble import RandomForestClassifier
dados_tce = pickles.carregarPickle("dados_tce_limpos")[:1000] # 265246
dados_juliete = pd.read_excel("dados_analisados.xlsx")
dados_juliete.insert(25, "Empenho (Sequencial Empenho)(EOF).1",
dados_juliete["Empenho (Sequencial Empenho)(EOF)"])
#deixando apenas os dados corretos e incorretos
dados_juliete = dados_juliete[dados_juliete["ANÁLISE"] != "INCONCLUSIVO"]
dados_juliete.reset_index(drop=True, inplace=True)
#dados_juliete['Natureza Despesa (Cod)(EOF)'].value_counts() #379 naturezas
tratamentoDados(dados_tce.copy(), "tfidf")
tratamentoDados(dados_tce.copy(), "OHE")
dados_tce = pickles.carregarPickle("data")
label = pickles.carregarPickle("label")
tfidf = pickles.carregarPickle("tfidf")
dados_tce = sparse.hstack((csr_matrix(dados_tce), csr_matrix(tfidf)))
del tfidf
print(dados_tce.shape)
# retirando as classes que nao estao no treino
naturezas_juliete = pd.DataFrame(dados_juliete['Natureza Despesa (Cod)(EOF)'])
def tratamentoDados(data, escolha):
# Trata o nome das colunas para trabalhar melhor com os dados
data.columns = [c.lower().replace(' ', '_') for c in data.columns]
data.columns = [
tratar_texto.removerCaracteresEspeciais(c) for c in data.columns
]
data.columns = [tratar_texto.tratarnomecolunas(c) for c in data.columns]
data = filtro(data.copy())
# Deleta colunas que atraves de analise foram identificadas como nao uteis
data = data.drop([
'exercicio_do_orcamento_ano', 'classificacao_orcamentaria_descricao',
'natureza_despesa_nome', 'valor_estorno_anulacao_empenho',
'valor_anulacao_cancelamento_empenho', 'fonte_recurso_cod',
'elemento_despesa', 'grupo_despesa', 'empenho_sequencial_empenho'
],
axis='columns')
# Funcao que separa o rotulo do dataset e retorna as linhas com as naturezas de despesa que so aparecem em 1 empenho
label, linhas_label_unica = tratar_label.tratarLabel(data)
label = pd.DataFrame(label)
# Excluindo as naturezas de despesas que so tem 1 empenho do dataset
data = data.drop(linhas_label_unica, axis=0)
data.reset_index(drop=True, inplace=True)
del linhas_label_unica
if (escolha == "dropar"):
return data["analise"]
if (escolha == "tfidf"):
# Funcao que limpa o texto retira stopwords acentos pontuacao etc.
textoTratado = tratar_texto.cleanTextData(data["empenho_historico"])
# Função que gera o TF-IDF do texto tratado
tfidf = tratar_texto.calculaTFIDF(textoTratado)
del textoTratado
pickles.criarPickle(tfidf, 'tfidf')
return 0
# Tratamento dos dados
data = tratamento_especifico(data.copy())
# Tratando o beneficiario nome
nome = [""] * data.shape[0]
for i in range(data.shape[0]):
if (data['pessoa_juridica'].iloc[i]):
nome[i] = data["beneficiario_nome"].iloc[i]
else:
nome[i] = "pessoafisica"
data["beneficiario_nome"] = nome
# Tratando o campo beneficiario nome como texto livre e fazendo TFIDF
texto_beneficiario = tratar_texto.cleanTextData(data["beneficiario_nome"])
cv = TfidfVectorizer(dtype=np.float32)
data_cv = cv.fit(texto_beneficiario)
with open('pickles/modelos_tratamentos/tfidf_beneficiario.pk',
'wb') as fin:
pickle.dump(cv, fin)
data_cv = cv.transform(texto_beneficiario)
tfidf_beneficiario = pd.DataFrame.sparse.from_spmatrix(
data_cv, columns=cv.get_feature_names())
data = data.drop("beneficiario_nome", axis='columns')
pickles.criarPickle(tfidf_beneficiario, "dados_tfidf_beneficiario")
# Normalizando colunas numéricas
min_max_scaler = preprocessing.MinMaxScaler()
colunas = data.columns
for col in colunas:
if (data[col].dtype != "O"):
min_max_scaler.fit(data[col].values.reshape(-1, 1))
with open(
'pickles/modelos_tratamentos/' + "normalization_" + col +
'.pk', 'wb') as fin:
pickle.dump(min_max_scaler, fin)
data[col] = pd.DataFrame(
min_max_scaler.transform(data[col].values.reshape(-1, 1)))
# Excluindo as colunas que ja foram tratadas
if (escolha == "Modelo 2"):
data = data.drop(['empenho_historico'], axis='columns')
escolha = "OHE"
else:
data = data.drop(['empenho_historico', 'natureza_despesa_cod'],
axis='columns')
if (escolha == "OHE"):
# Aplicando a estrategia One Hot Encoding
data = one_hot_encoding.oneHotEncoding(data)
tfidf_beneficiario = pickles.carregarPickle("dados_tfidf_beneficiario")
data = pd.concat([data, tfidf_beneficiario], axis=1)
pickles.criarPickle(data, 'data')
pickles.criarPickle(label, 'label')
else:
return None