Simulare vectori aleatori continui

April 27, 2023

1 Simularea unui vector aleator continuu uniform distribuit pe un

domeniu dreptunghiular
Ce inseamna a simula vectorul (𝑋, 𝑌 )? Vectorul (𝑋, 𝑌 ) este distribuit aleator, adica nu are o
valoare fixa. Cunoastem doar probabilitatea ca acesta sa ia o valoare intr-un anumit domeniu. A
simula acest vector inseamna a alege o valoare pe care acesta o poate lua, tinand cont de distributia
sa.
Dorim sa simulam un vector (𝑋, 𝑌 ) distribuit uniform pe un dreptunghi, deci avem 2 cerinte:
• valorile luate de vector sa se afle doar in dreptunghi
• fiecare valoare posibila “sa aiba aceeasi probabilitate” de a fi aleasa
Stim ca daca vectorul (𝑋, 𝑌 ) este uniform distribuit pe dreptunghiul [𝑎, 𝑏] × [𝑐, 𝑑], atunci variabila
𝑋 este distribuita uniform pe intervalul [𝑎, 𝑏], si variabila 𝑌 este distribuita uniform pe intervalul
[𝑐, 𝑑].
De asemenea, se poate arata ca variabilele 𝑋 si 𝑌 sunt independente. Atunci, putem simula vectorul
(𝑋, 𝑌 ) simuland separat variabilele 𝑋 si 𝑌 .
Variabilele 𝑋 si 𝑌 sunt distribuite uniform pe intervalele [𝑎, 𝑏] si [𝑐, 𝑑], deci stim sa le simulam!
In general, atunci cand simulam, presupunem ca avem la dispozitie o functie care ne genereaza uni-
form numere aleatoare in intervalul [0, 1]. In pseudocod vom numi aceasta functie urand(uniform
random).
Avem la dispozitie functia urand pentru a genera uniform numere aleatoare in intervalul [0, 1].
Cum ajungem sa generam in intervalul [𝑎, 𝑏]?
Primul pas este sa inmultim rezultatul lui urand cu 𝑏 − 𝑎, obtinand un numar in intervalul [0 ⋅ (𝑏 −
𝑎), 1 ⋅ (𝑏 − 𝑎)], adica in intervalul [0, 𝑏 − 𝑎].
Tot ce mai lipseste este sa adunam 𝑎, obtinand [0 + 𝑎, 𝑏 − 𝑎 + 𝑎] = [𝑎, 𝑏].
Pseudocodul pentru a simula variabila 𝑋, uniform distribuita pe intervalul [𝑎, 𝑏] arata atunci astfel:
x = urand() * (b - a) + a;
Stiind ca a simula vectorul (𝑋, 𝑌 ) distribuit uniform pe domeniul [𝑎, 𝑏] × [𝑐, 𝑑] este echivalent cu a
simula variabila 𝑋 pe intervalul [𝑎, 𝑏] si variabila 𝑌 pe intervalul [𝑐, 𝑑], rezulta urmatorul pseudocod
pentru simularea vectorului:
x = urand() * (b - a) + a;
y = urand() * (c - d) + c;

1
 Sa transformam acest pseudocod in cod Python, pe care il putem rula. Vom folosi libraria numpy
pentru a avea acces la o functie de tip urand:
[ ]: import numpy as np

Functia ce ne intereseaza este np.random.rand, care returneaza o valoare distribuita uniform din
intervalul [0, 1].
Vom defini functia sim_unif_vector(a, b, c, d), care va simula un vector distribuit uniform pe
domeniul [𝑎, 𝑏] × [𝑐, 𝑑]:

[ ]: def sim_unif_vector(a, b, c, d):

x = np.random.rand()*(b-a)+a
y = np.random.rand()*(d-c)+c
return [x, y]

Sa apelam aceasta functie, alegand domeniul [−1, 1] × [0, 2]:

[ ]: sim_unif_vector(-1, 1, 0, 2)

[ ]: [-0.49265310530360207, 1.0461126439144022]

Observam ca valorile returnate par sa apartina domeniului dorit. Simulam 1000 de valori pentru a
ne convinge de acest fapt:
[ ]: samples = []
for i in range(0, 1000):
samples.append(sim_unif_vector(-1, 1, 0, 2))
samples

Putem reprezenta aceste observatii grafic cu ajutorul librariei matplotlib:

[ ]: import matplotlib.pyplot as plot

Acum vom reprezenta grafic fiecare dintre cele 1000 de observatii:

[ ]: for i in range(0, 1000):
x = samples[i][0]
y = samples[i][1]
plot.scatter(x, y)

2
 Observam ca toate punctele sunt situate in dreptunghiul [−1, 1] × [0, 2], si ca nu exista zone ale
acestui dreptunghiu in care sa se afle mult mai multe puncte decat in alte zone, adica punctele sunt
distribuite uniform pe acest dreptunghi.
Observatie: Codul Python scris mai sus este ineficient, deoarece reprezentam observatie cu obser-
vatie. Puteam reprezenta toate observatiile dintr-un singur apel al functiei plot.scatter, dar am
ales codul cel mai simplu pentru a fi inteles mai usor.

2 Simularea unui vector aleator continuu uniform distribuit pe

domenii nedreptunghiulare
Vom considera drept domeniu discul de centru (0, 1) si raza 1, adica cercul de centru (0, 1) si raza
1, si interiorul sau.
[ ]: circle = plot.Circle((0, 1), 1, clip_on = False)
plot.gca().add_patch(circle)
plot.axis((-3, 3, -3, 3))
plot.gca().set_aspect('equal', adjustable='box')
plot.show()

3
 Dorim sa simulam un vector (𝑋, 𝑌 ) distribuit uniform pe acest cerc. Stim sa simulam vectori
distribuiti uniform pe dreptunghiuri.
Cautam un dreptunghi ce contine intreg cercul. Vizual, observam ca dreptunghiul [−2, 2] × [−1, 3]
contine intreg cercul.
[ ]: rectangle = plot.Rectangle((-2, -1), 4, 4, color="r", alpha=0.5)
circle = plot.Circle((0, 1), 1, clip_on = False)
plot.gca().add_patch(circle)
plot.gca().add_patch(rectangle)
plot.axis((-3, 3, -3, 3))
plot.gca().set_aspect('equal', adjustable='box')
plot.show()

4
Pentru a simula uniform puncte din interiorul cercului, vom simula puncte din dreptunghi pana
gasim unul care se afla si in cerc.
Altfel spus, simulam un punct din dreptunghi. Daca punctul se afla si in cerc, atunci acesta este
punctul ce ne intereseaza. Altfel, simulam un alt punct, pana cand gasim unul ce se afla si in cerc.
Pseudocodul arata astfel:
do{
genereaza un punct (x, y) din dreptunghi;
} while(punctul generat nu se afla si in cerc);
Generarea punctului din dreptunghi se realizeaza ca mai sus, anume:
x = urand() * (b - a) + a;
y = urand() * (d - c) + c;
Cercul de centru (0, 1) si raza 1 are ecuatia:

(𝑥 − 0)2 + (𝑦 − 1)2 = 12

Discul corespunzator acestui cerc contine si punctele din interiorul cercului, deci are aceasta ecuatie:

(𝑥 − 0)2 + (𝑦 − 1)2 ≤ 12

5
 Pentru a obtine punctele ce nu se afla in acest disc, este suficient sa negam ecuatia de mai sus, ceea
ce se poate face matematic prin inlocuirea semnului ≤ cu >:

(𝑥 − 0)2 + (𝑦 − 1)2 > 12

Deci pseudocodul arata astfel:

do{
x = urand() * (b - a) + a;
y = urand() * (d - c) + c;
} while (x^2 + (y-1)^2 > 1)
Acum vom scrie acelasi cod in limbajul Python, folosind functia sim_unif_vector de mai sus.
In acest limbaj nu exista do while, deci va trebuie sa il simulam folosind while:
[ ]: [x, y] = sim_unif_vector(-2, 2, -2, 2)
while x*x + (y - 1)*(y - 1) > 1:
[x, y] = sim_unif_vector(-2, 2, -2, 2)

Aceasta metoda de simulare a vectorilor aleatori continui este cunoscuta drept metoda respin-
gerii, deoarece generam puncte dintr-un dreptunghi si le respingem pe cele care nu se afla si in
domeniul ce ne intereseaza.
Metoda respingerii functioneaza pentru orice tip de domeniu, nu numai unul circular. Este suficient
sa gasim un dreptunghi care sa acopere intregul domeniu de interes!
Notand cu 𝐺 domeniul in care vrem sa simulam, si cu 𝐷 domeniul dreptunghiular care il include
pe 𝐺, se poate demonstra ca probabilitatea ca un punct simulat in domeniul 𝐷 sa se afle si in
domeniul 𝐺 este:
aria(𝐺)
aria(𝐷)

Putem folosi orice dreptunghi 𝐷 care include 𝐺, dar ne dorim sa alegem unul care duce la un
algoritm cat mai rapid. Algoritmul este cu atat mai rapid cu cat probabilitatea de mai sus creste.
Pentru ca probabilitatea sa creasca, trebuie ca aria(𝐷) sa scada, deci ne dorim un dreptunghi de
arie minima. Acest fapt se observa si din grafic, deoarece un dreptunghi de arie mai mica se afla
mai aproape de cerc.
Revenind la cercul de mai sus, observam ca dreptunghiul [−1, 1] × [0, 2] este dreptunghiul de arie
minima ce acopera complet cercul!
[ ]: rectangle = plot.Rectangle((-1, 0), 2, 2, color="r", alpha=0.5)
circle = plot.Circle((0, 1), 1, clip_on = False)
plot.gca().add_patch(circle)
plot.gca().add_patch(rectangle)
plot.axis((-3, 3, -3, 3))
plot.gca().set_aspect('equal', adjustable='box')
plot.show()

6
 Codul de simulare mai eficient va arata astfel:
[ ]: def sim_unif_circle():
[x, y] = sim_unif_vector(-1, 1, 0, 2)
while x*x + (y - 1)*(y - 1) > 1:
[x, y] = sim_unif_vector(-1, 1, 0, 2)
return [x, y]

In final, vom folosi functia de mai sus pentru a simula 1000 de puncte si a le reprezenta grafic:
[ ]: for i in range(0, 1000):
[x, y] = sim_unif_circle()
plot.scatter(x, y)
plot.gca().set_aspect('equal', adjustable='box')
plot.show()

7
 3 Exemplu simulare vector continuu uniform distribuit pe un tri-
unghi
Dorim sa geneream uniform puncte pe domeniul dat de urmatorul sistem de inecuatii:

0 ≤ 𝑥, 𝑦 ≤ 1
{
𝑦≤𝑥

Pentru a ne convinge ca acest domeniu este intr-adevar un triunghi, il vom reprezenta grafic.
Primele 2 inegalitati ne impun limite pentru 𝑥 si 𝑦.
Vom reprezenta mai intai grafic ultima inecuatie. Primul pas este sa reprezentam linia 𝑦 = 𝑥, si
apoi sa consideram toate punctele de sub ea, datorita semnului ≤:
[ ]: import matplotlib.pyplot as plot

[ ]: x = np.linspace(0, 4, 1000)
y = x
plot.plot(x, y)
plot.fill_between(x, y, alpha = 0.5)
plot.show()

8
 Adaugand si cele 2 inecuatii ce limiteaza valorile lui 𝑥 si 𝑦, vom obtine un triunghi mai mic:
[ ]: x = np.linspace(0, 4, 1000)
y = x
plot.plot(x, y)
plot.fill_between(x, y, where = (0 <= x) & (x <= 1) & (0 <= y) & (y <= 1),␣
↪alpha = 0.5)

plot.show()

9
 Observam ca cel mai bun dreptunghi ce contine intreg domeniul cautat este dreptunghiul [0, 1] ×
[0, 1]. Rezulta urmatorul cod Python de simulare:

[ ]: def sim_unif_triangle():
x = np.random.rand()
y = np.random.rand()
while y > x:
x = np.random.rand()
y = np.random.rand()
return [x, y]

[ ]: sim_unif_triangle()

[ ]: [0.8984701863881238, 0.5941793229509763]

Simulam 1000 de puncte si le reprezentam grafic:

[ ]: for i in range(0, 1000):
sample = sim_unif_triangle()
sample_x = sample[0]
sample_y = sample[1]
plot.scatter(sample_x, sample_y)

10
4 Vectori aleatori in Machine Learning
Cele mai multe aplicatii ale vectorilor aleatori continui, respectiv ale probabilitatii si statisticii sunt
in domeniul Machine Learning, domeniu ce se afla in spatele unor proiecte precum ChatGPT.
Algoritmii de Machine Learning au in general nevoie de o multime de date, din care sa invete sa
rezolve un anumit task. De exemplu, ChatGPT isi datoreaza performanta cantitatii imense de date
pe care a fost antrenat.
Putem vedea ChatGPT ca fiind un model de Machine Learning care genereaza propozitii cuvant
cu cuvant. Sa presupunem ca pana acum am generat 𝑛 cuvinte, anume cuvintele 𝑥1 , 𝑥2 , …, 𝑥𝑛 .
Dorim sa generam cuvantul urmator, adica 𝑥𝑛+1 . Cu 𝑐𝑖 notam toate cuvintele posibile, si pentru
fiecare dintre acestea calculam urmatoarea probabilitate:
𝑃 (𝑋𝑛+1 = 𝑐𝑖 |𝑋1 = 𝑥1 , 𝑋2 = 𝑥2 , ..., 𝑋𝑛 = 𝑥𝑛 )

Aceasta probabilitatea este probabilitatea ca urmatorul cuvant, cuvantul 𝑋𝑛+1 , sa fie 𝑐𝑖 , stiind ca
primul cuvant, 𝑋1 , a fost 𝑥1 , al 2lea cuvant, 𝑋2 , a fost cuvantul 𝑥2 , etc.
Daca stim aceste probabilitati, respectiv daca le putem estima, atunci vom putea genera cuvantul
urmator, alegand acel cuvant pentru care probabilitatea de mai sus este maxima!
Cum estimam insa o asemenea probabilitate? Folosind cantitatea uriasa de date ce o avem la
dispozitie! Aceste date contin o multime de propozitii, formate din o multime de cuvinte. Obser-

11
vand de cate ori apar anumite combinatii de cuvinte, combinatii de propozitii, etc, putem estima
probabilitati de acest tip:

𝑃 (𝑋1 = 𝑥1 , 𝑋2 = 𝑥2 , 𝑋3 = 𝑥3 , ..., 𝑋𝑛 = 𝑥𝑛 )

Observam ca (𝑋1 , 𝑋2 , ..., 𝑋𝑛 ) este un vector aleator! Deoarece variabilele 𝑋𝑖 iau valori in multimea
cuvintelor, care este o multime finita, este clar ca vectorul (𝑋1 , 𝑋2 , ..., 𝑋𝑛 ) este un vector discret!
Putem avea insa de a face si cu vectori continui, de exemplu daca dorim sa prezicem evoluatia
valorii(de exemplu, in dolari) a unei monede crypto, deoarece aceasta valoare este una continua.

5 Mai multe
Pentru a afla mult mai multe despre Machine Learning dintr-o perspectiva probabilistica, va reco-
mand Book 1 de la acest link: https://github.com/probml/pml-book.
Cartea include si un capitol despre Probablitate si Statistica!
De asemenea, daca aveti intrebari sau observatii, ma puteti contacta la aceasta adresa de email:
claudiutirisi@yahoo.com.

12