Beregning av Hamming -avstand i Python

Du lærer hvordan du bestemmer hammingavstanden i Python i denne leksjonen. Hammingavstanden er tilsetningen av alle matchende elementer som varierer mellom vektorer i maskinlæring. Du vil vite hva Hamming -avstand er og hvordan du bruker den på slutten av denne leksjonen, samt hvordan du beregner den ved hjelp av scipy, hvordan du beregner Hamming -avstanden mellom binære pluss numeriske matriser, og hvordan du beregner Hamming -avstanden mellom strengmatriser. Men først, la oss definere hva Hamming -avstanden er.

Hva er Hamming -avstand?

Hamming -avstanden er en statistikk som kan brukes til å sammenligne to binære datastrenger når to binære strenger med samme lengde blir sammenlignet, den beregnede hammingavstanden er antall bitsteder de er forskjellige. Data kan brukes til feildeteksjon samt reparasjon når de sendes over datanettverk. Det brukes også i kodingsteori for å sammenligne datarord med sammenlignbar lengde.

Når du sammenligner forskjellige tekster eller binære vektorer, brukes Hamming -avstanden ofte i maskinlæring. Hammingavstanden, for eksempel, kan brukes til å sammenligne og bestemme hvor forskjellige strengene er. Hammingavstanden brukes også ofte med en-varm kodede data. Binære strenger brukes ofte til å representere en-shot-kodede data (eller bitstrenger). En-varme kodede vektorer er perfekte for å bestemme forskjeller mellom to punkter ved bruk av hammingavstand siden de alltid er av like lengde.

Eksempel 1:

Vi vil bruke Scipy for å beregne Hamming -avstanden i Python gjennom dette eksemplet. For å finne Hamming -avstanden mellom to vektorer, bruk Hamming () -funksjonen i Python Scipy -biblioteket. Denne funksjonen er inkludert i det romlige.Avstandspakke, som også inkluderer andre beregning av nyttige lengder.

For å bestemme Hamming -avstanden mellom to lister med verdier, se først på dem. Importer Scipy -pakken til koden for å beregne Hamming -avstanden. Scipy.romlig.avstand. Hamming () tar val_one og val_two -matriser som inngangsparametere og returnerer Hamming -avstanden %, som deretter multipliseres med matriselengden for å få den faktiske avstanden.

Fra scipy.romlig.avstand import Hamming
val_one = [20, 40, 50, 50]
val_two = [20, 40, 50, 60]
dis = hamming (val_one, val_two)
trykk (dis)

Som du kan se på skjermbildet nedenfor, returnerte funksjonen et resultat av 0.25 i denne situasjonen.

Men hvordan tolker vi dette tallet? Brøkdelen av verdier som er forskjellige returneres av verdien. For å finne antall unike oppføringer i matrisen, multipliser du denne verdien med listelengden:

Fra scipy.romlig.avstand import Hamming
val_one = [20, 40, 50, 50]
val_two = [20, 40, 50, 60]
dis = hamming (val_one, val_two) * len (val_one)
trykk (dis)

Her er resultatet når vi multipliserer den resulterende verdien med lengden på listen.

Eksempel 2:

Nå vil vi forstå hvordan vi kan beregne hammingsavstanden mellom de to heltallvektorene. Anta at vi har to vektorer 'x' og 'y' med verdiene [3,2,5,4,8] og [3,1,4,4,4]. Hammingavstanden kan enkelt beregnes ved hjelp av Python -koden nedenfor. Importer Scipy -pakken for å beregne Hamming -avstanden i den medfølgende koden. Hamming () -funksjonen tar 'X' og 'Y' matriser som inngangsparametere og returnerer Hamming -avstanden %, som multipliseres med matriselengden for å få den faktiske avstanden.

Fra scipy.romlig.avstand import Hamming
x = [4,3,4,3,7]
y = [2,2,3,3,3]
dis = hamming (x, y) * len (x)
trykk (dis)

Følgende er utgangen fra Hamming Distance Python -koden vist ovenfor.

Eksempel 3:

I denne delen av artikkelen lærer du hvordan du beregner Hamming -avstanden mellom La oss si to binære matriser. Hammingavstanden mellom de to binære matriser bestemmes på samme måte som vi har gjort med beregningen av Hamming -avstanden til to numeriske matriser. Det er verdt å merke seg at Hamming -avstanden bare vurderer hvor langt gjenstander er atskilt, ikke hvor langt borte de er. Utforsk følgende eksempel på beregning av hammingsavstanden mellom to binære matriser i Python. Val_one -arrayen inneholder [0,0,1,1,0] og Val_two -matrisen inneholder [1,0,1,1,1] verdier.

Fra scipy.romlig.avstand import Hamming
val_one = [0, 0, 1, 1, 0]
val_two = [1, 0, 1, 1, 1]
dis = hamming (val_one, val_two) * len (val_one)
trykk (dis)

Hammingavstanden er 2 i denne situasjonen siden de første og siste varene er forskjellige, som vist i resultatet nedenfor.

Eksempel 4:

Å beregne forskjellen mellom strenger er en populær anvendelse av hammingavstanden. Fordi metoden forventer arraylignende strukturer, må eventuelle strenger vi ønsker å sammenligne først transformeres med matriser. Listen () -metoden, som gjør en streng til en liste over verdier, kan brukes til å oppnå dette. For å vise hvor forskjellige to strenger er, la oss sammenligne dem. Du kan se at vi har to strenger i koden nedenfor: 'Katalog' og 'Amerika.Følgende blir begge strengene sammenlignet, og resultatet vises.

Fra scipy.romlig.avstand import Hamming
first_str = 'katalog'
Second_str = 'America'
dis = Hamming (list (first_str), liste (andre_str)) * len (first_str)
trykk (dis)

Utfallet av ovennevnte Python -kode er 7.0, som du kan se her.

Du bør alltid huske at matriser må være av samme lengde. Python vil kaste en verdi om vi prøver å sammenligne strengene med ulik lengder. Fordi matriser som følger med bare kan matches hvis de har samme lengde. Se på koden nedenfor.

Fra scipy.romlig.avstand import Hamming
first_str = 'katalog'
Second_str = 'distanse'
dis = Hamming (list (first_str), liste (andre_str)) * len (first_str)
trykk (dis)

Her kaster koden ValueError fordi de to strengene i den gitte koden er forskjellige i lengde.

Konklusjon

Du lærte hvordan du beregner Hamming -avstanden i Python i denne opplæringen. Når to strenger eller matriser blir sammenlignet, brukes Hamming -avstanden for å bestemme hvor mange elementer som er forskjellige parvis. Hamming-avstanden brukes ofte i maskinlæring for å sammenligne strenger og en varm kodede matriser, som du vet. Til slutt lærte du hvordan du kan benytte deg av Scipy -biblioteket for å beregne Hamming -avstanden.