Az iteráció szemcsézettségű optimalizálási algoritmusok globális dekom-

A szekvenciális optimalizálási algoritmusok konvergenciájának bizonyítását a Zangwill [Zan 69] által kifejlesztett elméleten belül lehet elvégezni. Ehhez az optimalizálási algo-ritmus egy iterációs lépését, mint egy A : X → Y pont–halmaz leképezést tekintünk.

Az idevonatkozó eredmények ismertetését főleg Luenberger [Lue 84] jelöléseivel és kisebb mértékben Bazaraa [BSS 94] leírását követve adjuk meg.

Egy algoritmikus lépés (iteráció) úgy fogható fel, mint egyAleképezés, amely az előző iteráció végén kapott x ∈ X pontból előállít egy A(x) ∈ Y halmazt. Ha az A pont-halmaz leképezés zárt, akkor az A algoritmus ismételt alkalmazásával egy {xk},xk+1 ∈ A(x_k)pontsorozatot tudunk előállítani, amelynek a konvergens részsorozatai egy optimális megoldáshoz konvergálnak. A továbbiakban az ilyen algoritmusokat egyszerűen konver-gensnek nevezzük. Egy további, enyhe feltétel esetén két konvergens B : X → Y, C : Y → Z algoritmus egymásutáni alkalmazásával kapott A = CB, A : X → Z összetett algoritmus is konvergens lesz.

Néhány jelölést vezetünk be. Tegyük fel, hogy a

min g(x), x∈S (2.3)

optimalizálási feladat megoldását keressük, ahol S egy konvex halmaz. Jelölje az op-timális megoldások halmazát Γ ⊂ S, és tegyük fel, hogy létezik az S halmazon egy, az A, S,Γ függvényeként megadható Z leszálló függvény, amely rendelkezik a következő tu-lajdonsággal: ha az A : S → S leképezés egy konvergens algoritmust valósít meg, akkor Z(y) < Z(x),∀y ∈ A(x), x ∈/ Γ esetén és Z(y) ≤ Z(x), ∀y ∈ A(x), ha x ∈ Γ fennáll.

Általában a leszálló függvény szerepére a (minimalizálandó) célfüggvényt használják, de néha ettől eltérő leszálló függvény konstruálására is szükség lehet. Egy B algoritmust az yk, k-adik iterációban előállított megengedett megoldás és a Z leszálló függvény tekin-tetében leszálló algoritmusnak nevezünk, ha az nem növeli meg a leszálló függvény értékét, vagyis ha y_k+1 ∈B(y_k), akkor Z(y_k+1)≤Z(y_k)is fennáll, minden y_k∈S esetén.

A távolságtartó lépések tétele (spacer step theorem) fontos szerepet játszik a további-akban (a tételeket nem a legáltalánosabb formában mondjuk ki, csak a nekünk elégséges alakokat adjuk meg). Ez a tétel lényegében azt mondja ki, hogy ha egyH leszálló algorit-mus egy (vagy több) lépését beillesztjük egy konvergens C algoritmus lépései közé, akkor az A = CH (vagy A = CH· · ·H) összetett leképezés még mindig konvergens marad.

Jegyezzük meg, hogy itt a H algoritmus lehet heurisztikus algoritmus is, nem okvetlenül csak konvergens algoritmus használható ebben a szerepkörben. Más megfogalmazásban ez azt jelenti, hogy ha egy konvergens algoritmus (távolságtartó) lépéseit időnként (de végtelen sokszor) beillesztjük egy heurisztikus leszálló algoritmus lépései közé, akkor az összetett leképezés konvergens lesz.

5. Tétel. (Távolságtartó lépések tétele). Tegyük fel, hogy C egy konvergens algoritmus az S halmazon és hogy létezik egy C, S,Γ esetén használható Z leszálló függvény. Tegyük fel továbbá, hogy

(i) rendelkezésünkre áll egy olyan{x_k}^∞_k=1 pontsorozat, amelyre Z(x_k+1)≤Z(x_k) fennáll, minden k= 1,2, . . . esetén,

(ii) az {x|Z(x)≤Z(x₀)} nívóhalmaz kompakt,

(iii) ha k∈ K, akkor x_k+1 ∈C(x_k), ahol K egy végtelen indexhalmaz.

Ekkor az{xk}, k∈ Ktetszőleges konvergens részsorozatának azxhatárértéke egy optimális megoldás, vagyis x∈Γ.

Ezen előkészületek után az optimalizálási algoritmusok iterációs szemcsézettségű párhuzamosítására ajánlott globális dekompozíciót, valamint a megfelelő számítási eljárást adjuk meg. A

P_i, i = 1, . . . , N processzorokhoz hozzárendeljük a C_i és a H_i optimalizálási algoritmu-sokat, ahol a C_i algoritmusokról feltesszük, hogy konvergens eljárások, míg a H_i algorit-musról csak azt tesszük fel, hogy leszálló algoritmus minden olyan megengedett megoldás esetén, amelyet akármelyik processzornál a t időpillanatig kiszámítottunk (ezek a H_i al-goritmusok lehetnek akár konvergens, akár heurisztikus alal-goritmusok is, csak a leszálló

természetüket kötjük ki). Az algoritmusoknak a processzorokhoz való hozzárendelése tet-szőleges, de a kiválasztások elvégzése után nem változtatható. A C_i algoritmusok által adott megoldásokat x, a H_i által kiszámított megoldásokat y jelöli. A H_i algoritmus k-adik lépéseként használhatjuk a következő, egyszerű kiválasztási szabályt:

yⁱ_k =yⁱ(t) = argminm=1,2,...,N g(x^m(τ_jⁱ(t))), (2.4) amely nyilván egy leszálló algoritmust ad. A xⁱ(t) jelölést azért használjuk, hogy az időtől való függést is figyelembe tudjuk venni; ez azxⁱ(t)aP_i processzornál atidőpontban rendelkezésünkre álló megoldás, a τ_jⁱ(t) függvényt azt előző szakaszban definiáltuk, de most Tⁱ csak azokat az időpillanatokat tartalmazza, amikor az x_k = xⁱ(t) értékének kiszámítását befejeztük, vagyis a C_i konvergens algoritmikus lépés befejeződött.

A processzorok végezte feladatok és a kommunikációs hálózat működése egyszerűen megadható: a P_i processzor végrehajt egy C_i algoritmikus lépést, aztán a kapott xⁱ_k = xⁱ(t) megoldást és az ehhez tartozó g(xⁱ(t)), k skalárokat (a célfüggvény értékét és az iterációs lépésszámot) szétküldi a többi processzornak (vagy feltesszük, hogy valami-lyen módon az összes processzor hozzáfér a többi processzoroknál kiszámított xⁱ,g(xⁱ),k értékekhez). A megértés elősegítése céljából tegyük fel, hogy a P_i processzornál van egy kijelölt munkaterület, amelyet Xⁱ = {X_mⁱ }^N_m=1 tömbként (N ×(n+ 2) mátrixként) jelölünk, amelynek m-edik sora tartalmazza a P_m processzortól kapott eredményeket, az X_mⁱ = (x^m(τ(t)), g(x^m(τ(t))), k)értékeket.

Miután a Pi processzor szétküldte az {xⁱ(t), g(xⁱ(t)), k} értékeket, végrehajt egy Hi

iterációs lépést az eddig kapottXⁱ megoldásokon, kiszámítva egyy_k∈H_i(Xⁱ)megoldást.

AP_iezek után egyC_i lépést hajt végre azy_k megoldásból kiindulva, vagyisxⁱ_k+1 ∈C_i(y_k).

Tehát ezzel lényegében az xⁱ_k+1 ∈C_iH_i(Xⁱ,xⁱ_k) megoldást kaptuk.

6. Tétel. (A globális dekompozíció aszinkron konvergenciája)

Tegyük fel, hogy a C_i, i= 1, . . . , N algoritmusok konvergensek, a H_i algoritmusok leszálló algoritmusok az Xⁱ és a g szerint, valamint tegyük fel, hogy a teljes aszinkronitás TA feltétele fennáll, akkor

(i) a {xⁱ(t)}, t ∈ Tⁱ megoldás sorozat tetszőleges konvergens részsorozata minden i = 1,2, . . . , N esetén konvergál egy optimális megoldáshoz, továbbá

(ii) ha a Pⁱ processzornál a t időpontban rendelkezésünkre áll egy xⁱ(t) megoldás, akkor van olyan t > t időpillanat, hogy g(x^j(t)) ≤ g(xⁱ(t)), ha t ≥ t minden j = 1,2, . . . , N index esetén.

Bizonyítás. A tétel (i) része egyszerű következménye a 5. Tételnek, ha azt minden egyes processzorra alkalmazzuk. A H_i pótlólagos algoritmikus lépés (a P_i processzornál a C_i algoritmikus lépés után beillesztett heurisztika, mondjuk a (2.4)-ben adott mini-malizálás) úgy tekinthető, mint a távolságtartó lépések közé beillesztett közbülső lépés.

Az {xⁱ(t)}, t ∈ Tⁱ megoldások halmaza megfelel az 5. Tételben megadott {xk}, k ∈ K halmaznak, amely konvergens, az{yⁱ_k}vektorok halmaza pedig a{x_k}, k /∈ Khalmaznak.

A tétel (ii) részének bizonyításához tekintsük azt a t ∈ Tⁱ pillanatot, amikor P_i be-fejezte a xⁱ(t) kiszámítását. A TA teljes aszinkronitás feltevésének második része miatt limt→∞τ_i^j(t) = ∞, azaz létezik egy olyant_j időpillanat, amelyre τ_i^j(t)> t fennáll minden t > t_j esetén. Ebből pedig az következik, hogy τ_i^j(t_j) időpillanatra xⁱ(t)) ∈ {X^j}i igaz, továbbá g xⁱ(τ_i^j(t))

≤g(xⁱ(t)), ∀t≥t_j.

Legyen t^∗_j az az idő, amelyre P_j-nek szüksége van ahhoz, hogy a jelenlegi H_i iterációt befejezi, majd a C_i lépést elvégzi, valamint az ehhez kapcsolódó H_i leszálló lépést (itt t^∗_j véges a TA feltevés első része miatt), amivel kiszámítja ax^j(t_j+t^∗_j)értéket.

Mivel at_j időre aX^j tömb tartalmazza már axⁱ(t)értéket, ígyg(x^j(t_j+t^∗_j))≤g(xⁱ(t) fennáll. Ha most t-vel jelöljük az összes ilyen idő maximumát: t = maxj=1,2,...,N(tj +t^∗_j), akkor tudjuk, hogy at időre az összesP_j, j = 1, . . . , N processzoroknak olyan megoldások állnak a rendelkezésükre, amelyeken a felvett függvényértékek legalább olyan kicsik, mint aP_i processzornál voltak at időben.

A tétel (ii) része azt mutatja, amit a legjobb megoldás elterjedésének nevezhetünk;

ha egyszer egy processzor már megtalált egy jó közelítést, akkor némi idő után az összes processzornál legalább ilyen jó függvényértéket adó közelítések lesznek. AHialgoritmusok által gyakran használt g(x^j(t)) függvényértéket az egyes processzorok szétküldik azért, hogy a többi processzor ne végezzen felesleges munkát. A k iterációs számláló értékét azért küldik el azx^j(t)megoldással együtt, hogy egy másik processzor mindig a legutolsó kiszámított (és nem a legutolsó megkapott) megoldást tárolja. Ez az óvintézkedés annak a nehézségnek az elkerülésére szolgál, hogyha némely, processzorok közti üzenet késik, vagyis ha egy korábban P_j-ből P_i-be küldött megoldás később ér a rendeltetési helyére, mint egy később kiszámított és elküldött megoldás, akkor ne cseréljünk. Matematikailag ez feleslegessé teszi aτ_jⁱ(t) függvény monotonitásának megkövetelését.