def dataset_to_json(self, dataset_type):
'''
Função para transformar os inputs do dataset em json
'''
# vai guardar o index de cada uma das chaves presentes no cabeçalho do arquivo
dataset_config = self.get_config('dataset')
keys_dict = {}
dataset_list = []
path = dataset_config.get('path')
str_file_name = 'train_tsv' if dataset_type == 'train' else 'test_tsv'
str_json_file_name = 'train_json' if dataset_type == 'train' else 'test_json'
file_name = dataset_config.get(str_file_name)
json_file_name = dataset_config.get(str_json_file_name)
with open(f"{path}{file_name}") as fp:
# faz a leitura do arquivo, utilizando a tabulação como separeador
reader = csv.reader(fp, delimiter="\t")
# a primeira linha contém as chaves de cada um dos campos
keys = reader.__next__()
# preenche o dicionario de chaves com o indice
for index, value in enumerate(keys, start=0):
keys_dict[index] = value.lower()
# para as outras linhas do arquivo vai adicionando cada campo em seu respectivo lugar
for line in reader:
cur_dict = dictionary_creator_helper.create_dataset_dict()
for index, value in enumerate(line):
self.process_dataset_data(cur_dict, keys_dict.get(index), value)
dataset_list.append(cur_dict)
file_helper.dict_to_json(path, json_file_name, dataset_list, 4)
def create_pos_tag_input(self):
'''
Cria o input contendo as informações de part-of-speech dos dataset,
além de ir criando juntamente o dicionario de tags
'''
dataset_config = self.get_config('dataset')
dataset_path = dataset_config.get('path')
pos_config = self.get_config('part_of_speech')
pos_path = pos_config.get('path')
input_config = self.get_config('input')
input_path = input_config.get('path')
pos_tag_dict = { 'PAD' : 0 }
nlp = spacy.load('pt')
for dataset_type in self.dataset_types:
input_list = []
dataset_file_name = 'train_json' if dataset_type == 'train' else 'test_json'
input_file_name = 'train_pos_tagged_input' if dataset_type == 'train' else 'test_pos_tagged_input'
dataset = file_helper.get_json_file_data(dataset_path, dataset_config.get(dataset_file_name))
for data in dataset:
sentence = data.get('sentence')
tagged_sentence = [token.pos_ for token in nlp(sentence)]
for tag in tagged_sentence:
self.add_tag_in_pos_tag_dict(pos_tag_dict, tag)
input_data = self.include_padding([pos_tag_dict[tag] for tag in tagged_sentence])
input_list.append(input_data)
file_helper.dict_to_json(input_path, input_config.get(input_file_name), input_list, 4)
file_helper.dict_to_json(pos_path, pos_config.get('pos_tag_dict'), pos_tag_dict, 4)
def process_individual_dataset_to_word_to_id(self, path, file_name, word_to_id_dict, reverse_dict):
'''
Função para processar individualmente cada um dos datasets em word_to_id e reverse_dict
'''
dict_data = file_helper.get_json_file_data(path, file_name)
self.add_dataset_to_word_to_id(dict_data, word_to_id_dict, reverse_dict)
file_helper.dict_to_json(path, file_name, dict_data, 4)
def word_embeddings_to_json(self):
'''
Função para transformar o arquivo de word_embeddings em json
'''
word_embeddings_config = self.get_config('word_embeddings')
# lista de dicionarios com dados processados de word embeddings
word_embeddings_dict = {}
path = word_embeddings_config.get('path')
# seta o arquivo que vai ser utilizado de word embeddings
src_word_embedings = 'real_src' if word_embeddings_config.get('real') else 'example_src'
file_name = word_embeddings_config.get(src_word_embedings)
with open(f"{path}{file_name}") as fp:
# primeira linha do arquivo contém o número de linhas e a dimensionalidade do vetor
lines, vector_size = fp.readline().strip().split(' ')
word_embeddings_config['vocab_size'] = lines
word_embeddings_config['dimensions'] = vector_size
# itera por todas linhas que contém dados do word embeddings
for _ in range(int(lines)):
# separa os dados presentes em cada linha, e realiza o pop para separar a word do vetor
data_list = fp.readline().strip().split(' ')
word = data_list[0]
# transforma os dados do vetor em float
word_embeddings_dict[word] = [float(x) for x in data_list[1:]]
json_file_name = word_embeddings_config.get('word_embeddings_json')
file_helper.dict_to_json(path, json_file_name, word_embeddings_dict, 4)
def create_output_for_model(self):
'''
Cria o arquivo de output do modelo
'''
output_config = self.get_config('output')
dataset_config = self.get_config('dataset')
for dataset_type in self.dataset_types:
dataset_filename = 'train_json' if dataset_type == 'train' else 'test_json'
output_filename = 'train_sentence_output' if dataset_type == 'train' else 'test_sentence_output'
dataset = file_helper.get_json_file_data(dataset_config.get('path'), dataset_config.get(dataset_filename))
sentences_output = self.parse_output_sentence(dataset)
file_helper.dict_to_json(output_config.get('path'), output_config.get(output_filename), sentences_output, 4)
def create_word_dicts(self):
'''
Função que cria os dicionários de palavras(word_to_id, reverse_dict) presentes nos dados de entrada
'''
word_to_id_config = self.get_config('word_to_id')
path = word_to_id_config.get('path')
word_to_id_file_name = word_to_id_config.get('dict')
reverse_dict_file_name = word_to_id_config.get('reverse_dict')
word_to_id_dict = {}
reverse_dict = {}
self.process_all_dataset_to_word_to_id(word_to_id_dict, reverse_dict)
file_helper.dict_to_json(path, word_to_id_file_name, word_to_id_dict, 4)
file_helper.dict_to_json(path, reverse_dict_file_name, reverse_dict, 4)
def create_entity_input(self):
'''
Cria o arquivo de entity_input, que será utilizado como input no modelo
'''
dataset_config = self.get_config('dataset')
input_config = self.get_config('input')
dataset_path = dataset_config.get('path')
input_path = input_config.get('path')
for dataset_type in self.dataset_types:
dataset_type_filename = 'train_json' if dataset_type == 'train' else 'test_json'
input_type_filename = 'train_entity_input' if dataset_type == 'train' else 'test_entity_input'
dataset = file_helper.get_json_file_data(dataset_path, dataset_config.get(dataset_type_filename))
entity_input = self.parse_entity_input(dataset)
file_helper.dict_to_json(input_path, input_config.get(input_type_filename), entity_input, 4)
def save_predicted_output(self, dataset, predicted):
'''
Função para salvar de forma legivel o predict do modelo,
para evitar uma nova leitura do arquivo, os dados gravados são retornados pela função
'''
output_data = []
output_files_config = self.get_config('output_files')
output_path = output_files_config.get('path')
for index, data in enumerate(dataset):
pred = predicted[index]
sentence = data.get('sentence')
data['predicted_relation'] = self.parse_prediction_to_words(sentence, pred)
output_data.append(data)
file_helper.dict_to_json(output_path, output_files_config.get('predicted_output_json'), output_data, 4)
return output_data
def relation_to_id_json(self):
'''
Função para atribuir um id para cada uma das relações encontradas no dataset de treino
'''
dataset_config = self.get_config('dataset')
treino_json = file_helper.get_json_file_data(dataset_config.get('path'), dataset_config.get('train_json'))
relation_config = self.get_config('relation')
relation_dict = {}
# primeira relação deve ser NA e o id 0
relation_dict['NA'] = self.relation_id
for line in treino_json:
relation = line.get('relation')
if relation_dict.get(relation) is None:
self.increment_relation_id()
relation_dict[relation] = self.relation_id
file_helper.dict_to_json(relation_config.get('path'), relation_config.get('file_name'), relation_dict, 4)
def entities_types_to_id(self):
'''
Cria os dicionários para os tipos de entidades presentes no dataset de treino
'''
entities_type_dict = {}
reverse_entities_type_dict = {}
dataset_config = self.get_config('dataset')
entities_config = self.get_config('entities')
path = entities_config.get('path')
train_dataset = file_helper.get_json_file_data(dataset_config.get('path'), dataset_config.get('train_json'))
for sentence in train_dataset:
for str_type in ['head', 'tail']:
self.add_data_to_entities_dict(str_type, sentence, entities_type_dict, reverse_entities_type_dict)
file_helper.dict_to_json(path, entities_config.get('entities_to_id'), entities_type_dict, 4)
file_helper.dict_to_json(path, entities_config.get('reverse_entities_to_id'), reverse_entities_type_dict, 4)
def create_word_embeddings_weight(self):
'''
Função para criar o arquivo com vetor de pesos do word embeddings que será utilizado no modelo
'''
word_embeddings_config = self.get_config('word_embeddings')
word_embeddings = file_helper.get_json_file_data(word_embeddings_config.get('path'), word_embeddings_config.get('word_embeddings_json'))
word_embeddings_dimension = word_embeddings_config.get('dimensions')
word_to_id_config = self.get_config('word_to_id')
word_to_id = file_helper.get_json_file_data(word_to_id_config.get('path'), word_to_id_config.get('dict'))
word_embeddings_weight = self.create_empty_word_embeddings_weight_list(len(word_to_id) + 1, word_embeddings_dimension)
for word, index in word_to_id.items():
weight_in_embeddings = word_embeddings.get(word)
if weight_in_embeddings is not None:
word_embeddings_weight[index] = weight_in_embeddings
input_config = self.get_config('input')
file_helper.dict_to_json(input_config.get('path'), input_config.get('word_embeddings_weight'), word_embeddings_weight, 4)