Hajutusmudelite rakendamine loomingulise AI kunsti genereerimise jaoks

Sissejuhatus

Ühendamine tehisintellekti (AI) ja kunstilisus avavad uusi võimalusi loomingulises digitaalkunstis, silmapaistvalt difusioonimudelite kaudu. Need mudelid paistavad silma loomingulise AI kunsti põlvkonna seas, pakkudes tavapärastest närvivõrkudest erinevat lähenemist. See artikkel viib teid uurivale teekonnale difusioonimudelite sügavustesse, selgitades nende ainulaadset mehhanismi visuaalselt vapustavate ja loominguliselt rikkalike kunstiteoste meisterdamisel. Mõistke difusioonimudelite nüansse ja saage ülevaade nende rollist kunstilise väljenduse ümberdefineerimisel arenenud AI-tehnoloogiate objektiivi kaudu.

õppe eesmärgid

• Mõistke tehisintellekti difusioonimudelite põhikontseptsioone.
• Uurige difusioonimudelite ja traditsiooniliste närvivõrkude erinevust kunsti genereerimisel.
• Analüüsige kunsti loomise protsessi difusioonimudelite abil.
• Hinnake tehisintellekti loomingulist ja esteetilist mõju digitaalkunstis.
• Arutage tehisintellekti loodud kunstiteose eetilisi kaalutlusi.

See artikkel avaldati osana Andmeteaduse ajaveebi.

Difusioonimudelite mõistmine

Hajutusmudelid muudavad generatiivse tehisintellekti revolutsiooni, esitledes ainulaadset pildiloomemeetodit, mis erineb tavapärastest tehnikatest, nagu generatiivsed vastastikused võrgud (Generative Adversarial Networks, GAN). Alustades juhuslikust mürast, täiustavad need mudelid seda järk-järgult, meenutades maali peenhäälestavat kunstnikku, mille tulemuseks on keerukad ja ühtsed kujutised.

See järkjärguline täpsustamisprotsess peegeldab difusiooni metoodilist olemust. Siin muudab iga iteratsioon müra peenelt, tuues selle lõplikule kunstilisele visioonile lähemale. Väljund ei ole pelgalt juhuslikkuse produkt, vaid arenenud kunstiteos, mis erineb oma edenemise ja viimistluse poolest.

Difusioonimudelite kodeerimine nõuab närvivõrkude ja masinõpperaamistike, nagu TensorFlow või PyTorch, põhjalikku mõistmist. Saadud kood on keerukas ja nõuab ulatuslikku koolitust ekspansiivsete andmekogumite osas, et saavutada tehisintellekti loodud kunstis täheldatud nüansirikkad efektid.

Stabiilse difusiooni rakendamine art

AI kunstigeneraatorite, nagu stabiilsete difusioonimudelite, tulek nõuab keerukat kodeerimist sellistes platvormides nagu TensorFlow või PyTorch. Need mudelid paistavad silma oma võime poolest juhuslikkus metoodiliselt struktuuriks muuta, sarnaselt kunstnikule, kes lihvib esialgse visandi elavaks meistriteoseks.

Stabiilsed difusioonimudelid kujundavad AI-kunsti stseeni ümber, kujundades juhuslikkusest korrapäraseid pilte, vältides GAN-idele iseloomulikku konkurentsidünaamikat. Nad on suurepärased kontseptuaalsete juhiste tõlgendamisel visuaalseks kunstiks, soodustades sünergilist tantsu tehisintellekti võimaluste ja inimeste leidlikkuse vahel. PyTorchi rakendades jälgime, kuidas need mudelid viimistlevad kaose iteratiivselt selguseks, peegeldades kunstniku teekonda tärkavast ideest lihvitud loominguni.

Tehisintellekti loodud kunstiga katsetamine

See demonstratsioon süveneb AI-ga loodud kunsti põnevasse maailma, kasutades konvolutsioonilist närvivõrku, mida nimetatakse ConvDiffusionModel. See mudel on koolitatud erinevate kunstipiltide jaoks, mis hõlmavad jooniseid, maale, skulptuure ja graveeringuid, mis pärinevad see Kaggle'i andmestik. Meie eesmärk on uurida mudeli võimet tabada ja reprodutseerida nende kunstiteoste keerulist esteetikat.

Mudeliarhitektuur ja koolitus

Arhitektuurne disain

ConvDiffusionModel on oma tuumaks närvitehnoloogia ime, mis sisaldab keerukat kodeerija-dekoodri arhitektuuri, mis on kohandatud kunsti genereerimise nõudmistele. Mudeli struktuur on keeruline närvivõrk, mis integreerib täiustatud kodeerija-dekoodri mehhanisme, mis on spetsiaalselt loodud kunsti genereerimiseks. Täiendavate keerdkihtide ja vahelejätmise ühendustega, mis jäljendavad kunstiintuitsiooni, saab mudel kunsti lahata ja uuesti kokku panna, mõistes kompositsiooni ja stiili nutikalt.

• Kodeerija: Kodeerija on mudeli analüütiline silm, mis uurib iga sisendpildi pisiasju. Kui kujutised läbivad kodeerija konvolutsioonikihte, surutakse need järk-järgult varjatud ruumi – originaalse kunstiteose kompaktseks kodeeritud esituseks. Meie kodeerija mitte ainult ei kontrolli sisendpilte, vaid teeb seda tänu täiendavatele kihtidele ja partii normaliseerimise tehnikatele täiustatud tajusügavusega. See laiendatud uurimine võimaldab varjatud ruumis rikkalikumat, tihendatud esitust, peegeldades kunstniku sügavat mõtisklust teema üle.
• Dekooder: Seevastu dekooder toimib modelli loomingulise käena, võttes kodeerijast abstraktsed visandid ja puhudes neile elu sisse. See rekonstrueerib kunstiteose varjatud ruumist kiht kihi haaval, detail detaili haaval, kuni tekib terviklik pilt. Meie dekooder saab kasu ühenduste vahelejätmisest ja suudab kunstiteoseid suurema täpsusega rekonstrueerida. See vaatab uuesti läbi sisendi abstraktse olemuse ja kaunistab seda järk-järgult, saavutades algmaterjalile truu esituse. Täiustatud kihid töötavad koos, tagamaks, et lõplik pilt on ergas ja keerukas tükk, mis peegeldab sisendi kunstilisust.

Koolitusprotsess

ConvDiffusionModeli koolitus on teekond läbi kunstimaastiku, mis hõlmab 150 epohhi. Iga epohh tähistab kogu andmestiku täielikku läbimist, kusjuures mudel püüab täiustada oma arusaamist ja parandada loodud piltide täpsust.

• Hübriidkao funktsioon: Treeningu keskmes on keskmise ruudu vea (MSE) kadufunktsioon. See funktsioon kvantifitseerib erinevuse algse meistriteose ja mudeli rekreatsiooni vahel, pakkudes selget mõõdikut minimeerimiseks. Tutvustame tajukao komponenti, mis on tuletatud eelkoolitatud VGG võrgust, mis täiendab keskmise ruudu vea (MSE) mõõdikut. See kahekaoline strateegia sunnib mudelit austama originaalide kunstilist terviklikkust, täiustades samal ajal nende detailide tehnilist reprodutseerimist.
• Optimeerija: Ajakavandaja poolt dünaamiliselt kohandatud õppimiskiirusega juhib Adam optimeerija mudeli õppimist suurema targasti. See adaptiivne lähenemine tagab, et mudeli edusammud kunsti reprodutseerimise ja uuendamise õppimisel on ühtaegu püsivad ja jõulised.
• Iteratsioon ja täpsustamine: Treeningiteratsioonid on tants kunstilise olemuse säilitamise ja tehnilise replikatsiooni poole püüdlemise vahel. Iga tsükliga läheneb mudel truuduse ja loovuse sünteesile.
• Edenemise visualiseerimine: mudeli edenemise visualiseerimiseks salvestatakse treeningu ajal korrapäraste ajavahemike järel pilte. Need hetktõmmised pakuvad akent mudeli õppimiskõverale, näidates, kuidas selle loodud kunst areneb, muutudes iga epohhiga selgemaks, üksikasjalikumaks ja kunstiliselt sidusamaks.

Ülaltoodut demonstreeritakse järgmise koodilõigu kaudu:

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
from torchvision.utils import save_image
from torchvision.models import vgg16
from PIL import Image

# Defining a function to check for valid images
def is_valid_image(image_path):
    try:
        with Image.open(image_path) as img:
            img.verify()
        return True
    except (IOError, SyntaxError) as e:
      # Printing out the names of all corrupt files
        print(f'Bad file:', image_path)
        return False

# Defining the neural network
class ConvDiffusionModel(nn.Module):
    def __init__(self):
        super(ConvDiffusionModel, self).__init__()
        # Encoder
        self.enc1 = nn.Sequential(nn.Conv2d(3, 64, kernel_size=3, 
        stride=1, padding=1),
                                  nn.ReLU(),
                                  nn.BatchNorm2d(64),
                                  nn.MaxPool2d(kernel_size=2, 
                                  stride=2))
        self.enc2 = nn.Sequential(nn.Conv2d(64, 128, 
        kernel_size=3, padding=1),
                                  nn.ReLU(),
                                  nn.BatchNorm2d(128),
                                  nn.MaxPool2d(kernel_size=2, 
                                  stride=2))
        self.enc3 = nn.Sequential(nn.Conv2d(128, 256, kernel_size=3, 
        padding=1),
                                  nn.ReLU(),
                                  nn.BatchNorm2d(256),
                                  nn.MaxPool2d(kernel_size=2, 
                                  stride=2))
        
        # Decoder
        self.dec1 = nn.Sequential(nn.ConvTranspose2d(256, 128, 
        kernel_size=3, stride=2, padding=1, output_padding=1),
                                  nn.ReLU(),
                                  nn.BatchNorm2d(128))
        self.dec2 = nn.Sequential(nn.ConvTranspose2d(128, 64, 
        kernel_size=3, stride=2, padding=1, output_padding=1),
                                  nn.ReLU(),
                                  nn.BatchNorm2d(64))
        self.dec3 = nn.Sequential(nn.ConvTranspose2d(64, 3, 
        kernel_size=3, stride=2, padding=1, output_padding=1),
                                  nn.Sigmoid())

    def forward(self, x):
        # Encoder
        enc1 = self.enc1(x)
        enc2 = self.enc2(enc1)
        enc3 = self.enc3(enc2)
        
        # Decoder with skip connections
        dec1 = self.dec1(enc3) + enc2
        dec2 = self.dec2(dec1) + enc1
        dec3 = self.dec3(dec2)
        return dec3

# Using a pre-trained VGG16 model to compute perceptual loss
class VGGLoss(nn.Module):
    def __init__(self):
        super(VGGLoss, self).__init__()
        self.vgg = vgg16(pretrained=True).features[:16].cuda()
        .eval()  # Only the first 16 layers
        for param in self.vgg.parameters():
            param.requires_grad = False

    def forward(self, input, target):
        input_vgg = self.vgg(input)
        target_vgg = self.vgg(target)
        loss = torch.nn.functional.mse_loss(input_vgg, 
        target_vgg)
        return loss

# Checking if CUDA is available and set device to GPU if it is.
device = torch.device("cuda" if torch.cuda.is_available() 
else "cpu")

# Initializing the model and perceptual loss
model = ConvDiffusionModel().to(device)
vgg_loss = VGGLoss().to(device)
mse_loss = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, 
gamma=0.1)

# Dataset and DataLoader setup
transform = transforms.Compose([
    transforms.Resize((128, 128)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
    std=[0.229, 0.224, 0.225]),
])

dataset = datasets.ImageFolder(root='/content/Images', 
transform=transform, is_valid_file=is_valid_image)
dataloader = DataLoader(dataset, batch_size=32, 
shuffle=True)

# Training loop
num_epochs = 150
for epoch in range(num_epochs):
    for i, (inputs, _) in enumerate(dataloader):
        inputs = inputs.to(device)
        
        # Zero the parameter gradients
        optimizer.zero_grad()

        # Forward pass
        outputs = model(inputs)
        
        # Calculate losses
        mse = mse_loss(outputs, inputs)
        perceptual = vgg_loss(outputs, inputs)
        loss = mse + perceptual

        # Backward pass and optimize
        loss.backward()
        optimizer.step()

        if (i + 1) % 100 == 0:
            print(f'Epoch [{epoch+1}/{num_epochs}], 
            Step [{i+1}/{len(dataloader)}], Loss: {loss.item()}, 
            Perceptual Loss: {perceptual.item()}, MSE Loss: 
            {mse.item()}')
            # Saving the generated image for visualization
            save_image(outputs, f'output_epoch_{epoch+1}
            _step_{i+1}.png')

    # Updating the learning rate
    scheduler.step()

    # Saving model checkpoints
    if (epoch + 1) % 10 == 0:
        torch.save(model.state_dict(), 
        f'/content/model_epoch_{epoch+1}.pth')

print('Training Complete')

Loodud kunstiteose visualiseerimine

Avaldades tehisintellektiga loodud kunsti

Kuna ConvDiffusionModel on nüüd täielikult koolitatud, nihkub fookus abstraktselt konkreetsele – potentsiaalilt AI-ga loodud kunsti tegelikustamisele. Järgnev koodilõik realiseerib mudeli õpitud kunstilised võimalused, muutes sisendandmed digitaalseks väljenduslõuendiks.

import os
import matplotlib.pyplot as plt

# Loading the trained model
model = ConvDiffusionModel().to(device)
model.load_state_dict(torch.load('/content/model_epoch_150.pth'))
model.eval()  # Set the model to evaluation mode

# Transforming for the input image
transform = transforms.Compose([
    transforms.Resize((128, 128)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
    std=[0.229, 0.224, 0.225]),
])

# Function to de-normalize the image for viewing
def denormalize(tensor):
    mean = torch.tensor([0.485, 0.456, 0.406]).
    to(device).view(-1, 1, 1)
    std = torch.tensor([0.229, 0.224, 0.225]).
    to(device).view(-1, 1, 1)
    tensor = tensor * std + mean  # De-normalize
    tensor = tensor.clamp(0, 1)  # Clamp to the valid image range
    return tensor

# Loading and transforming the image
input_image_path = '/content/Validation/0006.jpg'  
input_image = Image.open(input_image_path).convert('RGB')
input_tensor = transform(input_image).unsqueeze(0).to(device)  
# Adding a batch dimension

# Generating the image
with torch.no_grad():
    generated_tensor = model(input_tensor)

# Converting the generated image tensor to an image
generated_image = denormalize(generated_tensor.squeeze(0))  
# Removing the batch dimension and de-normalizing
generated_image = generated_image.cpu()  # Move to CPU

# Saving the generated image
save_image(generated_image, '/content/generated_image.png')
print("Generated image saved to '/content/generated_image.png'")

# Displaying the generated image using matplotlib
plt.figure(figsize=(8, 8))
plt.imshow(generated_image.permute(1, 2, 0))  
# Rearrange the channels for plotting
plt.axis('off')  # Hide the axes
plt.show()

Kunstiteose genereerimise koodi tutvustus

• Ülestõusmise mudel: Esimene samm kunstiteoste loomisel on meie koolitatud ConvDiffusionModeli taaselustamine. Mudeli õpitud kaalud laaditakse ja viiakse hindamisrežiimi, seadistades loomiseks ilma selle parameetreid täiendavalt muutmata.
• Pildi teisendus: Treeningrežiimiga kooskõla tagamiseks töödeldakse sisendpilte sama teisenduste jada kaudu. See hõlmab suuruse muutmist, et see vastaks mudeli sisendmõõtmetele, tensori teisendamist PyTorchi ühilduvuse jaoks ja treeningandmete statistilisel profiilil põhinevat normaliseerimist.
• Denormaliseerimise utiliit: Kohandatud funktsioon pöörab eeltöötluse efektid ümber, skaleerides tensori ümber algse pildi värvivahemiku järgi. See samm on hädavajalik genereeritud väljundi visuaalselt täpseks esituseks.
• Sisestuse ettevalmistamine: Pilt laaditakse ja sellele tehakse eelnimetatud teisendused. Oluline on märkida, et see pilt on muusa, millest AI inspiratsiooni ammutab – vaikne sosin sütitab mudeli sünteetilise kujutlusvõime.
• Kunstiteose süntees: Edasiliikumise õrnas tantsus tõlgendab mudel sisendtensorit, võimaldades selle kihtidel teha koostööd uue kunstilise visiooni loomisel. Tehke seda protsessi ilma gradiente jälgimata, kuna oleme nüüd rakenduse, mitte koolituse valdkonnas.
• Pildi teisendamine: Mudeli tensorväljund, mis hoiab nüüd digitaalselt sündinud kunstiteoseid, on denormaliseeritud, tõlgides mudeli loomingu tagasi tuttavasse värvi- ja valgusruumi, mida meie silmad oskavad hinnata.
• Kunstiteose ilmutus: Teisendatud tensor asetatakse digitaalsele lõuendile, mis kulmineerub salvestatud pildifailiga. See fail on aken tehisintellekti loomingulisse hinge, sellele elu andnud dünaamilise protsessi staatiline kaja.
• Kunstiteose otsimine: Skript lõpetab loodud pildi salvestamisega määratud teele ja teatab selle valmimisest. Salvestatud pilt, õpitud kunstiliste põhimõtete ja tärkava loovuse süntees, on eksponeerimiseks ja mõtisklemiseks valmis.

Väljundi analüüsimine

ConvDiffusionModeli väljund kujutab endast kujundit, millel on selge suund ajaloolisele kunstile. Viimistletud riietusega AI-ga renderdatud pilt peegeldab klassikaliste portreede suurejoonelisust, kuid samas on see eristuva ja kaasaegse puudutusega. Katsealuse riietus on tekstuurirohke, segades modelli õpitud mustreid uudse tõlgendusega. Õrnad näojooned ning valguse ja varju peen koosmäng demonstreerivad tehisintellekti nüansirikkaid arusaamu traditsioonilistest kunstitehnikatest. See kunstiteos annab tunnistust mudeli keerukast väljaõppest, peegeldades elegantset ajaloolise kunsti sünteesi läbi täiustatud masinõppe prisma. Sisuliselt on see digitaalne kummardus minevikule, mis on meisterdatud oleviku algoritmidega.

Väljakutsed ja eetilised kaalutlused

Kunsti genereerimise difusioonimudelite rakendamine toob endaga kaasa mitmeid väljakutseid ja eetilisi kaalutlusi, mida peaksite kaaluma:

• Andmete päritolu: Koolituse andmekogumeid tuleb vastutustundlikult kureerida. Oluline on kontrollida, et levitusmudelite koolitamiseks kasutatavad andmed ei sisaldaks autoriõigusega kaitstud või kaitstud teoseid ilma nõuetekohase loata.
• Eelarvamus ja esindus: AI mudelid võivad oma treeningandmetes säilitada eelarvamusi. Mitmekesiste ja kaasavate andmekogumite tagamine on oluline, et vältida stereotüüpide tugevdamist tehisintellekti loodud kunstis.
• Väljundi juhtimine: Kuna difusioonimudelid võivad genereerida laia valikut väljundeid, on vaja seada piirid, et vältida sobimatu või solvava sisu loomist.
• Õiguslik raamistik: Tugeva õigusraamistiku puudumine AI nüansside käsitlemiseks loomeprotsessis on väljakutse. Seadusandlus peab arenema, et kaitsta kõigi asjaosaliste õigusi.

Järeldus

Difusioonimudelite tõus AI-s ja kunstis tähistab transformatiivset ajastut, mis ühendab arvutustäpsuse esteetilise uurimisega. Nende teekond kunstimaailmas toob esile märkimisväärse innovatsioonipotentsiaali, kuid sellega kaasneb ka keerukus. Originaalsuse, mõju, eetilise loomingu ja olemasolevate teoste austamise tasakaalustamine on kunstiprotsessi lahutamatu osa.

Võtme tagasivõtmine

• Hajutusmudelid on kunstiloomingu transformatiivse nihke esirinnas. Nad pakuvad uusi digitaalseid tööriistu, mis laiendavad kunstilise väljenduse lõuendit väljaspool traditsioonilisi piire.
• Tehisintellektiga täiustatud kunstis on digitaalse kunsti terviklikkuse säilitamiseks hädavajalik seada esikohale koolitusandmete eetiline kogumine ja austada loojate intellektuaalomandit.
• Kunstilise nägemuse ja tehnoloogilise innovatsiooni lähenemine avab uksed sümbiootilisele suhtele kunstnike ja tehisintellekti arendajate vahel. Edendada koostöökeskkonda, mis võib luua murrangulise kunsti.
• Oluline on tagada, et tehisintellekti loodud kunst esindaks laia valikut vaatenurki. Kaasake mitmesuguseid andmeid, mis kajastavad erinevate kultuuride ja seisukohtade rikkust, edendades seega kaasatust.
• Kasvav huvi tehisintellektiga loodud kunsti vastu nõuab tugeva õigusraamistiku loomist. Need raamistikud peaksid selgitama autoriõigustega seotud küsimusi, tunnustama kaastöid ja reguleerima tehisintellektiga loodud kunstiteoste ärilist kasutamist.

Selle kunstilise evolutsiooni koidik pakub teed, mis on täis loomingulist potentsiaali, kuid nõuab tähelepanelikku eestkostet. Meie kohus on kasvatada maastikku, kus tehisintellekti ja kunsti sulandumine areneb, juhindudes vastutustundlikest ja kultuuritundlikest tavadest.

Korduma kippuvad küsimused

Selles artiklis näidatud meedia ei kuulu Analytics Vidhyale ja seda kasutatakse autori äranägemisel.

seotud

• SEO-põhise sisu ja PR-levi. Võimenduge juba täna.
• PlatoData.Network Vertikaalne generatiivne Ai. Jõustage ennast. Juurdepääs siia.
• PlatoAiStream. Web3 luure. Täiustatud teadmised. Juurdepääs siia.
• PlatoESG. Süsinik, CleanTech, Energia, Keskkond päikeseenergia, Jäätmekäitluse. Juurdepääs siia.
• PlatoTervis. Biotehnoloogia ja kliiniliste uuringute luureandmed. Juurdepääs siia.
• Allikas: https://www.analyticsvidhya.com/blog/2023/12/implementing-diffusion-models-for-creative-ai-art-generation/