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
from sklearn.model_selection import train_test_split
from tratarDados import refinamento_hiperparametros
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())
from sklearn.model_selection import train_test_split
from preparacaoDados import tratamentoDados
from scipy.sparse import csr_matrix
from modelos import cenknn
from scipy import sparse
import pandas as pd
data, label = tratamentoDados("OHE")
tfidf = tratamentoDados("tfidf")
aux = sparse.hstack((csr_matrix(data), csr_matrix(tfidf)))
dados = pd.DataFrame.sparse.from_spmatrix(aux)
X_train, X_test, y_train, y_test = train_test_split(dados,
label,
test_size=0.3,
stratify=label,
random_state=5)
#for i in range(1,6,1):
# cenknn.cenknn(X_train, X_test, y_train, y_test,"com Cenknn", k_value = i) # numero de vizinhos
#import time
#start = time.time()
print(X_train.shape, " X_train")
print(X_test.shape, " X_test")
cenknn.cenknn(X_train, X_test, y_train, y_test, "com Cenknn",
k_value=2) # numero de vizinhos
#final = time.time()
#print(final-start)
bins = []
width = higher_bound / 100
for low in np.arange(lower_bound, higher_bound, width):
bins.append((low, low + width))
return bins
# Retorna em qual intervalo o valor esta
def find_bin(value, bins):
for i in range(0, len(bins)):
if bins[i][0] <= value < bins[i][1]:
return i
return -1
texto = tratamentoDados("texto")
dados, label = tratamentoDados("sem OHE")
# Trata os valores numericos colocando-os em intervalos e os valores categoricos limpando o texto
for col in dados.columns:
# Caso seja numerico entre
if (dados[col].dtype == "float" or dados[col].dtype != "O"):
# Se tiver apenas 1 valor
if (dados[col].value_counts().count() == 1):
dados[col] = "coluna_" + col + "_intervalo_0 "
continue
# Separa o range dos valores em 100 intervalos iguais
bins = create_bins(lower_bound=dados[col].min(),
higher_bound=dados[col].max() + 0.000001)
column = [0] * dados.shape[0]
# Verifica em qual intervalo o doc esta e coloca uma classe para ele
for i in range(dados.shape[0]):
#iniciando vetores
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)
from preparacaoDados import tratamentoDados
from matplotlib import pyplot as plt
import numpy as np
import pandas as pd
from tratamentos import tratar_texto
from wordcloud import WordCloud
data, label = tratamentoDados("OHE")
textoTratado = tratamentoDados("texto")
data.reset_index(drop=True, inplace=True)
for natureza in data['natureza_despesa_nome'].value_counts().index[43:]:
wordcloud = data['natureza_despesa_nome'].where(
data['natureza_despesa_nome'] == natureza)
wordcloud.dropna(inplace=True)
naturezas = pd.DataFrame(textoTratado).iloc[wordcloud.index]
wc_string = naturezas[0].str.cat(sep=' ')
wc = WordCloud(width=1600,
height=800,
background_color="white",
max_words=2000).generate(wc_string)
plt.ioff()
fig = plt.figure(figsize=(16, 10))
plt.imshow(wc, interpolation="bilinear")
plt.axis("off")
plt.tight_layout(pad=0)
plt.title('Natureza de despesa:' + natureza, fontsize=18)
plt.savefig("wordclouds/" + tratar_texto.remove_punctuation(natureza) +
".png",
dpi=300)
from preparacaoDados import tratamentoDados
import pandas as pd
import mlpack
data, label = tratamentoDados("sem OHE") # Carrega os dados
dados = pd.read_csv("dados_stacking.csv",
encoding="utf-8") # Carrega os dados do Stacking
# Calculando EMST
result = mlpack.emst(dados)
emst = pd.DataFrame(*result.values())
emst.to_csv('emst.csv', index=False, header=False)
# Retira o ponto do codigo do rotulo
label['natureza_despesa_cod'] = [
label['natureza_despesa_cod'].iloc[i].replace(".", "")
for i in range(data.shape[0])
]
# Convertendo os dados para o formato correto
data = dados.astype("str")
for i in range(data.shape[0]):
for j in range(data.shape[1]):
data.iloc[i].iloc[j] = "FEAT" + str(j + 1) + ":" + str(
data.iloc[i].iloc[j])
data.reset_index(drop=True, inplace=True)
dados_preparados = pd.concat([label, data], axis=1)
# Salva os dados
dados_preparados.to_csv('dados_preparados.csv',
index=False,
header=False,
data.drop(index_label_x_empenhos, inplace=True, axis=0)
data.reset_index(drop=True, inplace=True)
# Separando treino e teste
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,
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)
# =============================================================================
# MODELOS
# =============================================================================
identificador_empenho = pickles.carregarPickle("modelos_tratamentos/identificador_empenho")
from sklearn.metrics import silhouette_score
from sklearn.decomposition import IncrementalPCA
from sklearn.model_selection import train_test_split
# Meus packages
from modelos import single_value_decomposition
from preparacaoDados import tratamentoDados
from modelos import feature_importance
from modelos import gaussian_mixtures
from modelos import analise_cluster
from modelos import rocchio
from modelos import kmeans
from modelos import dbscan
# Retorna os dados tratados
data, label = tratamentoDados("OHE")
data = pd.DataFrame(data.values)
# =============================================================================
# Achar melhor eps
# =============================================================================
#min_sample = 2
#from sklearn.neighbors import NearestNeighbors
#nbrs = NearestNeighbors(n_neighbors=min_sample).fit(data)
#distances, indices = nbrs.kneighbors(data)
#distanceDec = sorted(distances[:,min_sample-1], reverse=True)
#plt.figure(figsize=(20,15))
#plt.plot(indices[:,0], distanceDec)
#plt.grid()
#plt.xticks(range(0,len(indices[:,0]),50))
##plt.yticks(np.arange(0,max(distanceDec),0.1))
#plt.show()
dados_tce = dados_tce_originais.copy()
# pega os empenhos pelo identificador
indexes_novos_dados = [0]*len(documentos_mais_90_certeza)
for j in range(len(documentos_mais_90_certeza)):
indexes_novos_dados[j] = dados_tce[dados_tce["Empenho (Sequencial Empenho)(EOF)"] == documentos_mais_90_certeza[j] ].index[0]
documentos_mais_90_certeza = dados_tce.iloc[indexes_novos_dados]
# adiciona os novos empenhos ao conjunto de dados principal
dados_juliete_originais = pd.concat([dados_juliete, documentos_mais_90_certeza], axis = 0)
dados_juliete_originais.reset_index(drop = True, inplace = True)
dados_juliete = dados_juliete_originais.copy()
# retirando os documentos ja selecionados do teste
dados_tce_originais.drop(indexes_novos_dados,axis = 0, inplace = True)
dados_tce_originais.reset_index(drop = True, inplace = True)
dados_tce = dados_tce_originais.copy()
#
tratamentoDados(dados_juliete.copy(),"tfidf")
tratamentoDados(dados_juliete.copy(),"OHE")
dados_juliete = pickles.carregarPickle("data")
label_juliete = pickles.carregarPickle("label")
tfidf_juliete = pickles.carregarPickle("tfidf")
dados_juliete = sparse.hstack((csr_matrix(dados_juliete),csr_matrix(tfidf_juliete) ))
del tfidf_juliete
print(dados_juliete.shape)
# retirando as classes que nao estao no treino
naturezas_tce = pd.DataFrame(dados_tce['Natureza Despesa (Cod)(EOF)'])
naturezas_juliete = list(label_juliete['natureza_despesa_cod'].value_counts().index)
fora_do_modelo = []
for i in range(len(naturezas_tce)):
if(naturezas_tce.iloc[i][0] not in naturezas_juliete):
fora_do_modelo.append(i)
dados_tce.drop(fora_do_modelo,inplace = True)
from gensim.scripts.glove2word2vec import glove2word2vec
from sklearn.model_selection import train_test_split
from preparacaoDados import tratamentoDados
from gensim.models import KeyedVectors
from scipy.sparse import csr_matrix
from modelos import randomforest
from scipy import sparse
import pandas as pd
import numpy as np
import re
# retorna o texto tratado e limpo
texto_tratado = tratamentoDados("texto")
data,label = tratamentoDados("OHE")
tfidf = tratamentoDados("tfidf")
# tokeniza os textos
sentences_ted = []
for sent_str in texto_tratado:
tokens = re.sub(r"[^a-z0-9]+", " ", sent_str.lower()).split()
sentences_ted.append(tokens)
del tokens,sent_str
embeddings_dict = {}
with open("glove.6B/glove_s100.txt", 'r') as f:
for line in f:
values = line.split()
word = values[0]
vector = np.asarray(values[1:], "float32")
embeddings_dict[word] = vector
del word,values,vector
#glove_file = pd.read_table('glove.6B/glove_s100.txt', sep=" ",index_col = 0)
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)'])
natureza_tce = list(label['natureza_despesa_cod'].value_counts().index)
fora_do_modelo = []
# remove naturezas que nao estao presentes nos dados de treino
for i in range(len(naturezas_juliete)):
if (naturezas_juliete.iloc[i][0] not in natureza_tce):
fora_do_modelo.append(i)
