def process():
global log
begin = time.time()
# starting log
logPath = join(PATH, "queryProcessor", "query_processor.log")
Log.setLog(__name__, logPath)
log = logging.getLogger(__name__)
log.info('Processing query processo generator module...')
log.info("Reading the configuration file")
config = QueryProcessorGenerator.readConfig(
join(PATH, "queryProcessor", "pc.cfg"))
log.info("Getting all queries from xml files")
queries, meanTimeXML = QueryProcessorGenerator.get_all_queries(
config["LEIA"])
log.info('XML reading operation finished with %s of time average.' %
str(meanTimeXML))
log.info('Writing files...')
ini = time.time()
QueryProcessorGenerator.saveFiles(config, queries)
log.info('Write operation finished with %s' % str(time.time() - ini))
log.info(
'End of query processor generator module. Total of %s elapsed.' %
str(time.time() - begin))
def process():
global log
begin = time.time()
# starting log
logPath = join(PATH, "searcher", "searcher.log")
Log.setLog(__name__, logPath)
log = logging.getLogger(__name__)
log.info('Processing searcher generator module...')
log.info("Reading the configuration file")
config_mod = SearcherGenerator.readConfig(
join(PATH, "searcher", "busca.cfg"))
config_query = SearcherGenerator.readConfig(
join(PATH, "queryProcessor", "pc.cfg"))
log.info("Loading indexer file")
ini = time.time()
indexer = IndexerGenerator.getIndexer(PATH + config_mod["MODELO"])
log.info('%s records read succesfully.' % str(len(indexer)))
log.info('Load operation finished with %s' % str(time.time() - ini))
log.info("Loading query file")
ini = time.time()
queries = QueryProcessorGenerator.getQueryFile(
PATH + config_query["CONSULTAS"])
results = QueryProcessorGenerator.getQueryFile(
PATH + config_query["RESULTADOS"])
log.info('%s records read succesfully.' % str(len(queries)))
log.info('Load operation finished with %s' % str(time.time() - ini))
log.info("Calculating the cosine similarity")
ini = time.time()
cnt = 0
accumulated = 0
for query in queries.keys():
ini_y = time.time()
df = VectorModel.getCosineSimilarity(indexer, queries[query])
SearcherGenerator.saveResult(PATH + config_mod["RESULTADOS"],
query, df, results)
accumulated += time.time() - ini_y
cnt += 1
log.info(
'Method cosine similarity operation finished with %s of time average by query.'
% str(accumulated / cnt))
log.info(
'End of calculate the cosine similarity. Total of %s elapsed.' %
str(time.time() - ini))
log.info('End of searcher generator module. Total of %s elapsed.' %
str(time.time() - begin))
def main():
# starting the time of application
begin = time.time()
# starting log
logPath = join(PATH,"main.log")
Log.setLog(__name__, logPath)
log = logging.getLogger(__name__)
log.info("System started")
log.info("Reading the configuration file")
# In this cfg you can choose each module will be run
config = readConfig("main.cfg")
if config["InvertedIndexGenerator"]:
log.info("Calling inverted index generator ")
ini = time.time()
InvertedIndexGenerator.process()
log.info('End of inverted index generator. Total of %s elapsed.' % str(time.time()-ini))
if config["Indexer"]:
log.info("Calling indexer generator ")
ini = time.time()
IndexerGenerator.process()
log.info('End of indexer generator. Total of %s elapsed.' % str(time.time()-ini))
if config["QueryProcessor"]:
log.info("Calling query processor generator ")
ini = time.time()
QueryProcessorGenerator.process()
log.info('End of query processor generator. Total of %s elapsed.' % str(time.time()-ini))
if config["Searcher"]:
log.info("Calling searcher generator ")
ini = time.time()
SearcherGenerator.process()
log.info('End of searcher generator. Total of %s elapsed.' % str(time.time()-ini))
end = time.time() - begin
log.info('End of system. Total of %s elapsed.' % str(end))
def main():
# Iniciando o tempo de execucao da aplicacao
begin = time.time()
# Iniciando o log
logPath = join(PATH, "main.log")
Log.setLog(__name__, logPath)
log = logging.getLogger(__name__)
log.info("Iniciando a aplicacao")
log.info("Lendo o arquivo de configuracao")
config = readConfig("main.cfg")
if config["ProcessaAgrupamentoAreaAtuacao"]:
log.info(
"Chamando o metodo de agrupamento das areas de atuacao por osc")
ini = time.time()
ProcessaAgrupamentoAreaAtuacao.processa()
log.info(
'Fim do processo de agrupamento das areas de atuacao. Total de %s decorrido.'
% str(time.time() - ini))
if config["GeraModelo"]:
log.info(
"Chamando o processamento para geracao do modelo de classificacao")
ini = time.time()
Modelo.gera_random_forest()
log.info(
'Fim do processamento da geracao do modelo. Total de %s decorrido.'
% str(time.time() - ini))
if config["GeraClassificacao"]:
log.info("Chamando o processamento de classificacao")
ini = time.time()
Classificacao.processa()
log.info(
'Fim do processamento da classificacao. Total de %s decorrido.' %
str(time.time() - ini))
end = time.time() - begin
log.info('Fim da execucao. Total de %s decorrido.' % str(end))
def processa():
log = ''
begin = time.time()
# iniciando o log
logPath = join(PATH, "classificacao", "classificacao.log")
Log.setLog("classificacao", logPath)
log = logging.getLogger("classificacao")
log.info('Iniciando o processo de classificacao da massa')
log.info("Lendo o arquivo de configuracao")
config = readConfig(join(PATH, "classificacao", "classificacao.cfg"))
log.info("Carregando o arquivo de label encoder")
file = open(join(PATH, 'dados', 'saida', config['LABEL_ENCODER']),
'rb')
le = pickle.load(file)
file.close()
log.info("Carregando o modelo random forest")
file = open(join(PATH, 'dados', 'saida', config['MODELO']), 'rb')
rf = pickle.load(file)
file.close()
log.info("Carregando o arquivo de dados")
df = pd.read_csv(join(PATH, 'dados', 'entrada', config['MASSA_DADOS']))
resultado = {}
resultado["classificacao"] = []
log.info("Iniciando a classificacao")
for i in tqdm(df.iterrows()):
classificacao = Classificacao.busca_area(i[1], le, rf)
resultado["classificacao"].append(classificacao)
log.info("Salvando o arquivo de resultado")
file = open(join(PATH, 'dados', 'saida', 'resultado.json'), 'w')
json.dump(resultado, file, default=str)
file.close()
end = time.time() - begin
log.info('Fim do processo de classificacao. Total de %s decorrido.' %
str(end))
def processa():
log = ''
begin = time.time()
# iniciando o log
logPath = join(PATH,"modelos","modelos.log")
Log.setLog("agrupamento", logPath)
log = logging.getLogger("agrupamento")
log.info('Iniciando o processo de agrupamento das areas de atuacao')
log.info("Lendo o arquivo de configuracao")
config = readConfig(join(PATH,"modelos","modelos.cfg"))
# definindo os tipos de dados para importacao
dtype={"id_area_atuacao":object, "id_osc": int, "cd_area_atuacao": int, "cd_subarea_atuacao": object,
"ft_area_atuacao": object, "bo_oficial": object, "tx_nome_outra": object}
log.info("Importando os dados do arquivo de area de atuacao")
caminho_arquivo = join(PATH,"dados","entrada",config["AREA_ATUACAO"])
df_area_atuacao = pd.read_csv(caminho_arquivo, sep=";",
encoding='utf-8', error_bad_lines=False, dtype=dtype)
log.info("Realizando alguns tratamentos nos dados importados")
""" removendo o tipo de area de atuacao igual a 8, devido somente existir 3 registros no arquivo de area de atuacao e so 1
como chave para dados gerais: para conferencia utilizar os codigos abaixo
df_area_atuacao[(df_area_atuacao.cd_area_atuacao == 8)] df[(df.id_osc == 521832)]
df_area_atuacao.groupby('cd_area_atuacao').id_area_atuacao.count()"""
df_area_atuacao.drop(df_area_atuacao[(df_area_atuacao.cd_area_atuacao == 8)].index, inplace=True)
""" removendo deixando no df de area de atuacao, somente o codigo da area, sendo a informacao que sera utilizada
para a classificacao """
df_area_atuacao.drop(columns=["id_area_atuacao","cd_subarea_atuacao","ft_area_atuacao","bo_oficial","tx_nome_outra"]
,inplace=True)
df_area_atuacao.drop_duplicates(inplace=True)
log.info("Iniciando o agrupamento")
series_cd_area = pd.Series()
old_id_osc = 0
for id_osc in tqdm(df_area_atuacao.id_osc.sort_values()):
if old_id_osc == id_osc:
continue
else:
old_id_osc = id_osc
area = str(df_area_atuacao[df_area_atuacao.id_osc == id_osc].cd_area_atuacao.sort_values().values).replace(' ','').replace('[','').replace(']','')
s = pd.Series([area], index=[id_osc])
series_cd_area = series_cd_area.append(s, ignore_index=False)
df_cd_area = pd.DataFrame(data=series_cd_area)
df_cd_area.reset_index(inplace=True)
df_cd_area.columns = ["id_osc", "cd_area_atuacao"]
arq = open(join(PATH,'dados','saida',config["AREA_AGRUPADA"]),'wb')
pickle.dump(df_cd_area, arq)
arq.close()
end = time.time() - begin
log.info('Fim do processo de agrupamento. Total de %s decorrido.' % str(end))
def gera_random_forest():
log = ''
begin = time.time()
# iniciando o log
logPath = join(PATH,"modelos","modelos.log")
Log.setLog("gera_modelo", logPath)
log = logging.getLogger("gera_modelo")
log.info('Iniciando o processo de geracao do modelo random forest')
log.info("Lendo o arquivo de configuracao")
config = readConfig(join(PATH,"modelos","modelos.cfg"))
#------------------------------------------------------------------------------
# definindo os tipos de dados para importação
dtype={"id_osc": int, "cd_natureza_juridica_osc": object,
"ft_natureza_juridica_osc": object, "tx_razao_social_osc": object,
"ft_razao_social_osc": object, "tx_nome_fantasia_osc": object,
"ft_nome_fantasia_osc": object, "im_logo": object, "ft_logo": object,
"tx_missao_osc": object, "ft_missao_osc": object, "tx_visao_osc": object,
"ft_visao_osc": object, "dt_fundacao_osc": object,
"ft_fundacao_osc": object, "dt_ano_cadastro_cnpj": object,
"ft_ano_cadastro_cnpj": object, "tx_sigla_osc": object,
"ft_sigla_osc": object, "tx_resumo_osc": object, "ft_resumo_osc": object,
"cd_situacao_imovel_osc": object, "ft_situacao_imovel_osc": object,
"tx_link_estatuto_osc": object, "ft_link_estatuto_osc": object,
"tx_historico": object, "ft_historico": object,
"tx_finalidades_estatutarias": object, "ft_finalidades_estatutarias": object,
"tx_link_relatorio_auditoria": object, "ft_link_relatorio_auditoria": object,
"tx_link_demonstracao_contabil": object, "ft_link_demonstracao_contabil": object,
"tx_nome_responsavel_legal": object, "ft_nome_responsavel_legal": object,
"cd_classe_atividade_economica_osc": object, "ft_classe_atividade_economica_osc": object,
"bo_nao_possui_sigla_osc": object, "bo_nao_possui_link_estatuto_osc": object}
log.info('Iniciando a importacao dos dados gerais')
ini = time.time()
# importando os dados do arquivo de dados gerais
df_dados_gerais = pd.read_csv(join(PATH,"dados","entrada",config["DADOS_GERAIS"]), sep=";",
encoding='utf-8', error_bad_lines=False, dtype=dtype)
log.info('Fim da importacao dos dados gerais. Total de %s decorrido' % str(time.time() - ini))
#------------------------------------------------------------------------------
log.info('Iniciando a importacao das areas de atuacao agrupada')
ini = time.time()
""" unindo os dataframes de area de atuacao e dados gerais pela chave de id_osc """
arq = open(join(PATH,'dados','saida',config['AREA_AGRUPADA']),'rb')
df_cd_area = pickle.load(arq)
arq.close()
log.info('Fim da importacao das areas de atuacao agrupada. Total de %s decorrido' % str(time.time() - ini))
log.info('Iniciando a uniao dos dados gerais com a area de atuacao agrupada')
ini = time.time()
df = pd.merge(df_cd_area,df_dados_gerais, on="id_osc")
""" verificando o tipo de classificacao """
if config['TIPO_MODELO'] == '1':
df.cd_area_atuacao = df.cd_area_atuacao.apply(int)
df = df[(df.cd_area_atuacao <= 11)]
elif config['TIPO_MODELO'] == '2':
df.cd_area_atuacao = df.cd_area_atuacao.apply(int)
df = df[(df.cd_area_atuacao > 11)]
log.info('Fim da uniao. Total de %s decorrido' % str(time.time() - ini))
#------------------------------------------------------------------------------
log.info('Iniciando a remocao das colunas 100% nulas')
ini = time.time()
""" aplicando a primeira limpeza no df, eliminando as colunas 100% nulas """
colunas = []
for coluna in df.columns:
qte_null = df[coluna].isnull().sum()
perc_null = round(qte_null/len(df[coluna]), 2)
if perc_null == 1.0:
colunas.append(coluna)
# armazenando as colunas excluidas
arq_colunas_excluidas = open(join(PATH,'dados','saida','colunasRemovidas100PorcentoNulas.txt'),"w")
arq_colunas_excluidas.write(str(colunas))
arq_colunas_excluidas.close()
# removendo as colunas do dataframe
df = df.drop(columns=colunas, axis=0)
log.info('Fim do processo. Total de %s decorrido' % str(time.time() - ini))
#------------------------------------------------------------------------------
log.info('Iniciando a remocao das colunas nao relevantes')
ini = time.time()
""" avaliando pontualmente cada variável do df definindo a relevancia
- retirada ft_link_relatorio_auditoria pois só havia um tipo de registro e o restante nulo
- retirada ft_link_demonstracao_contabil pois só havia um tipo de registro e o restante nulo
- retirada bo_nao_possui_sigla_osc pois só havia um tipo de registro e o restante nulo
- retirada bo_nao_possui_link_estatuto_osc pois só havia um tipo de registro e o restante nulo
- retirada a coluna da código da sub área de atuação, pois é uma informação vinculada a área de atuação. """
colunas_removidas = ["id_osc","bo_nao_possui_sigla_osc","bo_nao_possui_link_estatuto_osc","dt_fundacao_osc"
,"tx_razao_social_osc","tx_nome_fantasia_osc","ft_link_relatorio_auditoria","ft_link_demonstracao_contabil"
,"ft_classe_atividade_economica_osc"]
colunas_texto = ["ft_natureza_juridica_osc","ft_link_estatuto_osc","ft_historico","ft_finalidades_estatutarias"
,"ft_nome_responsavel_legal","ft_razao_social_osc","ft_nome_fantasia_osc","ft_logo","ft_missao_osc"
,"ft_visao_osc","ft_fundacao_osc","ft_sigla_osc","ft_resumo_osc","ft_situacao_imovel_osc"
,"ft_ano_cadastro_cnpj"]
# removendo as colunas do dataframe
df.drop(columns=colunas_removidas, axis=0, inplace=True)
# armazenando as colunas excluídas
arq_colunas_excluidas = open(join(PATH,'dados','saida','colunasRemovidasAposAvaliacao.txt'),"w")
arq_colunas_excluidas.write(str(colunas))
arq_colunas_excluidas.close()
log.info('Fim do processo. Total de %s decorrido' % str(time.time() - ini))
#------------------------------------------------------------------------------
log.info('Iniciando o tratamento com label_encoder e preparando o df')
ini = time.time()
dic = {}
log.info('Aplicando o LabelEncoder')
for col in colunas_texto:
df[col] = df[col].fillna("")
le = preprocessing.LabelEncoder()
tmp = le.fit(df[col])
dic[col] = tmp
df[col] = tmp.transform(df[col])
log.info('Salvando o LabelEncoder para aplicar em producao')
pickle.dump(dic,open(join(PATH,"dados","saida",config['LABEL_ENCODER']),'wb'))
log.info('Substituindo os valores nulos por -1')
df.fillna(-1, inplace=True)
log.info('Convertendo todos os dados do df para int')
for col in df.columns:
df[col] = df[col].apply(int)
log.info('Fim do processo. Total de %s decorrido' % str(time.time() - ini))
#------------------------------------------------------------------------------
log.info('Iniciando a remocao das colunas com alto nivel de correlacao')
ini = time.time()
log.info('criando uma matriz com a correlacao entre todas as variaveis do df')
dim = df.shape[1]
matrix = [[0]*dim for i in range(dim)]
for i in range(dim):
for j in range(dim):
matrix[i][j] = df.iloc[:,i].corr(df.iloc[:,j])
df_matrix = pd.DataFrame(matrix, columns=df.columns, index=df.columns)
log.info('Identificando as correlações acima de 0.9 ou menores de -0.9 e removendo as colunas do df')
colunas_alto_nivel_corr = []
arquivo_colunas_removidas = open(join(PATH,'dados','saida','colunasRemovidasDevidoAltoNivelCorrelacao.txt'), 'w')
for linha, valor in df_matrix.iterrows():
for coluna in df_matrix.columns:
if linha == coluna:
continue
if valor[coluna] >= 0.9 or valor[coluna] <= -0.9:
tx = "Correlação entre: {:s} e {:s} = {:f} \n".format(linha,coluna,valor[coluna])
arquivo_colunas_removidas.write(tx)
colunas_alto_nivel_corr.append(coluna)
arquivo_colunas_removidas.close()
df.drop(columns=set(colunas_alto_nivel_corr), inplace=True)
log.info('Fim do processo. Total de %s decorrido' % str(time.time() - ini))
#------------------------------------------------------------------------------
log.info('Separando os dados de treino e teste em 70% para treino e 30% para teste')
ini = time.time()
X_treino, X_teste, y_treino, y_teste = train_test_split(df, df.cd_area_atuacao, test_size=0.3)
log.info('Retirando a variavel de resposta do df de treino e teste')
X_treino = X_treino.iloc[:,1:]
X_teste = X_teste.iloc[:,1:]
log.info('Fim do processo. Total de %s decorrido' % str(time.time() - ini))
#------------------------------------------------------------------------------
log.info('Treinando o modelo de classificacao utilizando o algoritmo RandomForestClassifier da biblioteca sklearn')
ini = time.time()
log.info('Criando o modelo')
rf = RandomForestClassifier(n_estimators= 200, min_samples_split = 10, min_samples_leaf = 2,
max_features = 'sqrt', max_depth = 50, bootstrap = True)
log.info('Treinando o modelo')
rf.fit(X_treino, y_treino)
log.info('Salvando o modelo para ser usado em producao')
file = open(join(PATH,"dados","saida",config['MODELO']),'wb')
pickle.dump(rf,file)
file.close()
log.info('Fim do processo. Total de %s decorrido' % str(time.time() - ini))
#------------------------------------------------------------------------------
end = time.time() - begin
log.info('Fim do processo de geracao do modelo random forest. Total de %s decorrido.' % str(end))
def process():
global log
begin = time.time()
# starting log
logPath = join(PATH, "invertedIndex", "inverted_index.log")
Log.setLog(__name__, logPath)
log = logging.getLogger(__name__)
log.info('Processing inverted index generator module...')
log.info("Reading the configuration file")
config = InvertedIndexGenerator.readConfig(
join(PATH, "invertedIndex", "gli.cfg"))
log.info("Getting all documents from xml files")
docs, meanTimeXML = InvertedIndexGenerator.get_all_docs(config["LEIA"])
log.info('XML reading operation finished with %s of time average.' %
str(meanTimeXML))
ini = time.time()
log.info("Building the inverted index")
log.info("Concating all text of all docs in just one")
all_text = ''
for key, value in docs.items():
all_text += value + " "
log.info("Building all possible tokens")
all_words = Text.token_treated(all_text)
log.info("Building all possible keys")
inverted_index = {}
for w in all_words:
inverted_index[w] = []
log.info("Listing all docs and append to de main dict...")
for key, value in docs.items():
# building tokens of document
aw = Text.token_treated(value)
# add the document on inverted index
for w in aw:
inverted_index[w].append(key)
log.info('Inverted index finished with %s of time average.' % str(
(time.time() - ini) / float(len(config["LEIA"]))))
log.info('Writing inverted index on file...')
ini = time.time()
InvertedIndexGenerator.saveInvertedIndex(PATH + config["ESCREVA"],
inverted_index)
timeElapsed = time.time() - ini
log.info('Write operation finished with %s' % str(timeElapsed))
end = time.time() - begin
log.info(
'End of inverted index generator module. Total of %s elapsed.' %
str(end))
def process():
global log
begin = time.time()
# starting log
logPath = join(PATH, "indexer", "indexer.log")
Log.setLog(__name__, logPath)
log = logging.getLogger(__name__)
log.info('Processing indexer generator module...')
log.info("Reading the configuration file")
config = IndexerGenerator.readConfig(join(PATH, "indexer",
"index.cfg"))
log.info("Loading the inverted index")
ini = time.time()
inverted_index = InvertedIndexGenerator.getInvertedIndex(
PATH + config["LEIA"])
log.info('%s records read succesfully.' % str(len(inverted_index)))
log.info('Load operation finished with %s' % str(time.time() - ini))
log.info(
"Creating an auxiliary dictionary to help with calculations of tf-idf"
)
ini = time.time()
all_docs = {}
for termo, docs in inverted_index.items():
for doc in docs:
try:
all_docs[doc]["qte_termos_in_doc"] += 1
all_docs[doc]["termos"][termo]["qte_in_doc"] += 1
except KeyError:
try:
all_docs[doc]["termos"][termo] = {"qte_in_doc": 1}
except KeyError:
all_docs[doc] = {}
all_docs[doc]["qte_termos_in_doc"] = 1
all_docs[doc]["termos"] = {}
all_docs[doc]["termos"][termo] = {"qte_in_doc": 1}
log.info('Create operation finished with %s' % str(time.time() - ini))
indexer = {}
log.info("Calculating values of tf * idf")
ini = time.time()
for termo, docs in inverted_index.items():
# log2( total of documents / total of documents that the term appears)
idf = log2(len(all_docs.keys()) / float(len(set(docs))))
indexer[termo] = {}
indexer[termo]["idf"] = idf
for doc in docs:
# number of times the terms appear in the document / total document terms
tf = all_docs[doc]["termos"][termo]["qte_in_doc"] / float(
all_docs[doc]["qte_termos_in_doc"])
tf_idf = 1 + log2(tf) * log2(idf)
indexer[termo][doc] = tf_idf
log.info('End of calculate tf-idf. Total of %s elapsed.' %
str(time.time() - ini))
log.info('Writing Indexer on file...')
ini = time.time()
IndexerGenerator.saveIndexer(PATH + config["ESCREVA"], indexer)
log.info('%s records created successfully.' % str(len(indexer)))
log.info('Write operation finished with %s' % str(time.time() - ini))
end = time.time() - begin
log.info('End of indexer generator module. Total of %s elapsed.' %
str(end))
def extrai_dados_por_area_atuacao(areas):
log = ''
begin = time.time()
# iniciando o log
logPath = join(PATH, "extracao_dados.log")
Log.setLog("extracao_dados", logPath)
log = logging.getLogger("extracao_dados")
log.info('Iniciando o processo de extracao de dados')
log.info("Lendo o arquivo de configuracao")
config = readConfig(join(PATH, "modelos", "modelos.cfg"))
#------------------------------------------------------------------------------
# definindo os tipos de dados para importação
dtype = {
"id_osc": int,
"cd_natureza_juridica_osc": object,
"ft_natureza_juridica_osc": object,
"tx_razao_social_osc": object,
"ft_razao_social_osc": object,
"tx_nome_fantasia_osc": object,
"ft_nome_fantasia_osc": object,
"im_logo": object,
"ft_logo": object,
"tx_missao_osc": object,
"ft_missao_osc": object,
"tx_visao_osc": object,
"ft_visao_osc": object,
"dt_fundacao_osc": object,
"ft_fundacao_osc": object,
"dt_ano_cadastro_cnpj": object,
"ft_ano_cadastro_cnpj": object,
"tx_sigla_osc": object,
"ft_sigla_osc": object,
"tx_resumo_osc": object,
"ft_resumo_osc": object,
"cd_situacao_imovel_osc": object,
"ft_situacao_imovel_osc": object,
"tx_link_estatuto_osc": object,
"ft_link_estatuto_osc": object,
"tx_historico": object,
"ft_historico": object,
"tx_finalidades_estatutarias": object,
"ft_finalidades_estatutarias": object,
"tx_link_relatorio_auditoria": object,
"ft_link_relatorio_auditoria": object,
"tx_link_demonstracao_contabil": object,
"ft_link_demonstracao_contabil": object,
"tx_nome_responsavel_legal": object,
"ft_nome_responsavel_legal": object,
"cd_classe_atividade_economica_osc": object,
"ft_classe_atividade_economica_osc": object,
"bo_nao_possui_sigla_osc": object,
"bo_nao_possui_link_estatuto_osc": object
}
log.info('Iniciando a importacao dos dados gerais')
ini = time.time()
# importando os dados do arquivo de dados gerais
df_dados_gerais = pd.read_csv(join(PATH, "dados", "entrada",
config["DADOS_GERAIS"]),
sep=";",
encoding='utf-8',
error_bad_lines=False,
dtype=dtype)
log.info('Fim da importacao dos dados gerais. Total de %s decorrido' %
str(time.time() - ini))
#------------------------------------------------------------------------------
log.info('Iniciando a importacao das areas de atuacao agrupada')
ini = time.time()
""" unindo os dataframes de area de atuacao e dados gerais pela chave de id_osc """
arq = open(join(PATH, 'dados', 'saida', config['AREA_AGRUPADA']), 'rb')
df_cd_area = pickle.load(arq)
arq.close()
log.info(
'Fim da importacao das areas de atuacao agrupada. Total de %s decorrido'
% str(time.time() - ini))
log.info(
'Iniciando a uniao dos dados gerais com a area de atuacao agrupada')
ini = time.time()
df = pd.merge(df_cd_area, df_dados_gerais, on="id_osc")
""" retira as OSCs que tenham mais de uma area de atuacao e as que sao classificadas
como outras (10 e 11) """
log.info('Extraindo os dados atraves das areas informadas')
df.cd_area_atuacao = df.cd_area_atuacao.apply(int)
df = df[(df.cd_area_atuacao.isin(areas))]
""" realizando um slice para exportar somente as colunas utilizadas na classificacao do modelo """
df = df.loc[:, [
'id_osc', 'cd_natureza_juridica_osc', 'ft_razao_social_osc',
'ft_nome_fantasia_osc', 'ft_fundacao_osc',
'cd_classe_atividade_economica_osc'
]]
""" removendo duplicadas caso ocorra """
df.drop_duplicates(inplace=True)
log.info('Salvando em arquivo os dados extraidos')
df.to_csv(join(PATH, 'dados', 'saida', 'dados_extraidos.csv'), index=False)
log.info('Fim da uniao. Total de %s decorrido' % str(time.time() - ini))
end = time.time() - begin
log.info('Fim da execucao. Total de %s decorrido.' % str(end))