FLUX, Python மற்றும் Diffusers உடன் AI-இயங்கும் பட உருவாக்க API சேவை: ஒரு விரைவான வழிகாட்டி

இந்த கட்டுரையில், பைத்தானைப் பயன்படுத்தி உங்களுக்கான சொந்த ஃப்ளக்ஸ் சர்வரை உருவாக்குவோம். இந்த சேவையகம் ஒரு எளிய API வழியாக உரை அறிவுறுத்தல்களின் அடிப்படையில் படங்களை உருவாக்க உங்களை அனுமதிக்கும். நீங்கள் இந்த சேவையகத்தை தனிப்பட்ட பயன்பாட்டிற்காக இயக்கினாலும் அல்லது தயாரிப்பு பயன்பாட்டின் ஒரு பகுதியாக இதைப் பயன்படுத்தினாலும், தொடங்குவதற்கு இந்த வழிகாட்டி உங்களுக்கு உதவும்.

FLUX ( Black Forest Labs மூலம்) கடந்த சில மாதங்களில் புயலால் AI படத்தை உருவாக்குவதற்கான உலகத்தை எடுத்துள்ளது. இது பல வரையறைகளில் நிலையான பரவலை (முந்தைய திறந்த மூல ராஜா) வென்றது மட்டுமல்லாமல், சில அளவீடுகளில் Dall-E அல்லது Midjourney போன்ற தனியுரிம மாதிரிகளையும் விஞ்சியுள்ளது.

ஆனால் உங்கள் பயன்பாடுகளில் ஒன்றில் FLUX ஐ எவ்வாறு பயன்படுத்துவது? ரெப்ளிகேட் மற்றும் பிற போன்ற சர்வர்லெஸ் ஹோஸ்ட்களைப் பயன்படுத்துவதைப் பற்றி ஒருவர் நினைக்கலாம், ஆனால் இவை மிக விரைவாக விலை உயர்ந்து, உங்களுக்குத் தேவையான நெகிழ்வுத்தன்மையை வழங்காது. உங்கள் சொந்த தனிப்பயன் FLUX சேவையகத்தை உருவாக்குவது கைக்குள் வரும்.

முன்நிபந்தனைகள்

குறியீட்டிற்குள் நுழைவதற்கு முன், தேவையான கருவிகள் மற்றும் நூலகங்கள் அமைக்கப்பட்டுள்ளதை உறுதி செய்வோம்:

• பைதான்: உங்கள் கணினியில் பைதான் 3 நிறுவப்பட வேண்டும், முன்னுரிமை பதிப்பு 3.10.
• torch : FLUX ஐ இயக்க நாம் பயன்படுத்தும் ஆழமான கற்றல் கட்டமைப்பு.
• diffusers : FLUX மாதிரிக்கான அணுகலை வழங்குகிறது.
• transformers : டிஃப்பியூசர்களின் தேவையான சார்பு.
• sentencepiece : FLUX டோக்கனைசரை இயக்கத் தேவை
• protobuf : FLUX ஐ இயக்க தேவை
• accelerate : சில சந்தர்ப்பங்களில் FLUX மாதிரியை மிகவும் திறமையாக ஏற்ற உதவுகிறது.
• fastapi : பட உருவாக்க கோரிக்கைகளை ஏற்கக்கூடிய இணைய சேவையகத்தை உருவாக்குவதற்கான கட்டமைப்பு.
• uvicorn : FastAPI சேவையகத்தை இயக்க வேண்டும்.
• psutil : நமது கணினியில் எவ்வளவு ரேம் உள்ளது என்பதை சரிபார்க்க அனுமதிக்கிறது.

பின்வரும் கட்டளையை இயக்குவதன் மூலம் நீங்கள் அனைத்து நூலகங்களையும் நிறுவலாம்: pip install torch diffusers transformers sentencepiece protobuf accelerate fastapi uvicorn .

நீங்கள் M1 அல்லது M2 சிப் கொண்ட Mac ஐப் பயன்படுத்துகிறீர்கள் என்றால், உகந்த செயல்திறனுக்காக உலோகத்துடன் PyTorch ஐ அமைக்க வேண்டும். தொடர்வதற்கு முன் உலோக வழிகாட்டியுடன் அதிகாரப்பூர்வ PyTorch ஐப் பின்பற்றவும்.

நீங்கள் GPU சாதனத்தில் FLUXஐ இயக்கத் திட்டமிட்டிருந்தால், உங்களிடம் குறைந்தது 12 GB VRAM இருப்பதை உறுதிசெய்ய வேண்டும். அல்லது CPU/MPS இல் இயங்குவதற்கு குறைந்தபட்சம் 12 ஜிபி ரேம் (இது மெதுவாக இருக்கும்).

படி 1: சூழலை அமைத்தல்

நாம் பயன்படுத்தும் வன்பொருளின் அடிப்படையில் அனுமானத்தை இயக்க சரியான சாதனத்தைத் தேர்ந்தெடுப்பதன் மூலம் ஸ்கிரிப்டைத் தொடங்குவோம்.

 device = 'cuda' # can also be 'cpu' or 'mps' import os # MPS support in PyTorch is not yet fully implemented if device == 'mps': os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1" import torch if device == 'mps' and not torch.backends.mps.is_available(): raise Exception("Device set to MPS, but MPS is not available") elif device == 'cuda' and not torch.cuda.is_available(): raise Exception("Device set to CUDA, but CUDA is not available")

நீங்கள் cpu , cuda (NVIDIA GPU களுக்கு) அல்லது mps (ஆப்பிளின் மெட்டல் செயல்திறன் ஷேடர்களுக்கு) குறிப்பிடலாம். ஸ்கிரிப்ட் தேர்ந்தெடுக்கப்பட்ட சாதனம் கிடைக்கிறதா என்பதைச் சரிபார்த்து, இல்லையெனில் அது விதிவிலக்கு அளிக்கும்.

படி 2: FLUX மாதிரியை ஏற்றுகிறது

அடுத்து, FLUX மாதிரியை ஏற்றுகிறோம். மாடலை எஃப்பி 16 துல்லியத்தில் ஏற்றுவோம், இது தரத்தில் அதிக இழப்பு இல்லாமல் சில நினைவகத்தை சேமிக்கும்.

இந்த கட்டத்தில், FLUX மாடல் இணைக்கப்பட்டுள்ளதால், HuggingFace உடன் அங்கீகரிக்கும்படி உங்களிடம் கேட்கப்படலாம். வெற்றிகரமாக அங்கீகரிக்க, நீங்கள் ஒரு HuggingFace கணக்கை உருவாக்க வேண்டும், மாதிரி பக்கத்திற்குச் சென்று, விதிமுறைகளை ஏற்று, பின்னர் உங்கள் கணக்கு அமைப்புகளிலிருந்து HuggingFace டோக்கனை உருவாக்கி, அதை உங்கள் கணினியில் HF_TOKEN சூழல் மாறியாகச் சேர்க்க வேண்டும்.

 from diffusers import FlowMatchEulerDiscreteScheduler, FluxPipeline import psutil model_name = "black-forest-labs/FLUX.1-dev" print(f"Loading {model_name} on {device}") pipeline = FluxPipeline.from_pretrained( model_name, # Diffusion models are generally trained on fp32, but fp16 # gets us 99% there in terms of quality, with just half the (V)RAM torch_dtype=torch.float16, # Ensure we don't load any dangerous binary code use_safetensors=True # We are using Euler here, but you can also use other samplers scheduler=FlowMatchEulerDiscreteScheduler() ).to(device)

இங்கே, டிஃப்பியூசர்ஸ் லைப்ரரியைப் பயன்படுத்தி FLUX மாதிரியை ஏற்றுகிறோம். நாங்கள் பயன்படுத்தும் மாடல் black-forest-labs/FLUX.1-dev , fp16 துல்லியத்தில் ஏற்றப்பட்டது.

FLUX Schnell என்ற பெயரிடப்பட்ட டைம்ஸ்டெப்-டிஸ்டில்டு மாடலும் உள்ளது, இது வேகமான அனுமானத்தைக் கொண்டுள்ளது, ஆனால் குறைவான விரிவான படங்களை வெளியிடுகிறது, அத்துடன் மூடிய மூலமான FLUX Pro மாதிரியும் உள்ளது. நாங்கள் இங்கே Euler திட்டமிடலைப் பயன்படுத்துவோம், ஆனால் நீங்கள் இதைப் பரிசோதனை செய்யலாம். திட்டமிடுபவர்களைப் பற்றி இங்கே மேலும் படிக்கலாம். பட உருவாக்கம் வளம்-தீவிரமாக இருப்பதால், நினைவகப் பயன்பாட்டை மேம்படுத்துவது மிகவும் முக்கியமானது, குறிப்பாக CPU அல்லது குறைந்த நினைவகம் கொண்ட சாதனத்தில் இயங்கும் போது.

 # Recommended if running on MPS or CPU with < 64 GB of RAM total_memory = psutil.virtual_memory().total total_memory_gb = total_memory / (1024 ** 3) if (device == 'cpu' or device == 'mps') and total_memory_gb < 64: print("Enabling attention slicing") pipeline.enable_attention_slicing()

இந்த குறியீடு மொத்த கிடைக்கக்கூடிய நினைவகத்தை சரிபார்க்கிறது மற்றும் கணினியில் 64 ஜிபி ரேம் குறைவாக இருந்தால் கவனத்தை வெட்டுவதை செயல்படுத்துகிறது. கவனத்தை வெட்டுதல், பட உருவாக்கத்தின் போது நினைவகப் பயன்பாட்டைக் குறைக்கிறது, இது வரையறுக்கப்பட்ட வளங்களைக் கொண்ட சாதனங்களுக்கு அவசியம்.

படி 3: FastAPI உடன் API ஐ உருவாக்குதல்

அடுத்து, FastAPI சேவையகத்தை அமைப்போம், இது படங்களை உருவாக்க API ஐ வழங்கும்.

 from fastapi import FastAPI, HTTPException from pydantic import BaseModel, Field, conint, confloat from fastapi.middleware.gzip import GZipMiddleware from io import BytesIO import base64 app = FastAPI() # We will be returning the image as a base64 encoded string # which we will want compressed app.add_middleware(GZipMiddleware, minimum_size=1000, compresslevel=7)

FastAPI என்பது பைத்தானைக் கொண்டு வலை APIகளை உருவாக்குவதற்கான ஒரு பிரபலமான கட்டமைப்பாகும். இந்த நிலையில், படத்தை உருவாக்குவதற்கான கோரிக்கைகளை ஏற்கக்கூடிய சர்வரை உருவாக்க இதைப் பயன்படுத்துகிறோம். பதிலைச் சுருக்க GZip மிடில்வேரைப் பயன்படுத்துகிறோம், இது பேஸ்64 வடிவத்தில் படங்களை மீண்டும் அனுப்பும் போது மிகவும் பயனுள்ளதாக இருக்கும்.

ஒரு தயாரிப்பு சூழலில், நீங்கள் உருவாக்கப்படும் படங்களை S3 பக்கெட் அல்லது பிற கிளவுட் சேமிப்பகத்தில் சேமித்து, CDN மற்றும் பிற மேம்படுத்தல்களைப் பயன்படுத்த, base64-குறியீடு செய்யப்பட்ட சரங்களுக்குப் பதிலாக URLகளைத் திருப்பி அனுப்பலாம்.

படி 4: கோரிக்கை மாதிரியை வரையறுத்தல்

எங்கள் API ஏற்கும் கோரிக்கைகளுக்கான மாதிரியை இப்போது வரையறுக்க வேண்டும்.

 class GenerateRequest(BaseModel): prompt: str seed: conint(ge=0) = Field(..., description="Seed for random number generation") height: conint(gt=0) = Field(..., description="Height of the generated image, must be a positive integer and a multiple of 8") width: conint(gt=0) = Field(..., description="Width of the generated image, must be a positive integer and a multiple of 8") cfg: confloat(gt=0) = Field(..., description="CFG (classifier-free guidance scale), must be a positive integer or 0") steps: conint(ge=0) = Field(..., description="Number of steps") batch_size: conint(gt=0) = Field(..., description="Number of images to generate in a batch")

இந்த GenerateRequest மாதிரி ஒரு படத்தை உருவாக்க தேவையான அளவுருக்களை வரையறுக்கிறது. prompt புலம் என்பது நீங்கள் உருவாக்க விரும்பும் படத்தின் உரை விளக்கமாகும். பிற புலங்களில் பட பரிமாணங்கள், அனுமான படிகளின் எண்ணிக்கை மற்றும் தொகுதி அளவு ஆகியவை அடங்கும்.

படி 5: இமேஜ் ஜெனரேஷன் எண்ட்பாயிண்ட்டை உருவாக்குதல்

இப்போது, பட உருவாக்கக் கோரிக்கைகளைக் கையாளும் இறுதிப்புள்ளியை உருவாக்குவோம்.

 @app.post("/") async def generate_image(request: GenerateRequest): # Validate that height and width are multiples of 8 # as required by FLUX if request.height % 8 != 0 or request.width % 8 != 0: raise HTTPException(status_code=400, detail="Height and width must both be multiples of 8") # Always calculate the seed on CPU for deterministic RNG # For a batch of images, seeds will be sequential like n, n+1, n+2, ... generator = [torch.Generator(device="cpu").manual_seed(i) for i in range(request.seed, request.seed + request.batch_size)] images = pipeline( height=request.height, width=request.width, prompt=request.prompt, generator=generator, num_inference_steps=request.steps, guidance_scale=request.cfg, num_images_per_prompt=request.batch_size ).images # Convert images to base64 strings # (for a production app, you might want to store the # images in an S3 bucket and return the URLs instead) base64_images = [] for image in images: buffered = BytesIO() image.save(buffered, format="PNG") img_str = base64.b64encode(buffered.getvalue()).decode("utf-8") base64_images.append(img_str) return { "images": base64_images, }

இந்த இறுதிப்புள்ளி படத்தை உருவாக்கும் செயல்முறையை கையாளுகிறது. FLUX க்கு தேவையான உயரம் மற்றும் அகலம் 8 இன் மடங்குகள் என்பதை இது முதலில் சரிபார்க்கிறது. இது வழங்கப்பட்ட வரியில் படிமங்களை உருவாக்கி, அவற்றை அடிப்படை64-குறியீடு செய்யப்பட்ட சரங்களாகத் தருகிறது.

படி 6: சேவையகத்தைத் தொடங்குதல்

இறுதியாக, ஸ்கிரிப்ட் இயங்கும்போது சேவையகத்தைத் தொடங்க சில குறியீட்டைச் சேர்ப்போம்.

 @app.on_event("startup") async def startup_event(): print("Image generation server running") if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)

இந்தக் குறியீடு போர்ட் 8000 இல் FastAPI சேவையகத்தைத் தொடங்குகிறது, இது http://localhost:8000 இலிருந்து மட்டுமின்றி அதே நெட்வொர்க்கில் உள்ள பிற சாதனங்களிலிருந்தும் ஹோஸ்ட் இயந்திரத்தின் IP முகவரியைப் பயன்படுத்தி, 0.0.0.0 பிணைப்புக்கு நன்றி.

படி 7: உங்கள் சர்வரை உள்ளூரில் சோதனை செய்தல்

இப்போது உங்கள் FLUX சேவையகம் இயங்குகிறது, அதைச் சோதிக்க வேண்டிய நேரம் இது. உங்கள் சேவையகத்துடன் தொடர்பு கொள்ள, HTTP கோரிக்கைகளை உருவாக்குவதற்கான கட்டளை வரி கருவியான curl பயன்படுத்தலாம்:

 curl -X POST "http://localhost:8000/" \ -H "Content-Type: application/json" \ -d '{ "prompt": "A futuristic cityscape at sunset", "seed": 42, "height": 1024, "width": 1024, "cfg": 3.5, "steps": 50, "batch_size": 1 }' | jq -r '.images[0]' | base64 -d > test.png

இந்த கட்டளையானது curl , jq மற்றும் base64 பயன்பாடுகள் நிறுவப்பட்ட யுனிக்ஸ் அடிப்படையிலான கணினிகளில் மட்டுமே வேலை செய்யும். FLUX சேவையகத்தை வழங்கும் வன்பொருளைப் பொறுத்து இது முடிவதற்கு சில நிமிடங்கள் ஆகலாம்.

முடிவுரை

வாழ்த்துகள்! பைத்தானைப் பயன்படுத்தி உங்கள் சொந்த FLUX சேவையகத்தை வெற்றிகரமாக உருவாக்கியுள்ளீர்கள். எளிய API வழியாக உரைத் தூண்டுதல்களின் அடிப்படையில் படங்களை உருவாக்க இந்த அமைப்பு உங்களை அனுமதிக்கிறது. அடிப்படை FLUX மாதிரியின் முடிவுகளில் நீங்கள் திருப்தி அடையவில்லை என்றால், குறிப்பிட்ட பயன்பாட்டு நிகழ்வுகளில் இன்னும் சிறந்த செயல்திறனுக்காக மாடலை நன்றாகச் சரிசெய்வதை நீங்கள் பரிசீலிக்கலாம் .

முழு குறியீடு

கீழே உள்ள இந்த வழிகாட்டியில் பயன்படுத்தப்பட்ட முழு குறியீட்டையும் நீங்கள் காணலாம்:

 device = 'cuda' # can also be 'cpu' or 'mps' import os # MPS support in PyTorch is not yet fully implemented if device == 'mps': os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1" import torch if device == 'mps' and not torch.backends.mps.is_available(): raise Exception("Device set to MPS, but MPS is not available") elif device == 'cuda' and not torch.cuda.is_available(): raise Exception("Device set to CUDA, but CUDA is not available") from diffusers import FlowMatchEulerDiscreteScheduler, FluxPipeline import psutil model_name = "black-forest-labs/FLUX.1-dev" print(f"Loading {model_name} on {device}") pipeline = FluxPipeline.from_pretrained( model_name, # Diffusion models are generally trained on fp32, but fp16 # gets us 99% there in terms of quality, with just half the (V)RAM torch_dtype=torch.float16, # Ensure we don't load any dangerous binary code use_safetensors=True, # We are using Euler here, but you can also use other samplers scheduler=FlowMatchEulerDiscreteScheduler() ).to(device) # Recommended if running on MPS or CPU with < 64 GB of RAM total_memory = psutil.virtual_memory().total total_memory_gb = total_memory / (1024 ** 3) if (device == 'cpu' or device == 'mps') and total_memory_gb < 64: print("Enabling attention slicing") pipeline.enable_attention_slicing() from fastapi import FastAPI, HTTPException from pydantic import BaseModel, Field, conint, confloat from fastapi.middleware.gzip import GZipMiddleware from io import BytesIO import base64 app = FastAPI() # We will be returning the image as a base64 encoded string # which we will want compressed app.add_middleware(GZipMiddleware, minimum_size=1000, compresslevel=7) class GenerateRequest(BaseModel): prompt: str seed: conint(ge=0) = Field(..., description="Seed for random number generation") height: conint(gt=0) = Field(..., description="Height of the generated image, must be a positive integer and a multiple of 8") width: conint(gt=0) = Field(..., description="Width of the generated image, must be a positive integer and a multiple of 8") cfg: confloat(gt=0) = Field(..., description="CFG (classifier-free guidance scale), must be a positive integer or 0") steps: conint(ge=0) = Field(..., description="Number of steps") batch_size: conint(gt=0) = Field(..., description="Number of images to generate in a batch") @app.post("/") async def generate_image(request: GenerateRequest): # Validate that height and width are multiples of 8 # as required by FLUX if request.height % 8 != 0 or request.width % 8 != 0: raise HTTPException(status_code=400, detail="Height and width must both be multiples of 8") # Always calculate the seed on CPU for deterministic RNG # For a batch of images, seeds will be sequential like n, n+1, n+2, ... generator = [torch.Generator(device="cpu").manual_seed(i) for i in range(request.seed, request.seed + request.batch_size)] images = pipeline( height=request.height, width=request.width, prompt=request.prompt, generator=generator, num_inference_steps=request.steps, guidance_scale=request.cfg, num_images_per_prompt=request.batch_size ).images # Convert images to base64 strings # (for a production app, you might want to store the # images in an S3 bucket and return the URL's instead) base64_images = [] for image in images: buffered = BytesIO() image.save(buffered, format="PNG") img_str = base64.b64encode(buffered.getvalue()).decode("utf-8") base64_images.append(img_str) return { "images": base64_images, } @app.on_event("startup") async def startup_event(): print("Image generation server running") if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)