Was ist der Unterschied zwischen HyperLogLog und Count-Min Sketch?

HyperLogLog schätzt die Anzahl eindeutiger Elemente (Kardinalität), Count-Min Sketch die Häufigkeit spezifischer Elemente. HLL verwendet Register mit führenden Nullen, CMS eine Zählertabelle mit Minimum.

Wie viel Speicher verbrauchen diese Strukturen?

HyperLogLog: 1 KB für 1024 Register unabhängig vom Volumen. Count-Min Sketch: 200 KB bei width=10k, depth=5.

Sind Mutexes in der Implementierung erforderlich?

Ja, für asynchronen Zugriff. Im Beispiel sind die Strukturen thread-unsicher, fügen Sie sync.Mutex oder atomare Operationen hinzu.

HyperLogLog und Count-Min Sketch in Go für Big Data

Effiziente probabilistische Datenstrukturen in Go: HyperLogLog und Count-Min Sketch

HyperLogLog schätzt die Anzahl eindeutiger Elemente in einem Datenstrom mit einem Fehler von 1–3 % und verwendet nur 1 KB Speicher. Der Algorithmus hasht die Elemente, analysiert die Anzahl führender Nullen in ihrer binären Darstellung und speichert Statistiken in einem Array von Registern. Dies ermöglicht O(1)-Einfügezeit und O(m) für die Schätzung, wobei m die Anzahl der Register ist (typischerweise 1024).

Schlüsselparameter:

m = 1024 Register (8 Bit pro Register)
b = 8 Bit für die Registerindizierung
Hash-Funktionen: fnv64a mit Bit-Shuffling

package main

import (
	"fmt"
	"hash/fnv"
	"math"
	"math/rand"
	"strconv"
)

const (
	m = 1024 // count registtrov. This osnovnoy parametr, vliyayuschiy on tochnost.
	b = 8  // number bit, ispolzuemykh for opredeleniya indexa register from hash.
)

type HyperLogLog struct {
    // when asynchronous interaction worth think about mutexes
	registers [m]byte
}

func NewHyperLogLog() *HyperLogLog {
	return &HyperLogLog{}
}

// hash returns dva 32-bitnykh numbers from stroki
func hash(s string) (uint32, uint32) {
	h := fnv.New64a()
	h.Write([]byte(s))
	v := h.Sum64()

	// Shuffling bits, so that uluchshit raspredelenie
	w := uint32(v >> 32)
	z := uint32(v)

	// Dobavlyaem peremeshivanie, uluchshaet kachestvo sluchaynosti and pomogaet izbezhat problem with plokhim raspredeleniem hashes
	w ^= z<<13 | z>>(32-13)
	z ^= w<<7 | w>>(32-7)
	w ^= z<<17 | z>>(32-17)

	return w, z
}

// Withchitaet count zeros left in dvoichnoy record numbers,
// if all bits — nuli, vozvraschaetsya 32.
func countLeadingZeros(x uint32) byte {
	for i := 0; i < 32; i++ {
		if (x>>(31-i))&1 == 1 {
			return byte(i)
		}
	}
	return 32
}

// Kheshiruem stroku.
// Beryom chast hash h1, so that define, in kakoy registtr popadyot element.
// By vtoroy chasti h2 schitaem, how many veduschikh zeros (rho), pribavlyaem 1.
// If eto wartość greater, than uzhe est in registtre — update ego.
func (hll *HyperLogLog) Add(s string) {
	h1, h2 := hash(s)

	// opredelyaem index register
	idx := h1 % m

	// vychislyaem wartość for update register
	rho := countLeadingZeros(h2) + 1

	if rho > hll.registers[idx] {
		hll.registers[idx] = rho
	}
}

// Withlozhnye formuly, by essence eta function
// delaet otsenku kolichestva unique elements
func (hll *HyperLogLog) Estimate() float64 {
	sum := 0.0
	for _, val := range hll.registers {
		sum += 1 / math.Pow(2, float64(val))
	}
	estimate := alpha(m) * m * m / sum

	// korrektsiya for malykh znacheniy, usessya metod
	// Linear Counting : than greater nulevykh registtrov — then
	// menshe realnaya kardinalnost.
	if estimate <= 5*m/2 {
		zeros := 0
		for _, val := range hll.registers {
			if val == 0 {
				zeros++
			}
		}
		if zeros != 0 {
			estimate = float64(m) * math.Log(float64(m)/float64(zeros))
		}
	}

	return estimate
}

// alpha — popravochnyy koeffitsient, kompensiruyuschiy systemticheskuyu oshibku
func alpha(m int) float64 {
	switch m {
	case 16:
		return 0.673
	case 32:
		return 0.697
	case 64:
		return 0.709
	default:
		return 0.7213 / (1 + 1.079/float64(m))
	}
}

func main() {
	// Withzdayom HLL.
	hll := NewHyperLogLog()

	seen := make(map[string]struct{})
	for i := 0; i < 1_000_000; i++ {
		key := strconv.Itoa(rand.Intn(1_000_000))
		seen[key] = struct{}{}
		hll.Add(key)
	}

  	nonZero := 0
	for _, r := range hll.registers {
		if r > 0 {
			nonZero++
		}
	}
  
	fmt.Printf("Realnoe count unique elements: %d\n", len(seen))
	fmt.Printf("Otsenka unique elements: %.2f\n", hll.Estimate())
	fmt.Printf("Zapolnennykh registtrov: %d/%d\n", nonZero, m)
}

Für 1 Million eindeutige Elemente betrug der relative Fehler 0,84 %, bei 100 % gefüllten Registern. Speicher: 1 KB.

Count-Min Sketch für Häufigkeitszählung

Count-Min Sketch schätzt die Häufigkeiten von Elementen in einem Strom mithilfe einer 2D-Tabelle von Zählern (Tiefe × Breite). Jede Zeile verwendet eine separate Hash-Funktion mit Salt. Beim Einfügen inkrementiert das Element die Zähler in allen Zeilen; bei der Abfrage wird der Minimalwert genommen – das minimiert Kollisionseffekte.

Implementierungsparameter:

Breite = 10.000 Spalten
Tiefe = 5 Zeilen
Hash: fnv64a mit Seed-Shuffling

Abfragemethoden:

Minimum – basisch, genau für positive Updates
Mittelwert – robust gegenüber Löschungen
Count-mean-min – korrigiert Bias

package main

import (
    "fmt"
    "hash/fnv"
    "math"
)

type CountMinSketch struct {
    width  int
    depth  int
    // when asynchronous interaction worth think about mutexes
    table  [][]int
    hashes []uint64
}

func NewCountMinSketch(width, depth int) *CountMinSketch {
    return &CountMinSketch{
        width:  width,
        depth:  depth,
        table:  make([][]int, depth),
        hashes: make([]uint64, depth),
    }
}

func (cms *CountMinSketch) Init() {
    for i := range cms.table {
        cms.table[i] = make([]int, cms.width)
        cms.hashes[i] = uint64(i+1) // prostye soli for raznykh hashes
    }
}

// getHashIndex generiruet khesh and returns index in table
func (cms *CountMinSketch) getHashIndex(s string, seed uint64) int {
    h := fnv.New64a()
    h.Write([]byte(s))
    v := h.Sum64()

    // Shuffling bits with seed
    mixed := v ^ seed ^ (seed << 32)

    return int(mixed % uint64(cms.width))
}

// Add uvelichivaet schetchik for element
func (cms *CountMinSketch) Add(s string, count int) {
    for i := 0; i < cms.depth; i++ {
        idx := cms.getHashIndex(s, cms.hashes[i])
        cms.table[i][idx] += count
    }
}

// Count returns otsenochnoe number vkhozhdeniy element
func (cms *CountMinSketch) Count(s string) int {
    min := math.MaxInt32
    for i := 0; i < cms.depth; i++ {
        idx := cms.getHashIndex(s, cms.hashes[i])
        if cms.table[i][idx] < min {
            min = cms.table[i][idx]
        }
    }
    return min
}

func main() {
    width := 10_000
    depth := 5

    cms := NewCountMinSketch(width, depth)
    cms.Init()

    seen := make(map[string]int)
	for i := 0; i < 5_000_000; i++ {
		key := fmt.Sprintf("item-%d", i%1100)
		seen[key]++
		cms.Add(key, 1)
	}

  
    // vyvodim frequency
    for _, word := range []string{"item-1", "item-0", "item-1000", "item--1"} {
        fmt.Printf("Withglasno cms slovo '%s' meetingsaetsya primerno %d raz\t By faktu: %d\n", word, cms.Count(word), seen[word])
    }
}

Für 5 Millionen Einfügungen: Speicher 200 KB. Operationen sind O(Tiefe) für Einfügen und Abfrage.

Vergleich der Datenstrukturen

| Eigenschaft | HyperLogLog | Count-Min Sketch |

|---------------|-------------|------------------|

| Aufgabe | Kardinalität | Häufigkeit |

| Speicher | O(log(log N)) | O(d×w) |

| Fehler | 1–3 % | Abhängig von d,w |

| Einfügen | O(1) | O(Tiefe) |

| Abfrage | O(m) | O(Tiefe) |

Wichtige Punkte:

Beide Strukturen eignen sich für das Streaming-Verarbeiten von Millionen Elementen
HyperLogLog verwendet festen Speicher unabhängig vom Datenvolumen
Count-Min Sketch überschätzt Häufigkeiten aufgrund von Kollisionen, liefert aber Punktabfragen
Für verteilte Systeme Mutexe hinzufügen oder atomare Operationen verwenden
Mit realen Daten testen: Fehler hängt von der Hash-Verteilung ab

— Editorial Team