def Base_teste_treino():
'''
Importante código para separar teste e treinamento de bases
'''
conn = pymysql.connect("localhost", "root", "", "tw")
c = conn.cursor()
arq = Arquivo()
al = AnaliseLexica()
nome_arquivo = 'arquivos/treinamento.csv'
nome_arquivo1 = 'arquivos/teste.csv'
query = "SELECT id, id_tweet, tweet FROM selecionados_notrt_tb WHERE id=4216 OR id=7319 OR id=11542 OR id=11571 OR id=11764 OR id=14300 OR id=16303 OR id=19407 OR id=19439 OR id=21363 OR id=21577 OR id=22099"
c.execute(query)
lista = []
while True:
res = c.fetchall()
if not res:
break
for result in res:
tweet = al.Remocao_caracteres_Tweets(str(result[2]))
lista.append(
str(result[0]) + ';' + str(result[1]) + ';' + str(tweet))
# treino = int(len(lista)*0.7)
[print(i) for i in lista]
arq.Gravar_Arquivo(lista[:treino], nome_arquivo)
arq.Gravar_Arquivo(lista[treino:], nome_arquivo1)
def consulta_base(self, keywords, query='COMPLETA'):
if query == 'COMPLETA':
self.c.execute(self.query(keywords, ''))
else:
self.c.execute(self.query(keywords, query))
lista = []
arq = Arquivo()
count = 0
while True:
res = self.c.fetchall()
tamanho = len(res)
if not res:
break
for result in res:
if (self.Verifica_Dados(str(result[0]),
'arquivos/ids_selecionados.txt')):
lista.append(str(result[0]))
terminal.printProgressBar(count, tamanho, length=50)
self.Inserir_selecionados(result[0], result[1], result[2],
result[3], result[4], result[5],
result[6], result[7], result[8],
result[9], result[10],
result[11], result[12],
result[13])
count += 1
arq.Gravar_Arquivo(lista, 'arquivos/ids_selecionados.txt')
self.Fechar_Conexao()
return count
def Corrigir_Base_Dicionario(palavras):
if type(palavras) == str:
palavras = palavras.split()
arq = Arquivo()
arq.Gravar_Arquivo(palavras, 'arquivos/data/lsa/limpeza_feature_names.txt')
print(
'>> Método: Corrigir_Base_Dicionario <<\nType: %s Tamanho: %i Primeira Palavra: %s Ultima Palavra: %s'
% (type(palavras), len(palavras), palavras[0], palavras[-1]))
class Gerenciador_BagOfWords():
def __init__(self):
self.nome_arq_controle = 'arquivos/data/bow/arq_controle.json'
self.arq_controle = None
self.arq = Arquivo()
self.bow = BagOfWords()
self.vocabulario = None
self.freq_vocabulario = None
self.tweets = []
self.tweets_limpos = []
self.wc = WCloud()
self.Run()
def Inicializar_arq_controle(self):
lista = [
'atualizacao_data', 'atualizacao_hora', 'has_lista_vocabulario',
'lista_vocabulario_nome', 'has_dict_freq_vocabulario',
'dict_freq_vocabulario_nome', 'total_tweets', 'total_vocabulos',
'has_lista_tweets_limpos', 'lista_tweets_limpos_nome'
]
dicio = {}
for i in lista:
dicio.update({i: None})
self.Gravar_arq_JSON(self.nome_arq_controle, dicio)
def Gravar_arq_JSON(self, nome_arquivo, arquivo):
with open(nome_arquivo, 'w') as json_file:
json.dump(arquivo, json_file, indent=4, ensure_ascii=False)
def Carregar_arq_JSON(self, nome_arquivo):
with open(nome_arquivo, 'r', encoding='utf8') as json_file:
dados = json.load(json_file)
return dados
def Atualiza_arq_JSON(self, key, value):
self.arq_controle.update({key: value})
self.Gravar_arq_JSON(self.nome_arq_controle, self.arq_controle)
def Carregar_atualizacao(self):
try:
self.arq_controle = self.Carregar_arq_JSON(self.nome_arq_controle)
terminal.Mensagem('arq_controle carregado com Sucesso!', 'ok')
except Exception as identifier:
terminal.Mensagem(str(identifier), 'e')
try:
self.vocabulario = self.arq.Carregar_Arquivo_UTF8(
self.arq_controle['lista_vocabulario_nome'])
terminal.Mensagem('vocabulario carregado com Sucesso!', 'ok')
except Exception as identifier:
terminal.Mensagem(str(identifier), 'e')
try:
self.freq_vocabulario = self.Carregar_arq_JSON(
self.arq_controle['dict_freq_vocabulario_nome'])
terminal.Mensagem('freq_vocabulario carregado com Sucesso!', 'ok')
except Exception as identifier:
terminal.Mensagem(str(identifier), 'e')
try:
self.tweets_limpos = self.Carregar_PKL(
self.arq_controle['lista_tweets_limpos_nome'])
terminal.Mensagem('lista_tweets_limpos carregado com Sucesso!',
'ok')
except Exception as identifier:
terminal.Mensagem(str(identifier), 'e')
def __WordCloud(self):
try:
self.wc.Build_Nuvem_Palavras(self.tweets_limpos)
terminal.Mensagem('WordClound Gerado com Sucesso!', 'ok')
except Exception as identifier:
terminal.Mensagem(str(identifier), 'e')
def Gravar_PKL(self, arquivo, nome_arquivo):
output = open(nome_arquivo, 'wb')
dump(arquivo, output, -1)
output.close()
def Carregar_PKL(self, nome_arquivo):
Input = open(nome_arquivo, 'rb')
dados = load(Input)
Input.close()
return dados
def __BOW(self):
if len(self.tweets) == 0:
conn = pymysql.connect("localhost", "root", "", "tw")
c = conn.cursor()
query = "SELECT tweet FROM selecionados_notrt_tb"
c.execute(query)
while True:
res = c.fetchall()
if not res:
break
for result in res:
self.tweets.append(result[0])
tam = 1000
x = int(len(self.tweets) / tam) + 1
for i in range(x):
if i < x:
self.tweets_limpos.append(
self.bow.Construtor_Vocabulario(self.tweets[tam * i:tam *
(i + 1)]))
else:
self.tweets_limpos.append(
self.bow.Construtor_Vocabulario(self.tweets[tam * i:]))
def normalizar_lista(lista_tweets):
i = 0
aux = []
for i in range(len(lista_tweets)):
j = 0
for t in lista_tweets[i][0][j]:
aux.append(t)
j += 1
return aux
self.tweets_limpos = normalizar_lista(self.tweets_limpos)
self.Atualiza_arq_JSON('lista_tweets_limpos_nome',
'arquivos/data/bow/lista_tweets_limpos.pkl')
self.Gravar_PKL(self.tweets_limpos,
self.arq_controle['lista_tweets_limpos_nome'])
self.Atualiza_arq_JSON('has_lista_tweets_limpos', True)
self.Atualiza_arq_JSON('total_tweets', len(self.tweets))
self.Atualiza_arq_JSON('total_vocabulos', len(self.vocabulario))
self.Atualiza_arq_JSON('has_lista_vocabulario', True)
self.Atualiza_arq_JSON('lista_vocabulario_nome',
'arquivos/data/bow/vocabulario.txt')
self.arq.Gravar_Arquivo(self.bow.vocabulario,
self.arq_controle['lista_vocabulario_nome'])
for sent in self.tweets_limpos:
vetor = self.bow.Vetor(sent)
self.bow.Verifica_Freq_Vocabulario(vetor)
self.Atualiza_arq_JSON('has_dict_freq_vocabulario', True)
self.Atualiza_arq_JSON('dict_freq_vocabulario_nome',
'arquivos/data/bow/freq_vocabulario.json')
self.Gravar_arq_JSON(self.arq_controle['dict_freq_vocabulario_nome'],
self.bow.freq_vocabulario)
fim = time.time()
data = time.strftime("%d-%m-%Y", time.localtime(fim))
hora = time.strftime("%H:%M:%S", time.localtime(fim))
self.Atualiza_arq_JSON('atualizacao_data', data)
self.Atualiza_arq_JSON('atualizacao_hora', hora)
self.__WordCloud()
def Run(self):
resposta = ''
self.Carregar_atualizacao()
if self.arq_controle == None:
self.Inicializar_arq_controle()
else:
terminal.Mensagem(
'Arquivos Atualizados em %s às %s:\nTotal de Tweets: %i\nTotal de Vocábulos: %i\nDeseja atualizar o Bag Of Words?[S/N]'
% (self.arq_controle['atualizacao_data'],
self.arq_controle['atualizacao_hora'],
self.arq_controle['total_tweets'],
self.arq_controle['total_vocabulos']), 'w')
resposta = str(input()).upper()
if resposta == 'S':
self.tweets_limpos.clear()
self.__BOW()
elif resposta == 'N':
terminal.Mensagem(
'Deseja gerar WordCloud com o arquivo existente?[S/N]', 'w')
option = str(input()).upper()
if option == 'S':
self.__WordCloud()
else:
return False
else:
terminal.Mensagem('Resposta Inválida! Informe [S/N].', 'w')
return False
class TF_IDF():
def __init__(self):
self.data = []
self.arq = Arquivo()
def Gravar_PKL(self, arquivo, nome_arquivo):
output = open(nome_arquivo, 'wb')
dump(arquivo, output, -1)
output.close()
def Gerar_Dados(self, lista_tweets, dados=False):
vectorizer = TfidfVectorizer()
V = vectorizer.fit_transform(lista_tweets)
row_label = ['Tweet %i' % i for i in range(V.shape[0])]
col_label = vectorizer.get_feature_names()
self.arq.Gravar_Arquivo(col_label,
'arquivos/data/tf-idf/feature_names.txt')
aux = []
aux2 = []
[aux2.append(0.0) for i in range(len(col_label))]
for item in range(len(row_label)):
aux.append(aux2.copy())
p = 0
i = 0
for indice in range(len(V.indices)):
if indice < V.indptr[i + 1]:
aux[p][V.indices[indice]] = V.data[indice]
else:
p += 1
i += 1
aux[p][V.indices[indice]] = V.data[indice]
self.data = aux.copy()
self.Gravar_PKL(self.data, 'arquivos/data/tf-idf/vetor_tfidf.pkl')
print('Imprimir Tabela?[S/N] ', end='')
opcao = str(input()).upper()
if opcao == 'S':
print('Informe os dados necessários:\nQuantidade de Linhas: ',
end='')
row = int(input())
print('Quantidade de Colunas: ', end='')
col = int(input())
self.Gerar_tabela(row, 5, col, row_label, col_label, self.data)
else:
return False
def Gerar_tabela(self, tam_inicio, tam_final, col_tam, row_label,
col_label, lista):
if col_tam > len(col_label):
col_tam = len(col_label)
if len(lista) > tam_inicio + tam_final:
linha1 = 'Tweet\t'
for ind in range(col_tam):
linha1 += '{:<8} '.format(col_label[ind])
if col_tam < len(col_label):
linha1 += '{:<8} '.format('...')
print(linha1)
for i in range(tam_inicio):
linha = '%s ' % row_label[i]
for k in range(col_tam):
if lista[i][k] == 0.0:
linha += '{:<8} '.format('-')
else:
linha += '{:<8,.5f} '.format(lista[i][k])
if col_tam < len(col_label):
linha += '{:<8} '.format('...')
print(linha)
linha_intervalo = '{:<8} '.format('...')
linha_intervalo = linha_intervalo * (col_tam + 2)
print(linha_intervalo)
for i in range(-1, tam_final * -1, -1):
linha = '%s ' % row_label[i]
for k in range(col_tam):
if lista[i][k] == 0.0:
linha += '{:<8} '.format('-')
else:
linha += '{:<8,.5f} '.format(lista[i][k])
if col_tam < len(col_label):
linha += '{:<8} '.format('...')
print(linha)
else:
linha1 = 'Tweet\t'
for ind in range(col_tam):
linha1 += '{:<8} '.format(col_label[ind])
if col_tam < len(col_label):
linha1 += '{:<8} '.format('...')
print(linha1)
for i in range(len(lista)):
linha = '%s ' % row_label[i]
for k in range(col_tam):
if lista[i][k] == 0.0:
linha += '{:<8} '.format('-')
else:
linha += '{:<8,.5f} '.format(lista[i][k])
if col_tam < len(col_label):
linha += '{:<8} '.format('...')
print(linha)
def Gerar_Grafico(self, data):
plt.style.use(plt.style.available[-1])
plt.rcParams['figure.figsize'] = (11, 7)
fig, axs = plt.subplots(2, 2, figsize=(5, 5))
axs[0, 0].hist(data[0])
axs[1, 0].scatter(data[0], data[1], data[2], data[3])
axs[0, 1].plot(data[0], data[1], data[2], data[3])
axs[1, 1].bar(data[0], data[1], data[2], data[3])
plt.title('SEU TÍTULO LINDO')
plt.xlabel('NOME DO EIXO X')
plt.ylabel('NOME DO EIXO Y')
ax.grid(True)
fig.tight_layout()
plt.show()
nome_grafico = 'grafico_teste_01'
nome_arquivo = 'arquivos/data/tf-idf/graficos/' + nome_grafico + '.png'
class Latent_Semantic_Analysis:
def __init__(self):
self.arq = Arquivo()
self.feature_tweet = {}
self.termos_especiais = {}
self.arquivo_controle = {}
self.matriz_termos = self.Carregar_Matriz('matriz_termos')
self.matriz_topicos = self.Carregar_Matriz('matriz_topicos')
self.ids_tweets_feature_topicos = self.arq.Carregar_Arquivo('arquivos/data/lsa/_ids_tweets_feature_topicos.txt')
self.feature_topicos = self.Carregar_feature_topicos()
self.last_id_tweet = 0
self.TRUNCADO = 100
# CARREGAR TWEETS
self.body = self.Carregar_PKL('arquivos/data/bow/lista_tweets_limpos.pkl')[609:]
self._LSA_()
def Carregar_feature_topicos(self):
try:
with open( 'arquivos/data/lsa/feature_topicos.json', 'r', encoding='utf8') as json_file:
dados = json.load(json_file)
return dados
except Exception as identifier:
terminal.Mensagem('Erro [%s]: Não foi possível carregar o arquivo.'%identifier, 'e')
def Carregar_PKL(self, nome_arquivo):
try:
Input = open(nome_arquivo, 'rb')
dados = load(Input)
Input.close()
return dados
except Exception as identifier:
terminal.Mensagem('Erro [%s]: Não foi possível carregar o arquivo.'%identifier, 'e')
def Gravar_PKL(self, arquivo, nome_arquivo):
output = open(nome_arquivo, 'wb')
dump(arquivo, output, -1)
output.close()
def carregar_arq_controle(self):
try:
with open('arquivos/data/lsa/arq_controle_lsa.json', 'r', encoding='utf8') as json_file:
self.arquivo_controle = json.load(json_file)
terminal.Mensagem('arquivo_controle_lsa carregado com sucesso!', 'ok')
except Exception as identifier:
terminal.Mensagem('Erro %s ao carregar o arquivo.'%(identifier), 'e')
def carregar_feature_tweet(self):
self.carregar_arq_controle()
if self.arquivo_controle['has_feature_tweet']:
with open( 'arquivos/data/lsa/feature_tweet.json' , 'r', encoding='utf8') as json_file:
self.feature_tweet = json.load(json_file)
terminal.Mensagem('feature_tweet carregado com sucesso!', 'ok')
def Carregar_Matriz(self, nome_matriz='matriz_termos ou matriz_topicos'):
nome = nome_matriz.lower()
if nome == 'matriz_termos' or nome == None:
nome_arquivo = 'arquivos/data/lsa/matriz_termos.pkl'
elif nome == 'matriz_topicos':
nome_arquivo = 'arquivos/data/lsa/matriz_topicos.pkl'
try:
matriz_T = self.Carregar_PKL(nome_arquivo)
return matriz_T
except Exception as identifier:
terminal.Mensagem('Erro [%s]: Não foi possível carregar o arquivo \'%s\'.'%(identifier, nome_arquivo), 'e')
def gravar_feature_tweet(self, tipo_gravacao='w'):
with open('arquivos/data/lsa/feature_tweet.json', tipo_gravacao, encoding='utf-8') as json_file:
json.dump(self.feature_tweet, json_file, indent=4, ensure_ascii=False)
def Atualiza_arquivo_controle(self, key, value):
self.arquivo_controle.update({key: value})
with open('arquivos/data/lsa/arq_controle_lsa.json', 'w') as json_file:
json.dump(self.arquivo_controle, json_file, indent=4, ensure_ascii=False)
def _LSA_(self):
inicio = time.time()
terminal.Mensagem('Iniciando em Análise Semântica Latente', 'd')
print('0 - Análise Semântica Latente Completa\n1 - Cálculo de Relevância dos tweets\n2 - Seleção de tweets com Maior Relevância\n\t> Informe o que deseja fazer: ',end='')
_tipo_ = str(input())
if _tipo_ == '0':
resposta = 'S'
self.carregar_arq_controle()
if self.arquivo_controle['atualizacao_data'] != None:
terminal.Mensagem('Arquivos Atualizados em %s às %s. Deseja atualizar a LSA?[S/N]' %(self.arquivo_controle['atualizacao_data'], self.arquivo_controle['atualizacao_hora']),'w')
resposta = str(input()).upper()
if resposta == 'S':
# DEFINIR STOPWORDS
stw = []
stopword = stopwords.words('portuguese')
outras_palavras = self.arq.Carregar_Arquivo_UTF8('arquivos/data/lsa/limpeza_feature_names.txt')
[stw.append(s) for s in stopword]
[stw.append(s) for s in outras_palavras]
# CARREGAR LISTA DE TERMOS REFERENTES A VULNERABILIDADE E RISCO
with open('arquivos/data/lsa/termos_especiais.json', 'r', encoding='utf8') as json_file:
self.termos_especiais = json.load(json_file)
pa.Atualiza_Dict_Termos_especiais(True)
# VETOR TFIDF / BOW
vetor = TfidfVectorizer(min_df=1,stop_words=stw)
bag_of_words = vetor.fit_transform(self.body)
print(bag_of_words.shape)
LISTA_TRUNCADO = [x for x in range(self.TRUNCADO)]
# DEFINIR COLUNAS E TRUNCAR O VETOR TFIDF / BOW ==> LSA - ANALISE SEMANTICA LATENTE
svd = TruncatedSVD(n_components=self.TRUNCADO) #Truncar para X colunas
lsa = svd.fit_transform(bag_of_words)
def __matriz_topicos__():
topicos = pd.DataFrame(lsa, columns = LISTA_TRUNCADO)
topicos['body'] = self.body
print(topicos[['body', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])
self.Gravar_PKL(topicos, 'arquivos/data/lsa/matriz_topicos.pkl')
self.Atualiza_arquivo_controle('has_matriz_topicos', True)
# DEFINIÇÃO DOS TOPICOS
if self.arquivo_controle['has_matriz_topicos']:
terminal.Mensagem('Arquivos Atualizados em %s às %s. Deseja atualizar a Matriz de Tópicos?[S/N]' %(self.arquivo_controle['atualizacao_data'], self.arquivo_controle['atualizacao_hora']),'w')
resp = str(input()).upper()
if resp == 'S':
__matriz_topicos__()
else:
topicos = self.matriz_topicos
else:
__matriz_topicos__()
# DICIONÁRIO DE PALAVRAS - PRODUTO DA LSA
dicionario = vetor.get_feature_names()
print('Imprimir dicionário? [S/N] ', end='')
if input(str()).upper() == 'S':
print(dicionario)
print()
# MATRIZ DE TERMOS - PRODUTO DA LSA
if not self.arquivo_controle['has_matriz_termos']:
matriz = pd.DataFrame(svd.components_,
index=[LISTA_TRUNCADO],
columns=dicionario).T
self.Gravar_PKL(matriz, 'arquivos/data/lsa/matriz_termos.pkl')
self.Atualiza_arquivo_controle('has_matriz_termos', True)
print('Imprimir matriz_termos? [S/N] ', end='')
if input(str()).upper() == 'S':
print(self.Carregar_Matriz('matriz_termos'))
print()
print('Imprimir matriz_topicos? [S/N] ', end='')
if input(str()).upper() == 'S':
print(self.Carregar_Matriz('matriz_topicos'))
print()
self.last_id_tweet = self.arquivo_controle['last_id_tweet']
# VETOR AUXILIAR PARA TOPICOS DOS TERMOS
aux_topic = []
maior, pos, aux = -1000.0, 0, 0
for item in self.matriz_termos.values:
for j in item:
if j > maior:
maior = j
aux = pos #aux = topico
pos += 1
aux_topic.append([aux, maior])
pos, aux, maior = 0, 0, -1000.0
def Identificar_Topico(termo):
term = termo.lower()
achou = False
pos = -1
for item in dicionario:
pos += 1
if term == item:
achou = True
break
if achou:
return aux_topic[pos]
else:
return -1
def Identificar_Topico_Tweet(id_tweet):
maior, pos, _top = -1000.0, 0, 0
res = []
for item in self.matriz_topicos.values[id_tweet]:
if type(item) != str:
if item > maior:
maior = item # média das freq
_top = pos #aux = topico
pos += 1
res.append(_top)
res.append(maior)
return res
def Verifica_Dicionario(tweet):
count = 0
tweet = tweet.split()
for tw in tweet:
for item in dicionario:
if tw == item:
count += 1
return count
def Verifica_Termos_Especiais_(tweet):
import re
caract = [r'\b\"', r'\"\b', r'\b\-', r'\b\'', r'\'\b', r'\“', r'\”', r'\.', r'\.\.\.',
r'\,', r'\?', r'\!', r'\(', r'\)', r'\{', r'\}',r'\[',r'\]', r'\+', r'\*', r'\B\%'
r'\b\"+', r'\B\"', r'\"\B', r'\%', r'\\', r'\/', r'\|', r'\<', r'\>', r'\=',
r'\B\-', r'\b\‘', r'\B\‘', r'\b\`', r'\B\`', r'\b\ñ', r'\B\ñ', r'\b\º', r'\B\º',
r'\b\ª', r'\B\ª', r'\b\_', r'\B\_', r'\b\;', r'\B\;', r'\b\^', r'\~', r'\b\è',
r'\_', r'\–', r'\•', r'\#', r'\b\—', r'\B\—', r'\—', r'\°', r'\b\°', r'\B\°',
r'\'', r'\B\'', r'\«', r'\b\«', r'\B\«', r'\&', r'\b\&', r'\B\&', r'\¬',
r'\b\¬', r'\B\¬', r'\¨', r'\b\¨', r'\B\¨', r'\¢', r'\b\¢', r'\B\¢', r'\£',
r'\b\£', r'\B\£' , r'\³', r'\b\³', r'\B\³', r'\³\b', r'\³\B', r'\²', r'\b\²',
r'\B\²', r'\²\b', r'\²\B', r'\¹', r'\b\¹', r'\B\¹', r'\¹\b', r'\¹\B', r'\§',
r'\b\§', r'\B\§', r'\b\·', r'\B\·', r'\·', r'\^', r'\B\^', r'\ö', r'\b\ö',
r'\B\ö', r'\»', r'\b\»', r'\B\»', r'\@', r'\b\@', r'\B\@', r'\€', r'\b\€',
r'\B\€', r'\÷', r'\b\÷', r'\B\÷',r'\å', r'\b\å', r'\B\å', r'\×', r'\b\×',
r'\B\×', r'\¡', r'\b\¡', r'\B\¡', r'\¿', r'\b\¿', r'\B\¿', r'\´', r'\b\´',
r'\B\´', r'\$', r'\b\$', r'\B\$', r'\¥', r'\b\¥', r'\B\¥', r'\¯', r'\b\¯',
r'\B\¯']
espaco2 = re.compile(r'\b\s+')
for item in caract:
e = re.compile(item)
tweet = re.sub(e, ' ', tweet)
tweet = re.sub(espaco2, ' ', tweet)
count = 0
tweet = tweet.split()
for word in tweet:
inicial = word[0]
if self.termos_especiais[inicial] != None:
for item in self.termos_especiais[inicial]:
if word == item:
count += 1
return count
def feature_tweet_(lista, id_inicial):
try:
self.carregar_feature_tweet()
except Exception as identifier:
terminal.Mensagem('Erro %s Não foi possível acessar o arquivo.'%(identifier), 'e')
try:
contador = 0
pos = id_inicial -1
for tweet in lista:
contador += 1
pos += 1
_palavras = len(tweet.split())
_id = pos
_term = Verifica_Termos_Especiais_(tweet)
_aux = Identificar_Topico_Tweet(_id)
_topico = _aux[0]
_word_dicionary = Verifica_Dicionario(tweet)
_freq = _aux[1]
self.feature_tweet.update({_id:{'words': _palavras, 'special_terms': _term, 'words_dicionary': _word_dicionary, 'topic': _topico, 'score': _freq}})
terminal.printProgressBar(contador,len(lista),length=50)
self.Atualiza_arquivo_controle('has_lsa_tweet', True)
self.gravar_feature_tweet('w')
self.Atualiza_arquivo_controle('has_feature_tweet', True)
except Exception as identifier:
fim = time.time()
duracao = fim - inicio
terminal.Mensagem('Erro %s identificado na posição %i.'%(identifier, pos), 'e')
terminal.Mensagem('Programa finalizado!\tDuração: %.3f seg'%(duracao),'ok')
def Gerar_Grafico():
topicos = pd.DataFrame(matriz,
index=['Tweet'],
columns=dicionario).T
print(topicos)
fig, ax = plt.subplots()
top_1 = matriz[0].values
top_2 = matriz[1].values
ax.scatter(top_1, top_2, alpha=0.3)
ax.set_xlabel('Primeiro Topico')
ax.set_ylabel('Segundo Topico')
ax.axvline(linewidth=0.5)
ax.axhline(linewidth=0.5)
ax.legend()
plt.show()
# Produz Recurso de Tweets
tamanho = self.last_id_tweet + 15000
if tamanho > len(self.body):
tamanho = len(self.body)
feature_tweet_(self.body[self.last_id_tweet: tamanho], self.last_id_tweet)
self.Atualiza_arquivo_controle('last_id_tweet', tamanho)
# Calcula Relevancia dos Tweets
if self.arquivo_controle['has_lsa_tweet']:
self.Calcular_Relevancia_Tweet()
else:
terminal.Mensagem('lsa_tweet não executado!', 'e')
# Seleciona Tweets com maior Relevancia
if self.arquivo_controle['has_calculo_relevancia_tweet']:
self.Selecionar_Tweets_Relevancia('positive',0.5)
else:
terminal.Mensagem('calculo_relevancia_tweet não executado!', 'e')
fim = time.time()
data = time.strftime("%d-%m-%Y", time.localtime(fim))
hora = time.strftime("%H:%M:%S", time.localtime(fim))
self.Atualiza_arquivo_controle('atualizacao_data', data)
self.Atualiza_arquivo_controle('atualizacao_hora', hora)
duracao = fim - inicio
terminal.Mensagem('Programa finalizado!\tDuração: %.3f seg'%(duracao),'ok')
else:
terminal.Mensagem('Desconectando...','d')
return False
elif _tipo_ == '1':
self.Calcular_Relevancia_Tweet()
elif _tipo_ == '2':
self.Selecionar_Tweets_Relevancia('positive',0.5)
else:
terminal.Mensagem('Desconectando...','d')
return False
def Calcular_Relevancia_Tweet(self):
self.carregar_feature_tweet()
# Atribuição de relevância POSITIVA
for key in self.feature_tweet.keys():
if self.feature_tweet[key]['special_terms'] > 0:
term = (self.feature_tweet[key]['special_terms'])
dc = (self.feature_tweet[key]['words_dicionary'])
if dc != 0:
imp = (term / dc)
else:
imp = -1
if imp >= 0.50: # grau de importancia do tweet com o tema (>=50% POSITIVO, menor que 50% NEUTRO, não possui palavras que tenha a ver com o tema NEGATIVO)
self.feature_tweet[key].update({'relevance': 'POSITIVE'})
else:
self.feature_tweet[key].update({'relevance': 'NEUTRO'})
else:
# Atribuição de relevância NEGATIVA
self.feature_tweet[key].update({'relevance': 'NEGATIVE'})
self.gravar_feature_tweet('w')
self.Atualiza_arquivo_controle('has_calculo_relevancia_tweet', True)
def Selecionar_Tweets_Relevancia(self, relevancia='POSITIVE', maior_score=0.0):
self.carregar_feature_tweet()
self.carregar_arq_controle()
''' PERGUNTAR SE DESEJA IMPRIMIR MATRIZ TERMOS E TOPICOS E DICIONARIO'''
print('\tImprimir matriz_termos? [S/N] ', end='')
if input(str()).upper() == 'S':
print(self.Carregar_Matriz('matriz_termos'))
print()
print('\tImprimir matriz_topicos? [S/N] ', end='')
if input(str()).upper() == 'S':
print(self.Carregar_Matriz('matriz_topicos'))
print()
relevancia = relevancia.upper()
encontrado = False
status_relevancia = ['POSITIVE', 'NEGATIVE', 'NEUTRO']
def __run__():
score, posicao, termos, topico, palavras, dicio, importancia, tt = [], [], [], [], [], [], [], []
for key in self.feature_tweet.keys():
if self.feature_tweet[key]['relevance'] == relevancia and self.feature_tweet[key]['score'] >= maior_score:
term = self.feature_tweet[key]['special_terms']
dc = self.feature_tweet[key]['words_dicionary']
if dc != 0:
imp = (term / dc)
else:
imp = -1
score.append(self.feature_tweet[key]['score'])
posicao.append(key)
termos.append(term)
topico.append(self.feature_tweet[key]['topic'])
palavras.append(self.feature_tweet[key]['words'])
dicio.append(dc)
importancia.append(imp)
print('\t> Tweets com Score maior que %.2f e com Relevancia \'%s\': %i / %i (%.2f)' %(maior_score, relevancia, len(posicao), len(self.feature_tweet), float(len(posicao)/len(self.feature_tweet)*100)) + '%')
self.Atualiza_arquivo_controle('count_feature_topicos',len(posicao))
print()
for item in posicao: # Imprime os Tweets
tt.append(self.body[int(item)])
y = zip(posicao, topico, tt)
topic_unique = [topico[0]]
achou = False
for t1 in topico:
achou = False
for t2 in topic_unique:
if t1 == t2:
achou = True
if not achou:
topic_unique.append(t1)
topic_unique.sort()
topicos_dict, aux, p1 = {}, {}, 0
for t0 in topic_unique:
for t3 in topico:
if t3 == t0:
aux.update({posicao[p1]: self.feature_tweet[str(posicao[p1])]})
aux[posicao[p1]]['importancia'] = importancia[p1]
aux[posicao[p1]]['tweet'] = tt[p1]
topicos_dict.update({t3: aux.copy()})
p1 +=1
aux.clear()
p1=0
if not self.arquivo_controle['has_feature_topicos']:
with open('arquivos/data/lsa/feature_topicos.json', 'w', encoding='utf-8') as json_file:
json.dump(topicos_dict, json_file, indent=4, ensure_ascii=False)
self.arq.Gravar_Arquivo(posicao,'arquivos/data/lsa/_ids_tweets_feature_topicos.txt')
self.Atualiza_arquivo_controle('has_feature_topicos',True)
print('\tImprimir feature_topicos? [S/N] ', end='')
if input(str()).upper() == 'S':
tam =0
for t4 in topicos_dict.keys():
while tam < 10:
for t5 in topicos_dict[t4].keys():
print('id: {:<8} score: {:<8,.5f} terms: {:<2} topic: {:<2} words: {:<4} words_dicionary: {:<2} importancia: {:<2,.2f}'
.format(t5, topicos_dict[t4][t5]['score'], topicos_dict[t4][t5]['special_terms'], topicos_dict[t4][t5]['topic'],
topicos_dict[t4][t5]['words'], topicos_dict[t4][t5]['words_dicionary'], topicos_dict[t4][t5]['importancia']))
tam +=1
print('...\t\t...\t\t...\n')
tam =0
for t4 in topicos_dict.keys():
while tam < 10:
for t5 in topicos_dict[t4].keys():
print('id: {:<6} Topic: {:<2} Tweet: {:<80}'
.format(t5, topicos_dict[t4][t5]['topic'], topicos_dict[t4][t5]['tweet']))
tam +=1
print('\tImprimir relatorio_status_lsa_tweet? [S/N] ', end='')
if input(str()).upper() == 'S':
relt_topicos, tam_topic = [], 0
for t_u in topic_unique:
tam_topic += len(topicos_dict[t_u])
relt_topicos.append([t_u, len(topicos_dict[t_u])])
print('* * * RELATÓRIO DE STATUS LSA FEATURE * * * ')
for item in range(0,len(relt_topicos),4):
if item <=len(relt_topicos)-4:
print('Topic: {:<2} Qtde: {:<4} Topic: {:<2} Qtde: {:<4} Topic: {:<2} Qtde: {:<4} Topic: {:<2} Qtde: {:<4}'
.format(relt_topicos[item][0], relt_topicos[item][1],
relt_topicos[item+1][0], relt_topicos[item+1][1],
relt_topicos[item+2][0], relt_topicos[item+2][1],
relt_topicos[item+3][0], relt_topicos[item+3][1]))
elif item == len(relt_topicos)-1:
print('Topic: {:<2} Qtde: {:<4}'.format(relt_topicos[item][0], relt_topicos[item][1]))
elif item == len(relt_topicos)-2:
print('Topic: {:<2} Qtde: {:<4} Topic: {:<2} Qtde: {:<4}'
.format(relt_topicos[item][0], relt_topicos[item][1],
relt_topicos[item+1][0], relt_topicos[item+1][1]))
else:
print('Topic: {:<2} Qtde: {:<4} Topic: {:<2} Qtde: {:<4} Topic: {:<2} Qtde: {:<4}'
.format(relt_topicos[item][0], relt_topicos[item][1],
relt_topicos[item+1][0], relt_topicos[item+1][1],
relt_topicos[item+2][0], relt_topicos[item+2][1]))
print('\t > Total Tópicos: {:<2} Total Tweets: {:<4}'.format(len(topic_unique), tam_topic))
print('\n\tRealizar Etiquetagem <Treinamento> da Base de Tweets? [S/N] ', end='')
if input(str()).upper() == 'S':
pos, fim = 1, False
for i in topic_unique:
if i > self.arquivo_controle['topico_treinamento']:
print('\t> Treino da Base topic_num: \"%i\" [%i de %i tópicos]'%(i, pos, len(topic_unique)))
fim = self.Verifica_feature_topicos(i)
if fim:
return False
pos += 1
print('\n\tImprimir Estimativa de Tweets com Vulnerabilidade TRUE? [S/N] ', end='')
if input(str()).upper() == 'S':
pa.Levantamento_Score_Vulnerabilidade()
tweets_localizacao()
def tweets_localizacao():
dicts, _ids_tweets_localizacao, aux_ids = {}, [], []
with open( 'arquivos/data/lsa/feature_topicos.json' , 'r', encoding='utf8') as json_file:
dicts = json.load(json_file)
for topico in dicts.keys():
for _id in dicts[topico].keys():
if dicts[topico][_id]['vulnerabilidade'] == 1.0:
aux_ids.append(int(_id))
aux_ids.sort()
for item in aux_ids:
_ids_tweets_localizacao.append(str(item))
self.arq.Gravar_Arquivo(_ids_tweets_localizacao, 'arquivos/data/lsa/_ids_tweets_localizacao.txt')
print('Arquivo _ids_tweets_localizacao.txt tamanho: %i'%len(_ids_tweets_localizacao))
# __MAIN__
for item in status_relevancia:
if relevancia == item:
encontrado = True
if encontrado:
__run__()
else:
terminal.Mensagem('Erro ao inserir o dado [RELEVANCE]: \'%s\'' % (relevancia), 'e')
def Verifica_feature_topicos(self, _topic):
_topic = str(_topic)
_tweet, _id = [], []
clear = lambda: os.system('cls')
def _retorna_tweet_topico():
for item in self.feature_topicos[_topic].keys():
if self.feature_topicos[_topic][item]['vulnerabilidade'] == None:
_tweet.append(self.feature_topicos[_topic][item]['tweet'])
_id.append(item)
def _atualiza_feature_topicos_( _id, _key, _value):
self.feature_topicos[_topic][_id].update({_key: _value})
with open('arquivos/data/lsa/feature_topicos.json', 'w', encoding='utf-8') as json_file:
json.dump(self.feature_topicos, json_file, indent=4, ensure_ascii=False)
def _aplica_regra_treino(identificador, tweet):
print('\nTweet: %s'%tweet)
print('O Tweet Apresenta Vulnerabilidade? [S/N] ', end='')
chave = 'vulnerabilidade'
if input(str()).upper() == 'S':
valor = 1.0
else:
valor = 0.0
_atualiza_feature_topicos_(identificador, chave, valor)
clear()
_retorna_tweet_topico()
treino = int(len(_tweet)*0.6) ## Treino 60% da Base ##
tw = _tweet.copy()
ident = _id.copy()
pos = 0
print('Deseja Continuar a Etiquetagem da Base? [S/N] ', end='')
if input(str()).upper() == 'S':
if len(tw) > 0:
for item in tw:
print('%i de %i Tweets - tópico: \"%s\" Id: %s'%(pos+1, len(tw), _topic, ident[pos]))
_aplica_regra_treino(ident[pos], item)
pos += 1
self.Atualiza_arquivo_controle('topico_treinamento', int(_topic))
pa.Atualiza_Recursos_Classificador()
else:
print('Etiquetagem atualizada! Não há mais tweets para etiquetar.\n')
else:
return True
class AnaliseLocalização():
'''
Retorna lista de cidades validadas para aplicação de geolocalização
:parametro tweets_selecionados: lista de tweets selecionados
'''
def __init__(self):
self.arq = Arquivo()
self.analise = AnaliseLexica()
self.arquivo = self.arq.Carregar_Arquivo(
'arquivos/arq_controle_mun_bra_ibge.csv')
self.cidades = self.arq.Carregar_Arquivo(
'arquivos/municipios_brasileiros_ibge.csv')
self._ids_tweets_localizacao = self.arq.Carregar_Arquivo(
'arquivos/data/lsa/_ids_tweets_localizacao.txt')
self.arq_controle_cidades = {}
self.cidades_validadas = []
self.Carregar_arq_controle_cidades()
self.Localizacoes()
def AgregarListas(self, lista):
result = []
aux = []
if type(lista) == list:
for item in lista:
if type(item) == list:
aux = self.AgregarListas(item)
result = result + aux
else:
result.append(item)
else:
result.append(lista)
return result
def _Selecionar_localizacao_tweets_banco_(self, lista_ids_tweets):
aux = ''
for item in lista_ids_tweets:
if item != lista_ids_tweets[-1]:
aux += 'id=%i OR ' % (int(item) + 610
) #foram desprezados 609 tweets
else:
aux += 'id=%i' % (int(item) + 610)
conn = pymysql.connect("localhost", "root", "", "tw")
c = conn.cursor()
query = "SELECT user_local, geo, coordinates, place, tweet FROM `selecionados_notrt_tb` WHERE %s" % aux
c.execute(query)
lista = []
while True:
res = c.fetchall()
if not res:
break
for result in res:
lista.append(str(result[0]))
lista.append(str(result[1]))
lista.append(str(result[2]))
lista.append(str(result[3]))
c.close()
return lista
def Localizacoes(self):
terminal.Mensagem('Iniciando em Análise Localização', 'd')
lista = self._Selecionar_localizacao_tweets_banco_(
self._ids_tweets_localizacao)
point = []
cidades_validadas = []
# Verificação do user_local
for i in lista:
if i != None:
point.append(i)
teste = self.Validacao_cidades(point)
for item in teste:
self.EhCidade(item)
# cidades_validadas.append(item)
self.arq.Gravar_Arquivo(
self.cidades_validadas,
'arquivos/data/localizacao/arquivo_localizacao.txt')
print('Arquivo \'arquivo_localizacao.txt\' tamanho: ',
len(self.cidades_validadas))
count, encontrou, cids = 0, False, []
cids.append(self.cidades_validadas[0])
for item in self.cidades_validadas:
for cidade in cids:
if cidade == item:
encontrou = True
if not encontrou:
cids.append(item)
encontrou = False
print('%i Cidades Brasileiras encontradas.' % len(cids))
cids.sort()
print(cids)
def Carregar_arq_controle_cidades(self):
for linha in self.arquivo:
linhas = linha.split(',')
self.arq_controle_cidades.update(
{linhas[0]: [int(linhas[1]), int(linhas[2])]})
def Validacao_cidades(self, lista):
aux = []
sinais = [
'.', ',', '?', '!', '-', ':', ';', '...', '(', ')', '[', ']', '{',
'}', '&', '*', '``', '“', "''", '…'
]
numeros = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
count_num = 0
count_pont = 0
sinal = ''
for local in lista:
# contem numeros - para coordenadas
for caract in local:
for num in numeros:
if caract == num:
count_num += 1
for pontuacao in sinais:
if caract == pontuacao:
sinal = pontuacao
count_pont += 1
if (count_pont == 0 & count_num == 0):
aux.append(local)
count_num = 0
if count_pont > 0:
locais = local.split(sinal)
for l in locais:
aux.append(l)
count_pont = 0
return aux
def EhCidade(self, localidade):
result = False
loc = self.analise.Remocao_acentuacao(localidade)
loc = self.analise.Remocao_caracteres_Tweets(loc)
if type(loc) == list:
loc = self.AgregarListas(loc)
if loc[0] == '':
return False
local = loc[0]
else:
local = local.upper()
space2 = re.compile(r'\B\s+')
local = re.sub(space2, '', local)
# local = loc[0]
local = local.upper()
letra = local[0]
inicio = self.arq_controle_cidades[letra][0]
fim = self.arq_controle_cidades[letra][1]
i = inicio
while i < fim:
city = self.cidades[i - 1].split(',')
cidade = city[0]
if local == cidade:
self.cidades_validadas.append(cidade)
result = True
break
i += 1
return result