Probabilistyczne algorytmy i struktury danych

Łukasz Dubiel

Noc Informatyka 1.0

http://slides.com/bambucha/probabilistyczne-algorytmy-i-struktury-danych/live

Probabilistyka

Probabilistyka

\Omega
Ω\Omega
A
AA
Pr[A] = \frac{|A|}{|\Omega|}
Pr[A]=∣A∣∣Ω∣Pr[A] = \frac{|A|}{|\Omega|}

- przestrzeń zdarzeń z miarą

- podprzestrzeń sprzyjająca wydarzeniu

Zmienna losowa

X: \Omega \longrightarrow \mathbb{R}
X:Ω⟶RX: \Omega \longrightarrow \mathbb{R}
Pr[X = 12]
Pr[X=12]Pr[X = 12]
E(X) = \sum x_i *Pr[x_i]
E(X)=∑xi∗Pr[xi]E(X) = \sum x_i *Pr[x_i]

Nierówność Czebyszewa

Pr[X \geq \varepsilon] \leq \frac{E(X)}{\varepsilon}
Pr[X≥ε]≤E(X)εPr[X \geq \varepsilon] \leq \frac{E(X)}{\varepsilon}
Pr[X < 0] = 0
Pr[X<0]=0Pr[X < 0] = 0
Pr[X \geq \varepsilon] \leq \frac{E(X^k)}{\varepsilon^k}
Pr[X≥ε]≤E(Xk)εkPr[X \geq \varepsilon] \leq \frac{E(X^k)}{\varepsilon^k}

Algorytmy

Algorytm - skończony opis kroków potrzebnych do wykonania zadania

Algorytm probabilistyczny - algorytm wykorzystujący w swoim działaniu generator liczb pseudolosowych

Algorytmy probabilistyczne

algorytmy

Las Vegas

algorytmy

Monte Carlo

Quick sort

Problem

Gdy quick sort dokonuje złego wyboru elementu złożoność bardzo się psuję. 

O(n \log{n}) \longrightarrow O(n^2)
O(nlogn)⟶O(n2)O(n \log{n}) \longrightarrow O(n^2)

Jednocześnie quick sort nie zależy do tego który element wybierze. Pierwszy, drugi, środkowy, medianę, jest mu to obojętne do działania. Zawsze zwróci posortowany ciąg.

Wybierzmy element dzielący w sposób losy

Pr[X = max(A)] = \frac{1}{|A|}
Pr[X=max(A)]=1∣A∣Pr[X = max(A)] = \frac{1}{|A|}

Kolejne wywołania rekurencyjne quicksorta są niezależne co dodatkowo zmniejsza szansę na zły podział

Quick sort mimo podziału na poziomie 99:1 dalej utrzymuje złożność

O(n \log{n})
O(nlogn)O(n \log{n})

Test Millera-Rabina

Test Millera-Rabina

Sprawdzenie pierwszości liczby

Wejście: n - badana liczba,
         k - jakość badania
Wyjście: Złożona || Pierwsza
Powtórz k razy:
    a <- losowa liczba z [2, n-1]
    sprawdź czy a jest świadkiem dla n
    sprawdź czy x nie jest pierwiastkiem 1

Odpowiedź złożona jest zawsze poprawna, gdyż znaleziono przynajmniej jednego świadka złożności testowanej liczby

Jeżeli wszystkie testy przejdą poprawnie:

Pr[prime(n) = false] = \frac{1}{4^k}
Pr[prime(n)=false]=14kPr[prime(n) = false] = \frac{1}{4^k}

Do osiągnięcia prawdopodobieństwa wygrania w lotto potrzebne jest tylko 8 testów

Wykorzystywany w okolicach RSA do generowania kluczy

Algorytmy probabilistyczne

algorytmy

Las Vegas

algorytmy

Monte Carlo

jeżeli się skończą,

skończą się dobrze

na pewno się skończą,

ale nie zawsze dobrze

Struktury danych

a, a_i, a[i]
a,ai,a[i]a, a_i, a[i]

- ciąg skończony, tablica, element ciągu

- funkcje haszujące parami niezależne

h, h_i, h_i(a_j)
h,hi,hi(aj)h, h_i, h_i(a_j)
a_i(t) \leftarrow a_i(t-1) + c_i \equiv a_i \leftarrow a_i + c_i
ai(t)←ai(t−1)+ci≡ai←ai+cia_i(t) \leftarrow a_i(t-1) + c_i \equiv a_i \leftarrow a_i + c_i
A
AA

- zbiór liczbowy

\displaystyle{\forall_{n}}\quad a_n \in A
∀nan∈A\displaystyle{\forall_{n}}\quad a_n \in A
|a| = n
∣a∣=n|a| = n

- długość ciągu

Count-Min sketch

Count-Min sketch

Zadanie: Chcemy znać częstość występowania wartości w ciągu

a = (1,4,5,2,1,1,2,4,1000000000,...
a=(1,4,5,2,1,1,2,4,1000000000,...a = (1,4,5,2,1,1,2,4,1000000000,...

query(1) = 3

query(1000000000) = 1

query(4) = 2

query(6) = 0

Problem: Przestrzeń elementów jest duża 

|A| \geq 2^{32}
∣A∣≥232|A| \geq 2^{32}

Problem: Strumień nie mieści się w pamięci

Problem: Nie chcemy alokacji (z wyjątkiem inicjalizacji)

Założenie: Nie potrzebujemy dokładnych danych, jesteśmy zadowoleni z aproksymacji

Count-Min sketch

\varepsilon
ε\varepsilon

Count-Min sketch

- szerokość aproksymacji

\delta
δ\delta

- szansa aproksymacji

w = \lceil\frac{e}{\varepsilon}\rceil \quad d = \lceil\ln{\frac{1}{\delta}}\rceil
w=⌈eε⌉d=⌈ln1δ⌉w = \lceil\frac{e}{\varepsilon}\rceil \quad d = \lceil\ln{\frac{1}{\delta}}\rceil
w
ww
d
dd

CM sketch - insert

\forall_{i}\ sketch[i,h_i(v)] \leftarrow sketch[i,h_i(v)] + 1
∀i sketch[i,hi(v)]←sketch[i,hi(v)]+1\forall_{i}\ sketch[i,h_i(v)] \leftarrow sketch[i,h_i(v)] + 1
a(t) = v
a(t)=va(t) = v

CM sketch - query

query(v) =\ \displaystyle{\min_{j}} \ sketch[j, h_j(v)]
query(v)= minj sketch[j,hj(v)]query(v) =\ \displaystyle{\min_{j}} \ sketch[j, h_j(v)]
1 1 3 4 1 0 1
2 5 0 5 2 2 4
4 3 2 2 4 2 2
h_1(4) = 2\quad h_2(4) = 4\quad h_3(4) = 5
h1(4)=2h2(4)=4h3(4)=5h_1(4) = 2\quad h_2(4) = 4\quad h_3(4) = 5
query(4) = \min{\{3,5,2\}} = 2
query(4)=min{3,5,2}=2query(4) = \min{\{3,5,2\}} = 2

CM sketch 

\hat{q_i}
qi^\hat{q_i}
q_i
qiq_i

- rzeczywista częstotliwość

- query(i)

q_i \leq \hat{q_i} \leq q_i + \varepsilon n
qi≤qi^≤qi+εnq_i \leq \hat{q_i} \leq q_i + \varepsilon n

100%

1 - \delta
1−δ1 - \delta
q_i
qiq_i
q_i + \varepsilon n
qi+εnq_i + \varepsilon n

CM sketch

  • przedziały
  • iloczyny kartezjańskie
  • kwantyle (percentyle, kwadryle)
  • "gorące" wartości (ang. heavy hitters)

CM sketch - range

query(a,b) = \displaystyle{\sum_{i=a}^b}{query(i)}
query(a,b)=∑i=abquery(i)query(a,b) = \displaystyle{\sum_{i=a}^b}{query(i)}

Słabe, bo błąd się akumuluje dla każdego punktu. Czy można lepiej?

CM sketch - range

s1

s2

s3

s4

CM sketch - range

s1

s2

s3

s4

CM sketch - kwantyle

\phi
ϕ\phi

-kwantyl - wartość dla której 

\phi \cdot n
ϕ⋅n\phi \cdot n

wystąpień w strumieniu jest mniejszych

Skoro wiemy jak zapytać o przedział to czemu by nie wyszukać binarnie tej wartości

dopókióki(przedział (1,k) zawiera za mało / dużo elementów ):
   sprawdź ile elementów jest w przedziale (1,k) i (1,k+1)
   popraw element dzielący

CM sketch - HH

s1

s2

s3

s4

50

8

42

2

6

40

2

0

2

3

3

38

2

0

2

Inne struktury

  • Filtry Blooma  - przynależność elementu do zbioru
  • HyperLogLog - kardynalności multizbioru

Min-copy set

Min-copy set

Klaster obliczeniowy 1000 maszyn, każda po 8 dysków 1TB => 8 PB danych w ramach klastra.

 

Aplikacje działające na klastrze korzystają z HDFS (Hadoop File System)

Redundancja bloku ustawiona na n=3

HDFS

HDFS

Replikacja realizowana jest w sposób losowy - wybierz dwie losowe maszyny dla bloku i wyślij kopie

Grupę Maszyny współdzielących blok nazywamy aktywnym copy-setem 

Gdy wszystkie maszyny z copy-setu są niedostępne, tracimy dostęp do bloków przechowywanych przez niego

Min copy set

To ile właściwie jest tych copy-setów ?

{{1000}\choose{3}} = \frac{1000*999*998}{6} = 166 167 000 \sim 166M
(10003)=1000∗999∗9986=166167000∼166M{{1000}\choose{3}} = \frac{1000*999*998}{6} = 166 167 000 \sim 166M

Ile przypada pojemności na copy-set ?

\frac{8PB}{3 \cdot 150M} = \frac{8GB}{450} = 17777000 \sim 17 MB
8PB3⋅150M=8GB450=17777000∼17MB\frac{8PB}{3 \cdot 150M} = \frac{8GB}{450} = 17777000 \sim 17 MB

Min copy set

Przez losowy wybór maszyn mamy bardzo dużo aktywnych copy-setów.

 

W momencie kiedy padną nam 3 losowe maszyny, jest duża szansa na to iż "trafimy" w jakiś aktywny copy-set.

 

Powoduje to niedostępność danych mimo wysokiego poziomu redundancji

Min copy set

Derandomizacja pomaga w uzyskaniu wyższej dostępności.

 

W przypadku długoterminowym nie ma różnicy pomiędzy podejściami ze względu na dostępność.

 

Jak tylko podejście do problemu może wpływać na dostępność danych.