Zbierka - Viacúčelová optimalizácia 3D modelov

   https://kempelen.dai.fmph.uniba.sk/design/images/4/4f/MOEA.stl

Viacúčelová optimalizácia 3D modelov

Trvanie:

∞

Náročnosť:

ťažký

Zručnosti:

cykly, podmienky, funkcie, práca s bpy a s platypus

Nástroje:

Blender, Python

V predošlých úlohách sme sa naučili pracovať s prostredím Blender s použitím Pyhtonu. Teraz prechádzame do konceptu viacúčelovej optimalizácie, ktorú si vysvetlme a ukážeme. Definciou postačujúcou pre nás bude v tomto prípade, že viacúčelová optimalizácia je proces hľadania najlepších možných riešení pre viacero súčasne sledovaných cieľov alebo kritérií. Cieľom je nájsť také riešenia, ktoré predstavujú tzv. Pareto-optimálnu množinu, kde nie je možné zlepšiť jedno kritérium bez zhoršenia niektorého z ostatných kritérií. Ide o vyhľadávanie riešení pomocou kompormisu, ktoré vyvažujú protichodné požiadavky rôznych cieľov. Vo viacúčelovej optimalizácii nie je jedno jednoznačne najlepšie riešenie, ale skupina riešení, nazývaná Pareto-optimálna fronta, medzi ktorými musí rozhodovať užívateľ na základe preferencií alebo ďalších kritérií.

Zadanie úlohy

Cieľom tejto úlohy je oboznámiť sa s knižnicou platypus pre prácu s viacúčelovou optimalizáciou, zistiť ako funguje, čo všetko na to potrebujeme, ktoré aspekty pri ladení musíme zohľadňovať, ak uvažovať o tom ako by sa takáto optimalizácia dala zovšeobecňovať. Viacúčelová optimaliácia je jedným zo spôsobov akým môžeme implementovať parametrické a generatívne modelovanie 3D objektov. Taktiež si vo väčšom precvičíme prácu s Blenderom a Pythonom a načíme sa nové programátorksé praktiky. V našom prípade nám pôjde o to definovať takú optimalizáciu, ktorá by vyhovovala naším požiadavkám. V prípade optimalizácie 3D modelu pomocou ich modifikácie nám ide o hľadanie tých najoptimálnejších parametrov, ktoré nám umožnia objekt meniť tak aby spĺňal kritériá, ktoré naň kladieme.

Odkazy na materiály

V tejto sekcii nájdete odkazy na materiály, ktoré vám môžu pomôcť pri riešení daných problémov a naučia vás ako používať požívané nástroje:

• Teória - rozcestník stručnej teórie pre koncepty, ktoré potrebujeme
• Rozcestník dokumentácií Blendera - nájdete tu dokumentáciu pre vývojárov, používateľskú ríručku a aj Python API dokumentáciu
• Python syntax - syntax a použitie jazyka Python s ukážkami použitia
• Blender Python API - dokumentácia Python API v Blenderi - nájdete tu všetko čo sa týka programovania s Python API (s knižnicou bpy) v Blenderi
• Platypus - dokumentácia knižnice Platypus s ukážkami použitia

Inštrukcie

1. Zapneme si nástroj Blender a nastavíme si prostredie ako sme sa naučili v predošlých úlohách - necháme si v scéne objekt kocky, prepneme sa do režimu "Scripting" a vytvoríme si tam súbor, do ktorého budeme písať kód.
2. Môžeme si skúsiť pripomenúť prácu s knižnicou bpy z minulých úloh pomocou volania niektorých funkcií. Pre túto úlohu ju budeme potrebovať.
3. Ubezpečíme sa, že máme nainštalovanú knižnicu platypus - skúsime ju importovať pomocou
   

   import platypus
   

   a skúsiť si zavolať nejaký príkaz. Ak nie je nainštalovaná, vieme si ju nainštalovať pomocou príkazu
   

   import site
   import pip
   pip.main(['install', 'Platypus-Opt', '--target', site.USER_SITE])
   

4. Ďalej si vyskúšame prácu s knižnicou. Na tomto odkaze v teórii nájdeme príklad jej použitia: príklad použitia platypus, príklad je stručne aj tu:
   

   from platypus import NSGAII, Problem, Real
   
   def schaffer(x):
       return [x[0]**2, (x[0]-2)**2]
   
   problem = Problem(1, 2)
   problem.types[:] = Real(-10, 10)
   problem.function = schaffer
   
   algorithm = NSGAII(problem)
   algorithm.run(10000)
   

   Tento kód si vieme spustiť v Pythone a následne uvidíme výpis výsledkov optimalizácie problému. Ak ho nikde nevidíme, môžeme si otvoriť systémovú konzolu v Blenderi nasledovne:
   
   Toto je definícia problému s 1 premennou 2 cieľmi s funkciou schaffer(x), ktorá priradzuje týmto premenným hodnoty. Keby sme si zobrazili na grafe toto riešenie, vyzeralo by nasledovne:
   
   

   Na grafe vidíme Paretov front. Je to množina všetkých optimálnych riešení, ktorú budeme chcieť hľadať aj pri optimálizácii našich 3D modelov. Najprv však musíme definovať vlastný problém a vlastnú funkciu, ktorá bude slúžiť na ohodnotenie parametrov, ktoré sa budeme snažiť optimalizovať.
5. Čo ak budeme chcieť optimalizovať viac ako 2 parametre? Aj toto knižnica Platypus dokáže, skúste si skopírovať qa spustiť nasledovný kód:
   

   from platypus import NSGAII, Problem, Real
   import math
   
   def test_functions(x):
       return [math.sin(x[0]), math.cos(x[0]), x[0]**2]
   
   problem = Problem(1, 3)
   problem.types[:] = Real(-3, 3)
   problem.function = test_functions
   
   algorithm = NSGAII(problem)
   algorithm.run(10000)
   
   for s in algorithm.result:
       print("VARIABLES:  ", s.variables)
       print("OBJECTIVES: ", s.objectives)
       
       
   # plot the results using matplotlib
   import matplotlib.pyplot as plt
   from mpl_toolkits.mplot3d import Axes3D
   
   fig = plt.figure()
   ax = fig.add_subplot(111, projection='3d')
   
   for s in algorithm.result:
       ax.scatter(s.objectives[0], s.objectives[1], s.objectives[2])
   
   ax.set_xlabel('$f_1(x)=sin(x)$')
   ax.set_ylabel('$f_2(x)=cos(x)$')
   ax.set_zlabel('$f_3(x)=x^2$')
   
   plt.show()
   

   Ak ste všetko spravili správne, kód by vám mal vygenerovať takýto 3D graf:
   
   Takže kým sa snažíme optimalizovať 2 alebo 3 parametre, vieme si to takto vizualizovať, no pri viacerých parametroch by výpovedná hodnota vizualizácie riešenia bola len veľmi nízka, takže my sa zameriame najmä na 2 či 3 parametre.

6. Pre ďalšiu prácu si otvorte vzorové riešenie a môžete sledovať kód - v nasledovných inštrukciách si vysvetlíme fungovanie algoritmu.
7. Optimalizovať budeme parametre meniace náš objekt. Týmito parametrami môže byť napríklad číslo škálovania objektu, alebo úroveň (levels) aplikácie levelu modifikátora "subdivision surface." Skúsme si preto vymyslieť modifikácie, ktoré budeme chcieť aplikovať a vytvorme si k ním funkcie podobné funkciám, ktoré inicializujú modifikácie z minulých cvičení. Takéto funkcie budeme potrebovať, pretože na to, aby sme dokázali ohodnotiť dané zmeny na objektu aby nám naša funkcia na hodnotenie vrátila validné hodnoty, musíme najskôr tieto zmeny na model aplikovať. Takouto funkciou je napríklad init_subdivision_modifier(obj, levels=1).
8. Ďalej si definujeme problém. Potrebujeme si definovať počet parametrov a počet cieľov, ktoré chceme dosiahnuť. Náš problém bude definovaný ako Problem(3,3), pretože chceme definovať 3 ciele: veľkosť objektu, veľkosť počtu polygónov a hladkosť objektu, toto chceme to dosiahnuť úpravou 3 parametrov - škálovanie (scale), napríkald úroveň "decimate" modifikátora a úroveň levelu modifikátora "subdivision surface".
9. Pre optimalizáciu slúži viac algoritmov, my si vyberieme NSGA-II. Môžete si naštudovať ostatné algoritmy v dokumentácii Platyus a posúdiť, na aké problémy by bol ktorý algoritmus vhodný. Niektoré totiž pracujú rýchlejšie, iné lepšie konvergujú ku konkrétnym hodnotám.
10. Ďalej si potrebujeme vytvoriť našu hodnotiaciu funkciu (fitness funkciu) - niečo ako funkcia schaffer v počiatočnej ukážke. Táto funkcia slúži na pridelenie hodnotenia daným parametrom, ktoré náhodne algoritmus vygeneroval. Náhodne bude tieto hodnoty generovať z definície typov, ktoré mu určíme, napríklad takto:
    

    problem.types[:] = [Real(0.5, 1), Real(0, 30), Real(0.5, 2)]

    Rovnako to vieme zapísať aj takto:

    problem.types[0] = Real(0.5, 1)
    problem.types[1] = Real(0, 30)
    problem.types[2] = Real(0.5, 2)
    

    kde prvý parameter určuje rozsahy ratio modifikátora "decimate",
    druhý určuje levely modifikátora "subdivision surface"
    tretí určuje škálovanie vo všetkých smeroch
    a všetky sú typu Real, čo je nejaké desatinné číslo
    Je potrebné dať si pozor aby typy boli rovnaké, inak by algoritmus nefungoval správne, je možné vytvoriť si Variator (nájdete v dokumentácii) alebo si môžete hodnoty nejakým spôsobom mapovať medzi sebou (čo robíme v prípade modifikátora "subdivision surface," ktorý dovoľuje len celé čísla v rozsahu 0 až 6), mapovanie nájdete v ukážkovom riešení.

11. Potom je potrebné vytvoriť si fitness funkciu. Fitness funkcia (v našom prípade fitness_function) bude vždy brať parameter params, ktorý bude obsahovať n-ticu vygenerovaných náhodných parametrov na pozíciach v akom sme definovali typy daného problému. Tieto parametre budeme chcieť aplikovať na náš model a vyhodnotiť ho pomocou pomocných fitness funkcií, ako je v našom prípade napríklad get_surface_smoothness_fitness(object). Túto funkciu predávame algoritmu, aby ju spúšťal pri ohodnocovaní každého jedinca na náhodne generovaných parametroch, ktoré sme si definovali.
    

    problem.function = fitness_function
    

    V našej implementácii si vytvoríme 3 fitness funkcie, kde jedna bude ohodnocovať hladkosť, druhá počet plôch objektu a tretia objem bounding boxu. Všetky sa budú volať v rámci hlavnej fitness_function: Najprv v nej robíme kopírovanie nášho objektu, aplikujeme naň modifikácie, vyhodnotíme ho pomocou našich pomocných fitness funkcií a nakoniec ho vymažeme aby nám nezostal zbytočne v scéne. Funkcia vracia n-ticu ohodnotení zodpovedajúcich parametrov na rovnakých indexoch. Je veľmi dôležité určiť si minimálne a maximálne hodnoty ak ich potrebujeme pre vytvorenie fitness funkcie. Fitness funkcie chceme mapovať na hodnoty 0 až 100, aby mali ohodnotenia daných parametrov rovnovážne obsadenie v optimalizácií. Musíme preto aj odhadnúť minimálne a maximálne hodnoty vo fitness funkciách podľa potreby. Napríklad vo funkcii get_faces_count_fitness(obj, min_faces, max_faces) musíme určiť minimálny a maximálny možný počet plôch, ktoré objekt môže obsahovať aby sme vedeli validne vyčísliť hodnotu. Ak napríklad pracujeme s objektom kocky, ktorá má v zkladnej verzii 6 plôch a modifikujeme ju do takej miery, že môže mať 100 plôch, môžeme si tieto okrajové hodnoty určiť napríklad od 4 do 200, no ak by sme mali komplexný objekt, takéto krajné hodnoty nemôžeme nechať takéto. Dajme tomu, že náš základný objekt má 100 plôch a chceme ho modifikovať pri čom sa môže znížiť aj zvýšiť počet plôch, podľa modifikácií, ktoré aplikujem - napríklad sudivision modifier vie exponenciálne zvýšiť počet plôch, v takom prípade by som si nastavil hodnotu max_faces napríklad na 100 000. Pri tvorbe fitness funkcií je potrebné zohľadniť tieto veci:
    

    • možné rozsahy pred a po modifikácii objektu, čo sme si vysvetlili
    • modifikácie, ktoré aplikujeme a zmeny, ktoré môžu v objektoch pred meraniami nastať - ak máme napríklad plochu tvorenú 3 bodmi, nemôžeme napríklad použiť modifikátor, ktorý znižuje počet bodov alebo hrán v objekte
    • poradie aplikácie modifikátorov - iné poradie aplikovania modifikátorov môže kompletne zmeniť výsledný objekt
    • rozumné rozsahy modifikácií - je potrebné zvážiť do akej miery chceme objekty modifikovať, pretože môže nastať, že objekt modifikujeme tak zložito, že výpočet môže trvať extrémne dlho, alebo môže celý program spadnúť
12. Celý proces optimalizácie sustíme nasledovne:
    

    algorithm = NSGAII(problem, population_size=100) # optimalizačný algoritmus, ktorému predávame problém a veľkosť populácie
    algorithm.run(100)  # hovoríme mu aby vytvoril 100 generácií a na nich optimalizoval dané vstupy
    

13. Výsledok optimalizácie získame z algorithm.result po dobehnutí optimalizácie, tento výsleodk obsahuje 2 polia, 1. sú generované premenné pri ktorých na zodpovedajúcom indexe ískali ohodnotenie v 2. poli. Takže prvé obsahuje premenné a druhé ich ohodnotenia. Z hodnôt objectives sa vytvára Paretov front.

    for solution in algorithm.result:
        print("Parameters:", solution.variables)
        print("Objectives:", solution.objectives)
    

14. Ostáva nám tieto parametre si prejsť a aplikovať na náš model, toto robíme vo funkcii apply_parameters_and_position_objects(best_parameters, worst_parameters, o).
15. Skúste si na základe poskytnutého kódu vytvoriť inú optimalizáciu, pozmeniť modifkátori alebo implementovať iné modifikácie objektov, iné hodnotiace funkcie. Vzorové riešenie obsahuje modifikácie, hodnotiace funkcie, inicializáciu problému a spustenie algoritmu, taktiež vykreslovanie ohodnotení / Paretovho frontu na grafe, výpis riešenia a vytvorenie niekoľkých modelov pomocou vygenerovaných parametrov a vytvorenie ich inštancií v scéne Blendera.

Testovanie a úpravy

Analyzujte či výsledky, ktoré váš optimalizačný algoritmus vracia sú relevantné a vieme ich zužitkovať, návrhy na vylepšenie máme tu:

• skúste si odfiltrovať tie najlepšie a najhoršie ohodnotené riešenia optimalizačného algoritmu a vytvorit si podľa nich modely
• pokúste sa navrhnúť optimalizáciu ďalšieho parametra, to zahŕňa: vytvorenie fitness funkcie, špecifikácia typu a rozsahu parametru (prípadne jeho mapovanie), vytvorenie funkcie, ktorá dané modifikácie na model aplikuje
• vyskúšajte si importovať vlastný objekt a otestovať váš algoritmus na ňom
• skúste implmentovať optimalizáciu pre rôzny počet parametrov a cieľov a sledujte ako to zmení výsledky
• namiesto algoritmu NSGA-II si vyskúšajte iné algoritmy ako napríklad NSGA-III, MOEAD a pozorujte rýchlosti výpočtu odchylky vo výsledkoch

Vzorové riešenie

Ak budete potrebovať motiváciu alebo si skontrolovať váš výsledný model, v nasledujúcich odkazoch nájdete implementáciu daného modelu v nástrojoch, ktoré ste na implementáciu mohli použiť:

• Python

Záver

Týmto cvičením sme si ukázali ako si dokážeme navrhnúť a vytvoriť vlastnú viacúčelovú optimalizáciu a vedieť s ňou vyriešiť vlastný problém, ktorý môže mať aj protichodné kritéria. Vieme na to využiť existujúce knižnice a aplikovať riešenie na výsledné modely.
Pre rozbehanie a prácu Blendera z Visual Studio Code potupujte podľa inštrukcii v tomto videu: Blender + VS Code.