Sekarang ini, sudah ada banyak aplikasi yang dapat membantu kita menghasilkan gambar dari teks. Namun, hampir semua aplikasi tersebut menjalankan prosesnya di sisi server, sehingga membutuhkan koneksi internet dan terkadang prosesnya cukup lama tergantung seberapa banyak pengguna yang mengaksesnya.

Dari sisi privasi dan keamanan data, kita juga tidak tahu apakah gambar yang kita buat akan disimpan di server mereka atau tidak. Di beberapa aplikasi juga terdapat batasan jumlah gambar yang dapat kita buat dan prompt yang boleh kita berikan sehingga kita tidak bisa bebas berkreasi.

Pada artikel kali ini kita akan belajar bagaimana cara membuat aplikasi macOS untuk menghasilkan gambar dari teks secara lokal di perangkat kita sendiri, sehingga lebih bebas, cepat dan aman.

Stable Diffusion adalah model kecerdasan buatan yang dikembangkan oleh Stability AI untuk menghasilkan gambar dari teks (prompt). Model ini meupakan model open-source sehingga dapat kita gunakan secara gratis.

Stable Diffusion (SD) merilis beberapa versi model, mulai dari SD 1.0, SD 1.5, SD 2.1, SDXL, SDXL Turbo, dan paling baru adalah SD 3.5 yang dirilis pada bulan oktober 2024 lalu. Model SD 3.5 ini dapat menghasilkan gambar dengan kualitas yang sangat baik, merender tulisan di dalam gambar dan juga dapat memahami prompt yang lebih kompleks.

Berikut adalah beberapa contoh penggunaan Stable Diffusion untuk menghasilkan gambar dari teks:

• Pembuatan Ilustrasi: misalnya ilustrasi buku, poster, atau thumbnail video youtube. (bahkan thumbnail pada artikel ini pun dibuat menggunakan Stable Diffusion 😁)

• Arsitektur dan Interior Desain: arsitek dapat menggambarkan ide ruangan atau rumah dari deskripsi sebelum modeling 3D.

• Desain Produk & Fashion: desainer dapat merancang sepatu atau pakaian hanya dari deskripsi teks.

• Konten Media Sosial dan Marketing: membuat gambar menarik untuk postingan media sosial atau iklan.

Berikut adalah langkah-langkah utama dalam proses pembuatan gambar dari teks yang dilakukan oleh Stable Diffusion:

Stable Diffusion dimulai dengan mengubah teks (prompt) menjadi representasi numerik menggunakan model text encoder bernama CLIP.

CLIP mengubah teks menjadi vektor yang merepresentasikan makna dari teks tersebut. Vektor ini akan digunakan untuk memandu proses pembuatan gambar.

Setelah teks di-encode, proses selanjutnya adalah membuat noise acak. Noise ini adalah gambar awal yang tidak memiliki makna. Noise ini akan menjadi dasar untuk proses pembuatan gambar.

Noise ini berupa latent image yang merupakan representasi dari gambar dalam bentuk tensor. Latent image ini memiliki dimensi yang lebih kecil dibandingkan dengan gambar asli (64x64x4), sehingga proses pembuatan gambar menjadi lebih efisien.

Dengan bantuan model U-Net, noise tadi dihilangkan secara bertahap (biasanya 20–50 langkah). Setiap langkah, model U-Net akan memperbaiki noise tersebut dengan mengacu pada vektor teks yang telah di-encode sebelumnya. Proses ini menghasilkan gambar yang semakin mendekati deskripsi teks.

Setelah proses denoising selesai, latent image yang dihasilkan masih dalam bentuk tensor. Kita perlu menggunakan Variational Autoencoder (VAE) untuk men-decode latent image tersebut menjadi gambar yang dapat dilihat manusia. VAE akan mengubah tensor tersebut menjadi gambar dengan resolusi yang lebih tinggi (512x512 piksel misalnya).

Agar lebih mudah dipahami, berikut adalah diagram bagaimana Stable Diffusion bekerja:

Diagram Stable Diffusion

Untuk menjalankan Stable Diffusion di macOS, kita memerlukan model dalam format Core ML. Ada beberapa cara untuk mendapatkan model ini:

Apple telah menyediakan berbagai model Stable Diffusion dalam format Core ML yang dapat langsung digunakan. Kamu dapat melihat daftar model yang tersedia di sini

Untuk mengunduhnya, silakan pilih versi model yang diinginkan, maka akan diarahkan ke website Hugging Face, kemudian pilih tab "Files and versions" dan klik icon "download".

Hugging Face

Meskipun Apple telah menyediakan beberapa model yang siap pakai, tidak semua versi model tersedia dalam format Core ML. Misalnya model SD 3.5 yang merupakan versi terbaru saat ini belum tersedia.

Jika kamu ingin menggunakan model yang belum tersedia dalam format Core ML, kamu dapat mengonversi sendiri model Stable Diffusion dari format PyTorch ke Core ML menggunakan script python_coreml_stable_diffusion.torch2coreml dari library ml-stable-diffusion.

Untuk mengonversi model, kita perlu menyiapkan environment Python serta menginstall beberapa dependensi yang diperlukan. Jalankan perintah berikut di terminal:

Copy
1git clone https://github.com/apple/ml-stable-diffusion.git
2cd ml-stable-diffusion
3
4python -m venv venv
5source venv/bin/activate
6
7pip install -e .

Setelah itu, kita dapat mengonversi model dengan perintah berikut:

Copy
1python -m python_coreml_stable_diffusion.torch2coreml \
2    --bundle-resources-for-swift-cli \
3    --model-version stabilityai/stable-diffusion-3.5-large \
4    --convert-unet \
5    --convert-text-encoder \
6    --convert-vae-decoder \
7    --convert-vae-encoder \
8    -o Resources

Silakan ganti stabilityai/stable-diffusion-3.5-large dengan versi model yang ingin dikonversi. Setelah proses konversi selesai, kamu akan mendapatkan file Core ML model di dalam folder Resources.

Sekarang kita akan membuat aplikasi macOS sederhana yang dapat menghasilkan sebuah gambar dari teks menggunakan model Stable Diffusion yang telah kita siapkan.

Silakan clone project "iMagine" dan checkout ke branch starter yang telah disediakan. Branch ini sudah berisi setup awal project macOS dengan SwiftUI sehingga kita bisa lebih fokus pada implementasi model Stable Diffusion.

Copy
1git clone https://github.com/alfinsyahruddin/iMagine.git
2cd iMagine
3git checkout starter

Silakan copy semua file model Core ML yang telah kita siapkan sebelumnya ke dalam folder Resources.

Resources

Kita perlu menambahkan library StableDiffusion dari Apple untuk memudahkan kita dalam menggunakan model Stable Diffusion di Swift.

Silakan klik File -> Add Package Dependencies, kemudian masukkan URL berikut: https://github.com/apple/ml-stable-diffusion.

Add Package Dependencies

Silakan buka file "ImageGenerator.swift", import StableDiffusion dan ubah implementasi dari fungsi generate menjadi seperti ini:

ImageGenerator.swift
Copy
1static func generate(
2    prompt: String,
3    image: CGImage? = nil,
4    imageSize: CGSize = CGSize(width: 512, height: 512),
5    numberOfImages: Int = 1
6) async throws -> [CGImage] {
8    guard let resourcesURL = Bundle.main.url(forResource: "Resources", withExtension: nil)?.path() else { return [] }
9
10    let url = URL(fileURLWithPath: resourcesURL)
11    let configuration = MLModelConfiguration()
12    configuration.computeUnits = .all
13
14    let pipeline = try StableDiffusionPipeline(
15        resourcesAt: url,
16        controlNet: [],
17        configuration: configuration
18    )
19    try pipeline.loadResources()
20
21    var pipelineConfig = StableDiffusionPipeline.Configuration(prompt: prompt)
22    pipelineConfig.startingImage = image?.resize(to: imageSize)
24    pipelineConfig.negativePrompt = "blurry, low detail, low resolution, low quality, ugly, distorted"
25    pipelineConfig.seed = UInt32.random(in: (0..<UInt32.max))
26    pipelineConfig.stepCount = 50
28    pipelineConfig.originalSize = Float32(imageSize.width)
29    pipelineConfig.targetSize = Float32(imageSize.width)
30    pipelineConfig.imageCount = numberOfImages
31
32    return try pipeline.generateImages(configuration: pipelineConfig)
33        .compactMap { $0 }
34}

Penjelasan kode:

• Pertama, kita memberitahu Stable Diffusion dimana letak folder yang berisi model Core ML berada. Dalam hal ini adalah di folder Resources.

• negativePrompt berfungsi untuk memberi tahu model, apa yang harus dihindari saat menghasilkan gambar.

• seed digunakan untuk menghasilkan noise acak. Dengan seed yang sama, kita akan mendapatkan gambar yang sama setiap kali kita menjalankan proses ini.

• stepCount menentukan berapa banyak langkah denoising yang akan dilakukan. Semakin tinggi nilainya, semakin detail gambar yang dihasilkan, namun semakin lama juga prosesnya.

Kalau kita jalankan aplikasi kita, hasilnya akan seperti ini:

iMagine ✨

Sekarang kita telah berhasil membuat aplikasi macOS yang dapat menghasilkan gambar dari teks di lokal menggunakan model Stable Diffusion. Selanjutnya kamu dapat eksplorasi lebih lanjut misalnya dengan menambahkan ControlNet untuk mengubah sketsa menjadi gambar realistis atau mendownload model pada saat runtime agar ukuran aplikasi lebih kecil.

Oke mungkin itu saja yang bisa saya bagikan kali ini, kalau kamu merasa artikel ini bermanfaat silakan Like & Share artikel ini ke teman-teman kamu atau jika kamu punya pertanyaan, tulis aja di kolom komentar, Thank you! 😁 🙏

Referensi :

• https://github.com/apple/ml-stable-diffusion

• https://www.polpiella.dev/stable-diffusion-swift-apps

• https://stable-diffusion-art.com/how-stable-diffusion-work