Show page
Recent changes

Differences

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

Link to this comparison view

gp:laboratoare:07 [2026/03/30 09:27]
maria_anca.balutoiu [Concepte Cheie] 		gp:laboratoare:07 [2026/05/06 08:10] (current)
maria_anca.balutoiu [Concepte Cheie]
Line 6: Line 6:
  
   - **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.   - **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.
-  - **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.+  - **Discriminatorul** ​este 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.
  
 ==== Cum funcționează un GAN ==== ==== Cum funcționează un GAN ====
Line 26: Line 26:
 ==== Concepte Cheie ==== ==== Concepte Cheie ====
 === Spațiul Latent (Latent Space) === === 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. Fiecare punct din spațiul latent va produce un teren diferit. Dacă folosim ​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.
  
 <​code>​ <​code>​
Line 40: Line 40:
 === Seed-uri pentru Reproducibilitate === === 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. 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.
- 
-<​code>​ 
-# 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>​ 
  
 <​code>​ <​code>​
Line 71: Line 60:
  
 === Interpolare în Spațiul Latent === === Interpolare în Spațiul Latent ===
-Prin **interpolarea** putem crea o tranziție graduală între doi vectori latenți.+Prin **interpolare** putem crea o tranziție graduală între doi vectori latenți.
  
 <​code>​ <​code>​
-vector_interpolat ​= (1 - alpha) * A + alpha * B, 0 <= alpha <= 1+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)
 </​code>​ </​code>​
- 
  
  
Line 121: Line 121:
  
 ==== Tasks ==== ==== Tasks ====
-  - Generați o hartă aleatoare de teren folosind o rețea Generator. +  - Generați 5 hărți aleatorii de teren folosind o rețea Generator: 
-  - **Bonus.** Antrenați un GAN pentru generare de teren. +    * Inițializați un Generator 
- +    ​* ​Generați 5 terenuri diferite folosind vectori latenți aleatorii 
-<​hidden>​ +    ​* ​Vizualizați cele 5 terenuri într-o grilă 
- +    ​* ​Salvați imaginea rezultată 
- +  - **Bonus.** Interpolați doi vectori latenți: 
-==== Implementare ==== +    * Generați doi vectori latenți aleatorii (A și B) 
- +    ​* ​Interpolați între ei în 10 pași 
-=== Generarea unui Teren Aleatoriu === +    ​* ​Vizualizați tranziția de la A la B 
- +    ​* ​Salvați imaginea rezultată
- +
-=== Interpolarea între Terenuri === +
- +
-<code python>​ +
-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) +
-            alpha = i / (steps - 1) +
-             +
-            # Interpolare liniară +
-            noise_interpolated = (1 - alpha) * noise_start + alpha * noise_end +
-             +
-            # 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 === +
- +
-<code python>​ +
-import matplotlib.pyplot as plt +
- +
-def visualize_terrains(terrains,​ titles=None):​ +
-    fig, axes = plt.subplots(1,​ len(terrains),​ figsize=(15,​ 5)) +
-     +
-    for idx, terrain in enumerate(terrains):​ +
-        # Convertim la numpy +
-        terrain_np = terrain.cpu().numpy() +
-         +
-        # Plotăm cu colormap '​terrain'​ +
-        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:​ +
-  * Albastru închis → ape adânci (valori foarte negative) +
-  * Albastru deschis → ape puțin adânci +
-  * Verde → câmpii, păduri (valori aproape de 0) +
-  * Maro → dealuri (valori pozitive mici) +
-  * Gri/Alb → munți înalți (valori foarte pozitive) +
- +
-==== Tasks ==== +
- +
-=== 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:​** +
-  - De ce terenurile arată diferit unul de altul? +
-  - Cum ar arăta terenurile dacă generatorul ar fi antrenat pe date reale? +
-  - Ce rol are vectorul latent în generarea de teren? +
- +
-=== Task Bonus === +
- +
-**Explorați spațiul latent prin interpolarea între ​doi vectori latenți.** +
- +
-**Cerințe:​** +
-  - 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ă +
- +
-**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.1774852051.txt.gz · Last modified: 2026/03/30 09:27 by maria_anca.balutoiu
Show pageOld revisions
Media ManagerBack to top
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0