O rețea Generative Adversarial Network (GAN) este o clasă de modele de machine learning utilizată pentru sarcini generative, cum ar fi generarea de imagini, muzică, text sau alte tipuri de date. GAN-urile sunt cunoscute în special pentru capacitatea lor de a genera date foarte realiste (cum ar fi imagini fotorealiste) prin învățarea dintr-un set de date de antrenament.

Un GAN este format din două rețele neurale: generatorul și discriminatorul. Aceste rețele funcționează împreună într-un scenariu asemănător unui joc, în care Generatorul încearcă să producă date false care arată ca date reale, iar Discriminatorul încearcă să facă distincția între datele reale și cele false.

1. Generatorul este responsabil pentru crearea de date sintetice (de exemplu, o imagine, muzică, teren etc.) din zgomot aleatoriu (spațiu latent). Este nevoie de un vector aleatoriu ca intrare și generează o ieșire care imită distribuția datelor țintă (de exemplu, generarea unei imagini a unei fețe care arată ca cele din setul de date de antrenament). Generatorul primește de obicei un vector de zgomot aleator ca input, care este trecut prin mai multe straturi (de obicei straturi complet conectate, straturi convoluționale sau alte tipuri) pentru a produce un output care seamănă cu date reale. Acesta învață să producă rezultate mai realiste de-a lungul timpului încercând să-l „păcălească” pe Discriminator să creadă că datele generate sunt reale.
2. Discriminatorul etse responsabil să facă distincția între datele reale (din setul de antrenament) și datele false (generate de Generator). Acesta calculează o probabilitate care indică dacă datele de intrare sunt reale sau false. În timp, învață să devină mai bun în identificarea datelor false pe care le produce Generatorul.

Generatorul și Discriminatorul sunt antrenate simultan, dar cu obiective diferite:

• Generatorul vrea să creeze date atât de realiste încât discriminatorul nu le poate deosebi de datele reale.
• Discriminatorul vrea să devină mai bun în a face distincția între datele reale (din setul de antrenament) și datele false (de la Generator).

Pași în procesul de antrenare:

1. Generatorul produce date false, pornind de la un vector latent aleatoriu (de obicei eșantionat dintr-o distribuție normală)
2. Discriminatorul primește atât date reale, cât și false (de la generator) și încearcă să le clasifice dacă sunt reale sau false.
3. Loss Function:
   • Discriminatorul este recompensat pentru identificarea corectă a datelor reale ca fiind reale și a datelor false ca fiind false.
   • Generatorul este recompensat atunci când datele sale false sunt clasificate ca fiind reale de către Discriminator.
4. Backpropagation: Ambele rețele (Generator și Discriminator) sunt actualizate prin backpropagation. Ponderile Discriminatorului sunt actualizate pentru a-și îmbunătăți capacitatea de a distinge datele reale de cele false, în timp ce ponderile Generatorului sunt actualizate pentru a face datele false mai realiste și mai greu de distins de datele reale.
5. Repetarea ciclului

În timp, Generatorul devine foarte bun la producerea de date care sunt aproape imposibil de distins de datele reale, în timp ce Discriminatorul devine din ce în ce mai bun în a distinge datele reale de cele false.

Spațiul latent este spațiul vectorilor aleatorii de intrare pentru Generator. Fiecare punct din spațiul latent va produce un teren diferit. Dacă folim vectori latenți apropiați, vom obține terenuri similare, iar dacă folosim vectori latenți îndepărtați, terenurile generate vor fi foarte diferite.

# Două vectori latenți diferiți
noise1 = torch.randn(1, 100)  # Vector aleator 1
noise2 = torch.randn(1, 100)  # Vector aleator 2

# Vor produce terenuri diferite
terrain1 = generator(noise1)
terrain2 = generator(noise2)

Un seed este un număr care inițializează generatorul de numere aleatorii. Pentru a obține vectori latenți aleatori diferiți, este necesar să setăm seed-uri diferite.

def generate_terrain_with_seed(generator, seed):
    generator.eval() # Mod de evaluare
    
    with torch.no_grad(): # Nu calculăm gradienți
        # Setăm seed-ul
        torch.manual_seed(seed)
        
        # Generăm zgomot
        noise = torch.randn(1, 100)
        
        # Generăm terenul
        terrain = generator(noise)
    
    return terrain[0]

Prin interpolarea putem crea o tranziție graduală între doi vectori latenți.

def interpolate_latent_vectors(generator, noise_start, noise_end, steps=10):
    generator.eval()
    
    with torch.no_grad():
        for i in range(steps):
            # Calculăm alpha (0 → 1)
            alpha = i / (steps - 1)
            
            # Interpolare liniară
            noise_interpolated = (1 - alpha) * noise_start + alpha * noise_end
            
            # Generăm terenul
            terrain = generator(noise_interpolated)

Într-un GAN, straturile din rețelele generatoare și discriminatoare îndeplinesc roluri specifice în generarea și distingerea datelor reale de cele false.

• Input Layer (Latent Vector): Intrarea către generator este de obicei un vector aleatoriu de dimensiune fixă. Acest vector este prelevat dintr-un spațiu latent. Vectorul latent este o sursă de aleatorie pe care Generatorul o folosește pentru a produce diverse rezultate. Aceasta ar putea reprezenta diferite tipuri de conținut generat (de exemplu, diferite fețe, texturi sau terenuri).
• Fully Connected (Linear) Layers: Datele de input sunt trecute prin mai multe straturi complet conectate (adesea straturi nn.Linear() în PyTorch). Aceste straturi învață să mapeze inputul aleator la reprezentări de dimensiuni mai mari. Fiecare strat complet conectat efectuează o transformare liniară (o multiplicare a matricei) urmată de o funcție de activare neliniară.
• Funcțiile de Activare: Funcțiile des folosite de activare sunt ReLU (Rectified Linear Unit), LeakyReLU sau Tanh. Acestea introduc neliniaritatea modelului, permițându-i să învețe modele complexe.
  • ReLU este utilizat pe scară largă în straturile intermediare ale generatorului, deoarece ajută rețeaua să învețe mai repede și să evite problema gradientului care dispare prin introducerea de neliniaritate.
  • Tanh (de obicei în stratul de ieșire) este adesea folosit pentru a scala ieșirea la un interval între -1 și 1, făcându-l potrivit pentru generarea de pixeli de imagine sau alte date continue.
• Output Layer: Remodelează rezultatul pentru a se potrivi cu forma dorită (de exemplu, o imagine de 64×64).

• Input Layer (Imagine sau Date): Inputul este fie o imagine reală din setul de date de antrenament, fie o imagine falsă generată de Generator.
• Convolutional Layers (pentru imagini): Pentru sarcinile legate de imagini, se folosesc adesea rețele neurale convoluționale (CNN), care aplică straturi convoluționale datelor de intrare. Aceste straturi învață să extragă caracteristici din imaginea de intrare, cum ar fi laturi, texturi și modele. Straturile convoluționale folosesc filtre care parcurg toată imaginea și detectează aceste caracteristici.
  • Straturile de grupare (cum ar fi MaxPooling) pot fi folosite după pentru a reduce dimensionalitatea și a evidenția cele mai importante caracteristici.
• Fully Connected (Linear) Layers: După extragerea caracteristicilor (prin convoluție și pooling), caracteristicile se aplatizează într-un vector, iar datele trec prin straturi complet conectate. Aceste straturi învață să ia decizii finale cu privire la faptul dacă intrarea este reală sau falsă.
• Funcții de Activare:
  • LeakyReLU este adesea folosit ca funcție de activare în straturile ascunse ale Discriminatorului.
  • Stratul de ieșire utilizează de obicei funcția Sigmoid (sau uneori Softmax) pentru a genera o probabilitate între 0 și 1. Această probabilitate reprezintă probabilitatea ca intrarea să fie reală (aproape de 1) sau falsă (aproape de 0).

class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(100, 256),  # First linear layer (input: 100 -> 256)
            nn.ReLU(),            # Activation function
            nn.Linear(256, 512),  # Second linear layer (256 -> 512)
            nn.ReLU(),            # Activation function
            nn.Linear(512, 1024), # Third linear layer (512 -> 1024)
            nn.ReLU(),            # Activation function
            nn.Linear(1024, 64*64),  # Final layer (1024 -> 64x64 terrain)
            nn.Tanh()             # Activation function for output (-1 to 1)
        )

    def forward(self, x):
        return self.model(x).view(-1, 64, 64)

1. Generați 5 hărți aleatorii de teren folosind o rețea Generator:
   • Inițializați un Generator
   • Generați 5 terenuri diferite folosind vectori latenți aleatorii
   • Vizualizați cele 5 terenuri într-o grilă
   • Salvați imaginea rezultată
2. Bonus. Interpolați doi vectori latenți:
   • Generați doi vectori latenți aleatorii (A și B)
   • Interpolați între ei în 10 pași
   • Vizualizați tranziția de la A la B
   • Salvați imaginea rezultată