O documento discute estruturas de dados probabilísticas para lidar com grandes volumes de dados, como Bloom Filters, Hit Counting e HyperLogLog. Essas estruturas permitem estimar cardinalidades de forma eficiente em termos de espaço e tempo.

1. Estruturas de Dados
Probabilísticas para lidar com
DADO PRA CARAMBA
Juan Lopes
@juanplopes

3. Bloom Filters (1970)
Hit Counting (1990)
HyperLogLog (2007)

4. Detectar duplicações
indexar(documento):
se documento não está indexado:
lucene.indexar(documento)

5. Detectar duplicações
indexar(documento):
se documento não está indexado:
lucene.indexar(documento)

6. Consultar no disco?

7. Consultar no disco?

8. Consultar em memória?
HashSet<T>

9. Consultar em memória?
100M ids

10. Consultar em memória?
100M ids × 32 chars / id

11. Consultar em memória?
100M ids × 104 bytes / id
> 10GB

12. Consultar em memória?
100M ids × 104 bytes / id
> 10GB

13. Bloom Filters
I had a big data problem,
"I know, I'll use a bloom filter."
Now I'm not sure how many
problems I have, but I know
which ones I don't.

14. Bloom Filters
Adicione!(item)
Contém?(item)

15. Bloom Filters
Contém?(item)
não 100%
sim ~95%

16. Bloom Filters
0
x
h(x)
0
1
0
0
0
0
0

17. Bloom Filters
1
x
h(x)
0
1
h(y)
0
y
0
0
0
0

18. Bloom Filters
1
x
h(x)
0
1
h(y)
0
y
0
0
h(z)
z 0
0

19. Bloom Filters
adicionar!(item):
V[hash(item)] ← 1
contém?(item):
retorne V[hash(item)] = 1

20. Bloom Filters
100M itens
2Gbits (256MB)
5% de erro

21. Bloom Filters
g(x) 1
x
h(x)
0
h(y) 1
0
y
g(y)
0
h(z) 1
z g(z) 0
1

22. Bloom Filters
adicionar!(item):
para cada hash em hashes:
V[hash(item)] ← 1
contém?(item):
para cada hash em hashes:
se V[hash(item)] = 0:
retorne falso
retorne verdadeiro

23. Bloom Filters
100M itens
4 funções de hash
625Mbits (78MB)
5% de erro

24. Bloom Filters
100M itens
5 funções de hash
1Gbit (128MB)
1% de erro

25. Bloom Filters
100M itens
7 funções de hash
2Gbit (256MB)
0.01% de erro

26. Bloom Filters
Probabilidade de falso
positivo:

27. Cardinalidade
Quantos ips distintos
acessaram o site na
última hora?

28. Cardinalidade
Qual a cardinalidade do
stream S?

29. Consultar em memória?
HashSet<T>

30. Usando HashSet
adicionar!(item):
S ← S ∪ { item }
quantos?:
retorne |S|

31. Consultar em memória?
>10K eventos/s

32. Consultar em memória?
> 10K eventos/s × 3.600s/h
× 100 bytes / evento
> 3GB/h

33. Consultar em memória?
> 10K eventos/s × 3.600s/h
× 100 bytes / evento
> 3GB/h

34. Hit Counting
n/10 bits
-c log (z/c) 2% de erro

35. Hit Counting
n/10 bits
-c log (z/c) 2% de erro
36M eventos
3.6Mbits
450KB

36. Hit Counting
adicionar!(item):
V[hash(item)] ← 1
quantos?:
z ← número de zeros em V
c ← tamanho de V
retorne -c × log(z/c)

37. HyperLogLog
Contar até 1 bilhão
de elementos
usando 1.5KB

39. Hash
"To hash" é
"espalhar"

40. Hash
04 = 00000100
08 = 00001000
12 = 00001100
16 = 00010000

41. Hash
It is theoretically impossible to define a
hash function that creates random
data from non-random data in actual
files. But in practice it is not difficult to
produce a pretty good imitation of
random data.
Donald Knuth

42. HyperLogLog
Qual a
probabilidade dos n
primeiros bits
serem 0...01?

43. HyperLogLog
1xxxxxxx -> 50%
01xxxxxx -> 25%
001xxxxx -> 12.5%
0001xxxx -> 6.25%

44. HyperLogLog
Dado que existe uma
palavra com os n
primeiros bits
0...01, qual a
cardinalidade provável?

45. HyperLogLog
1xxxxxxx -> 2
01xxxxxx -> 4
001xxxxx -> 8
0001xxxx -> 16

46. HyperLogLog
Multiplas funções de
hash?

47. HyperLogLog
Dividir o stream em
"m" substreams

48. HyperLogLog
01100010
i=3 v=4
0 0 0 4 0 0 0 0
0 1 2 3 4 5 6 7

49. HyperLogLog
21 22 20 24 20 25 20 20
1 2 0 4 0 5 0 0
0 1 2 3 4 5 6 7

50. HyperLogLog
2 4 1 16 1 32 1 1
1 2 0 4 0 5 0 0
0 1 2 3 4 5 6 7

51. HyperLogLog
M(i)
2 , i<m

52. HyperLogLog
M(i)
Ê = média(2 , i<m)

53. HyperLogLog
M(i)
Ê = m × média(2 , i<m)

54. HyperLogLog
Ê = αm × m × média(2M(i), i<m)
α m=

55. HyperLogLog
Ê = αm × m × média(2M(i), i<m)
α m=
αm= (0.7213 / (1 + 1.079 / m))

56. HyperLogLog
adicionar!(item):
x ← hash(item)
i ← log2m primeiros bits de x
v ← pos. do primeiro 1 nos bits restantes de x
M(i) ← max(M(i), v)
quantos?:
retorne αm × m × média(2M(i), i<m)

57. HyperLogLog
média aritmética:
(M(0) + M(1) + ... + M(m-1)) / m
média geométrica:
(M(0) × M(1) × ... × M(m-1))1/m
média harmônica:
m / (M(0)-1 + M(1)-1 + ... + M(m-1)-1)

58. HyperLogLog
Cada registro de M tem 5 bits.
Por isso "LogLog":
32
log2(log2(2 )) = 5
Registradores Erro
m (104/√m) %
m = 2048 (1.25KB) 2.3%
m = 65536 (40KB) 0.4%
m = 1048576 (648KB) 0.1%

59. HyperLogLog
Para baixas
cardinalidades, o erro
relativo aumenta.

60. HyperLogLog
quantos?:
Ê ← αm × m × média(2M(i), i<m)
se Ê < 2.5 × m:
z ← número de zeros em M
retorne -m × log(z/m)
senão:
retorne Ê

61. HyperLogLog
1 2 2 4 0 5 0 0
0 1 2 3 4 5 6 7
5 0 1 0 5 2 3 1
0 1 2 3 4 5 6 7

62. HyperLogLog
1 2 2 4 0 5 0 0
0 1 2 3 4 5 6 7
5 0 1 0 5 2 3 1
0 1 2 3 4 5 6 7
5 2 2 4 5 5 3 1
0 1 2 3 4 5 6 7

63. Referências
Space/Time Trade-offs in Hash Coding with Allowable Errors (Bloom Filters)
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.20.2080
A Linear-Time Probabilistic Counting Algorithm for Database Applications
http://dblab.kaist.ac.kr/Publication/pdf/ACM90_TODS_v15n2.pdf
HyperLogLog: the analysis of a near-optimal cardinality estimation algorithm
http://algo.inria.fr/flajolet/Publications/FlFuGaMe07.pdf
Hashing Explained - Google Guava
http://code.google.com/p/guava-libraries/wiki/HashingExplained
StreamLib
https://github.com/clearspring/stream-lib