Show page

Differences

This shows you the differences between two versions of the page.

--- gp:laboratoare:07 [2026/03/30 08:51]
maria_anca.balutoiu [Tasks]
+++ gp:laboratoare:07 [2026/03/30 09:38] (current)
maria_anca.balutoiu [Tasks]
@@ Line 23: / Line 23: @@
 Î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.
-==== Layers ====
-Într-un GAN, straturile din rețelele generatoare și discriminatoare îndeplinesc roluri specifice în generarea și distingerea datelor reale de cele false.
-=== Generator Layers ===
-  * **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.
-    * **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 64x64).
-=== Discriminator Layers ===
-  * **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).
-==== Implementarea unui GAN în PyTorch ====
-<code>
-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)
-</code>
-==== Tasks ====
-  - Generați o hartă aleatoare de teren folosind o rețea Generator.
-  - **Bonus.** Antrenați un GAN pentru generare de teren.
-<hidden>
-===== Laboratorul 07. GAN în Generarea Procedurală =====
-==== Componentele unei Rețele GAN ====
-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:
-  * **Generatorul** încearcă să producă date false care arată ca date reale
-  * **Discriminatorul** încearcă să facă distincția între datele reale și cele false
-=== Generatorul ===
-**Generatorul** este responsabil pentru crearea de date sintetice (de exemplu, o imagine, muzică, teren etc.) din zgomot aleatoriu (spațiu latent).
-Procesul:
-  - Primește un **vector aleatoriu** ca intrare (vector latent)
-  - Vector-ul este trecut prin mai multe straturi neurale
-  - Produce un output care seamănă cu date reale (în cazul nostru, o hartă de teren)
-<code python>
-class Generator(nn.Module):
-    def __init__(self, latent_dim=100, terrain_size=64):
-        super(Generator, self).__init__()
-        self.model = nn.Sequential(
-            nn.Linear(100, 256),      # Input: 100 → 256
-            nn.ReLU(),                # Funcție de activare
-            nn.Linear(256, 512),      # 256 → 512
-            nn.ReLU(),
-            nn.Linear(512, 1024),     # 512 → 1024
-            nn.ReLU(),
-            nn.Linear(1024, 64*64),   # 1024 → 4096 (64x64 teren)
-            nn.Tanh()                 # Output în [-1, 1]
-        )
-    def forward(self, x):
-        output = self.model(x)
-        terrain = output.view(-1, 64, 64)  # Reshape la 64x64
-        return terrain
-</code>
-**Observații importante:**
-  * **Input**: Vector de 100 de numere aleatorii (zgomot)
-  * **Output**: Matrice 64×64 reprezentând altitudinile terenului
-  * **ReLU**: Funcție de activare care introduce neliniaritate (permite rețelei să învețe pattern-uri complexe)
-  * **Tanh**: Produce valori între -1 și 1 (perfecte pentru altitudini normalizate)
-=== Discriminatorul ===
-**Discriminatorul** este responsabil să facă distincția între datele reale (din setul de antrenament) și datele false (generate de Generator).
-**NOTĂ**: În acest laborator ne concentrăm doar pe Generator. Discriminatorul este folosit în timpul antrenamentului unui GAN complet, dar pentru generare procedurală simplă avem nevoie doar de Generator.
 ==== Concepte Cheie ====
 === Spațiul Latent (Latent Space) ===
+**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.
-**Spațiul latent** este spațiul vectorilor aleatorii de intrare pentru Generator.
+<code>
-  * Fiecare punct din spațiul latent → un teren diferit
-  * Vectori latenți apropiați → terenuri similare
-  * Vectori latenți îndepărtați → terenuri foarte diferite
-**Exemplu**:
-<code python>
 # Două vectori latenți diferiți
-noise1 = torch.randn(1, 100)  # Vector aleatoriu 1
+noise1 = torch.randn(1, 100)  # Vector aleator 1
-noise2 = torch.randn(1, 100)  # Vector aleatoriu 2
+noise2 = torch.randn(1, 100)  # Vector aleator 2
 # Vor produce terenuri diferite
@@ Line 144: / Line 38: @@
 </code>
-=== Interpolare în Spațiul Latent ===
+=== Seed-uri pentru Reproducibilitate ===
+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.
-**Interpolarea** înseamnă să creezi o tranziție graduală între două puncte.
-Dacă avem doi vectori latenți (A și B), putem crea vectori intermediari:
-  * 0% A + 100% B = B
-  * 25% A + 75% B = între A și B
-  * 50% A + 50% B = la jumătatea drumului
-  * 75% A + 25% B = între A și B
-  * 100% A + 0% B = A
-Formula matematică:
 <code>
-vector_interpolat = (1 - alpha) * A + alpha * B
-</code>
-Unde **alpha** variază de la 0 la 1.
-**Utilitate în game development:**
-  * Tranziții smooth între biome-uri
-  * Generarea de variații ale aceluiași tip de teren
-  * Control artistic asupra terenurilor generate
-=== Seed-uri pentru Reproducibilitate ===
-Un **seed** este un număr care inițializează generatorul de numere aleatorii.
-**Același seed** → **aceleași numere aleatorii** → **același teren**
-<code python>
-# Setăm seed-ul
-torch.manual_seed(42)
-# Generăm zgomot
-noise = torch.randn(1, 100)  # Va fi întotdeauna același pentru seed 42
-# Generăm teren
-terrain = generator(noise)  # Întotdeauna același teren
-</code>
-**Aplicații în game development:**
-  * **Minecraft**: Același seed = același world
-  * **No Man's Sky**: Seed-uri pentru fiecare planetă
-  * **Speedruns**: Jucătorii folosesc seed-uri cunoscute
-  * **Multiplayer**: Toți jucătorii au același map
-==== Implementare ====
-=== Generarea unui Teren Aleatoriu ===
-<code python>
-def generate_random_terrain(generator, num_samples=1):
-    generator.eval()  # Mod de evaluare
-    with torch.no_grad():  # Nu calculăm gradienți
-        # Generăm zgomot aleatoriu
-        noise = torch.randn(num_samples, 100)
-        # Generăm terenurile
-        terrains = generator(noise)
-    return terrains
-</code>
-**Pași**:
-  - `generator.eval()`: Punem rețeaua în modul de evaluare (nu de antrenament)
-  - `torch.no_grad()`: Nu calculăm gradienți (economisim memorie)
-  - `torch.randn()`: Generăm numere aleatorii din distribuția normală
-  - `generator(noise)`: Trecem noise-ul prin rețea și obținem terenul
-=== Generarea cu Seed Specific ===
-<code python>
 def generate_terrain_with_seed(generator, seed):
-    generator.eval()
+    generator.eval() # Mod de evaluare
-    with torch.no_grad():
+    with torch.no_grad(): # Nu calculăm gradienți
         # Setăm seed-ul
         torch.manual_seed(seed)
@@ Line 233: / Line 58: @@
 </code>
-=== Interpolarea între Terenuri ===
-<code python>
+=== Interpolare în Spațiul Latent ===
+Prin **interpolarea** putem crea o tranziție graduală între doi vectori latenți.
+<code>
 def interpolate_latent_vectors(generator, noise_start, noise_end, steps=10):
     generator.eval()
     with torch.no_grad():
-        terrains = []
         for i in range(steps):
             # Calculăm alpha (0 → 1)
@@ Line 251: / Line 76: @@
             # Generăm terenul
             terrain = generator(noise_interpolated)
-            terrains.append(terrain[0].numpy())
-    return terrains
 </code>
-**Exemplu vizual al interpolării:**
-<code>
-Pas 1:  100% Start + 0% End     → Terenul A
-Pas 2:  87.5% Start + 12.5% End → Aproape de A
-Pas 3:  75% Start + 25% End     → Mai aproape de mijloc
-...
-Pas 8:  25% Start + 75% End     → Aproape de B
-Pas 9:  12.5% Start + 87.5% End → Foarte aproape de B
-Pas 10: 0% Start + 100% End     → Terenul B
-</code>
-=== Vizualizare ===
+==== Layers ====
+Într-un GAN, straturile din rețelele generatoare și discriminatoare îndeplinesc roluri specifice în generarea și distingerea datelor reale de cele false.
-<code python>
+=== Generator Layers ===
-import matplotlib.pyplot as plt
+  * **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 64x64).
-def visualize_terrains(terrains, titles=None):
+=== Discriminator Layers ===
-    fig, axes = plt.subplots(1, len(terrains), figsize=(15, 5))
+  * **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.
-    for idx, terrain in enumerate(terrains):
+    * Straturile de grupare (cum ar fi **MaxPooling**) pot fi folosite după pentru a reduce dimensionalitatea și a evidenția cele mai importante caracteristici.
-        # Convertim la numpy
+  * **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ă.
-        terrain_np = terrain.cpu().numpy()
+  * **Funcții de Activare:**
+    * **LeakyReLU** este adesea folosit ca funcție de activare în straturile ascunse ale Discriminatorului.
-        # Plotăm cu colormap 'terrain'
+    * 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).
-        axes[idx].imshow(terrain_np, cmap='terrain', vmin=-1, vmax=1)
-        axes[idx].axis('off')
-        if titles:
-            axes[idx].set_title(titles[idx])
-    plt.colorbar(label='Altitudine')
-    plt.show()
-</code>
-**Colormap 'terrain'**: Palet de culori special pentru reprezentarea terenurilor:
+==== Implementarea unui Generator GAN în PyTorch ====
-  * Albastru închis → ape adânci (valori foarte negative)
+<code>
-  * Albastru deschis → ape puțin adânci
+class Generator(nn.Module):
-  * Verde → câmpii, păduri (valori aproape de 0)
+    def __init__(self):
-  * Maro → dealuri (valori pozitive mici)
+        super(Generator, self).__init__()
-  * Gri/Alb → munți înalți (valori foarte pozitive)
+        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)
+        )
-==== Tasks ====
+    def forward(self, x):
+        return self.model(x).view(-1, 64, 64)
-=== Task Obligatoriu ===
-**Generați 5 hărți aleatorii de teren folosind o rețea Generator.**
-**Cerințe:**
-  - 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ă
-**Cod de pornire:**
-<code python>
-# Inițializare
-generator = Generator(latent_dim=100, terrain_size=64)
-# Generare
-terrains = generate_random_terrain(generator, num_samples=5)
-# Vizualizare
-titles = [f"Teren #{i+1}" for i in range(5)]
-visualize_terrains(terrains, titles=titles)
 </code>
-**Ce să observați:**
-  * Fiecare teren este diferit (vectori latenți diferiți)
-  * Terenurile arată ca zgomot structurat (generatorul nu e antrenat)
-  * Valorile sunt în intervalul [-1, 1] datorită funcției Tanh
-**Întrebări de reflecție:**
+==== Tasks ====
-  - De ce terenurile arată diferit unul de altul?
+  - Generați 5 hărți aleatorii de teren folosind o rețea Generator:
-  - Cum ar arăta terenurile dacă generatorul ar fi antrenat pe date reale?
+    * Inițializați un Generator
-  - Ce rol are vectorul latent în generarea de teren?
+    * Generați 5 terenuri diferite folosind vectori latenți aleatorii
+    * Vizualizați cele 5 terenuri într-o grilă
-=== Task Bonus ===
+    * Salvați imaginea rezultată
+  - **Bonus.** Interpolați doi vectori latenți:
-**Explorați spațiul latent prin interpolarea între doi vectori latenți.**
+    * Generați doi vectori latenți aleatorii (A și B)
+    * Interpolați între ei în 10 pași
-**Cerințe:**
+    * Vizualizați tranziția de la A la B
-  - Generați doi vectori latenți aleatorii (A și B)
+    * Salvați imaginea rezultată
-  - Interpolați între ei în 10 pași
-  - Vizualizați tranziția de la A la B
-  - Salvați imaginea rezultată
-**Cod de pornire:**
-<code python>
-# Generare vectori latenți
-torch.manual_seed(42)
-noise_start = torch.randn(1, 100)
-torch.manual_seed(123)
-noise_end = torch.randn(1, 100)
-# Interpolare
-terrains = interpolate_latent_vectors(generator, noise_start, noise_end, steps=10)
-# Vizualizare
-titles = [f"Pas {i+1}/10" for i in range(10)]
-visualize_terrains(terrains, titles=titles)
-</code>
-**Ce să observați:**
-  * Primul teren (Pas 1) corespunde vectorului de start
-  * Ultimul teren (Pas 10) corespunde vectorului de final
-  * Terenurile intermediare sunt combinații ale celor doi vectori
-  * Tranziția este graduală și continuă (nu sunt salturi bruște)
-**Întrebări de reflecție:**
-  - Cum ați putea folosi interpolarea în game development?
-  - Ce se întâmplă dacă folosiți mai mulți pași de interpolare (ex: 50)?
-  - De ce e importantă continuitatea în spațiul latent?
-**Aplicații practice:**
-  * **Biome transitions**: Tranziție smoothă de la deșert la pădure
-  * **Level variations**: Generarea de variații ale aceluiași level
-  * **Artistic control**: Designer-ul ajustează terenul prin deplasarea în spațiul latent
-=== Demonstrație Extra (Opțional) ===
-**Reproducibilitatea cu seed-uri**
-Demonstrați că același seed produce întotdeauna același teren:
-<code python>
-# Generăm același teren de 3 ori
-terrain1 = generate_terrain_with_seed(generator, seed=42)
-terrain2 = generate_terrain_with_seed(generator, seed=42)
-terrain3 = generate_terrain_with_seed(generator, seed=42)
-# Generăm un teren diferit
-terrain4 = generate_terrain_with_seed(generator, seed=999)
-# Vizualizare
-terrains = [terrain1, terrain2, terrain3, terrain4]
-titles = ["Seed 42 (run 1)", "Seed 42 (run 2)", "Seed 42 (run 3)", "Seed 999"]
-visualize_terrains(terrains, titles=titles)
-</code>
-**Observații:**
-  * Primele 3 terenuri sunt **IDENTICE**
-  * Al 4-lea teren este **DIFERIT**
-==== Întrebări de Reflecție Generale ====
-  - **Î1:** Care este rolul vectorului latent în generarea procedurală?
-  - **Î2:** De ce folosim funcția Tanh la sfârșitul Generatorului?
-  - **Î3:** Cum ar putea fi folosită interpolarea în spațiul latent pentru a crea tranziții între biome-uri într-un joc?
-  - **Î4:** Ce avantaje oferă generarea bazată pe seed-uri în game development?
-  - **Î5:** Dacă generatorul ar fi antrenat pe un dataset de munți reali, ce ați aștepta să genereze?
-==== Notițe Tehnice ====
-=== Dimensiuni și Parametri ===
-^ Parametru ^ Valoare ^ Semnificație ^
-| **latent_dim** | 100 | Dimensiunea vectorului de zgomot (tipic: 64-256) |
-| **terrain_size** | 64 | Rezoluția terenului generat (64×64 pixeli) |
-| **hidden layers** | 256, 512, 1024 | Dimensiunile straturilor ascunse |
-| **output range** | [-1, 1] | Intervalul valorilor de ieșire (datorită Tanh) |
-=== Funcții de Activare ===
-**ReLU (Rectified Linear Unit):**
-  * Formula: f(x) = max(0, x)
-  * Introduce neliniaritate în rețea
-  * Permite învățarea de pattern-uri complexe
-  * Rapid de calculat
-**Tanh (Tangentă Hiperbolică):**
-  * Formula: f(x) = (e^x - e^(-x)) / (e^x + e^(-x))
-  * Output în intervalul [-1, 1]
-  * Folosit la stratul final
-  * Perfect pentru reprezentarea altitudinii normalizate
-=== De ce Generatorul Neantrenant Produce Zgomot? ===
-Un Generator **neantrenant** (cu greutăți aleatorii inițiale) produce zgomot structurat pentru că:
-  - Nu a învățat pattern-urile din date reale
-  - Greutățile sunt aleatorii → transformări aleatorii
-  - Structura rețelei impune o formă de bază (64×64), dar conținutul e aleatoriu
-**Pentru terenuri realiste**, generatorul ar trebui:
-  - Antrenat pe un dataset de terenuri reale
-  - Învățat în tandem cu un Discriminator
-  - Antrenat pentru mii de iterații
-**În acest laborator**, scopul este să înțelegeți:
-  - Cum funcționează un Generator
-  - Cum spațiul latent controlează output-ul
-  - Conceptul de interpolare
-  - Reproducibilitatea cu seed-uri
-==== Resurse Suplimentare ====
-=== Cod Complet ===
-Codul complet pentru laborator se găsește în fișierul:
-  * **gan_terrain_simple.py** - implementarea completă cu toate funcțiile
-=== Rulare ===
-<code bash>
-# Rulează tot laboratorul (task obligatoriu + bonus + demo)
-python gan_terrain_simple.py
-# Sau importă funcțiile individual
-python
->>> from gan_terrain_simple import Generator, generate_random_terrain
->>> generator = Generator()
->>> terrains = generate_random_terrain(generator, num_samples=3)
-</code>
-=== Dependințe Necesare ===
-<code bash>
-pip install torch torchvision matplotlib numpy
-</code>
-=== Extensii Posibile ===
-Dacă vreți să mergeți mai departe:
-  * **Antrenarea efectivă a unui GAN** pe terenuri reale (Lab 08?)
-  * **3D Terrain Generation**: Generare de terenuri tridimensionale
-  * **Conditional GAN**: Control asupra tipului de teren generat (muntos/plat/ondulat)
-  * **Higher Resolution**: Generare de terenuri 128×128 sau 256×256
-  * **Export pentru Unity/Unreal**: Integrare în engine-uri de jocuri
-==== Referințe ====
-  * **Goodfellow et al. (2014)** - "Generative Adversarial Networks" (paper-ul original GAN)
-  * **PyTorch Documentation** - https://pytorch.org/docs/stable/index.html
-  * **Procedural Generation Wiki** - https://pcg.fandom.com/wiki/Procedural_Generation_Wiki
-</hidden>

Cursuri

Laboratoare

Temă

Generarea Procedurală a unei Lumi Virtuale

Resurse

gp/laboratoare/07.1774849863.txt.gz · Last modified: 2026/03/30 08:51 by maria_anca.balutoiu

Show page Old revisions

Media Manager Back to top