import torch
import poptorch

<?php
# Use huggingface transformer library 


import transformers 


import torch 


import poptorch 


... 


# Pre-trained model and tokenizer. 


tokenizer = transformers.BertTokenizer.from_pretrained( 


    'mrm8488/bert-medium-finetuned-squadv2', return_token_type_ids=True) 


model = transformers.BertForQuestionAnswering.from_pretrained( 


    'mrm8488/bert-medium-finetuned-squadv2') 


 


# Read context/questions from file. Pad last batch with empty question if required 


context = context_file.read() 


questions = questions_file.readlines() 


questions = [q.rstrip() for q in questions] 


questions += [""] * (len(questions) % options.batch_size) 


num_questions = len(questions) 


 


# Pipeline the model over two IPUs.  


model.bert.embeddings.position_embeddings = poptorch.BeginBlock( 


   layer_to_call=model.bert.embeddings.position_embeddings, ipu_id=1) 


 


# Wrap PyTorch model inside a PopTorch InferenceModel. This will make the model run on the IPU. 


opts = poptorch.Options().deviceIterations(batch_size) 


inference_model = poptorch.inferenceModel(model, options=opts) 


 


# Process inputs in batches. 


for batch_idx in range(num_batches): 


        # Use tokenizer to get input and then convert to PyTorch tensors. 


        input_pairs = [(questions[batch_size*batch_idx + i], context) for i in range(batch_size)] 


        batched_encoding = tokenizer.batch_encode_plus(input_pairs, max_length=110,  


                                                       pad_to_max_length='right') 


        input_batch = torch.tensor(batched_encoding["input_ids"]) 


        attention_batch = torch.tensor(batched_encoding["attention_mask"]) 


 


        # Execute on IPU. 


        start_score_pop, end_scores_pop = inference_model(input_batch, attention_batch) 


 


        # Process outputs. 


        for i, (start_score, end_score) in enumerate(zip(start_score_pop, end_scores_pop)): 


            answer_start, answer_stop = start_score.argmax(), end_score.argmax() 


            answer_ids = input_batch[i][answer_start:answer_stop + 1] 


            answer_tokens = tokenizer.convert_ids_to_tokens(answer_ids, skip_special_tokens=True) 


            answer = tokenizer.convert_tokens_to_string(answer_tokens) 


 


            print(f"Question: {questions[batch_size*batch_idx + i]}") 


            print(f"Answer: {answer}")