handler.py

from typing import Dict, List, Any
from transformers import AutoImageProcessor, Swin2SRForImageSuperResolution, Swin2SRModel
import torch
import base64
import logging
import numpy as np
import gc
from PIL import Image
from io import BytesIO
import subprocess


logger = logging.getLogger()
logger.setLevel(logging.DEBUG)

# check for GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
gpu_count = torch.cuda.device_count()

class EndpointHandler:
 def __init__(self, path=""):
 # load the model 
 self.processor = AutoImageProcessor.from_pretrained("caidas/swin2SR-classical-sr-x2-64")

 if(gpu_count > 1):
 Swin2SRModel._no_split_modules = ["Swin2SREmbeddings", "Swin2SRStage"]
 Swin2SRForImageSuperResolution._no_split_modules = ["Swin2SREmbeddings", "Swin2SRStage"]
 model = Swin2SRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64", device_map="auto")
 logger.info(model.hf_device_map)
 model.hf_device_map["swin2sr.conv_after_body"] = model.hf_device_map["swin2sr.embeddings"]
 model.hf_device_map["upsample"] = model.hf_device_map["swin2sr.embeddings"]
 self.model = Swin2SRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64", device_map=model.hf_device_map)

 print(subprocess.run(["nvidia-smi"]))

 else:
 self.model = Swin2SRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64")
 # move model to device
 self.model.to(device)


 def __call__(self, data: Any):
 """
 Args:
 data (:obj:):
 binary image data to be labeled
 Return:
 A :obj:`string`:. Base64 encoded image string
 """

 image = data["inputs"]

 if(gpu_count > 1):
 inputs = self.processor(image, return_tensors="pt")
 else:
 inputs = self.processor(image, return_tensors="pt").to(device)

 try:
 with torch.no_grad():
 outputs = self.model(**inputs)

 print(subprocess.run(["nvidia-smi"]))

 output = outputs.reconstruction.data.squeeze().float().cpu().clamp_(0, 1).numpy()
 output = np.moveaxis(output, source=0, destination=-1)
 output = (output * 255.0).round().astype(np.uint8)

 img = Image.fromarray(output)
 buffered = BytesIO()
 img.save(buffered, format="JPEG")
 img_str = base64.b64encode(buffered.getvalue())

 return img_str.decode()

 except Exception as e:
 logger.error(str(e))
 del inputs
 gc.collect()
 torch.cuda.empty_cache()

 return {"error": str(e)}