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)