HuggingFace Diffusers: Membangun Aplikasi Generatif Gambar dengan Python

# HuggingFace Diffusers: Membangun Aplikasi Generatif Gambar dengan Python Halo temen-temen, kali ini kita bahas library yang jadi fondasi hampir semua aplikasi generatif gambar berbasis Python, nama...

By Ruby Abdullah · · tutorial
diffusersstable-diffusioncontrolnetloragenerative-ai

HuggingFace Diffusers: Membangun Aplikasi Generatif Gambar dengan Python

Halo temen-temen, kali ini kita bahas library yang jadi fondasi hampir semua aplikasi generatif gambar berbasis Python, namanya Diffusers dari HuggingFace. Kalau kalian selama ini pakai ComfyUI atau Automatic1111 dan penasaran gimana caranya membangun sendiri fitur generate gambar di dalam aplikasi kalian, Diffusers adalah jawabannya.

Bedanya begini. ComfyUI dan sejenisnya adalah aplikasi untuk manusia, dengan antarmuka visual. Diffusers adalah library untuk programmer, yang memungkinkan kalian menaruh kemampuan generate gambar di dalam API backend, di dalam pipeline otomatis, atau di dalam produk kalian sendiri. Dan yang menyenangkan, dia dirancang dengan sangat modular, jadi kalian bisa memakai pipeline siap pakai untuk cepat, atau membongkar komponennya kalau butuh kontrol penuh.

Di tutorial ini kita bahas cara kerja diffusion model secara konsep, instalasi, generate gambar pertama, parameter penting yang benar-benar berpengaruh, image-to-image dan inpainting, ControlNet, LoRA, optimasi memori, sampai membungkusnya jadi API produksi.

Introduction

Bagaimana Diffusion Model Bekerja

Aku mau kalian paham konsepnya dulu, karena ini bikin semua parameter nanti masuk akal.

Bayangkan kalian punya foto, lalu kalian tambahkan sedikit noise acak. Ulangi seribu kali, dan akhirnya foto itu jadi noise murni yang tidak berbentuk apa-apa. Nah, diffusion model dilatih untuk melakukan kebalikannya: diberikan gambar berisi noise, dia memprediksi noise mana yang harus dibuang untuk mendapatkan gambar yang sedikit lebih bersih.

Waktu kalian generate gambar, prosesnya dimulai dari noise acak murni. Model kemudian menghilangkan noise sedikit demi sedikit, sebanyak jumlah langkah yang kalian tentukan, sampai muncul gambar yang koheren. Teks prompt kalian dipakai untuk mengarahkan proses penghilangan noise itu ke arah yang sesuai deskripsi.

Ada tiga komponen utama dalam pipeline ini. Text encoder mengubah prompt kalian menjadi vektor yang bisa dipahami model. UNet (atau transformer di model generasi baru) adalah otak yang memprediksi noise di setiap langkah. VAE adalah penerjemah antara ruang laten yang kecil tempat semua komputasi terjadi, dan gambar berukuran penuh yang kalian lihat.

Kenapa ada ruang laten? Karena melakukan komputasi di resolusi penuh 1024x1024 itu sangat mahal. Model modern bekerja di ruang laten yang jauh lebih kecil, misalnya 128x128, lalu VAE memperbesarnya jadi gambar penuh di akhir. Ini optimasi yang membuat semua ini praktis.

Instalasi

python -m venv venv

source venv/bin/activate # Linux / Mac

venv\Scripts\activate # Windows

pip install diffusers transformers accelerate

pip install torch --index-url https://download.pytorch.org/whl/cu121

pip install pillow safetensors

Untuk fitur tambahan yang akan kita pakai nanti:

pip install peft controlnet-aux

Generate Gambar Pertama

import torch

from diffusers import StableDiffusionXLPipeline

pipe = StableDiffusionXLPipeline.frompretrained(

"stabilityai/stable-diffusion-xl-base-1.0",

torchdtype=torch.float16,

variant="fp16",

usesafetensors=True,

)

pipe = pipe.to("cuda")

prompt = "foto produk kopi arabika dalam kemasan kraft, latar kayu, pencahayaan studio lembut, tajam, komersial"

negative = "blur, buram, distorsi, teks, watermark, kualitas rendah"

gambar = pipe(

prompt=prompt,

negativeprompt=negative,

numinferencesteps=30,

guidancescale=7.0,

width=1024,

height=1024,

).images[0]

gambar.save("produk.png")

Mari kita bahas parameter yang benar-benar penting di sini, karena ini yang paling sering salah dipahami.

num
inferencesteps adalah berapa kali proses penghilangan noise diulang. Lebih banyak langkah berarti lebih detail, tapi ada titik jenuh. Untuk SDXL, 25 sampai 40 langkah biasanya sudah optimal. Di atas 50 kalian membuang waktu tanpa perbaikan berarti. guidancescale (sering disebut CFG) mengatur seberapa ketat model mengikuti prompt kalian. Nilai rendah seperti 3 menghasilkan gambar lebih kreatif tapi kurang sesuai prompt. Nilai tinggi seperti 15 menghasilkan gambar yang sangat menuruti prompt tapi sering terlihat terlalu kontras dan tidak natural. Untuk SDXL, 5 sampai 8 adalah rentang yang sehat. negativeprompt menyebutkan hal yang tidak kalian inginkan. Ini sangat efektif dan sering diremehkan. Isi dengan hal-hal yang mengganggu di hasil kalian sebelumnya. width dan height sebaiknya sesuai resolusi latih model. SDXL dilatih di sekitar 1024x1024, jadi jangan minta 512x512 darinya karena hasilnya justru jelek. Sebaliknya, SD 1.5 dilatih di 512x512 dan akan kacau kalau diminta 1024.

Reproducibility dengan Seed

Ini penting untuk pekerjaan serius. Tanpa seed, hasil kalian tidak bisa diulang.

import torch

generator = torch.Generator(device="cuda").manualseed(42)

gambar = pipe(

prompt=prompt,

generator=generator,

numinferencesteps=30,

).images[0]

Simpan seed bersama prompt di database kalian. Nanti waktu klien bilang "yang kemarin lebih bagus", kalian bisa menghasilkan ulang gambar itu persis.

Mengganti Scheduler

Scheduler menentukan bagaimana langkah penghilangan noise dijadwalkan. Menggantinya bisa mengubah kualitas dan kecepatan secara signifikan tanpa mengganti model.

from diffusers import DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler

Cepat dan bagus, favorit banyak orang

pipe.scheduler = DPMSolverMultistepScheduler.fromconfig(

pipe.scheduler.config, usekarrassigmas=True

)

Alternatif dengan karakter berbeda, lebih variatif

pipe.scheduler = EulerAncestralDiscreteScheduler.fromconfig(pipe.scheduler.config)

print("scheduler tersedia:", pipe.scheduler.compatibles)

DPMSolver dengan Karras sigma memungkinkan hasil bagus dengan langkah lebih sedikit, sekitar 20 sampai 25. Ini menghemat waktu inference secara nyata di produksi.

Image-to-Image

Alih-alih mulai dari noise murni, kalian bisa mulai dari gambar yang sudah ada.

import torch

from diffusers import StableDiffusionXLImg2ImgPipeline

from PIL import Image

pipe = StableDiffusionXLImg2ImgPipeline.frompretrained(

"stabilityai/stable-diffusion-xl-base-1.0",

torchdtype=torch.float16,

).to("cuda")

awal = Image.open("sketsa.png").convert("RGB").resize((1024, 1024))

gambar = pipe(

prompt="ilustrasi digital berwarna, gaya poster modern, warna cerah",

image=awal,

strength=0.6,

guidancescale=7.0,

numinferencesteps=30,

).images[0]

gambar.save("hasili2i.png")

Parameter kuncinya adalah strength, nilainya 0 sampai 1. Nilai rendah seperti 0.2 hanya mengubah sedikit, cocok untuk memperhalus atau mengubah warna. Nilai tinggi seperti 0.8 hampir mengabaikan gambar aslinya. Untuk mengubah sketsa jadi ilustrasi jadi, 0.5 sampai 0.7 biasanya titik manisnya.

Inpainting

Inpainting mengganti bagian tertentu dari gambar sesuai mask yang kalian berikan.

import torch

from diffusers import StableDiffusionXLInpaintPipeline

from PIL import Image

pipe = StableDiffusionXLInpaintPipeline.frompretrained(

"diffusers/stable-diffusion-xl-1.0-inpainting-0.1",

torchdtype=torch.float16,

).to("cuda")

gambarasli = Image.open("ruangan.png").convert("RGB").resize((1024, 1024))

mask = Image.open("mask.png").convert("L").resize((1024, 1024))

hasil = pipe(

prompt="sofa kulit cokelat modern",

image=gambarasli,

maskimage=mask,

strength=0.99,

numinferencesteps=30,

).images[0]

hasil.save("hasilinpaint.png")

Mask itu gambar grayscale di mana area putih akan diganti dan area hitam dipertahankan. Tips penting: buat mask sedikit lebih besar dari objek yang mau diganti, dan beri blur di tepinya supaya transisinya halus. Mask dengan tepi tajam sering menghasilkan garis batas yang kelihatan.

Ini pola yang sangat berguna untuk aplikasi bisnis, misalnya mengganti latar belakang foto produk atau menghapus objek yang tidak diinginkan dari foto properti.

ControlNet: Mengontrol Komposisi

ControlNet membuat kalian bisa mengontrol struktur gambar dengan presisi, misalnya memakai deteksi tepi, peta kedalaman, atau kerangka pose sebagai panduan.

import torch

from diffusers import StableDiffusionXLControlNetPipeline, ControlNetModel

from controlnetaux import CannyDetector

from PIL import Image

controlnet = ControlNetModel.frompretrained(

"diffusers/controlnet-canny-sdxl-1.0",

torchdtype=torch.float16,

)

pipe = StableDiffusionXLControlNetPipeline.frompretrained(

"stabilityai/stable-diffusion-xl-base-1.0",

controlnet=controlnet,

torchdtype=torch.float16,

).to("cuda")

Ekstrak tepi dari gambar referensi

canny = CannyDetector()

referensi = Image.open("denahruangan.png").convert("RGB").resize((1024, 1024))

petatepi = canny(referensi, lowthreshold=100, highthreshold=200)

gambar = pipe(

prompt="interior ruang tamu minimalis skandinavia, cahaya alami, foto arsitektur",

image=petatepi,

controlnetconditioningscale=0.7,

numinferencesteps=30,

).images[0]

gambar.save("interior.png")

controlnetconditioningscale mengatur seberapa kuat panduan struktur diterapkan. Nilai 1.0 mengikuti struktur dengan sangat ketat, kadang terlalu kaku. Nilai 0.5 sampai 0.8 biasanya memberi keseimbangan yang baik antara mengikuti struktur dan tetap terlihat natural.

Ini teknik yang membuat generative AI benar-benar bisa dipakai untuk pekerjaan profesional, karena kalian tidak lagi berharap pada keberuntungan, kalian mengontrol komposisinya.

LoRA: Gaya dan Karakter Khusus

LoRA adalah bobot tambahan kecil yang mengubah gaya atau menambahkan konsep baru ke model tanpa melatih ulang seluruhnya.

import torch

from diffusers import StableDiffusionXLPipeline

pipe = StableDiffusionXLPipeline.frompretrained(

"stabilityai/stable-diffusion-xl-base-1.0",

torchdtype=torch.float16,

).to("cuda")

Muat LoRA dari HuggingFace atau file lokal

pipe.loadloraweights("path/ke/lora", weightname="gayaperusahaan.safetensors",

adaptername="gaya")

Atur kekuatannya

pipe.setadapters(["gaya"], adapterweights=[0.8])

gambar = pipe(prompt="ilustrasi maskot perusahaan sedang menyapa").images[0]

gambar.save("maskot.png")

Lepas kalau tidak dipakai lagi

pipe.unloadloraweights()

Kalian bahkan bisa menggabungkan beberapa LoRA sekaligus:

pipe.loadloraweights("loragaya", adaptername="gaya")

pipe.loadloraweights("lorakarakter", adaptername="karakter")

pipe.setadapters(["gaya", "karakter"], adapterweights=[0.7, 0.5])

Untuk perusahaan, ini cara paling praktis membuat semua gambar yang dihasilkan konsisten dengan identitas visual brand. Latih satu LoRA dengan 20 sampai 50 gambar bergaya brand kalian, dan semua output berikutnya akan mengikuti gaya itu.

Optimasi Memori

Kalau VRAM kalian terbatas, ada beberapa teknik yang bisa dipakai dan dampaknya besar.

# 1. Pindahkan komponen ke CPU saat tidak dipakai (hemat besar, agak lambat)

pipe.enablemodelcpuoffload()

2. Offload lebih agresif per-layer (paling hemat, paling lambat)

pipe.enablesequentialcpuoffload()

3. Attention slicing, mengurangi puncak memori

pipe.enableattentionslicing()

4. VAE tiling, penting untuk resolusi besar

pipe.enablevaetiling()

5. Kompilasi UNet untuk kecepatan (PyTorch 2.0 ke atas)

pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)

Panduan praktisnya, dengan enablemodelcpuoffload() kalian bisa menjalankan SDXL di GPU 8 GB. Dengan enablesequentialcpuoffload() bahkan 6 GB masih bisa, meski lambat. Jangan pakai torch.compile bersamaan dengan offload agresif karena keduanya bisa saling mengganggu.

Satu peringatan soal torch.compile: kompilasi pertama memakan waktu satu sampai dua menit. Itu wajar. Yang penting jangan mengganti resolusi gambar terus menerus, karena setiap bentuk input baru memicu kompilasi ulang.

Membungkus Jadi API

from fastapi import FastAPI

from pydantic import BaseModel

from diffusers import StableDiffusionXLPipeline

import torch, io, base64, uuid

app = FastAPI()

Muat SEKALI saat startup

pipe = StableDiffusionXLPipeline.frompretrained(

"stabilityai/stable-diffusion-xl-base-1.0",

torchdtype=torch.float16,

variant="fp16",

).to("cuda")

pipe.enableattentionslicing()

class Permintaan(BaseModel):

prompt: str

negativeprompt: str = "blur, distorsi, watermark, kualitas rendah"

steps: int = 30

guidance: float = 7.0

seed: int | None = None

@app.post("/generate")

def generate(req: Permintaan):

seed = req.seed if req.seed is not None else int(uuid.uuid4().int % (2**31))

generator = torch.Generator(device="cuda").manualseed(seed)

gambar = pipe(

prompt=req.prompt,

negativeprompt=req.negativeprompt,

numinferencesteps=req.steps,

guidancescale=req.guidance,

generator=generator,

).images[0]

buf = io.BytesIO()

gambar.save(buf, format="PNG")

return {

"seed": seed,

"image_base64": base64.b64encode(buf.getvalue()).decode(),

}

Dua catatan produksi. Pertama, jangan biarkan request masuk paralel ke satu GPU tanpa antrian, karena kalian akan kena out of memory. Pakai antrian seperti Celery atau semaphore sederhana. Kedua, selalu kembalikan seed ke klien supaya hasil bisa direproduksi.

Tips dan Best Practice

Selalu catat prompt, negative prompt, seed, scheduler, dan semua parameter di database bersama gambarnya. Tanpa ini kalian tidak bisa memperbaiki apa pun secara sistematis.

Hormati resolusi latih model. SDXL di sekitar 1024, SD 1.5 di sekitar 512. Menyimpang jauh dari itu menghasilkan anatomi aneh dan komposisi berulang.

Untuk konsistensi brand, LoRA jauh lebih efektif daripada menulis prompt sangat panjang. Prompt panjang justru sering membuat model kehilangan fokus.

Gunakan ControlNet kalau komposisi itu penting. Mengandalkan prompt saja untuk mengatur tata letak adalah perjuangan yang tidak perlu.

Untuk produksi, pertimbangkan model yang dioptimasi untuk langkah sedikit seperti SDXL Turbo atau varian LCM, yang bisa menghasilkan gambar layak dalam 1 sampai 4 langkah. Kualitasnya sedikit di bawah, tapi biayanya jauh lebih murah dan sering cukup untuk pratinjau.

Perhatikan aspek legal dan etika. Jangan melatih LoRA dari karya orang lain tanpa izin, dan jangan menghasilkan gambar orang nyata tanpa persetujuan mereka. Ini bukan cuma soal hukum, ini soal reputasi produk kalian.

Kesimpulan

Diffusers adalah pintu masuk yang tepat kalau kalian ingin menaruh kemampuan generatif gambar ke dalam produk kalian sendiri. Ringkasannya:

Diffusion model bekerja dengan menghilangkan noise secara bertahap dari noise acak, dipandu oleh prompt kalian, dan semua parameter penting menjadi masuk akal begitu kalian paham proses ini.

Parameter yang benar-benar berpengaruh adalah jumlah langkah, guidance scale, negative prompt, resolusi yang sesuai model, dan pilihan scheduler.

Image-to-image dan inpainting membuka use case bisnis nyata seperti mengganti latar produk atau memperbaiki foto.

ControlNet memberi kontrol struktur yang presisi, dan inilah yang mengubah generative AI dari mainan jadi alat kerja.

LoRA adalah cara termurah dan tercepat menjaga konsistensi gaya brand di semua output.

Optimasi memori seperti CPU offload memungkinkan SDXL berjalan bahkan di GPU 8 GB.

Coba mulai dari satu kebutuhan nyata di kantor kalian, misalnya membuat variasi latar belakang untuk foto produk katalog. Bangun pipeline kecil dengan inpainting dan ControlNet, lalu ukur berapa jam kerja desain yang bisa dihemat. Angka itu biasanya yang membuat proyek generative AI kalian disetujui. Selamat mencoba.

Artikel Terkait

Tutorial Stable Diffusion: Generative AI untuk Pembuatan Gambar

Stable Diffusion: Tutorial Komprehensif Daftar Isi Pendahuluan Prasyarat Memahami Arsitektur Stable Diffusion 4....

Tutorial Torchtune: Fine-Tuning LLM dengan PyTorch Native

Tutorial Torchtune: Fine-Tuning LLM dengan PyTorch Native Pendahuluan Torchtune adalah library resmi dari PyTorch untuk ...

Tutorial Lengkap LlamaFactory: Toolkit Fine-Tuning LLM All-in-One

Tutorial Lengkap LlamaFactory: Toolkit Fine-Tuning LLM All-in-One Fine-tuning Large Language Model (LLM) sering kali men...

Tutorial Unsloth: Fine-Tuning LLM yang Cepat dan Hemat Memori

Fine-Tuning LLM Secara Efisien dengan Unsloth Dahulu, melakukan fine-tuning model bahasa besar membutuhkan server multi-...