| # File: notebooks-main/longform-qa/lfqa_utils.py | |
| import functools | |
| import math | |
| import os | |
| from random import choice, randint | |
| from time import time | |
| import numpy as np | |
| import torch | |
| import torch.utils.checkpoint as checkpoint | |
| from torch.utils.data import DataLoader, Dataset, RandomSampler, SequentialSampler | |
| from tqdm import tqdm | |
| import faiss | |
| import nlp | |
| import pandas as pd | |
| from elasticsearch import Elasticsearch | |
| from elasticsearch.helpers import bulk, streaming_bulk | |
| from transformers import AdamW, AutoModel, AutoModelForSeq2SeqLM, AutoTokenizer, get_linear_schedule_with_warmup | |
| pd.set_option('display.max_colwidth', None) | |
| def make_es_index_snippets(es_client, passages_dset, index_name='english_wiki_kilt_snippets_100w'): | |
| index_config = {'settings': {'number_of_shards': 1, 'analysis': {'analyzer': {'stop_standard': {'type': 'standard', ' stopwords': '_english_'}}}}, 'mappings': {'properties': {'article_title': {'type': 'text', 'analyzer': 'standard', 'similarity': 'BM25'}, 'section_title': {'type': 'text', 'analyzer': 'standard', 'similarity': 'BM25'}, 'passage_text': {'type': 'text', 'analyzer': 'standard', 'similarity': 'BM25'}}}} | |
| es_client.indices.create(index=index_name, body=index_config) | |
| number_of_docs = passages_dset.num_rows | |
| progress = tqdm(unit='docs', total=number_of_docs) | |
| successes = 0 | |
| def passage_generator(): | |
| for passage in passages_dset: | |
| yield passage | |
| for (ok, action) in streaming_bulk(client=es_client, index=index_name, actions=passage_generator()): | |
| progress.update(1) | |
| successes += ok | |
| print('Indexed %d documents' % (successes,)) | |
| def query_es_index(question, es_client, index_name='english_wiki_kilt_snippets_100w', n_results=10, min_length=20): | |
| q = question.lower() | |
| banned = ['how', 'why', 'what', 'where', 'which', 'do', 'does', 'is', '?', 'eli5', 'eli5:'] | |
| q = ' '.join([w for w in q.split() if w not in banned]) | |
| response = es_client.search(index=index_name, body={'query': {'multi_match': {'query': q, 'fields': ['article_title', 'section_title', 'passage_text^2'], 'type': 'cross_fields'}}, 'size': 2 * n_results}) | |
| hits = response['hits']['hits'] | |
| support_doc = '<P> ' + ' <P> '.join([hit['_source']['passage_text'] for hit in hits]) | |
| res_list = [dict([(k, hit['_source'][k]) for k in hit['_source'] if k != 'passage_text']) for hit in hits] | |
| for (r, hit) in zip(res_list, hits): | |
| r['passage_id'] = hit['_id'] | |
| r['score'] = hit['_score'] | |
| r['passage_text'] = hit['_source']['passage_text'] | |
| res_list = [res for res in res_list if len(res['passage_text'].split()) > min_length][:n_results] | |
| return (support_doc, res_list) | |
| class ELI5DatasetQARetriver(Dataset): | |
| def __init__(self, examples_array, extra_answer_threshold=3, min_answer_length=64, training=True, n_samples=None): | |
| self.data = examples_array | |
| self.answer_thres = extra_answer_threshold | |
| self.min_length = min_answer_length | |
| self.training = training | |
| self.n_samples = self.data.num_rows if n_samples is None else n_samples | |
| def __len__(self): | |
| return self.n_samples | |
| def make_example(self, idx): | |
| example = self.data[idx] | |
| question = example['title'] | |
| if self.training: | |
| answers = [a for (i, (a, sc)) in enumerate(zip(example['answers']['text'], example['answers']['score']))] | |
| answer_tab = choice(answers).split(' ') | |
| start_idx = randint(0, max(0, len(answer_tab) - self.min_length)) | |
| answer_span = ' '.join(answer_tab[start_idx:]) | |
| else: | |
| answer_span = example['answers']['text'][0] | |
| return (question, answer_span) | |
| def __getitem__(self, idx): | |
| return self.make_example(idx % self.data.num_rows) | |
| class RetrievalQAEmbedder(torch.nn.Module): | |
| def __init__(self, sent_encoder, dim): | |
| super(RetrievalQAEmbedder, self).__init__() | |
| self.sent_encoder = sent_encoder | |
| self.output_dim = 128 | |
| self.project_q = torch.nn.Linear(dim, self.output_dim, bias=False) | |
| self.project_a = torch.nn.Linear(dim, self.output_dim, bias=False) | |
| self.ce_loss = torch.nn.CrossEntropyLoss(reduction='mean') | |
| def embed_sentences_checkpointed(self, input_ids, attention_mask, checkpoint_batch_size=-1): | |
| if checkpoint_batch_size < 0 or input_ids.shape[0] < checkpoint_batch_size: | |
| return self.sent_encoder(input_ids, attention_mask=attention_mask)[1] | |
| else: | |
| device = input_ids.device | |
| input_shape = input_ids.size() | |
| token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device) | |
| head_mask = [None] * self.sent_encoder.config.num_hidden_layers | |
| extended_attention_mask: torch.Tensor = self.sent_encoder.get_extended_attention_mask(attention_mask, input_shape, device) | |
| def partial_encode(*inputs): | |
| encoder_outputs = self.sent_encoder.encoder(inputs[0], attention_mask=inputs[1], head_mask=head_mask) | |
| sequence_output = encoder_outputs[0] | |
| pooled_output = self.sent_encoder.pooler(sequence_output) | |
| return pooled_output | |
| embedding_output = self.sent_encoder.embeddings(input_ids=input_ids, position_ids=None, token_type_ids=token_type_ids, inputs_embeds=None) | |
| pooled_output_list = [] | |
| for b in range(math.ceil(input_ids.shape[0] / checkpoint_batch_size)): | |
| b_embedding_output = embedding_output[b * checkpoint_batch_size:(b + 1) * checkpoint_batch_size] | |
| b_attention_mask = extended_attention_mask[b * checkpoint_batch_size:(b + 1) * checkpoint_batch_size] | |
| pooled_output = checkpoint.checkpoint(partial_encode, b_embedding_output, b_attention_mask) | |
| pooled_output_list.append(pooled_output) | |
| return torch.cat(pooled_output_list, dim=0) | |
| def embed_questions(self, q_ids, q_mask, checkpoint_batch_size=-1): | |
| q_reps = self.embed_sentences_checkpointed(q_ids, q_mask, checkpoint_batch_size) | |
| return self.project_q(q_reps) | |
| def embed_answers(self, a_ids, a_mask, checkpoint_batch_size=-1): | |
| a_reps = self.embed_sentences_checkpointed(a_ids, a_mask, checkpoint_batch_size) | |
| return self.project_a(a_reps) | |
| def forward(self, q_ids, q_mask, a_ids, a_mask, checkpoint_batch_size=-1): | |
| device = q_ids.device | |
| q_reps = self.embed_questions(q_ids, q_mask, checkpoint_batch_size) | |
| a_reps = self.embed_answers(a_ids, a_mask, checkpoint_batch_size) | |
| compare_scores = torch.mm(q_reps, a_reps.t()) | |
| loss_qa = self.ce_loss(compare_scores, torch.arange(compare_scores.shape[1]).to(device)) | |
| loss_aq = self.ce_loss(compare_scores.t(), torch.arange(compare_scores.shape[0]).to(device)) | |
| loss = (loss_qa + loss_aq) / 2 | |
| return loss | |
| def make_qa_retriever_model(model_name='google/bert_uncased_L-8_H-512_A-8', from_file=None, device='cuda:0'): | |
| tokenizer = AutoTokenizer.from_pretrained(model_name) | |
| bert_model = AutoModel.from_pretrained(model_name).to(device) | |
| d_ids = torch.LongTensor([[bert_model.config.bos_token_id if bert_model.config.bos_token_id is not None else 1]]).to(device) | |
| d_mask = torch.LongTensor([[1]]).to(device) | |
| sent_dim = bert_model(d_ids, attention_mask=d_mask)[1].shape[-1] | |
| qa_embedder = RetrievalQAEmbedder(bert_model, sent_dim).to(device) | |
| if from_file is not None: | |
| param_dict = torch.load(from_file) | |
| qa_embedder.load_state_dict(param_dict['model']) | |
| return (tokenizer, qa_embedder) | |
| def make_qa_retriever_batch(qa_list, tokenizer, max_len=64, device='cuda:0'): | |
| q_ls = [q for (q, a) in qa_list] | |
| a_ls = [a for (q, a) in qa_list] | |
| q_toks = tokenizer.batch_encode_plus(q_ls, max_length=max_len, pad_to_max_length=True) | |
| (q_ids, q_mask) = (torch.LongTensor(q_toks['input_ids']).to(device), torch.LongTensor(q_toks['attention_mask']).to(device)) | |
| a_toks = tokenizer.batch_encode_plus(a_ls, max_length=max_len, pad_to_max_length=True) | |
| (a_ids, a_mask) = (torch.LongTensor(a_toks['input_ids']).to(device), torch.LongTensor(a_toks['attention_mask']).to(device)) | |
| return (q_ids, q_mask, a_ids, a_mask) | |
| def train_qa_retriever_epoch(model, dataset, tokenizer, optimizer, scheduler, args, e=0): | |
| model.train() | |
| train_sampler = RandomSampler(dataset) | |
| model_collate_fn = functools.partial(make_qa_retriever_batch, tokenizer=tokenizer, max_len=args.max_length, device='cuda:0') | |
| data_loader = DataLoader(dataset, batch_size=args.batch_size, sampler=train_sampler, collate_fn=model_collate_fn) | |
| epoch_iterator = tqdm(data_loader, desc='Iteration', disable=True) | |
| loc_steps = 0 | |
| loc_loss = 0.0 | |
| st_time = time() | |
| for (step, batch) in enumerate(epoch_iterator): | |
| (q_ids, q_mask, a_ids, a_mask) = batch | |
| pre_loss = model(q_ids, q_mask, a_ids, a_mask, checkpoint_batch_size=args.checkpoint_batch_size) | |
| loss = pre_loss.sum() | |
| loss.backward() | |
| optimizer.step() | |
| scheduler.step() | |
| model.zero_grad() | |
| loc_loss += loss.item() | |
| loc_steps += 1 | |
| if step % args.print_freq == 0 or step == 1: | |
| print('{:2d} {:5d} of {:5d} \t L: {:.3f} \t -- {:.3f}'.format(e, step, len(dataset) // args.batch_size, loc_loss / loc_steps, time() - st_time)) | |
| loc_loss = 0 | |
| loc_steps = 0 | |
| def train_qa_retriever_joint_epoch(model, dataset_list, tokenizer, optimizer, scheduler, args, e=0): | |
| model.train() | |
| model_collate_fn = functools.partial(make_qa_retriever_batch, tokenizer=tokenizer, max_len=args.max_length, device='cuda:0') | |
| train_samplers = [RandomSampler(dataset) for dataset in dataset_list] | |
| data_loaders = [DataLoader(dataset, batch_size=args.batch_size, sampler=train_sampler, collate_fn=model_collate_fn) for (dataset, train_sampler) in zip(dataset_list, train_samplers)] | |
| iterators = [iter(dloader) for dloader in data_loaders] | |
| joint_iter = zip(*iterators) | |
| loc_steps = 0 | |
| loc_loss = 0.0 | |
| st_time = time() | |
| for (step, (batches,)) in enumerate(zip(joint_iter)): | |
| for batch in batches: | |
| (q_ids, q_mask, a_ids, a_mask) = batch | |
| loss = model(q_ids, q_mask, a_ids, a_mask, checkpoint_batch_size=args.checkpoint_batch_size) | |
| loss.backward() | |
| optimizer.step() | |
| scheduler.step() | |
| model.zero_grad() | |
| loc_loss += loss.item() | |
| loc_steps += 1 | |
| if step % args.print_freq == 0: | |
| print('{:2d} {:5d} of {:5d} \t L: {:.3f} \t -- {:.3f}'.format(e, step, len(dataset_list[0]) // args.batch_size, loc_loss / loc_steps, time() - st_time)) | |
| loc_loss = 0 | |
| loc_steps = 0 | |
| def evaluate_qa_retriever(model, dataset, tokenizer, args): | |
| model.eval() | |
| eval_sampler = SequentialSampler(dataset) | |
| model_collate_fn = functools.partial(make_qa_retriever_batch, tokenizer=tokenizer, max_len=args.max_length, device='cuda:0') | |
| data_loader = DataLoader(dataset, batch_size=args.batch_size, sampler=eval_sampler, collate_fn=model_collate_fn) | |
| epoch_iterator = tqdm(data_loader, desc='Iteration', disable=True) | |
| tot_loss = 0.0 | |
| with torch.no_grad(): | |
| for (step, batch) in enumerate(epoch_iterator): | |
| (q_ids, q_mask, a_ids, a_mask) = batch | |
| loss = model(q_ids, q_mask, a_ids, a_mask) | |
| tot_loss += loss.item() | |
| return tot_loss / (step + 1) | |
| def train_qa_retriever(qar_model, qar_tokenizer, qar_train_dset, qar_valid_dset, qar_args): | |
| qar_optimizer = AdamW(qar_model.parameters(), lr=qar_args.learning_rate, eps=1e-08) | |
| qar_scheduler = get_linear_schedule_with_warmup(qar_optimizer, num_warmup_steps=100, num_training_steps=(qar_args.num_epochs + 1) * math.ceil(len(qar_train_dset) / qar_args.batch_size)) | |
| for e in range(qar_args.num_epochs): | |
| train_qa_retriever_epoch(qar_model, qar_train_dset, qar_tokenizer, qar_optimizer, qar_scheduler, qar_args, e) | |
| m_save_dict = {'model': qar_model.state_dict(), 'optimizer': qar_optimizer.state_dict(), 'scheduler': qar_scheduler.state_dict()} | |
| print('Saving model {}'.format(qar_args.model_save_name)) | |
| torch.save(m_save_dict, '{}_{}.pth'.format(qar_args.model_save_name, e)) | |
| eval_loss = evaluate_qa_retriever(qar_model, qar_valid_dset, qar_tokenizer, qar_args) | |
| print('Evaluation loss epoch {:4d}: {:.3f}'.format(e, eval_loss)) | |
| class ELI5DatasetS2S(Dataset): | |
| def __init__(self, examples_array, make_doc_fun=None, extra_answer_threshold=3, document_cache=None, training=True): | |
| self.training = training | |
| self.data = examples_array | |
| self.make_doc_function = make_doc_fun | |
| self.document_cache = {} if document_cache is None else document_cache | |
| assert not (make_doc_fun is None and document_cache is None) | |
| if self.training: | |
| self.qa_id_list = [(i, j) for (i, qa) in enumerate(self.data) for (j, (a, sc)) in enumerate(zip(qa['answers']['text'], qa['answers']['score'])) if j == 0 or sc >= extra_answer_threshold] | |
| else: | |
| self.qa_id_list = [(i, 0) for i in range(self.data.num_rows)] | |
| def __len__(self): | |
| return len(self.qa_id_list) | |
| def make_example(self, idx): | |
| (i, j) = self.qa_id_list[idx] | |
| example = self.data[i] | |
| question = example['title'] + ' ' + example['selftext'] | |
| answer = example['answers']['text'][j] | |
| q_id = example['q_id'] | |
| if self.make_doc_function is not None: | |
| self.document_cache[q_id] = self.document_cache.get(q_id, self.make_doc_function(example['title'])) | |
| document = self.document_cache[q_id] | |
| in_st = 'question: {} context: {}'.format(question.lower().replace(' --t--', '').strip(), document.lower().strip()) | |
| out_st = answer | |
| return (in_st, out_st) | |
| def __getitem__(self, idx): | |
| return self.make_example(idx) | |
| def make_qa_s2s_model(model_name='facebook/bart-large', from_file=None, device='cuda:0'): | |
| tokenizer = AutoTokenizer.from_pretrained(model_name) | |
| model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to(device) | |
| if from_file is not None: | |
| param_dict = torch.load(from_file) | |
| model.load_state_dict(param_dict['model']) | |
| return (tokenizer, model) | |
| def make_qa_s2s_batch(qa_list, tokenizer, max_len=64, max_a_len=360, device='cuda:0'): | |
| q_ls = [q for (q, a) in qa_list] | |
| a_ls = [a for (q, a) in qa_list] | |
| q_toks = tokenizer.batch_encode_plus(q_ls, max_length=max_len, pad_to_max_length=True) | |
| (q_ids, q_mask) = (torch.LongTensor(q_toks['input_ids']).to(device), torch.LongTensor(q_toks['attention_mask']).to(device)) | |
| a_toks = tokenizer.batch_encode_plus(a_ls, max_length=min(max_len, max_a_len), pad_to_max_length=True) | |
| (a_ids, a_mask) = (torch.LongTensor(a_toks['input_ids']).to(device), torch.LongTensor(a_toks['attention_mask']).to(device)) | |
| lm_labels = a_ids[:, 1:].contiguous().clone() | |
| lm_labels[a_mask[:, 1:].contiguous() == 0] = -100 | |
| model_inputs = {'input_ids': q_ids, 'attention_mask': q_mask, 'decoder_input_ids': a_ids[:, :-1].contiguous(), 'lm_labels': lm_labels} | |
| return model_inputs | |
| def train_qa_s2s_epoch(model, dataset, tokenizer, optimizer, scheduler, args, e=0, curriculum=False): | |
| model.train() | |
| if curriculum: | |
| train_sampler = SequentialSampler(dataset) | |
| else: | |
| train_sampler = RandomSampler(dataset) | |
| model_collate_fn = functools.partial(make_qa_s2s_batch, tokenizer=tokenizer, max_len=args.max_length, device='cuda:0') | |
| data_loader = DataLoader(dataset, batch_size=args.batch_size, sampler=train_sampler, collate_fn=model_collate_fn) | |
| epoch_iterator = tqdm(data_loader, desc='Iteration', disable=True) | |
| loc_steps = 0 | |
| loc_loss = 0.0 | |
| st_time = time() | |
| for (step, batch_inputs) in enumerate(epoch_iterator): | |
| pre_loss = model(**batch_inputs)[0] | |
| loss = pre_loss.sum() / pre_loss.shape[0] | |
| loss.backward() | |
| if step % args.backward_freq == 0: | |
| optimizer.step() | |
| scheduler.step() | |
| model.zero_grad() | |
| loc_loss += loss.item() | |
| loc_steps += 1 | |
| if step % args.print_freq == 0 or step == 1: | |
| print('{:2d} {:5d} of {:5d} \t L: {:.3f} \t -- {:.3f}'.format(e, step, len(dataset) // args.batch_size, loc_loss / loc_steps, time() - st_time)) | |
| loc_loss = 0 | |
| loc_steps = 0 | |
| def eval_qa_s2s_epoch(model, dataset, tokenizer, args): | |
| model.eval() | |
| train_sampler = SequentialSampler(dataset) | |
| model_collate_fn = functools.partial(make_qa_s2s_batch, tokenizer=tokenizer, max_len=args.max_length, device='cuda:0') | |
| data_loader = DataLoader(dataset, batch_size=args.batch_size, sampler=train_sampler, collate_fn=model_collate_fn) | |
| epoch_iterator = tqdm(data_loader, desc='Iteration', disable=True) | |
| loc_steps = 0 | |
| loc_loss = 0.0 | |
| st_time = time() | |
| with torch.no_grad(): | |
| for (step, batch_inputs) in enumerate(epoch_iterator): | |
| pre_loss = model(**batch_inputs)[0] | |
| loss = pre_loss.sum() / pre_loss.shape[0] | |
| loc_loss += loss.item() | |
| loc_steps += 1 | |
| if step % args.print_freq == 0: | |
| print('{:5d} of {:5d} \t L: {:.3f} \t -- {:.3f}'.format(step, len(dataset) // args.batch_size, loc_loss / loc_steps, time() - st_time)) | |
| print('Total \t L: {:.3f} \t -- {:.3f}'.format(loc_loss / loc_steps, time() - st_time)) | |
| def train_qa_s2s(qa_s2s_model, qa_s2s_tokenizer, s2s_train_dset, s2s_valid_dset, s2s_args): | |
| s2s_optimizer = AdamW(qa_s2s_model.parameters(), lr=s2s_args.learning_rate, eps=1e-08) | |
| s2s_scheduler = get_linear_schedule_with_warmup(s2s_optimizer, num_warmup_steps=400, num_training_steps=(s2s_args.num_epochs + 1) * math.ceil(len(s2s_train_dset) / s2s_args.batch_size)) | |
| for e in range(s2s_args.num_epochs): | |
| train_qa_s2s_epoch(qa_s2s_model, s2s_train_dset, qa_s2s_tokenizer, s2s_optimizer, s2s_scheduler, s2s_args, e, curriculum=e == 0) | |
| m_save_dict = {'model': qa_s2s_model.state_dict(), 'optimizer': s2s_optimizer.state_dict(), 'scheduler': s2s_scheduler.state_dict()} | |
| print('Saving model {}'.format(s2s_args.model_save_name)) | |
| eval_qa_s2s_epoch(qa_s2s_model, s2s_valid_dset, qa_s2s_tokenizer, s2s_args) | |
| torch.save(m_save_dict, '{}_{}.pth'.format(s2s_args.model_save_name, e)) | |
| def qa_s2s_generate(question_doc, qa_s2s_model, qa_s2s_tokenizer, num_answers=1, num_beams=None, min_len=64, max_len=256, do_sample=False, temp=1.0, top_p=None, top_k=None, max_input_length=512, device='cuda:0'): | |
| model_inputs = make_qa_s2s_batch([(question_doc, 'A')], qa_s2s_tokenizer, max_input_length, device=device) | |
| n_beams = num_answers if num_beams is None else max(num_beams, num_answers) | |
| generated_ids = qa_s2s_model.generate(input_ids=model_inputs['input_ids'], attention_mask=model_inputs['attention_mask'], min_length=min_len, max_length=max_len, do_sample=do_sample, early_stopping=True, num_beams=1 if do_sample else n_beams, temperature=temp, top_k=top_k, top_p=top_p, eos_token_id=qa_s2s_tokenizer.eos_token_id, no_repeat_ngram_size=3, num_return_sequences=num_answers, decoder_start_token_id=qa_s2s_tokenizer.bos_token_id) | |
| return [qa_s2s_tokenizer.decode(ans_ids, skip_special_tokens=True).strip() for ans_ids in generated_ids] | |
| def embed_passages_for_retrieval(passages, tokenizer, qa_embedder, max_length=128, device='cuda:0'): | |
| a_toks = tokenizer.batch_encode_plus(passages, max_length=max_length, pad_to_max_length=True) | |
| (a_ids, a_mask) = (torch.LongTensor(a_toks['input_ids']).to(device), torch.LongTensor(a_toks['attention_mask']).to(device)) | |
| with torch.no_grad(): | |
| a_reps = qa_embedder.embed_answers(a_ids, a_mask).cpu().type(torch.float) | |
| return a_reps.numpy() | |
| def embed_questions_for_retrieval(q_ls, tokenizer, qa_embedder, device='cuda:0'): | |
| q_toks = tokenizer.batch_encode_plus(q_ls, max_length=128, pad_to_max_length=True) | |
| (q_ids, q_mask) = (torch.LongTensor(q_toks['input_ids']).to(device), torch.LongTensor(q_toks['attention_mask']).to(device)) | |
| with torch.no_grad(): | |
| q_reps = qa_embedder.embed_questions(q_ids, q_mask).cpu().type(torch.float) | |
| return q_reps.numpy() | |
| def make_qa_dense_index(qa_embedder, tokenizer, passages_dset, batch_size=512, max_length=128, index_name='kilt_passages_reps.dat', dtype='float32', device='cuda:0'): | |
| st_time = time() | |
| fp = np.memmap(index_name, dtype=dtype, mode='w+', shape=(passages_dset.num_rows, 128)) | |
| n_batches = math.ceil(passages_dset.num_rows / batch_size) | |
| for i in range(n_batches): | |
| passages = [p for p in passages_dset[i * batch_size:(i + 1) * batch_size]['passage_text']] | |
| reps = embed_passages_for_retrieval(passages, tokenizer, qa_embedder, max_length, device) | |
| fp[i * batch_size:(i + 1) * batch_size] = reps | |
| if i % 50 == 0: | |
| print(i, time() - st_time) | |
| def evaluate_retriever(qa_list, retriever_func, scoring_func, n_ret=10, verbose=False): | |
| total_retriever_time = 0.0 | |
| total_retriever_score = 0.0 | |
| st_time = time() | |
| for (i, (question, answer)) in enumerate(qa_list): | |
| r_time = time() | |
| retrieved_passages = retriever_func(question, n_ret) | |
| total_retriever_time += time() - r_time | |
| total_retriever_score += scoring_func(retrieved_passages, answer) | |
| if verbose and ((i + 1) % 500 == 0 or i <= 1): | |
| print('{:03d}: S-{:.4f} T-{:.4f} | {:.2f}'.format(i + 1, total_retriever_score / (i + 1), total_retriever_time / (i + 1), time() - st_time)) | |
| return {'idf_recall': total_retriever_score / (i + 1), 'retrieval_time': total_retriever_time / (i + 1)} | |
| def query_qa_dense_index(question, qa_embedder, tokenizer, wiki_passages, wiki_index, n_results=10, min_length=20, device='cuda:0'): | |
| q_rep = embed_questions_for_retrieval([question], tokenizer, qa_embedder, device=device) | |
| (D, I) = wiki_index.search(q_rep, 2 * n_results) | |
| res_passages = [wiki_passages[int(i)] for i in I[0]] | |
| support_doc = '<P> ' + ' <P> '.join([p['passage_text'] for p in res_passages]) | |
| res_list = [dict([(k, p[k]) for k in wiki_passages.column_names]) for p in res_passages] | |
| res_list = [res for res in res_list if len(res['passage_text'].split()) > min_length][:n_results] | |
| for (r, sc) in zip(res_list, D[0]): | |
| r['score'] = float(sc) | |
| return (support_doc, res_list) | |
| def batch_query_qa_dense_index(questions, qa_embedder, tokenizer, wiki_passages, wiki_index, n_results=10): | |
| q_rep = embed_questions_for_retrieval(questions, tokenizer, qa_embedder) | |
| (D, I) = wiki_index.search(q_rep, n_results) | |
| res_passages_lst = [[wiki_passages[int(i)] for i in i_lst] for i_lst in I] | |
| support_doc_lst = ['<P> ' + ' <P> '.join([p['passage_text'] for p in res_passages]) for res_passages in res_passages_lst] | |
| all_res_lists = [] | |
| for (res_passages, dl) in zip(res_passages_lst, D): | |
| res_list = [dict([(k, p[k]) for k in wiki_passages.column_names]) for p in res_passages] | |
| for (r, sc) in zip(res_list, dl): | |
| r['score'] = float(sc) | |
| all_res_lists += [res_list[:]] | |
| return (support_doc_lst, all_res_lists) | |
| def query_qa_dense_index_nn(passage, qa_embedder, tokenizer, wiki_passages, wiki_index, n_results=10, min_length=20): | |
| a_rep = embed_passages_for_retrieval([passage], tokenizer, qa_embedder) | |
| (D, I) = wiki_index.search(a_rep, 2 * n_results) | |
| res_passages = [wiki_passages[int(i)] for i in I[0]] | |
| support_doc = '<P> ' + ' <P> '.join([p['passage_text'] for p in res_passages]) | |
| res_list = [dict([(k, p[k]) for k in wiki_passages.column_names]) for p in res_passages] | |
| res_list = [res for res in res_list if len(res['passage_text'].split()) > min_length][:n_results] | |
| for (r, sc, i) in zip(res_list, D[0], I[0]): | |
| r['passage_id'] = int(i) | |
| r['score'] = float(sc) | |
| return (support_doc, res_list) | |
| def batch_query_qa_dense_index_nn(passages, qa_embedder, tokenizer, wiki_passages, wiki_index, n_results=10): | |
| a_reps = embed_passages_for_retrieval(passages, tokenizer, qa_embedder) | |
| (D, I) = wiki_index.search(a_reps, n_results) | |
| res_passages_lst = [[wiki_passages[int(i)] for i in i_lst] for i_lst in I] | |
| support_doc_lst = ['<P> ' + ' <P> '.join([p['passage_text'] for p in res_passages]) for res_passages in res_passages_lst] | |
| all_res_lists = [] | |
| for (res_passages, dl, il) in zip(res_passages_lst, D, I): | |
| res_list = [dict([(k, p[k]) for k in wiki_passages.column_names]) for p in res_passages] | |
| for (r, sc, i) in zip(res_list, dl, il): | |
| r['passage_id'] = int(i) | |
| r['score'] = float(sc) | |
| all_res_lists += [res_list[:]] | |
| return (support_doc_lst, all_res_lists) | |
| # File: notebooks-main/sagemaker/17_custom_inference_script/code/inference.py | |
| from transformers import AutoTokenizer, AutoModel | |
| import torch | |
| import torch.nn.functional as F | |
| def mean_pooling(model_output, attention_mask): | |
| token_embeddings = model_output[0] | |
| input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float() | |
| return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-09) | |
| def model_fn(model_dir): | |
| tokenizer = AutoTokenizer.from_pretrained(model_dir) | |
| model = AutoModel.from_pretrained(model_dir) | |
| return (model, tokenizer) | |
| def predict_fn(data, model_and_tokenizer): | |
| (model, tokenizer) = model_and_tokenizer | |
| sentences = data.pop('inputs', data) | |
| encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt') | |
| with torch.no_grad(): | |
| model_output = model(**encoded_input) | |
| sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask']) | |
| sentence_embeddings = F.normalize(sentence_embeddings, p=2, dim=1) | |
| return {'vectors': sentence_embeddings} | |
| # File: notebooks-main/sagemaker/18_inferentia_inference/code/inference.py | |
| import os | |
| from transformers import AutoConfig, AutoTokenizer | |
| import torch | |
| import torch.neuron | |
| os.environ['NEURON_RT_NUM_CORES'] = '1' | |
| AWS_NEURON_TRACED_WEIGHTS_NAME = 'neuron_model.pt' | |
| def model_fn(model_dir): | |
| tokenizer = AutoTokenizer.from_pretrained(model_dir) | |
| model = torch.jit.load(os.path.join(model_dir, AWS_NEURON_TRACED_WEIGHTS_NAME)) | |
| model_config = AutoConfig.from_pretrained(model_dir) | |
| return (model, tokenizer, model_config) | |
| def predict_fn(data, model_tokenizer_model_config): | |
| (model, tokenizer, model_config) = model_tokenizer_model_config | |
| inputs = data.pop('inputs', data) | |
| embeddings = tokenizer(inputs, return_tensors='pt', max_length=model_config.traced_sequence_length, padding='max_length', truncation=True) | |
| neuron_inputs = tuple(embeddings.values()) | |
| with torch.no_grad(): | |
| predictions = model(*neuron_inputs)[0] | |
| scores = torch.nn.Softmax(dim=1)(predictions) | |
| return [{'label': model_config.id2label[item.argmax().item()], 'score': item.max().item()} for item in scores] | |
| # File: notebooks-main/sagemaker/22_accelerate_sagemaker_examples/src/seq2seq/run_seq2seq_no_trainer.py | |
| """""" | |
| import argparse | |
| import json | |
| import logging | |
| import math | |
| import os | |
| import random | |
| from pathlib import Path | |
| from time import time | |
| import datasets | |
| import nltk | |
| import numpy as np | |
| import torch | |
| from datasets import load_dataset, load_metric | |
| from torch.utils.data import DataLoader | |
| from tqdm.auto import tqdm | |
| import transformers | |
| from accelerate import Accelerator | |
| from accelerate.logging import get_logger | |
| from accelerate.utils import DummyOptim, DummyScheduler, set_seed | |
| from filelock import FileLock | |
| from huggingface_hub import Repository | |
| from transformers import CONFIG_MAPPING, MODEL_MAPPING, AutoConfig, AutoModelForSeq2SeqLM, AutoTokenizer, DataCollatorForSeq2Seq, SchedulerType, get_scheduler | |
| from transformers.utils import get_full_repo_name, is_offline_mode | |
| from transformers.utils.versions import require_version | |
| logger = get_logger(__name__) | |
| require_version('datasets>=1.8.0', 'To fix: pip install -r examples/pytorch/summarization/requirements.txt') | |
| MODEL_CONFIG_CLASSES = list(MODEL_MAPPING.keys()) | |
| MODEL_TYPES = tuple((conf.model_type for conf in MODEL_CONFIG_CLASSES)) | |
| try: | |
| nltk.data.find('tokenizers/punkt') | |
| except (LookupError, OSError): | |
| if is_offline_mode(): | |
| raise LookupError('Offline mode: run this script without TRANSFORMERS_OFFLINE first to download nltk data files') | |
| with FileLock('.lock') as lock: | |
| nltk.download('punkt', quiet=True) | |
| def parse_args(): | |
| parser = argparse.ArgumentParser(description='Finetune a transformers model on a summarization task') | |
| parser.add_argument('--dataset_name', type=str, default=None, help='The name of the dataset to use (via the datasets library).') | |
| parser.add_argument('--dataset_config_name', type=str, default=None, help='The configuration name of the dataset to use (via the datasets library).') | |
| parser.add_argument('--train_file', type=str, default=None, help='A csv or a json file containing the training data.') | |
| parser.add_argument('--validation_file', type=str, default=None, help='A csv or a json file containing the validation data.') | |
| parser.add_argument('--ignore_pad_token_for_loss', type=bool, default=True, help='Whether to ignore the tokens corresponding to padded labels in the loss computation or not.') | |
| parser.add_argument('--max_source_length', type=int, default=1024, help='The maximum total input sequence length after tokenization.Sequences longer than this will be truncated, sequences shorter will be padded.') | |
| parser.add_argument('--source_prefix', type=str, default=None, help='A prefix to add before every source text (useful for T5 models).') | |
| parser.add_argument('--preprocessing_num_workers', type=int, default=None, help='The number of processes to use for the preprocessing.') | |
| parser.add_argument('--overwrite_cache', type=bool, default=None, help='Overwrite the cached training and evaluation sets') | |
| parser.add_argument('--max_target_length', type=int, default=128, help='The maximum total sequence length for target text after tokenization. Sequences longer than this will be truncated, sequences shorter will be padded.during ``evaluate`` and ``predict``.') | |
| parser.add_argument('--val_max_target_length', type=int, default=None, help='The maximum total sequence length for validation target text after tokenization.Sequences longer than this will be truncated, sequences shorter will be padded. Will default to `max_target_length`.This argument is also used to override the ``max_length`` param of ``model.generate``, which is used during ``evaluate`` and ``predict``.') | |
| parser.add_argument('--val_min_target_length', type=int, default=10, help='The minimum total sequence length for validation target text after tokenization.Sequences longer than this will be truncated, sequences shorter will be padded. Will default to `max_target_length`.This argument is also used to override the ``max_length`` param of ``model.generate``, which is used during ``evaluate`` and ``predict``.') | |
| parser.add_argument('--n_train', type=int, default=2000, help='Number of training examples to use. If None, all training examples will be used.') | |
| parser.add_argument('--n_val', type=int, default=500, help='Number of validation examples to use. If None, all validation examples will be used.') | |
| parser.add_argument('--n_val_batch_generations', type=int, default=5, help='Number of validation examples to use. If None, all validation examples will be used.') | |
| parser.add_argument('--max_length', type=int, default=128, help='The maximum total input sequence length after tokenization. Sequences longer than this will be truncated, sequences shorter will be padded if `--pad_to_max_lengh` is passed.') | |
| parser.add_argument('--num_beams', type=int, default=None, help='Number of beams to use for evaluation. This argument will be passed to ``model.generate``, which is used during ``evaluate`` and ``predict``.') | |
| parser.add_argument('--pad_to_max_length', type=bool, default=False, help='If passed, pad all samples to `max_length`. Otherwise, dynamic padding is used.') | |
| parser.add_argument('--model_name_or_path', type=str, help='Path to pretrained model or model identifier from huggingface.co/models.', required=False) | |
| parser.add_argument('--config_name', type=str, default=None, help='Pretrained config name or path if not the same as model_name') | |
| parser.add_argument('--tokenizer_name', type=str, default=None, help='Pretrained tokenizer name or path if not the same as model_name') | |
| parser.add_argument('--text_column', type=str, default=None, help='The name of the column in the datasets containing the full texts (for summarization).') | |
| parser.add_argument('--summary_column', type=str, default=None, help='The name of the column in the datasets containing the summaries (for summarization).') | |
| parser.add_argument('--use_slow_tokenizer', type=bool, default=False, help='If passed, will use a slow tokenizer (not backed by the 🤗 Tokenizers library).') | |
| parser.add_argument('--per_device_train_batch_size', type=int, default=8, help='Batch size (per device) for the training dataloader.') | |
| parser.add_argument('--per_device_eval_batch_size', type=int, default=8, help='Batch size (per device) for the evaluation dataloader.') | |
| parser.add_argument('--learning_rate', type=float, default=5e-05, help='Initial learning rate (after the potential warmup period) to use.') | |
| parser.add_argument('--weight_decay', type=float, default=0.0, help='Weight decay to use.') | |
| parser.add_argument('--num_train_epochs', type=int, default=3, help='Total number of training epochs to perform.') | |
| parser.add_argument('--max_train_steps', type=int, default=None, help='Total number of training steps to perform. If provided, overrides num_train_epochs.') | |
| parser.add_argument('--gradient_accumulation_steps', type=int, default=1, help='Number of updates steps to accumulate before performing a backward/update pass.') | |
| parser.add_argument('--lr_scheduler_type', type=SchedulerType, default='linear', help='The scheduler type to use.', choices=['linear', 'cosine', 'cosine_with_restarts', 'polynomial', 'constant', 'constant_with_warmup']) | |
| parser.add_argument('--num_warmup_steps', type=int, default=0, help='Number of steps for the warmup in the lr scheduler.') | |
| parser.add_argument('--output_dir', type=str, default=None, help='Where to store the final model.') | |
| parser.add_argument('--seed', type=int, default=None, help='A seed for reproducible training.') | |
| parser.add_argument('--model_type', type=str, default=None, help='Model type to use if training from scratch.', choices=MODEL_TYPES) | |
| parser.add_argument('--push_to_hub', type=bool, default=False, help='Whether or not to push the model to the Hub.') | |
| parser.add_argument('--hub_model_id', type=str, help='The name of the repository to keep in sync with the local `output_dir`.') | |
| parser.add_argument('--hub_token', type=str, help='The token to use to push to the Model Hub.') | |
| parser.add_argument('--checkpointing_steps', type=str, default=None, help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.") | |
| parser.add_argument('--resume_from_checkpoint', type=str, default=None, help='If the training should continue from a checkpoint folder.') | |
| parser.add_argument('--load_best_model', type=bool, default=False, help='Whether to load the best model at the end of training') | |
| parser.add_argument('--logging_steps', type=int, default=None, help='log every n steps') | |
| parser.add_argument('--with_tracking', type=bool, default=False, help='Whether to enable experiment trackers for logging.') | |
| parser.add_argument('--report_to', type=str, default='all', help='The integration to report the results and logs to. Supported platforms are `"tensorboard"`, `"wandb"` and `"comet_ml"`. Use `"all"` (default) to report to all integrations.Only applicable when `--with_tracking` is passed.') | |
| parser.add_argument('--report_name', type=str, default='chatbot_no_trainer', help='The name of the experiment tracking folder. Only applicable when `--with_tracking` is passed.') | |
| args = parser.parse_args() | |
| if args.dataset_name is None and args.train_file is None and (args.validation_file is None): | |
| raise ValueError('Need either a dataset name or a training/validation file.') | |
| else: | |
| if args.train_file is not None: | |
| extension = args.train_file.split('.')[-1] | |
| assert extension in ['csv', 'json'], '`train_file` should be a csv or a json file.' | |
| if args.validation_file is not None: | |
| extension = args.validation_file.split('.')[-1] | |
| assert extension in ['csv', 'json'], '`validation_file` should be a csv or a json file.' | |
| if args.push_to_hub: | |
| assert args.output_dir is not None, 'Need an `output_dir` to create a repo when `--push_to_hub` is passed.' | |
| return args | |
| def checkpoint_model(checkpoint_folder, ckpt_id, model, epoch, last_global_step, **kwargs): | |
| checkpoint_state_dict = {'epoch': epoch, 'last_global_step': last_global_step} | |
| checkpoint_state_dict.update(kwargs) | |
| success = model.save_checkpoint(checkpoint_folder, ckpt_id, checkpoint_state_dict) | |
| status_msg = f'checkpointing: checkpoint_folder={checkpoint_folder}, ckpt_id={ckpt_id}' | |
| if success: | |
| logging.info(f'Success {status_msg}') | |
| else: | |
| logging.warning(f'Failure {status_msg}') | |
| return | |
| def evaluate(args, model, metric, tokenizer, eval_dataloader, accelerator, max_length): | |
| accelerator.print('starting evaluation') | |
| count_printed = 0 | |
| def postprocess_text(preds, labels): | |
| preds = [pred.strip() for pred in preds] | |
| labels = [[label.strip()] for label in labels] | |
| return (preds, labels) | |
| model.eval() | |
| if args.val_max_target_length is None: | |
| args.val_max_target_length = args.max_target_length | |
| gen_kwargs = {'max_length': args.val_max_target_length if args is not None else max_length, 'num_beams': args.num_beams, 'min_length': args.val_min_target_length, 'length_penalty': False, 'no_repeat_ngram_size': 3, 'encoder_no_repeat_ngram_size': 3, 'repetition_penalty': 1.2} | |
| samples_seen = 0 | |
| for (step, batch) in enumerate(eval_dataloader): | |
| with torch.no_grad(): | |
| generated_tokens = accelerator.unwrap_model(model).generate(batch['input_ids'], attention_mask=batch['attention_mask'], **gen_kwargs) | |
| generated_tokens = accelerator.pad_across_processes(generated_tokens, dim=1, pad_index=tokenizer.pad_token_id) | |
| labels = batch['labels'] | |
| if not args.pad_to_max_length: | |
| labels = accelerator.pad_across_processes(batch['labels'], dim=1, pad_index=tokenizer.pad_token_id) | |
| (generated_tokens, labels) = accelerator.gather((generated_tokens, labels)) | |
| generated_tokens = generated_tokens.cpu().numpy() | |
| labels = labels.cpu().numpy() | |
| if args.ignore_pad_token_for_loss: | |
| labels = np.where(labels != -100, labels, tokenizer.pad_token_id) | |
| decoded_preds = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True) | |
| decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True) | |
| if count_printed < args.n_val_batch_generations: | |
| logger.info('printing few sample generations and corresponding labels from eval set') | |
| logger.info('prompt | generated | label') | |
| decoded_prompts = tokenizer.batch_decode(batch['input_ids'], skip_special_tokens=False) | |
| for (prompt, generated_response, response) in zip(decoded_prompts, decoded_preds, decoded_labels): | |
| cleaned_prompt = prompt.replace('<pad>', '').strip() | |
| logger.info(f'{cleaned_prompt} | {generated_response} | {response}') | |
| count_printed += 1 | |
| (decoded_preds, decoded_labels) = postprocess_text(decoded_preds, decoded_labels) | |
| if accelerator.num_processes > 1: | |
| if step == len(eval_dataloader) - 1: | |
| decoded_preds = decoded_preds[:len(eval_dataloader.dataset) - samples_seen] | |
| decoded_labels = decoded_labels[:len(eval_dataloader.dataset) - samples_seen] | |
| else: | |
| samples_seen += len(decoded_labels) | |
| metric.add_batch(predictions=decoded_preds, references=decoded_labels) | |
| result = metric.compute() | |
| logger.info({'bleu': result['score']}) | |
| accelerator.print('evaluation completed') | |
| return result['score'] | |
| def load_training_checkpoint(model, load_dir, tag=None, **kwargs): | |
| (_, checkpoint_state_dict) = model.load_checkpoint(load_dir, tag=tag, **kwargs) | |
| epoch = checkpoint_state_dict['epoch'] | |
| last_global_step = checkpoint_state_dict['last_global_step'] | |
| del checkpoint_state_dict | |
| return (epoch, last_global_step) | |
| def main(): | |
| args = parse_args() | |
| accelerator = Accelerator(log_with=args.report_to, logging_dir=args.output_dir) if args.with_tracking else Accelerator() | |
| if args.source_prefix is None and args.model_name_or_path in ['t5-small', 't5-base', 't5-large', 't5-3b', 't5-11b']: | |
| logger.warning("You're running a t5 model but didn't provide a source prefix, which is the expected, e.g. with `--source_prefix 'summarize: ' `") | |
| logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO) | |
| logger.info(accelerator.state, main_process_only=False) | |
| if accelerator.is_local_main_process: | |
| datasets.utils.logging.set_verbosity_warning() | |
| transformers.utils.logging.set_verbosity_info() | |
| else: | |
| datasets.utils.logging.set_verbosity_error() | |
| transformers.utils.logging.set_verbosity_error() | |
| if args.seed is not None: | |
| set_seed(args.seed) | |
| if accelerator.is_main_process: | |
| if args.push_to_hub: | |
| if args.hub_model_id is None: | |
| repo_name = get_full_repo_name(Path(args.output_dir).name, token=args.hub_token) | |
| else: | |
| repo_name = args.hub_model_id | |
| repo = Repository(args.output_dir, clone_from=repo_name) | |
| with open(os.path.join(args.output_dir, '.gitignore'), 'w+') as gitignore: | |
| if 'step_*' not in gitignore: | |
| gitignore.write('step_*\n') | |
| if 'epoch_*' not in gitignore: | |
| gitignore.write('epoch_*\n') | |
| elif args.output_dir is not None: | |
| os.makedirs(args.output_dir, exist_ok=True) | |
| accelerator.wait_for_everyone() | |
| if args.dataset_name is not None: | |
| raw_datasets = load_dataset(args.dataset_name, args.dataset_config_name) | |
| if args.n_train > 0: | |
| raw_datasets['train'] = datasets.Dataset.from_dict(raw_datasets['train'][:args.n_train]) | |
| if args.n_val > 0: | |
| raw_datasets['validation'] = datasets.Dataset.from_dict(raw_datasets['validation'][:args.n_val]) | |
| else: | |
| data_files = {} | |
| if args.train_file is not None: | |
| data_files['train'] = args.train_file | |
| if args.validation_file is not None: | |
| data_files['validation'] = args.validation_file | |
| extension = args.train_file.split('.')[-1] | |
| raw_datasets = load_dataset(extension, data_files=data_files) | |
| if args.config_name: | |
| config = AutoConfig.from_pretrained(args.config_name) | |
| elif args.model_name_or_path: | |
| config = AutoConfig.from_pretrained(args.model_name_or_path) | |
| else: | |
| config = CONFIG_MAPPING[args.model_type]() | |
| logger.warning('You are instantiating a new config instance from scratch.') | |
| if args.tokenizer_name: | |
| tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, use_fast=not args.use_slow_tokenizer) | |
| elif args.model_name_or_path: | |
| tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, use_fast=not args.use_slow_tokenizer) | |
| else: | |
| raise ValueError('You are instantiating a new tokenizer from scratch. This is not supported by this script.You can do it from another script, save it, and load it from here, using --tokenizer_name.') | |
| if args.model_name_or_path: | |
| model = AutoModelForSeq2SeqLM.from_pretrained(args.model_name_or_path, from_tf=bool('.ckpt' in args.model_name_or_path), config=config) | |
| else: | |
| logger.info('Training new model from scratch') | |
| model = AutoModelForSeq2SeqLM.from_config(config) | |
| model.resize_token_embeddings(len(tokenizer)) | |
| if model.config.decoder_start_token_id is None: | |
| raise ValueError('Make sure that `config.decoder_start_token_id` is correctly defined') | |
| prefix = args.source_prefix if args.source_prefix is not None else '' | |
| column_names = raw_datasets['train'].column_names | |
| dataset_columns = column_names | |
| if args.text_column is None: | |
| text_column = dataset_columns[0] if dataset_columns is not None else column_names[0] | |
| else: | |
| text_column = args.text_column | |
| if text_column not in column_names: | |
| raise ValueError(f"--text_column' value '{args.text_column}' needs to be one of: {', '.join(column_names)}") | |
| if args.summary_column is None: | |
| summary_column = dataset_columns[1] if dataset_columns is not None else column_names[1] | |
| else: | |
| summary_column = args.summary_column | |
| if summary_column not in column_names: | |
| raise ValueError(f"--summary_column' value '{args.summary_column}' needs to be one of: {', '.join(column_names)}") | |
| max_target_length = args.max_target_length | |
| padding = 'max_length' if args.pad_to_max_length else False | |
| def preprocess_function(examples): | |
| inputs = examples[text_column] | |
| targets = examples[summary_column] | |
| inputs = [prefix + inp for inp in inputs] | |
| model_inputs = tokenizer(inputs, max_length=args.max_source_length, padding=padding, truncation=True) | |
| if 't5' in args.model_name_or_path: | |
| with tokenizer.as_target_tokenizer(): | |
| labels = tokenizer(targets, max_length=max_target_length, padding=padding, truncation=True) | |
| else: | |
| labels = tokenizer(targets, max_length=max_target_length, padding=padding, truncation=True) | |
| if padding == 'max_length' and args.ignore_pad_token_for_loss: | |
| labels['input_ids'] = [[l if l != tokenizer.pad_token_id else -100 for l in label] for label in labels['input_ids']] | |
| model_inputs['labels'] = labels['input_ids'] | |
| return model_inputs | |
| with accelerator.main_process_first(): | |
| processed_datasets = raw_datasets.map(preprocess_function, batched=True, num_proc=args.preprocessing_num_workers, remove_columns=column_names, load_from_cache_file=not args.overwrite_cache, desc='Running tokenizer on dataset') | |
| train_dataset = processed_datasets['train'] | |
| eval_dataset = processed_datasets['validation'] | |
| for index in random.sample(range(len(train_dataset)), 1): | |
| logger.info(f'Sample {index} of the training set: {train_dataset[index]}.') | |
| label_pad_token_id = -100 if args.ignore_pad_token_for_loss else tokenizer.pad_token_id | |
| data_collator = DataCollatorForSeq2Seq(tokenizer, model=model, label_pad_token_id=label_pad_token_id, pad_to_multiple_of=8 if accelerator.use_fp16 else None) | |
| train_dataloader = DataLoader(train_dataset, shuffle=True, collate_fn=data_collator, batch_size=args.per_device_train_batch_size) | |
| eval_dataloader = DataLoader(eval_dataset, collate_fn=data_collator, batch_size=args.per_device_eval_batch_size) | |
| no_decay = ['bias', 'LayerNorm.weight'] | |
| optimizer_grouped_parameters = [{'params': [p for (n, p) in model.named_parameters() if not any((nd in n for nd in no_decay))], 'weight_decay': args.weight_decay}, {'params': [p for (n, p) in model.named_parameters() if any((nd in n for nd in no_decay))], 'weight_decay': 0.0}] | |
| optimizer_cls = torch.optim.Adam if accelerator.state.deepspeed_plugin is None or 'optimizer' not in accelerator.state.deepspeed_plugin.deepspeed_config else DummyOptim | |
| optimizer = optimizer_cls(optimizer_grouped_parameters, lr=args.learning_rate) | |
| if accelerator.state.deepspeed_plugin is not None: | |
| args.gradient_accumulation_steps = accelerator.state.deepspeed_plugin.deepspeed_config['gradient_accumulation_steps'] | |
| num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) | |
| if args.max_train_steps is None: | |
| args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch | |
| else: | |
| args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) | |
| if accelerator.state.deepspeed_plugin is None or 'scheduler' not in accelerator.state.deepspeed_plugin.deepspeed_config: | |
| lr_scheduler = get_scheduler(name=args.lr_scheduler_type, optimizer=optimizer, num_warmup_steps=args.num_warmup_steps, num_training_steps=args.max_train_steps) | |
| else: | |
| lr_scheduler = DummyScheduler(optimizer, total_num_steps=args.max_train_steps, warmup_num_steps=args.num_warmup_steps) | |
| (model, optimizer, train_dataloader, eval_dataloader, lr_scheduler) = accelerator.prepare(model, optimizer, train_dataloader, eval_dataloader, lr_scheduler) | |
| num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) | |
| args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch | |
| if hasattr(args.checkpointing_steps, 'isdigit'): | |
| checkpointing_steps = args.checkpointing_steps | |
| if args.checkpointing_steps.isdigit(): | |
| checkpointing_steps = int(args.checkpointing_steps) | |
| else: | |
| checkpointing_steps = None | |
| if args.with_tracking: | |
| if accelerator.is_main_process: | |
| experiment_config = vars(args) | |
| experiment_config['lr_scheduler_type'] = experiment_config['lr_scheduler_type'].value | |
| accelerator.init_trackers(args.report_name, experiment_config) | |
| metric = load_metric('sacrebleu') | |
| total_batch_size = args.per_device_train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps | |
| logger.info('***** Running training *****') | |
| logger.info(f' Num examples = {len(train_dataset)}') | |
| logger.info(f' Num Epochs = {args.num_train_epochs}') | |
| logger.info(f' Instantaneous batch size per device = {args.per_device_train_batch_size}') | |
| logger.info(f' Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}') | |
| logger.info(f' Gradient Accumulation steps = {args.gradient_accumulation_steps}') | |
| logger.info(f' Total optimization steps = {args.max_train_steps}') | |
| progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process) | |
| completed_steps = 0 | |
| starting_epoch = 0 | |
| best_metric = None | |
| best_metric_checkpoint = None | |
| if args.resume_from_checkpoint: | |
| (_, last_global_step) = load_training_checkpoint(model, args.resume_from_checkpoint, **{'load_optimizer_states': True, 'load_lr_scheduler_states': True}) | |
| accelerator.print(f'Resumed from checkpoint: {args.resume_from_checkpoint}') | |
| resume_step = last_global_step | |
| starting_epoch = resume_step // len(train_dataloader) | |
| resume_step -= starting_epoch * len(train_dataloader) | |
| for epoch in range(starting_epoch, args.num_train_epochs): | |
| start_time = time() | |
| model.train() | |
| if args.with_tracking: | |
| total_loss = 0 | |
| for (step, batch) in enumerate(train_dataloader): | |
| if args.resume_from_checkpoint and epoch == starting_epoch: | |
| if resume_step is not None and step < resume_step: | |
| completed_steps += 1 | |
| continue | |
| decoder_input_ids = batch['labels'].new_zeros(batch['labels'].shape) | |
| decoder_input_ids[..., 1:] = batch['labels'][..., :-1].clone() | |
| decoder_input_ids[..., 0] = 0 | |
| decoder_input_ids.masked_fill_(decoder_input_ids == -100, 0) | |
| batch['decoder_input_ids'] = decoder_input_ids | |
| outputs = model(**batch) | |
| loss = outputs.loss | |
| if args.with_tracking: | |
| total_loss += loss.detach().float() | |
| loss = loss / args.gradient_accumulation_steps | |
| accelerator.backward(loss) | |
| if step % args.gradient_accumulation_steps == 0 or step == len(train_dataloader) - 1: | |
| optimizer.step() | |
| lr_scheduler.step() | |
| optimizer.zero_grad() | |
| progress_bar.update(1) | |
| completed_steps += 1 | |
| if isinstance(args.logging_steps, int): | |
| if completed_steps % args.logging_steps == 0: | |
| steps_this_epoch = completed_steps % len(train_dataloader) | |
| train_loss = total_loss.item() / steps_this_epoch | |
| train_perplexity = math.exp(train_loss) | |
| accelerator.log({'train_loss': train_loss, 'train_perplexity': train_perplexity, 'epoch': epoch, 'step': completed_steps, 'steps_this_epoch': steps_this_epoch}, step=completed_steps) | |
| logger.info(f'Epoch: {epoch}, Step: {completed_steps}, Loss: {train_loss}, Perplexity: {train_perplexity}') | |
| if isinstance(checkpointing_steps, int): | |
| if completed_steps % checkpointing_steps == 0: | |
| if accelerator.state.deepspeed_plugin is not None: | |
| checkpoint_model(args.output_dir, epoch, model, epoch, completed_steps) | |
| else: | |
| accelerator.wait_for_everyone() | |
| if accelerator.is_main_process: | |
| ckpt_path = os.path.join(args.output_dir, str(epoch)) | |
| os.makedirs(ckpt_path, exist_ok=True) | |
| accelerator.save(accelerator.get_state_dict(model), os.path.join(ckpt_path, 'model.pt')) | |
| if completed_steps >= args.max_train_steps: | |
| break | |
| end_time = time() | |
| logger.info(f'Epoch {epoch} training took {end_time - start_time} seconds') | |
| if accelerator.state.deepspeed_plugin is not None: | |
| checkpoint_model(args.output_dir, epoch, model, epoch, completed_steps) | |
| else: | |
| accelerator.wait_for_everyone() | |
| if accelerator.is_main_process: | |
| ckpt_path = os.path.join(args.output_dir, str(epoch)) | |
| os.makedirs(ckpt_path, exist_ok=True) | |
| accelerator.save(accelerator.get_state_dict(model), os.path.join(ckpt_path, 'model.pt')) | |
| start_time = time() | |
| bleu_score = evaluate(args, model, metric, tokenizer, eval_dataloader, accelerator, config.max_length) | |
| end_time = time() | |
| logger.info(f'Epoch {epoch} evaluation took {end_time - start_time} seconds') | |
| result = {} | |
| if args.with_tracking: | |
| result['bleu_score'] = bleu_score | |
| result['train_loss'] = total_loss.item() / len(train_dataloader) | |
| result['train_perplexity'] = math.exp(result['train_loss']) | |
| result['epoch'] = epoch | |
| result['step'] = completed_steps | |
| accelerator.log(result, step=completed_steps) | |
| if (best_metric is None or best_metric < bleu_score) and args.load_best_model: | |
| best_metric = bleu_score | |
| best_metric_checkpoint = os.path.join(args.output_dir, str(epoch)) | |
| accelerator.print(f'New best metric: {best_metric} at epoch {epoch}') | |
| accelerator.print(f'best_metric_checkpoint: {best_metric_checkpoint}') | |
| if args.load_best_model: | |
| if accelerator.state.deepspeed_plugin is not None: | |
| (_, last_global_step) = load_training_checkpoint(model, '/'.join(best_metric_checkpoint.split('/')[:-1]), tag=best_metric_checkpoint.split('/')[-1], **{'load_optimizer_states': True, 'load_lr_scheduler_states': True}) | |
| else: | |
| map_location = {'cuda:0': 'cuda:{}'.format(accelerator.local_process_index)} | |
| model.load_state_dict(torch.load(os.path.join(best_metric_checkpoint, 'model.pt'), map_location=map_location)) | |
| bleu_score = evaluate(args, model, metric, tokenizer, eval_dataloader, accelerator, config.max_length) | |
| logger.info(f'Best model metrics: bleu_score: {bleu_score}') | |
| if bleu_score != best_metric: | |
| raise AssertionError(f'Best metric {best_metric} does not match the metric {bleu_score} of the loaded best model.') | |
| if args.output_dir is not None: | |
| accelerator.wait_for_everyone() | |
| unwrapped_model = accelerator.unwrap_model(model) | |
| unwrapped_model.save_pretrained(args.output_dir, is_main_process=accelerator.is_main_process, save_function=accelerator.save, state_dict=accelerator.get_state_dict(model)) | |
| if accelerator.is_main_process: | |
| tokenizer.save_pretrained(args.output_dir) | |
| if args.push_to_hub: | |
| repo.push_to_hub(commit_message='End of training', auto_lfs_prune=True) | |
| with open(os.path.join(args.output_dir, 'all_results.json'), 'w') as f: | |
| json.dump({'eval_bleu': bleu_score}, f) | |
| if __name__ == '__main__': | |
| main() | |
| # File: notebooks-main/sagemaker/22_accelerate_sagemaker_examples/src/text-classification/train_using_s3_data.py | |
| import argparse | |
| import os | |
| import torch | |
| from torch.optim import AdamW | |
| from torch.utils.data import DataLoader | |
| import evaluate | |
| from accelerate import Accelerator, DistributedType | |
| from datasets import load_from_disk | |
| from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed | |
| MAX_GPU_BATCH_SIZE = 16 | |
| EVAL_BATCH_SIZE = 32 | |
| def training_function(config, args): | |
| if args.with_tracking: | |
| accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision, log_with='all', logging_dir=args.logging_dir) | |
| else: | |
| accelerator = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision) | |
| if hasattr(args.checkpointing_steps, 'isdigit'): | |
| if args.checkpointing_steps == 'epoch': | |
| checkpointing_steps = args.checkpointing_steps | |
| elif args.checkpointing_steps.isdigit(): | |
| checkpointing_steps = int(args.checkpointing_steps) | |
| else: | |
| raise ValueError(f'Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.') | |
| else: | |
| checkpointing_steps = None | |
| lr = config['lr'] | |
| num_epochs = int(config['num_epochs']) | |
| seed = int(config['seed']) | |
| batch_size = int(config['batch_size']) | |
| if args.with_tracking: | |
| run = os.path.split(__file__)[-1].split('.')[0] | |
| accelerator.init_trackers(run, config) | |
| tokenizer = AutoTokenizer.from_pretrained('bert-base-cased') | |
| metric = evaluate.load('glue', 'mrpc') | |
| gradient_accumulation_steps = 1 | |
| if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU: | |
| gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE | |
| batch_size = MAX_GPU_BATCH_SIZE | |
| def collate_fn(examples): | |
| if accelerator.distributed_type == DistributedType.TPU: | |
| return tokenizer.pad(examples, padding='max_length', max_length=128, return_tensors='pt') | |
| return tokenizer.pad(examples, padding='longest', return_tensors='pt') | |
| train_dataset = load_from_disk(args.training_dir) | |
| validation_dataset = load_from_disk(args.validation_dir) | |
| accelerator.print(f' loaded train_dataset length is: {len(train_dataset)}') | |
| accelerator.print(f' loaded test_dataset length is: {len(validation_dataset)}') | |
| train_dataloader = DataLoader(train_dataset, shuffle=True, collate_fn=collate_fn, batch_size=batch_size) | |
| eval_dataloader = DataLoader(validation_dataset, shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE) | |
| set_seed(seed) | |
| model = AutoModelForSequenceClassification.from_pretrained('bert-base-cased', return_dict=True) | |
| model = model.to(accelerator.device) | |
| optimizer = AdamW(params=model.parameters(), lr=lr) | |
| lr_scheduler = get_linear_schedule_with_warmup(optimizer=optimizer, num_warmup_steps=100, num_training_steps=len(train_dataloader) * num_epochs // gradient_accumulation_steps) | |
| (model, optimizer, train_dataloader, eval_dataloader, lr_scheduler) = accelerator.prepare(model, optimizer, train_dataloader, eval_dataloader, lr_scheduler) | |
| overall_step = 0 | |
| starting_epoch = 0 | |
| if args.resume_from_checkpoint: | |
| if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != '': | |
| accelerator.print(f'Resumed from checkpoint: {args.resume_from_checkpoint}') | |
| accelerator.load_state(args.resume_from_checkpoint) | |
| path = os.path.basename(args.resume_from_checkpoint) | |
| else: | |
| dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()] | |
| dirs.sort(key=os.path.getctime) | |
| path = dirs[-1] | |
| training_difference = os.path.splitext(path)[0] | |
| if 'epoch' in training_difference: | |
| starting_epoch = int(training_difference.replace('epoch_', '')) + 1 | |
| resume_step = None | |
| else: | |
| resume_step = int(training_difference.replace('step_', '')) | |
| starting_epoch = resume_step // len(train_dataloader) | |
| resume_step -= starting_epoch * len(train_dataloader) | |
| for epoch in range(starting_epoch, num_epochs): | |
| model.train() | |
| if args.with_tracking: | |
| total_loss = 0 | |
| for (step, batch) in enumerate(train_dataloader): | |
| if args.resume_from_checkpoint and epoch == starting_epoch: | |
| if resume_step is not None and step < resume_step: | |
| overall_step += 1 | |
| continue | |
| batch.to(accelerator.device) | |
| outputs = model(**batch) | |
| loss = outputs.loss | |
| loss = loss / gradient_accumulation_steps | |
| if args.with_tracking: | |
| total_loss += loss.detach().float() | |
| accelerator.backward(loss) | |
| if step % gradient_accumulation_steps == 0: | |
| optimizer.step() | |
| lr_scheduler.step() | |
| optimizer.zero_grad() | |
| overall_step += 1 | |
| if isinstance(checkpointing_steps, int): | |
| output_dir = f'step_{overall_step}' | |
| if overall_step % checkpointing_steps == 0: | |
| if args.output_dir is not None: | |
| output_dir = os.path.join(args.output_dir, output_dir) | |
| accelerator.save_state(output_dir) | |
| model.eval() | |
| for (step, batch) in enumerate(eval_dataloader): | |
| batch.to(accelerator.device) | |
| with torch.no_grad(): | |
| outputs = model(**batch) | |
| predictions = outputs.logits.argmax(dim=-1) | |
| (predictions, references) = accelerator.gather_for_metrics((predictions, batch['labels'])) | |
| metric.add_batch(predictions=predictions, references=references) | |
| eval_metric = metric.compute() | |
| accelerator.print(f'epoch {epoch}:', eval_metric) | |
| if args.with_tracking: | |
| accelerator.log({'accuracy': eval_metric['accuracy'], 'f1': eval_metric['f1'], 'train_loss': total_loss.item() / len(train_dataloader), 'epoch': epoch}, step=epoch) | |
| if checkpointing_steps == 'epoch': | |
| output_dir = f'epoch_{epoch}' | |
| if args.output_dir is not None: | |
| output_dir = os.path.join(args.output_dir, output_dir) | |
| accelerator.save_state(output_dir) | |
| accelerator.save(accelerator.get_state_dict(model), os.path.join(args.output_dir, 'model.pt')) | |
| if args.with_tracking: | |
| accelerator.end_training() | |
| def main(): | |
| parser = argparse.ArgumentParser(description='Simple example of training script.') | |
| parser.add_argument('--mixed_precision', type=str, default='no', choices=['no', 'fp16', 'bf16'], help='Whether to use mixed precision. Choosebetween fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.and an Nvidia Ampere GPU.') | |
| parser.add_argument('--cpu', action='store_true', help='If passed, will train on the CPU.') | |
| parser.add_argument('--checkpointing_steps', type=str, default=None, help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.") | |
| parser.add_argument('--resume_from_checkpoint', type=str, default=None, help='If the training should continue from a checkpoint folder.') | |
| parser.add_argument('--with_tracking', action='store_true', help='Whether to load in all available experiment trackers from the environment and use them for logging.') | |
| parser.add_argument('--logging_dir', type=str, default=os.path.join(os.environ['SM_OUTPUT_DATA_DIR'], 'logs'), help='Location on where to store experiment tracking logs`') | |
| parser.add_argument('--output_dir', type=str, default=os.environ['SM_MODEL_DIR']) | |
| parser.add_argument('--training_dir', type=str, default=os.environ['SM_CHANNEL_TRAIN']) | |
| parser.add_argument('--validation_dir', type=str, default=os.environ['SM_CHANNEL_VALIDATION']) | |
| args = parser.parse_args() | |
| config = {'lr': 2e-05, 'num_epochs': 3, 'seed': 42, 'batch_size': 16} | |
| training_function(config, args) | |
| if __name__ == '__main__': | |
| main() | |
| # File: notebooks-main/sagemaker/23_stable_diffusion_inference/code/inference.py | |
| import base64 | |
| import torch | |
| from io import BytesIO | |
| from diffusers import StableDiffusionPipeline | |
| def model_fn(model_dir): | |
| pipe = StableDiffusionPipeline.from_pretrained(model_dir, torch_dtype=torch.float16) | |
| pipe = pipe.to('cuda') | |
| return pipe | |
| def predict_fn(data, pipe): | |
| prompt = data.pop('inputs', data) | |
| num_inference_steps = data.pop('num_inference_steps', 50) | |
| guidance_scale = data.pop('guidance_scale', 7.5) | |
| num_images_per_prompt = data.pop('num_images_per_prompt', 4) | |
| generated_images = pipe(prompt, num_inference_steps=num_inference_steps, guidance_scale=guidance_scale, num_images_per_prompt=num_images_per_prompt)['images'] | |
| encoded_images = [] | |
| for image in generated_images: | |
| buffered = BytesIO() | |
| image.save(buffered, format='JPEG') | |
| encoded_images.append(base64.b64encode(buffered.getvalue()).decode()) | |
| return {'generated_images': encoded_images} | |