Numpy Array -multiplikasjon

Numpy er biblioteket til Python som gir oss et bredt spekter av metoder for å utføre forskjellige matematiske beregninger på matriser. Når det gjelder multiplikasjon av en matrise, er det enkelt å multiplisere 2 × 2, 3 × 3, eller opptil 5 × 5. Men når det overstiger størrelsen 5 × 5, kan det være en vanskelig og tid å ta oppgave å multiplisere dem manuelt. Men numpy innebygde funksjoner gjorde det enkelt for oss å utføre multiplikasjon på store matriser. Matriksmultiplikasjon er den der to matriser multipliseres og gir en enkelt matrise som et resultat. Det er tre metoder levert av Numpy for å multiplisere matriser.

Det er tre metoder for å utføre array -multiplikasjonen. Disse er som følger:

Prikkproduktet av matriser

Dot -produktet er også kjent som Scalar -produktet. I denne typen multiplikasjon multipliseres en konstant heltallverdi med matrisen, eller to matriser av de samme dimensjonene multipliseres. I en skalærmatrise spiller ingen rolle når som helst når en konstant multipliseres fordi vi bare multipliserer den konstante verdien med hver matriseverdi.

Syntaks

Følgende syntaks brukes til å beregne prikkproduktet til matrisen:

np.DOT (CONSTANT_VALUE, Array)

Her blir to argumenter bestått først - det ene er det konstante tallet og den andre er matrisen som skal multipliseres. En ting til å huske er at denne rekkefølgen av argumentene som er gitt, ikke betyr noe. Vi kan passere matrisen først, og den andre kan være de konstante verdiene, det samme som i tilfelle av array multiplikasjon.

np.DOT (array_a, array_b)

Her blir to argumenter bestått: dette er matriser.

Eksempel 1

La oss utføre et eksempel for å forstå det skalære produktet dypt. I dette eksemplet vil vi multiplisere en matrise med konstant verdi. Importer først Numpy-biblioteket når vi bruker den innebygde funksjonen som leveres av Numpy Library. Deretter erklærer vi en variabel som inneholder verdien som skal multipliseres med matrisvariabelen “cons_val” som har verdi “2” og en matrise som holder 2 × 2 -matrisen som har verdier på “3”, “6”, “5 ”Og“ 2 ”.

Etter å ha erklært vår konstante variabel og matrise, erklærer vi en annen variabel som heter “Resultat_arr” som inneholder prikkproduktet til matrisen. Vi passerer NP.dot () -funksjon som er ansvarlig for å beregne prikkproduktet med to argumenter: vår matrise og konstant verdi.

Importer numpy som NP
cons_val = 2
arr = [[3, 6], [5, 2]]
reslting_arr = np.DOT (Cons_Val, ARR)
Print ("Original Array:", ARR)
Print ("Scalar Product of Array ARR er:", reslting_arr)

Til slutt, ved hjelp av PRINT () -uttalelsen, skriver vi ut begge matriser - den originale matrisen og den resulterende matrisen som er prikkproduktet til det originale. Utgangen fra koden vår vises i følgende prøve etter at den er utført:

Eksempel 2

I forrige eksempel multipliserte vi den konstante verdien med en matrise ved hjelp av NP.dot () funksjon. Skalær multiplikasjon kan også utføres på to matriser. La oss utføre dette eksemplet for å forstå arbeidet med prikkprodukter på forskjellige matriser. For det første, import av vårt numpy bibliotek med hell, erklærer vi to matriser av samme størrelse som er: array_a hvis verdier er “3” og “6” og array_b som har verdier på “12” og “4”. Deretter erklærer vi en annen variabel som vi tildeler NP.dot () -funksjon som inneholder to argumenter som er våre matriser som skal multipliseres. Vis deretter begge originale matriser ved hjelp av utskriftsuttalelsene.

Følgende utdrag er utdataene fra koden som vi utførte. Det resulterende skalare produktet av matriser er “60”.

Matriseprodukt av matriser

Matriksproduktet fra matrisen gjør at vi kan multiplisere to matriser som vi gjør matematisk. I denne typen multiplikasjoner tar vi en rad fra den første matrisen og en kolonne fra den andre. "R1" -rekken i den første matrisen multipliseres med "C1" -kolonnen i den andre matrisen, og deretter legger vi dem til å få produktet. I denne typen multiplikasjoner må radene i den første matrisen være lik kolonnen i den andre matrisen.

Syntaks

np.Matmul (Array1, Array2)

Matmul () er den innebygde funksjonen levert av Numpy-biblioteket for å beregne Matrix-multiplikasjonen ved ganske enkelt å sende dem matriser som skal multipliseres. I forrige syntaks er Array1 og Array2 matriser som vi vil multiplisere.

Eksempel 1

For å forstå bruken av matmul () -funksjonen mer kort, la oss implementere et eksempel. Når vi har importert vårt Numpy -bibliotek, erklærer vi to matriser - “Arr_a” og “Arr_b”. Firt -arrayen, "arr_a", inneholder verdiene “3”, “6”, “5” og “2”, mens “ARR_B” inneholder “12”, “4”, “6” og “1”. Nå som vi flytter til neste trinn hvor vi erklærer en annen variabel som er ansvarlig for å holde resultatet av multiplikasjonen av matriser til variabelen som heter “RESLING_ARR”, passerer vi Matmul () -funksjonen med matriser som argumenter. Til slutt skriver vi ut de originale matriser og produktet av matriser som vi beregnet ved hjelp av Matmul () -funksjonen.

Importer numpy som NP
arr_a = np.Array ([[3, 6], [5, 2]])
arr_b = np.Array ([[12, 4], [6, 1]])
reslting_arr = np.MATMUL (ARR_A, ARR_B)
Print ("Original Array A:", arr_a)
Print ("Original Array B:", ARR_B)
Print ("Matrix Product of Array ARR er:", reslting_arr)

Hvordan det fungerer

I dette tilfellet multipliseres ARR_A (0,0) med ARR_B (0,0) og legges til produktet fra ARR_A (0,1) og ARR_B (1,0) for å få reslting_arr (0,0) elementet i den resulterende matrisen. Det samme gjøres for de neste elementene som tilsvarer hverandre.

Vi beregnet produktet av begge matriser som sett i følgende figur:

Elementmessig multiplikasjon

Begge matriser må ha de samme dimensjonene som 2 × 2, 3 × 3, og så videre. Elementsmessig multiplikasjon utføres ved hjelp av den numpy innebygde funksjonen som er NP.multiplisere().

Syntaks

np.Multipliser (Array1, Array2)

Eksempel 1

For å forklare begrepet elementmessig multiplikasjon, har vi et eksempel for å få en bedre forståelse. La oss først inkludere vårt numpy bibliotek som NP. Etter det initialiserer vi to variabler som inneholder den opprinnelige matrisen som vi kommer til å multiplisere. Array1 holder verdiene “5”, “1”, “6” og “2”, mens Array2 inneholder verdiene “3”, “3”, “4” og “2”. Nå lager vi en annen variabel som inneholder det resulterende utvalget av multiplikasjon som vi passerer begge matriser som argumenter til vår NP.Multiply () -funksjonen som er ansvarlig for å beregne det elementsmessige produktet.

Hvordan det fungerer

ARR_A (0,0) multipliseres med matrisen ARR_B (0, 0). Mens arr_a (0,1) multipliseres med ARR_B (0,1), og så videre. Resultatet lagres i det resulterende utvalget som vi erklærte som resulterende_arr som vi tildelte NP.Multiply () -funksjonen med to parametere som er våre originale matriser.

Importer numpy som NP
Array1 = NP.Array ([[5, 1], [6, 2]])
Array2 = NP.Array ([[3, 3], [4, 2]])
array_result = np.Multipliser (Array1, Array2)
Print ("Original Array1:", Array1)
Print ("Original Array2:", Array2)
PRINT ("Element Wise Product of Array Array er:", Array_Result)

Til slutt skriver vi ganske enkelt ut begge matriser og den resulterende matrisen ved hjelp av setningen (). Når det gjelder utførelsen, viser følgende utdrag utdataene fra koden vår:

Konklusjon

I denne artikkelen diskuterte vi om Numpy Matrix -multiplikasjonen ved hjelp av forskjellige Numpy -funksjoner. Vi prøvde vårt beste for å utdype de forskjellige metodene for å beregne produktet av matriser. Numpy gjør oss i stand til å utføre forskjellige beregninger på matriser ved hjelp av de enkle innebygde metodene. Når det gjelder et stort antall matriksmultiplikasjoner, kan det holdes ved bare å bruke de forklarte funksjonene. Vi trenger ikke å beregne dem manuelt.