Neural Style Transfer (NST) adalah salah satu teknik paling menarik dalam bidang computer vision dan deep learning, yang memungkinkan kita untuk “melukis ulang” sebuah gambar (gambar konten) menggunakan gaya artistik dari gambar lain (gambar gaya). Hasilnya adalah sebuah karya seni baru yang menggabungkan struktur konten gambar pertama dengan tekstur dan palet warna gambar kedua. Teknik ini membuka banyak kemungkinan kreatif, mulai dari pembuatan seni digital unik hingga aplikasi dalam efek visual. Tutorial ini akan memandu Anda langkah demi langkah dalam proses implementasi style transfer dari awal menggunakan library PyTorch, salah satu framework deep learning terpopuler. Meskipun fokus kita adalah PyTorch style transfer, konsep dasar yang dibahas juga dapat diterapkan pada framework lain seperti TensorFlow (TensorFlow style transfer).
Memahami Konsep Dasar Cara Kerja Neural Style Transfer
Sebelum melangkah ke implementasi kode, penting untuk memahami cara kerja neural style transfer. Inti dari NST adalah penggunaan Convolutional Neural Network (CNN) yang sudah dilatih sebelumnya (pre-trained), biasanya pada dataset besar seperti ImageNet. Model seperti VGG, ResNet, atau Inception terbukti sangat efektif dalam mengekstraksi fitur hierarkis dari sebuah gambar.
Arsitektur Umum NST
Proses NST melibatkan tiga gambar utama: gambar konten (C), gambar gaya (S), dan gambar hasil (G). Gambar hasil ini awalnya dapat berupa salinan dari gambar konten atau bahkan noise acak. Ketiga gambar ini kemudian dilewatkan melalui CNN pre-trained. Fitur-fitur yang diekstrak dari layer-layer yang berbeda dalam CNN inilah yang digunakan untuk menghitung dua jenis ukuran kerugian (loss): Content Loss dan Style Loss. Tujuan utamanya adalah meminimalkan total loss tersebut dengan cara mengoptimalkan piksel-piksel pada gambar hasil (G) secara iteratif.
Content Loss: Mempertahankan Struktur Konten
Content Loss dirancang untuk memastikan bahwa gambar hasil (G) tetap mempertahankan struktur dan objek utama yang ada pada gambar konten (C). Perhitungan loss ini dilakukan dengan mengukur perbedaan (umumnya menggunakan Mean Squared Error – MSE) antara representasi fitur dari gambar C dan G pada layer-layer yang lebih dalam (high-level) dari CNN. Layer yang lebih dalam cenderung menangkap informasi konten global gambar, bukan detail tekstur spesifik.
Style Loss: Menangkap Karakteristik Gaya
Di sisi lain, Style Loss bertujuan memastikan bahwa gambar hasil (G) berhasil mengadopsi tekstur, pola visual, dan palet warna dari gambar gaya (S). Perhitungannya sedikit lebih kompleks dibandingkan Content Loss. Style Loss dihitung dengan membandingkan korelasi antar fitur pada berbagai layer CNN. Korelasi inilah yang efektif menangkap esensi gaya, yang kemudian diukur menggunakan Gram Matrix.
Peran Gram Matrix dalam Style Loss
Gram Matrix memegang peranan kunci dalam menangkap ‘gaya’. Alih-alih membandingkan fitur secara langsung (yang sangat sensitif terhadap lokasi spasial objek), Gram Matrix menghitung korelasi antara filter-filter yang berbeda dalam satu layer. Pendekatan ini secara efektif menangkap informasi mengenai tekstur dan pola (gaya) tanpa terlalu terikat pada susunan spasial objek dalam gambar. Style Loss kemudian dihitung sebagai MSE antara Gram Matrix dari gambar S dan G pada beberapa layer CNN, biasanya mencakup layer-layer awal hingga menengah.
Total Loss: Menggabungkan Content dan Style
Gambar hasil (G) dioptimalkan untuk meminimalkan kombinasi dari kedua jenis loss tersebut. Total Loss umumnya dihitung sebagai jumlah tertimbang dari keduanya:
Total Loss = α * Content Loss + β * Style Loss
Di mana α (alpha) dan β (beta) adalah bobot yang menentukan seberapa besar penekanan diberikan pada mempertahankan konten versus mengadopsi gaya. Mengubah nilai α dan β akan menghasilkan output yang berbeda secara visual, memberikan kontrol atas hasil akhir.
Langkah 1: Persiapan Lingkungan Kerja Python
Langkah pertama adalah memastikan Anda memiliki Python terinstal di sistem Anda. Selanjutnya, instal library-library yang diperlukan menggunakan pip. Buka terminal atau command prompt Anda, lalu jalankan perintah berikut:
pip install torch torchvision numpy matplotlib PillowPerintah ini akan menginstal PyTorch (framework deep learning utama), Torchvision (untuk model pre-trained dan utilitas pemrosesan gambar), NumPy (untuk operasi numerik efisien), Matplotlib (untuk visualisasi hasil), dan Pillow (untuk memuat dan memanipulasi file gambar).
Langkah 2: Memuat Data dan Model Pre-trained
Setelah lingkungan siap, kita perlu menyiapkan gambar konten, gambar gaya, dan memuat model CNN pre-trained yang akan digunakan sebagai tulang punggung proses ekstraksi fitur.
Mempersiapkan Gambar Konten dan Gaya
Pilihlah sebuah gambar konten (misalnya, foto pemandangan, potret diri) dan sebuah gambar gaya (misalnya, lukisan impresionis, abstrak). Untuk mempercepat proses komputasi, terutama pada tahap awal eksperimen, disarankan menggunakan gambar dengan resolusi yang tidak terlalu besar. Berikut adalah fungsi untuk memuat, mengubah ukuran, dan melakukan pra-pemrosesan gambar agar sesuai dengan format input model:
import torch
import torch.optim as optim
import torchvision.transforms as transforms
import torchvision.models as models
from torchvision.utils import save_image
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
import copy
# Tentukan device komputasi (GPU jika tersedia, jika tidak CPU)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Menggunakan device: {device}")
# Ukuran gambar yang diinginkan (lebih besar jika menggunakan GPU)
imsize = 512 if torch.cuda.is_available() else 128
# Definisikan transformasi untuk memuat dan pra-pemrosesan gambar
loader = transforms.Compose([
transforms.Resize((imsize, imsize)), # Ubah ukuran gambar
transforms.ToTensor()]) # Konversi gambar ke Tensor PyTorch
def image_loader(image_name):
"""Memuat gambar, menerapkan transformasi, dan menambahkan dimensi batch."""
try:
image = Image.open(image_name).convert('RGB')
except FileNotFoundError:
print(f"Error: File gambar tidak ditemukan di {image_name}")
return None
# Tambahkan dimensi batch yang diperlukan model (N, C, H, W)
image = loader(image).unsqueeze(0)
return image.to(device, torch.float)
# --- PENTING: Ganti dengan path ke gambar konten dan gaya Anda ---
content_img_path = "path/ke/gambar_konten.jpg"
style_img_path = "path/ke/gambar_gaya.jpg"
content_img = image_loader(content_img_path)
style_img = image_loader(style_img_path)
# Lanjutkan hanya jika gambar berhasil dimuat
if content_img is not None and style_img is not None:
print("Ukuran Tensor Content Image:", content_img.shape)
print("Ukuran Tensor Style Image:", style_img.shape)
# Fungsi untuk mengkonversi tensor kembali ke gambar PIL untuk ditampilkan
unloader = transforms.ToPILImage()
def imshow(tensor, title=None):
"""Menampilkan tensor sebagai gambar."""
image = tensor.cpu().clone() # Kloning tensor ke CPU
image = image.squeeze(0) # Hapus dimensi batch
image = unloader(image)
plt.imshow(image)
if title is not None:
plt.title(title)
# plt.pause(0.001) # Jeda singkat agar plot diperbarui (opsional)
# Baris berikut bisa di-uncomment untuk menampilkan gambar input
# plt.figure()
# imshow(content_img, title='Content Image')
# plt.figure()
# imshow(style_img, title='Style Image')
# plt.show()
else:
print("Gagal memuat gambar. Pastikan path file sudah benar.")
# Anda mungkin ingin menghentikan eksekusi di sini jika gambar gagal dimuat
exit()
Pastikan Anda mengganti nilai variabel `content_img_path` dan `style_img_path` dengan path file yang sesuai di sistem Anda.
Memuat Model VGG19 Pre-trained
Kita akan memanfaatkan model VGG19 yang sudah dilatih pada dataset ImageNet. Penggunaan VGG network style transfer cukup populer karena arsitekturnya yang relatif sederhana namun efektif dalam menangkap fitur hierarkis visual. Kita hanya memerlukan bagian ekstraksi fiturnya (`features`), bukan bagian klasifikasi (`classifier`).
# Muat model VGG19 pre-trained (hanya bagian fitur)
cnn = models.vgg19(pretrained=True).features.to(device).eval()
# VGG dilatih dengan gambar yang dinormalisasi, jadi kita perlu normalisasi yang sama
cnn_normalization_mean = torch.tensor([0.485, 0.456, 0.406]).to(device)
cnn_normalization_std = torch.tensor([0.229, 0.224, 0.225]).to(device)
# Buat modul kustom untuk normalisasi input
class Normalization(torch.nn.Module):
def __init__(self, mean, std):
super(Normalization, self).__init__()
# Ubah shape mean dan std agar bisa di-broadcast
self.mean = mean.clone().detach().view(-1, 1, 1)
self.std = std.clone().detach().view(-1, 1, 1)
def forward(self, img):
# Normalisasi gambar: (img - mean) / std
return (img - self.mean) / self.std
# Tentukan layer-layer VGG yang akan digunakan untuk menghitung loss
# Eksperimen dengan layer berbeda dapat menghasilkan gaya yang berbeda
content_layers_default = ['conv_4'] # Layer lebih dalam untuk konten
style_layers_default = ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5'] # Kombinasi layer untuk gaya
# Bekukan parameter VGG agar tidak terupdate selama optimasi
for param in cnn.parameters():
param.requires_grad_(False)
Kode di atas memuat arsitektur VGG19, mendefinisikan parameter normalisasi yang sesuai dengan data latihnya, dan yang terpenting, ‘membekukan’ bobot model (`requires_grad_(False)`) karena kita tidak ingin melatih ulang VGG, melainkan hanya menggunakannya untuk ekstraksi fitur.
Langkah 3: Mendefinisikan Fungsi Loss (Content Loss & Style Loss Python)
Sekarang, kita akan mengimplementasikan kelas-kelas Pytorch untuk menghitung Content Loss dan Style Loss. Implementasi content loss style loss python yang tepat adalah inti dari keberhasilan transfer gaya.
Implementasi Content Loss
Content loss mengukur seberapa mirip representasi fitur antara gambar konten asli dan gambar hasil pada layer yang ditentukan. Biasanya dihitung sebagai Mean Squared Error (MSE).
class ContentLoss(torch.nn.Module):
def __init__(self, target,):
super(ContentLoss, self).__init__()
# Kita 'detach' target content agar tidak ikut terhitung dalam gradien
# Ini adalah nilai fitur target yang tetap, bukan variabel yang dioptimalkan.
self.target = target.detach()
self.loss_fn = torch.nn.MSELoss()
self.loss_val = 0.0 # Inisialisasi nilai loss
def forward(self, input):
# Hitung MSE antara fitur input (gambar hasil) dan fitur target (gambar konten)
self.loss_val = self.loss_fn(input, self.target)
# Penting: Kembalikan input asli agar bisa diteruskan ke layer berikutnya
return input
Implementasi Style Loss dengan Gram Matrix
Untuk Style Loss, kita perlu fungsi yang menghitung Gram Matrix terlebih dahulu. Gram Matrix menangkap korelasi antar fitur, yang merepresentasikan tekstur dan gaya.
def gram_matrix(input):
"""Menghitung Gram Matrix dari sebuah batch fitur map."""
# Dapatkan ukuran dimensi: batch_size, num_feature_maps (channel), height, width
b, c, h, w = input.size()
# Reshape fitur menjadi matriks 2D: (channels) x (height * width)
features = input.view(b * c, h * w)
# Hitung produk Gram: (features) x (features transpose)
G = torch.mm(features, features.t())
# Normalisasi Gram matrix dengan membaginya dengan jumlah total elemen di fitur map
# Ini penting untuk mencegah nilai loss menjadi terlalu besar pada layer dengan banyak fitur
return G.div(b * c * h * w)
class StyleLoss(torch.nn.Module):
def __init__(self, target_feature):
super(StyleLoss, self).__init__()
# Hitung Gram Matrix target (dari gambar gaya) dan detach
self.target = gram_matrix(target_feature).detach()
self.loss_fn = torch.nn.MSELoss()
self.loss_val = 0.0 # Inisialisasi nilai loss
def forward(self, input):
# Hitung Gram Matrix dari input (gambar hasil)
G = gram_matrix(input)
# Hitung MSE antara Gram Matrix input dan Gram Matrix target
self.loss_val = self.loss_fn(G, self.target)
# Kembalikan input asli untuk layer berikutnya
return input
Kelas `StyleLoss` menggunakan fungsi `gram_matrix` untuk menghitung representasi gaya dari fitur input dan fitur target (gambar gaya), lalu menghitung MSE di antara keduanya.
Langkah 4: Proses Implementasi Style Transfer (Kode Python Style Transfer)
Dengan semua komponen siap, kita akan membangun model baru yang secara dinamis menyisipkan layer-layer loss (Content Loss dan Style Loss) ke dalam arsitektur VGG. Kemudian, kita akan menjalankan loop optimasi untuk memperbarui gambar hasil. Bagian ini menyajikan inti dari kode python style transfer.
Inisialisasi Gambar Output
Gambar output (gambar yang akan dioptimalkan) dapat dimulai dari salinan gambar konten atau gambar noise acak. Memulai dari salinan gambar konten seringkali mempercepat konvergensi dan menghasilkan output yang lebih mempertahankan struktur asli.
# Mulai optimasi dari salinan gambar konten
input_img = content_img.clone()
# Alternatif: Mulai dari noise acak
# input_img = torch.randn(content_img.data.size(), device=device)
# Pastikan gambar input ini memerlukan perhitungan gradien karena ini yang akan dioptimalkan
input_img.requires_grad_(True)
Menyiapkan Optimizer
Optimizer bertugas memperbarui piksel-piksel pada `input_img` berdasarkan gradien yang dihitung dari total loss. Optimizer Adam seringkali menjadi pilihan yang baik dan lebih mudah digunakan daripada LBFGS (yang digunakan di paper asli NST tetapi memerlukan *closure* yang lebih kompleks).
# Gunakan optimizer Adam untuk memperbarui gambar input
# Eksperimen dengan learning rate (lr) bisa diperlukan
optimizer = optim.Adam([input_img], lr=0.01)
Loop Optimasi Langkah-demi-Langkah
Ini adalah jantung dari proses implementasi style transfer. Kita akan secara iteratif memperbarui piksel `input_img` untuk meminimalkan total loss (kombinasi Content Loss dan Style Loss).
def get_style_model_and_losses(cnn, normalization_mean, normalization_std,
style_img, content_img,
content_layers=content_layers_default,
style_layers=style_layers_default):
"""Membangun model baru dengan menyisipkan loss layers ke dalam VGG."""
# Buat salinan CNN agar tidak mengubah model asli
cnn = copy.deepcopy(cnn)
# Modul normalisasi
normalization = Normalization(normalization_mean, normalization_std).to(device)
# List untuk menyimpan instance loss layer
content_losses = []
style_losses = []
# Mulai model baru dengan layer normalisasi
model = torch.nn.Sequential(normalization)
i = 0 # Counter untuk layer konvolusi
for layer in cnn.children():
if isinstance(layer, torch.nn.Conv2d):
i += 1
name = 'conv_{}'.format(i)
elif isinstance(layer, torch.nn.ReLU):
name = 'relu_{}'.format(i)
# Versi ReLU inplace=False lebih aman saat menyisipkan loss layer
layer = torch.nn.ReLU(inplace=False)
elif isinstance(layer, torch.nn.MaxPool2d):
name = 'pool_{}'.format(i)
# Beberapa implementasi NST menggunakan AvgPool2d sebagai pengganti MaxPool2d
# layer = torch.nn.AvgPool2d(kernel_size=layer.kernel_size, stride=layer.stride, padding=layer.padding)
# name = 'avgpool_{}'.format(i)
elif isinstance(layer, torch.nn.BatchNorm2d):
name = 'bn_{}'.format(i)
else:
raise RuntimeError('Unrecognized layer: {}'.format(layer.__class__.__name__))
model.add_module(name, layer)
# Jika nama layer ada di daftar content layers
if name in content_layers:
# Hitung fitur target dari gambar konten sekali saja
target = model(content_img).detach()
# Buat instance ContentLoss
content_loss = ContentLoss(target)
# Tambahkan loss layer ke model setelah layer VGG yang sesuai
model.add_module("content_loss_{}".format(i), content_loss)
content_losses.append(content_loss)
# Jika nama layer ada di daftar style layers
if name in style_layers:
# Hitung fitur target dari gambar gaya sekali saja
target_feature = model(style_img).detach()
# Buat instance StyleLoss
style_loss = StyleLoss(target_feature)
# Tambahkan loss layer ke model
model.add_module("style_loss_{}".format(i), style_loss)
style_losses.append(style_loss)
# Pangkas layer-layer VGG setelah loss layer terakhir
# Kita tidak perlu menjalankannya karena loss sudah dihitung
for i in range(len(model) - 1, -1, -1):
if isinstance(model[i], ContentLoss) or isinstance(model[i], StyleLoss):
break
model = model[:(i + 1)]
return model, style_losses, content_losses
# --- Loop Optimasi Utama ---
num_steps = 300 # Jumlah iterasi optimasi (bisa ditambah untuk hasil lebih baik)
style_weight = 1000000 # Bobot untuk style loss (beta), biasanya tinggi
content_weight = 1 # Bobot untuk content loss (alpha)
print('Membangun model style transfer...')
model, style_losses, content_losses = get_style_model_and_losses(cnn,
cnn_normalization_mean, cnn_normalization_std, style_img, content_img)
# Pindahkan model ke device yang dipilih (GPU/CPU)
model.to(device)
# Pastikan input_img juga memerlukan gradien (penting untuk optimasi)
input_img.requires_grad_(True)
# Set model ke mode evaluasi jika ada layer seperti Dropout atau BatchNorm
# Meskipun VGG biasanya tidak punya ini di 'features', ini praktik yang baik.
model.eval()
# model.requires_grad_(False) # Kita hanya mengoptimalkan input_img, bukan modelnya
print('Memulai optimasi...')
run = [0]
while run[0] <= num_steps:
def closure():
# Koreksi nilai piksel gambar input agar tetap dalam rentang valid [0, 1]
with torch.no_grad(): # Tidak perlu gradien untuk operasi clamp
input_img.clamp_(0, 1)
optimizer.zero_grad() # Reset gradien sebelum backward pass
# Jalankan input_img melalui model
# Ini akan secara otomatis menghitung loss di dalam loss layers
model(input_img)
style_score = 0
content_score = 0
# Akumulasikan loss dari setiap instance loss layer
for sl in style_losses:
style_score += sl.loss_val
for cl in content_losses:
content_score += cl.loss_val
# Terapkan bobot pada masing-masing loss
style_score *= style_weight
content_score *= content_weight
# Hitung total loss
loss = style_score + content_score
# Hitung gradien total loss terhadap piksel input_img
loss.backward()
run[0] += 1
if run[0] % 50 == 0: # Cetak progres setiap 50 langkah
print(f"Iterasi {run[0]}:", end=' ')
print(f'Style Loss: {style_score.item():.4f} Content Loss: {content_score.item():.4f} Total Loss: {loss.item():.4f}')
return loss # Kembalikan total loss
# Lakukan satu langkah optimasi
optimizer.step(closure)
# Lakukan clamping terakhir setelah loop selesai
with torch.no_grad():
input_img.clamp_(0, 1)
print("Optimasi Selesai!")
Loop ini secara berulang melakukan forward pass `input_img` melalui model (yang kini berisi loss layers), menghitung total loss (kombinasi tertimbang dari content loss style loss python), melakukan backpropagation untuk mendapatkan gradien loss terhadap piksel `input_img`, dan akhirnya memperbarui `input_img` menggunakan `optimizer.step()`. Proses ini diulang sebanyak `num_steps` kali.
Langkah 5: Visualisasi Hasil Tutorial Transfer Gaya Gambar
Setelah proses optimasi selesai, `input_img` kini berisi gambar hasil transfer gaya. Langkah terakhir adalah memvisualisasikan gambar konten asli, gambar gaya asli, dan gambar output hasil tutorial transfer gaya gambar ini untuk melihat hasilnya.
def display_results(content_tensor, style_tensor, output_tensor):
"""Menampilkan gambar konten, gaya, dan hasil."""
plt.figure(figsize=(18, 6)) # Ukuran figure bisa disesuaikan
plt.subplot(1, 3, 1)
imshow(content_tensor, title='Content Image')
plt.axis('off')
plt.subplot(1, 3, 2)
imshow(style_tensor, title='Style Image')
plt.axis('off')
plt.subplot(1, 3, 3)
imshow(output_tensor, title='Output Image')
plt.axis('off')
plt.tight_layout() # Menyesuaikan layout agar tidak tumpang tindih
plt.show()
# Tampilkan hasil akhir
display_results(content_img, style_img, input_img)
# Simpan gambar hasil ke file (opsional)
# Pastikan tensor berada di CPU dan hapus dimensi batch sebelum menyimpan
output_image_to_save = input_img.squeeze(0).cpu()
try:
save_image(output_image_to_save, 'output_image.png')
print("Gambar hasil disimpan sebagai output_image.png")
except Exception as e:
print(f"Gagal menyimpan gambar: {e}")
Kode ini menggunakan Matplotlib untuk menampilkan ketiga gambar secara berdampingan dan juga menyediakan opsi untuk menyimpan gambar hasil akhir ke dalam sebuah file bernama `output_image.png`.
Tips untuk Hasil Neural Style Transfer yang Lebih Baik
Mendapatkan hasil yang memuaskan seringkali memerlukan sedikit eksperimen. Berikut beberapa tips:
- Bobot Loss (α dan β): Bereksperimenlah dengan nilai `style_weight` (β) dan `content_weight` (α). Meningkatkan `style_weight` akan membuat hasil lebih condong ke arah gaya, sementara meningkatkan `content_weight` akan mempertahankan lebih banyak detail konten asli. Rasio β/α seringkali berkisar antara 1e3 hingga 1e6.
- Pemilihan Layer Loss: Menggunakan layer yang berbeda untuk menghitung content dan style loss dapat memberikan efek yang berbeda. Menggunakan layer yang lebih awal (misalnya, 'conv_1', 'conv_2') untuk style loss cenderung menangkap detail gaya yang lebih halus dan tekstural, sementara layer yang lebih dalam menangkap pola yang lebih besar. Untuk content loss, layer menengah hingga dalam ('conv_4' atau 'conv_5') biasanya bekerja dengan baik.
- Ukuran Gambar: Resolusi gambar input (`imsize`) sangat memengaruhi detail hasil dan waktu komputasi. Mulailah dengan ukuran kecil untuk iterasi cepat, lalu tingkatkan resolusi untuk hasil akhir yang lebih detail.
- Iterasi & Learning Rate: Jumlah langkah optimasi (`num_steps`) dan laju pembelajaran (`lr`) pada optimizer sangat krusial. Terlalu sedikit iterasi mungkin belum mencapai konvergensi yang baik, sedangkan terlalu banyak akan memakan waktu. Learning rate yang terlalu tinggi bisa menyebabkan optimasi tidak stabil dan menghasilkan artefak, sementara learning rate yang terlalu rendah akan memperlambat konvergensi.
- Inisialisasi Gambar Output: Mencoba memulai optimasi dari noise acak (`torch.randn`) kadang-kadang dapat menghasilkan output yang lebih 'murni' secara gaya, meskipun mungkin memerlukan lebih banyak iterasi atau penyesuaian bobot loss dibandingkan memulai dari gambar konten.
- Model CNN: Meskipun VGG populer, Anda juga bisa mencoba model pre-trained lain seperti VGG16, ResNet, atau bahkan model yang lebih baru, meskipun mungkin memerlukan penyesuaian pada pemilihan layer loss.
Kesimpulan: Merangkum Tutorial PyTorch Style Transfer
Dalam style transfer tutorial ini, kita telah berhasil mengimplementasikan algoritma Neural Style Transfer dari awal menggunakan PyTorch. Kita telah membahas konsep fundamental di balik cara kerja neural style transfer, termasuk peran penting content loss, style loss, dan Gram Matrix. Langkah demi langkah, kita menyiapkan lingkungan pengembangan, memuat gambar input dan model VGG19 pre-trained, mendefinisikan fungsi loss secara kustom, dan menjalankan loop optimasi untuk menghasilkan gambar artistik baru yang menggabungkan konten dan gaya. Terakhir, kita memvisualisasikan dan menyimpan hasilnya. Dengan pemahaman dan kode python style transfer yang telah disediakan, Anda kini memiliki fondasi yang kuat untuk bereksperimen lebih lanjut dengan gambar, parameter, dan teknik berbeda untuk menciptakan karya seni unik menggunakan AI art generator code Anda sendiri! Pendekatan ini merupakan dasar dari banyak aplikasi menarik dalam ranah style transfer deep learning.
Jelajahi Solusi AI Lainnya
Neural Style Transfer adalah contoh yang memukau dari kemampuan deep learning dan computer vision. Jika Anda tertarik untuk menerapkan solusi kecerdasan buatan (AI) yang lebih canggih atau disesuaikan untuk kebutuhan bisnis spesifik Anda—mulai dari otomatisasi tugas repetitif, peningkatan visibilitas online melalui AI Agent SEO, hingga pengembangan platform aplikasi mobile atau website yang cerdas—Kirim.ai menawarkan rangkaian solusi komprehensif. Kami tidak hanya menyediakan platform SaaS berbasis AI kami sendiri, tetapi juga layanan pengembangan kustom dan strategi pemasaran digital terintegrasi untuk mendukung transformasi digital Anda. Pelajari lebih lanjut tentang bagaimana Kirim.ai dapat membantu mengakselerasi pertumbuhan bisnis Anda di era digital yang semakin kompetitif.
Tanggapan (0 )