ক্লাউড রান জিপিইউতে কীভাবে টর্চসার্ভ এবং স্থিতিশীল ডিফিউশন চালানো যায়

1. ভূমিকা

ওভারভিউ

ক্লাউড রান সম্প্রতি GPU সমর্থন যোগ করেছে। এটি একটি অপেক্ষা তালিকাভুক্ত সর্বজনীন পূর্বরূপ হিসাবে উপলব্ধ। আপনি যদি বৈশিষ্ট্যটি ব্যবহার করে দেখতে আগ্রহী হন তবে অপেক্ষা তালিকায় যোগ দিতে এই ফর্মটি পূরণ করুন ৷ ক্লাউড রান হল Google ক্লাউডের একটি কন্টেইনার প্ল্যাটফর্ম যা আপনাকে একটি ক্লাস্টার পরিচালনা করার প্রয়োজন ছাড়াই একটি কন্টেইনারে আপনার কোড চালানো সহজ করে তোলে।

আজ, আমরা যে GPU গুলি উপলব্ধ করি তা হল 24 GB vRAM সহ Nvidia L4 GPU গুলি৷ প্রতি ক্লাউড রান দৃষ্টান্তে একটি জিপিইউ রয়েছে এবং ক্লাউড রান স্বয়ংক্রিয় স্কেলিং এখনও প্রযোজ্য। এর মধ্যে 5টি পর্যন্ত (কোটা বৃদ্ধির উপলভ্য) দৃষ্টান্ত পর্যন্ত স্কেল করা অন্তর্ভুক্ত, সেইসাথে কোন অনুরোধ না থাকলে শূন্য দৃষ্টান্তে স্কেল করা অন্তর্ভুক্ত।

এই কোডল্যাবে, আপনি একটি টর্চসার্ভ অ্যাপ তৈরি এবং স্থাপন করবেন যা টেক্সট প্রম্পট থেকে ছবি তৈরি করতে স্থিতিশীল ডিফিউশন এক্সএল ব্যবহার করে। উত্পন্ন চিত্রটি একটি বেস64 এনকোডেড স্ট্রিং হিসাবে কলারের কাছে ফেরত দেওয়া হয়।

এই উদাহরণটি Torchserve-এ Huggingface Diffusers ব্যবহার করে রানিং স্টেবল ডিফিউশন মডেলের উপর ভিত্তি করে। এই কোডল্যাব আপনাকে দেখায় কিভাবে ক্লাউড রানের সাথে কাজ করার জন্য এই উদাহরণটি পরিবর্তন করতে হয়।

আপনি কি শিখবেন

• জিপিইউ ব্যবহার করে ক্লাউড রানে একটি স্থিতিশীল ডিফিউশন এক্সএল মডেল কীভাবে চালাবেন

2. এপিআই সক্ষম করুন এবং এনভায়রনমেন্ট ভেরিয়েবল সেট করুন

আপনি এই কোডল্যাব ব্যবহার শুরু করার আগে, আপনাকে সক্রিয় করতে হবে এমন বেশ কয়েকটি API আছে। এই কোডল্যাবের জন্য নিম্নলিখিত API ব্যবহার করা প্রয়োজন। আপনি নিম্নলিখিত কমান্ডটি চালিয়ে সেই APIগুলি সক্ষম করতে পারেন:

gcloud services enable run.googleapis.com \
    storage.googleapis.com \
    cloudbuild.googleapis.com

তারপর আপনি পরিবেশ ভেরিয়েবল সেট করতে পারেন যা এই কোডল্যাব জুড়ে ব্যবহার করা হবে।

PROJECT_ID=<YOUR_PROJECT_ID>
REPOSITORY=<YOUR_REPOSITORY_ID>

NETWORK_NAME=default
REGION=us-central1
IMAGE=us-central1-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/gpu-torchserve

আপনি REPOSITORY জন্য যে মানটি সেট করেছেন তা হল আর্টিফ্যাক্ট রেজিস্ট্রি সংগ্রহস্থলের জন্য যেখানে আপনার চিত্র বিল্ড সংরক্ষণ করা হবে। আপনি একটি বিদ্যমান ব্যবহার করতে পারেন বা একটি নতুন তৈরি করতে পারেন:

gcloud artifacts repositories create $REPOSITORY \
    --location=us-central1 \
    --repository-format=docker

3. টর্চসার্ভ অ্যাপ তৈরি করুন

প্রথমে, সেই ডিরেক্টরিতে সোর্স কোড এবং সিডির জন্য একটি ডিরেক্টরি তৈরি করুন।

mkdir stable-diffusion-codelab && cd $_

একটি config.properties ফাইল তৈরি করুন। এটি টর্চসার্ভের জন্য কনফিগারেশন ফাইল।

inference_address=http://0.0.0.0:8080
enable_envvars_config=true
min_workers=1
max_workers=1
default_workers_per_model=1
default_response_timeout=1000
load_models=all
max_response_size=655350000
# to enable authorization, see https://github.com/pytorch/serve/blob/master/docs/token_authorization_api.md#how-to-set-and-disable-token-authorization
disable_token_authorization=true

দ্রষ্টব্য: এই উদাহরণটি TorchService-এর অনুমোদন ব্যবহার করে না। প্রমাণীকরণ সক্ষম করতে, দয়া করে https://github.com/pytorch/serve/blob/master/docs/token_authorization_api.md#how-to-set-and-disable-token-authorization পর্যালোচনা করুন

মনে রাখবেন এই উদাহরণে, ক্লাউড রানে কাজ করার জন্য http://0.0.0.0 লিসেনিং অ্যাড্রেস ব্যবহার করা হয়। ক্লাউড রানের জন্য ডিফল্ট পোর্ট হল পোর্ট 8080।

একটি requirements.txt ফাইল তৈরি করুন।

python-dotenv
accelerate
transformers
diffusers
numpy
google-cloud-storage
nvgpu

stable_diffusion_handler.py নামে একটি ফাইল তৈরি করুন

from abc import ABC
import base64
import datetime
import io
import logging
import os

from diffusers import StableDiffusionXLImg2ImgPipeline
from diffusers import StableDiffusionXLPipeline
from google.cloud import storage
import numpy as np
from PIL import Image
import torch
from ts.torch_handler.base_handler import BaseHandler


logger = logging.getLogger(__name__)


def image_to_base64(image: Image.Image) -> str:
  """Convert a PIL image to a base64 string."""
  buffer = io.BytesIO()
  image.save(buffer, format="JPEG")
  image_str = base64.b64encode(buffer.getvalue()).decode("utf-8")
  return image_str


class DiffusersHandler(BaseHandler, ABC):
  """Diffusers handler class for text to image generation."""

  def __init__(self):
    self.initialized = False

  def initialize(self, ctx):
    """In this initialize function, the Stable Diffusion model is loaded and

       initialized here.
    Args:
        ctx (context): It is a JSON Object containing information pertaining to
          the model artifacts parameters.
    """
    logger.info("Initialize DiffusersHandler")
    self.manifest = ctx.manifest
    properties = ctx.system_properties
    model_dir = properties.get("model_dir")
    model_name = os.environ["MODEL_NAME"]
    model_refiner = os.environ["MODEL_REFINER"]

    self.bucket = None

    logger.info(
        "GPU device count: %s",
        torch.cuda.device_count(),
    )
    logger.info(
        "select the GPU device, cuda is available: %s",
        torch.cuda.is_available(),
    )
    self.device = torch.device(
        "cuda:" + str(properties.get("gpu_id"))
        if torch.cuda.is_available() and properties.get("gpu_id") is not None
        else "cpu"
    )
    logger.info("Device used: %s", self.device)

    # open the pipeline to the inferenece model 
    # this is generating the image
    logger.info("Downloading model %s", model_name)
    self.pipeline = StableDiffusionXLPipeline.from_pretrained(
        model_name,
        variant="fp16",
        torch_dtype=torch.float16,
        use_safetensors=True,
    ).to(self.device)
    logger.info("done downloading model %s", model_name)

    # open the pipeline to the refiner
    # refiner is used to remove artifacts from the image
    logger.info("Downloading refiner %s", model_refiner)
    self.refiner = StableDiffusionXLImg2ImgPipeline.from_pretrained(
        model_refiner,
        variant="fp16",
        torch_dtype=torch.float16,
        use_safetensors=True,
    ).to(self.device)
    logger.info("done downloading refiner %s", model_refiner)

    self.n_steps = 40
    self.high_noise_frac = 0.8
    self.initialized = True
    # Commonly used basic negative prompts.
    logger.info("using negative_prompt")
    self.negative_prompt = ("worst quality, normal quality, low quality, low res, blurry")

  # this handles the user request
  def preprocess(self, requests):
    """Basic text preprocessing, of the user's prompt.

    Args:
        requests (str): The Input data in the form of text is passed on to the
          preprocess function.

    Returns:
        list : The preprocess function returns a list of prompts.
    """
    logger.info("Process request started")
    inputs = []
    for _, data in enumerate(requests):
      input_text = data.get("data")
      if input_text is None:
        input_text = data.get("body")
      if isinstance(input_text, (bytes, bytearray)):
        input_text = input_text.decode("utf-8")
      logger.info("Received text: '%s'", input_text)
      inputs.append(input_text)
    return inputs

  def inference(self, inputs):
    """Generates the image relevant to the received text.

    Args:
        input_batch (list): List of Text from the pre-process function is passed
          here

    Returns:
        list : It returns a list of the generate images for the input text
    """
    logger.info("Inference request started")
    # Handling inference for sequence_classification.
    image = self.pipeline(
        prompt=inputs,
        negative_prompt=self.negative_prompt,
        num_inference_steps=self.n_steps,
        denoising_end=self.high_noise_frac,
        output_type="latent",
    ).images
    logger.info("Done model")

    image = self.refiner(
        prompt=inputs,
        negative_prompt=self.negative_prompt,
        num_inference_steps=self.n_steps,
        denoising_start=self.high_noise_frac,
        image=image,
    ).images
    logger.info("Done refiner")

    return image

  def postprocess(self, inference_output):
    """Post Process Function converts the generated image into Torchserve readable format.

    Args:
        inference_output (list): It contains the generated image of the input
          text.

    Returns:
        (list): Returns a list of the images.
    """
    logger.info("Post process request started")
    images = []
    response_size = 0
    for image in inference_output:
      # Save image to GCS
      if self.bucket:
        image.save("temp.jpg")

        # Create a blob object
        blob = self.bucket.blob(
            datetime.datetime.now().strftime("%Y%m%d_%H%M%S") + ".jpg"
        )

        # Upload the file
        blob.upload_from_filename("temp.jpg")

      # to see the image, encode to base64
      encoded = image_to_base64(image)
      response_size += len(encoded)
      images.append(encoded)

    logger.info("Images %d, response size: %d", len(images), response_size)
    return images

start.sh নামে একটি ফাইল তৈরি করুন এই ফাইলটি TorchServe শুরু করার জন্য কন্টেইনারে একটি এন্ট্রিপয়েন্ট হিসেবে ব্যবহৃত হয়।

#!/bin/bash

echo "starting the server"
# start the server. By default torchserve runs in backaround, and start.sh will immediately terminate when done
# so use --foreground to keep torchserve running in foreground while start.sh is running in a container  
torchserve --start --ts-config config.properties --models "stable_diffusion=${MAR_FILE_NAME}.mar" --model-store ${MAR_STORE_PATH} --foreground

এবং তারপরে এটিকে একটি এক্সিকিউটেবল ফাইল করতে নিম্নলিখিত কমান্ডটি চালান।

chmod 755 start.sh

একটি dockerfile তৈরি করুন।

# pick a version of torchserve to avoid any future breaking changes
# docker pull pytorch/torchserve:0.11.1-cpp-dev-gpu
FROM pytorch/torchserve:0.11.1-cpp-dev-gpu AS base

USER root

WORKDIR /home/model-server

COPY requirements.txt ./
RUN pip install --upgrade -r ./requirements.txt

# Stage 1 build the serving container.
FROM base AS serve-gcs

ENV MODEL_NAME='stabilityai/stable-diffusion-xl-base-1.0'
ENV MODEL_REFINER='stabilityai/stable-diffusion-xl-refiner-1.0'

ENV MAR_STORE_PATH='/home/model-server/model-store'
ENV MAR_FILE_NAME='model'
RUN mkdir -p $MAR_STORE_PATH

COPY config.properties ./
COPY stable_diffusion_handler.py ./
COPY start.sh ./

# creates the mar file used by torchserve
RUN torch-model-archiver --force --model-name ${MAR_FILE_NAME} --version 1.0 --handler stable_diffusion_handler.py -r requirements.txt --export-path ${MAR_STORE_PATH}

# entrypoint
CMD ["./start.sh"]

4. ক্লাউড NAT সেটআপ করুন

ক্লাউড NAT আপনাকে ইন্টারনেট অ্যাক্সেস করতে এবং HuggingFace থেকে মডেলটি ডাউনলোড করার জন্য উচ্চতর ব্যান্ডউইথের অনুমতি দেয়, যা আপনার স্থাপনার সময়কে উল্লেখযোগ্যভাবে ত্বরান্বিত করবে।

দ্রষ্টব্য: ক্লাউড NAT ক্লাউড রানের মতো মূল্য-প্রদানের মডেল অনুসরণ করে না। অনুগ্রহ করে Cloud NAT মূল্যের ডকুমেন্টেশন পর্যালোচনা করুন](https://cloud.google.com/nat/pricing)।

Cloud NAT ব্যবহার করতে, একটি Cloud NAT উদাহরণ সক্ষম করতে নিম্নলিখিত কমান্ডটি চালান:

gcloud compute routers create nat-router --network $NETWORK_NAME --region us-central1
gcloud compute routers nats create vm-nat --router=nat-router --region=us-central1 --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges

5. ক্লাউড রান পরিষেবা তৈরি করুন এবং স্থাপন করুন৷

ক্লাউড বিল্ডে আপনার কোড জমা দিন।

gcloud builds submit --tag $IMAGE

এরপরে, ক্লাউড রানে স্থাপন করুন

gcloud beta run deploy gpu-torchserve \
 --image=$IMAGE \
 --cpu=8 --memory=32Gi \
 --gpu=1 --no-cpu-throttling --gpu-type=nvidia-l4 \
 --allow-unauthenticated \
 --region us-central1 \
 --project $PROJECT_ID \
 --execution-environment=gen2 \
 --max-instances 1 \
 --network $NETWORK_NAME \
 --vpc-egress all-traffic

6. পরিষেবা পরীক্ষা করুন

আপনি নিম্নলিখিত কমান্ডগুলি চালিয়ে পরিষেবাটি পরীক্ষা করতে পারেন:

PROMPT_TEXT="a cat sitting in a magnolia tree"

SERVICE_URL=$(gcloud run services describe gpu-torchserve --region $REGION --format 'value(status.url)')

time curl $SERVICE_URL/predictions/stable_diffusion -d "data=$PROMPT_TEXT" | base64 --decode > image.jpg

ক্লাউড রান প্রমাণীকরণের প্রয়োজনে কনফিগার করা থাকলে কার্ল কমান্ডে অনুমোদনের শিরোনাম যোগ করা নিশ্চিত করুন।

আপনি দেখতে পাবেন image.jpg ফাইলটি আপনার বর্তমান ডিরেক্টরিতে প্রদর্শিত হবে। আপনি একটি গাছে বসে থাকা একটি বিড়ালের চিত্র দেখতে ক্লাউড শেল এডিটরে ছবিটি খুলতে পারেন।

7. অভিনন্দন!

কোডল্যাব সম্পূর্ণ করার জন্য অভিনন্দন!

আমরা ক্লাউড রান জিপিইউ- তে ডকুমেন্টেশন পর্যালোচনা করার পরামর্শ দিই।

আমরা কভার করেছি কি

• জিপিইউ ব্যবহার করে ক্লাউড রানে একটি স্থিতিশীল ডিফিউশন এক্সএল মডেল কীভাবে চালাবেন

8. পরিষ্কার করুন

অসাবধানতাবশত চার্জ এড়াতে, (উদাহরণস্বরূপ, যদি এই ক্লাউড রান জবটি আপনার মাসিক ক্লাউড রান ইনভোকমেন্ট বরাদ্দের চেয়ে অজান্তেই ফ্রি টিয়ারে বেশি বার আহ্বান করা হয়), আপনি হয় ক্লাউড রান কাজটি মুছে ফেলতে পারেন বা ধাপ 2-এ আপনার তৈরি করা প্রকল্পটি মুছে ফেলতে পারেন।

ক্লাউড রান কাজটি মুছে ফেলতে, https://console.cloud.google.com/run/ এ ক্লাউড রান ক্লাউড কনসোলে যান এবং gpu-torchserve পরিষেবাটি মুছুন।

এছাড়াও আপনি আপনার Cloud NAT কনফিগারেশন মুছে ফেলতে চাইবেন।

আপনি যদি সম্পূর্ণ প্রকল্প মুছে ফেলার সিদ্ধান্ত নেন, আপনি https://console.cloud.google.com/cloud-resource-manager- এ যেতে পারেন, ধাপ 2-এ আপনার তৈরি করা প্রকল্পটি নির্বাচন করুন এবং মুছুন নির্বাচন করুন৷ আপনি যদি প্রকল্পটি মুছে ফেলেন, তাহলে আপনাকে আপনার ক্লাউড SDK-এ প্রকল্পগুলি পরিবর্তন করতে হবে৷ আপনি gcloud projects list চালিয়ে সমস্ত উপলব্ধ প্রকল্পের তালিকা দেখতে পারেন।