context = """We introduce a new language representation model called BERT, which stands forBidirectional Encoder Representations from Transformers. Unlike recent languagerepresentation models (Peters et al., 2018a; Radford et al., 2018), BERT isdesigned to pretrain deep bidirectional representations from unlabeled text byjointly conditioning on both left and right context in all layers. As a result,the pre-trained BERT model can be finetuned with just one additional outputlayer to create state-of-the-art models for a wide range of tasks, such asquestion answering and language inference, without substantial taskspecificarchitecture modifications. BERT is conceptually simple and empiricallypowerful. It obtains new state-of-the-art results on eleven natural languageprocessing tasks, including pushing the GLUE score to 80.5% (7.7% point absoluteimprovement), MultiNLI accuracy to 86.7% (4.6% absolute improvement), SQuAD v1.1question answering Test F1 to 93.2 (1.5 point absolute improvement) and SQuADv2.0 Test F1 to 83.1 (5.1 point absolute improvement).""" question_one = "What is BERTs best score on Squadv2 ?"# 83 . 1 question_two = "What does the 'B' in BERT stand for?"# 'bidirectional encoder representations from transformers'

serverless create --template aws-python3 --path serverless-bert

import json def hello(event, context):    body = {        "message": "Go Serverless v1.0! Your function executed successfully!",        "input": event    }    response = {        "statusCode": 200,        "body": json.dumps(body)    }    return response

https://download.pytorch.org/whl/cpu/torch-1.5.0%2Bcpu-cp38-cp38-linux_x86_64.whltransformers==2.10

aws s3api create-bucket --bucket bucket-name --region eu-central-1 --create-bucket-configuration LocationConstraint=eu-central-1

import boto3 def upload_model(model_path='', s3_bucket='', key_prefix='', aws_profile='default'):    s3 = boto3.session.Session(profile_name=aws_profile)    client = s3.client('s3')    client.upload_file(model_path, s3_bucket, key_prefix)

service: serverless-bert provider:  name: aws  runtime: python3.8  region: eu-central-1  timeout: 60  iamRoleStatements:    - Effect: 'Allow'      Action:        - s3:getObject      Resource: arn:aws:s3:::<your-S3-Bucket>/<key_prefix>/* custom:  pythonRequirements:    dockerizePip: true    zip: true    slim: true    strip: false    noDeploy:      - docutils      - jmespath      - pip      - python-dateutil      - setuptools      - six      - tensorboard    useStaticCache: true    useDownloadCache: true    cacheLocation: './cache'package:  individually: false  exclude:    - package.json    - package-log.json    - node_modules/**    - cache/**    - test/**    - __pycache__/**    - .pytest_cache/**    - model/pytorch_model.bin    - raw/**    - .vscode/**    - .ipynb_checkpoints/** functions:  predict_answer:    handler: handler.predict_answer    memorySize: 3008    timeout: 60    events:      - http:          path: ask          method: post          cors: true plugins:  - serverless-python-requirements

from transformers import AutoModelForQuestionAnswering, AutoTokenizer, AutoConfigimport torchimport boto3import osimport tarfileimport ioimport base64import jsonimport re s3 = boto3.client('s3') class ServerlessModel:    def __init__(self, model_path=None, s3_bucket=None, file_prefix=None):        self.model, self.tokenizer = self.from_pretrained(            model_path, s3_bucket, file_prefix)     def from_pretrained(self, model_path: str, s3_bucket: str, file_prefix: str):        model = self.load_model_from_s3(model_path, s3_bucket, file_prefix)        tokenizer = self.load_tokenizer(model_path)        return model, tokenizer     def load_model_from_s3(self, model_path: str, s3_bucket: str, file_prefix: str):        if model_path and s3_bucket and file_prefix:            obj = s3.get_object(Bucket=s3_bucket, Key=file_prefix)            bytestream = io.BytesIO(obj['Body'].read())            tar = tarfile.open(fileobj=bytestream, mode="r:gz")            config = AutoConfig.from_pretrained(f'{model_path}/config.json')            for member in tar.getmembers():                if member.name.endswith(".bin"):                    f = tar.extractfile(member)                    state = torch.load(io.BytesIO(f.read()))                    model = AutoModelForQuestionAnswering.from_pretrained(                        pretrained_model_name_or_path=None, state_dict=state, config=config)            return model        else:            raise KeyError('No S3 Bucket and Key Prefix provided')     def load_tokenizer(self, model_path: str):        tokenizer = AutoTokenizer.from_pretrained(model_path)        return tokenizer     def encode(self, question, context):        encoded = self.tokenizer.encode_plus(question, context)        return encoded["input_ids"], encoded["attention_mask"]     def decode(self, token):        answer_tokens = self.tokenizer.convert_ids_to_tokens(            token, skip_special_tokens=True)        return self.tokenizer.convert_tokens_to_string(answer_tokens)     def predict(self, question, context):        input_ids, attention_mask = self.encode(question, context)        start_scores, end_scores = self.model(torch.tensor(            [input_ids]), attention_mask=torch.tensor([attention_mask]))        ans_tokens = input_ids[torch.argmax(            start_scores): torch.argmax(end_scores)+1]        answer = self.decode(ans_tokens)        return answer

try:    import unzip_requirementsexcept ImportError:    passfrom model.model import ServerlessModelimport json model = ServerlessModel('./model', <s3_bucket>, <file_prefix>) def predict_answer(event, context):    try:        body = json.loads(event['body'])        answer = model.predict(body['question'], body['context'])         return {            "statusCode": 200,            "headers": {                'Content-Type': 'application/json',                'Access-Control-Allow-Origin': '*',                "Access-Control-Allow-Credentials": True             },            "body": json.dumps({'answer': answer})        }    except Exception as e:        return {            "statusCode": 500,            "headers": {                'Content-Type': 'application/json',                'Access-Control-Allow-Origin': '*',                "Access-Control-Allow-Credentials": True            },            "body": json.dumps({"error": repr(e)})        }

{  "context": "We introduce a new language representation model called BERT, which stands for idirectional Encoder Representations from Transformers. Unlike recent language epresentation models (Peters et al., 2018a; Radford et al., 2018), BERT is designed to pretrain deep bidirectional representations from unlabeled text by jointly conditioning on both left and right context in all layers. As a result, the pre-trained BERT model can be finetuned with just one additional output layer to create state-of-the-art models for a wide range of tasks, such as question answering and language inference, without substantial taskspecific architecture modifications. BERT is conceptually simple and empirically powerful. It obtains new state-of-the-art results on eleven natural language processing tasks, including pushing the GLUE score to 80.5% (7.7% point absolute improvement), MultiNLI accuracy to 86.7% (4.6% absolute improvement), SQuAD v1.1 question answering Test F1 to 93.2 (1.5 point absolute improvement) and SQuAD v2.0 Test F1 to 83.1 (5.1 point absolute improvement).",  "question":https://www.philschmid.dehttps://www.philschmid.de/static/blog/serverless-bert-with-huggingface-and-aws-lambda/insomnia-request.pngne="">}