Twiittaa Jaa Jaa

Viimeisin päivitetty 9. elokuuta 2019

Monia monimutkaisia matriisioperaatioita ei voida ratkaista tehokkaasti tai vakaasti tietokoneiden rajallisella tarkkuudella.

Matriisin hajotukset ovat menetelmiä, joiden avulla matriisi voidaan pelkistää osiin, jotka helpottavat monimutkaisempien matriisioperaatioiden laskemista. Matriisien hajotusmenetelmät, joita kutsutaan myös matriisifaktorointimenetelmiksi, ovat tietokoneiden lineaarialgebran perusta jopa perusoperaatioissa, kuten lineaaristen yhtälösysteemien ratkaisemisessa, käänteisluvun laskemisessa ja matriisin determinantin laskemisessa.

Tässä opetusohjelmassa tutustut matriisipurkuihin ja niiden laskemiseen Pythonissa.

Tämän opetusohjelman jälkeen tiedät:

  • Mitä matriisipurku on ja miksi tällaiset operaatiot ovat tärkeitä.
  • Kuinka lasketaan LU- jaQR-matriisipoistot Pythonissa.
  • Kuinka lasketaan Cholesky-matriisipoistot Pythonissa.

Käynnistä projektisi uudella kirjallani Linear Algebra for Machine Learning, joka sisältää vaiheittaiset opetusohjelmat ja Python-lähdekooditiedostot kaikille esimerkeille.

Lähdetään liikkeelle.

  • Päivitys maaliskuu 2018: Korjattu pieni kirjoitusvirhe QR-dekomposition kuvauksessa.
  • Päivitys heinäkuu/2019: Korjattu pieni kirjoitusvirhe positiivisesti definiittisten matriisien kuvauksessa.
A Gentle Introduction to Matrix Decompositions for Machine Learning

A Gentle Introduction to Matrix Decompositions for Machine Learning
Kuvan on ottanut mickey, jotkin oikeudet pidätetään.

Oppikirjan yleiskatsaus

Tämä opetusohjelma on jaettu neljään osaan; ne ovat:

  1. Mikä on matriisipurku?
  2. LU-matriisin purku
  3. QR-matriisin purku
  4. Cholesky-matriisin purku

Need help with Linear Algebra for Machine Learning?

Osta nyt ilmainen 7 päivän sähköpostin pikakurssini (esimerkkikoodilla).

Klikkaa ilmoittautuaksesi ja saat myös ilmaisen PDF-kirjaversion kurssista.

Lataa itsellesi ILMAINEN minikurssi

Mikä on matriisien dekompositio?

Matriisien dekompositiossa matriisi pelkistetään sen osiin.

Se on lähestymistapa, jolla voidaan yksinkertaistaa monimutkaisempia matriisioperaatioita, jotka voidaan suorittaa hajotetulle matriisille eikä alkuperäiselle matriisille itselleen.

Yleinen analogia matriisin hajotukselle on lukujen faktorointi, kuten 10:n faktorointi 2 x 5:ksi. Tästä syystä matriisin hajotusta kutsutaan myös matriisifaktoroinniksi. Kuten reaalilukujen faktoroinnissa, myös matriisin hajottamiseen on monia tapoja, joten on olemassa useita erilaisia matriisien hajotustekniikoita.

Kaksi yksinkertaista ja laajalti käytettyä matriisien hajotusmenetelmää ovat LU-matriisien hajotus ja QR-matriisien hajotus.

Seuraavaksi tarkastelemme tarkemmin kumpaakin näistä menetelmistä.

LU-matriisipurku

LU-matriisipurku on tarkoitettu neliömatriiseille, ja se purkaa matriisin L- ja U-komponentteihin.

1
A = L . U

Vai ilman pisteen merkintää.

1
A = LU

Jossa A on neliömatriisi, joka halutaan hajottaa, L on alempi kolmiomatriisi ja U on ylempi kolmiomatriisi.

Tekijät L ja U ovat kolmiomatriiseja. Eliminaation tuloksena saatava faktorisaatio on A = LU.

– Page 97, Introduction to Linear Algebra, Fifth Edition, 2016.

LU-dekompositio löydetään iteratiivisen numeerisen prosessin avulla, ja se voi epäonnistua niiden matriisien kohdalla, joita ei voida purkaa tai purkaa helposti.

Tämän hajotuksen muunnosta, joka on numeerisesti vakaampi ratkaista käytännössä, kutsutaan LUP-hajotukseksi eli LU-hajotukseksi osittaisella pivotoinnilla.

1
1
 >
A = P . L . U

Vanhemman matriisin rivit järjestetään uudelleen dekompositioprosessin yksinkertaistamiseksi, ja ylimääräinen P-matriisi määrittää tavan, jolla tulos permuteoidaan tai palautetaan alkuperäiseen järjestykseen. LU:sta on myös muita variaatioita.

LU-dekompositio on usein käytössä lineaaristen yhtälösysteemien ratkaisemisen yksinkertaistamisessa, kuten lineaarisen regression kertoimien löytämisessä, sekä matriisin determinantin ja käänteisluvun laskemisessa.

LU-dekompositio voidaan toteuttaa Pythonissa lu()-funktiolla. Tarkemmin sanottuna tämä funktio laskee LPU-dekomposition.

Alla olevassa esimerkissä määritellään ensin 3×3-neliömatriisi. Lasketaan LU-dekompositio, minkä jälkeen alkuperäinen matriisi rekonstruoidaan komponenteista.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# LU-dekompositio
from numpy import array
from scipy.linalg import lu
# määrittele neliömatriisi
A = array(, , ])
print(A)
# LU-dekompositio
P, L, U = lu(A)
print(P)
print(L)
print(U)
# reconstruct
B = P.dot(L).dot(U)
print(B)

Esimerkin suorittaminen tulostaa ensin määritellyn 3×3-matriisin, sitten hajotuksen P-, L- ja U-komponentit ja lopuksi alkuperäisen matriisin rekonstruoinnin.

1
2
3
4
5
6
7
8
]
]
]
]
]

QR-matriisipurku

QR-purku on m x n-matriiseille (ei rajoitu neliömatriiseihin) ja se purkaa matriisin Q- ja R-komponentteihin.

1
A = Q . R

Vai ilman pistemerkintää.

1
A = QR

Jossa A on matriisi, jonka haluamme hajottaa, Q matriisi, jonka koko on m x m, ja R on yläkolmiomatriisi, jonka koko on m x n.

QR-dekompositio löydetään käyttämällä iteratiivista numeerista menetelmää, joka voi epäonnistua niiden matriisien kohdalla, joita ei voida purkaa tai purkaa helposti.

Kuten LU-dekompositio, myös QR-dekompositio käytetään usein lineaaristen yhtälösysteemien ratkaisemiseen, vaikkakaan se ei rajoitu vain neliömatriiseihin.

QR-dekompositio voidaan toteuttaa NumPy:ssä funktiolla qr(). Oletusarvoisesti funktio palauttaa Q- ja R-matriisit pienemmillä tai ”pelkistetyillä” ulottuvuuksilla, mikä on taloudellisempaa. Voimme muuttaa tämän palauttamaan Q:lle odotetut koot m x m ja R:lle m x n määrittelemällä moodi-argumentiksi ’complete’, vaikka tätä ei useimmissa sovelluksissa tarvita.

Oheinen esimerkki määrittelee 3×2-matriisin, laskee QR-dekomposition ja rekonstruoi sitten alkuperäisen matriisin dekomposoitujen alkioiden avulla.

1
2
3
4
5
6
7
8
9
10
11
12
13
# QR decomposition
from numpy import array
from numpy.linalg import qr
# define a 3×2 matrix
A = array(, , ])
print(A)
# QR decomposition
Q, R = qr(A, ’complete’)
print(Q)
print(R)
# reconstruct
B = Q.dot(R)
print(B)

Esimerkin suorittaminen tulostaa ensin määritellyn 3×2-matriisin, sitten Q:n ja R:n alkiot ja lopuksi rekonstruoidun matriisin, joka vastaa sitä, millä aloitimme.

1
2
3
4
5
6
]
]
]
]

Cholesky-dekompositio

Cholesky-dekompositio on tarkoitettu neliösymmetrisille matriiseille, joissa kaikki ominaisarvot ovat suurempia kuin nolla, niin sanottuja positiivisesti definiittisiä matriiseja.

Koneoppimiseen liittyvien intressiemme vuoksi keskitymme Choleskyn hajotukseen reaaliarvoisille matriiseille ja jätämme huomiotta tapaukset, joissa työskennellään kompleksilukujen kanssa.

Dekompositio määritellään seuraavasti:

1
A = L . L^T

Vai ilman pistemerkintää:

1
A = LL^T

Jossa A on purettava matriisi, L on alempi kolmiomatriisi ja L^T on L:n transponointi.

Dekompositio voidaan kirjoittaa myös ylemmän kolmiomatriisin tulona, esimerkiksi:

1
A = U^T . U

Jossa U on ylempi kolmiomatriisi.

Choleskyn hajotusta käytetään lineaarisen pienimmän neliösumman ratkaisemiseen lineaarista regressiota varten sekä simulointi- ja optimointimenetelmissä.

Symmetrisiä matriiseja hajotettaessa Cholesky-dekompositio on lähes kaksi kertaa tehokkaampi kuin LU-dekompositio, ja sitä tulisi suosia näissä tapauksissa.

Symmetriset, positiivisesti definiittiset matriisit ovat melko erikoisia, mutta ne esiintyvät melko usein joissakin sovelluksissa, joten niiden erityinen faktorisointi, jota kutsutaan nimellä Cholesky-dekompositio, on hyvä tuntea. Kun sitä voi käyttää, Choleskyn hajotus on noin kaksi kertaa nopeampi kuin vaihtoehtoiset menetelmät lineaaristen yhtälöiden ratkaisemiseksi.

– Sivu 100, Numeeriset reseptit: The Art of Scientific Computing, Third Edition, 2007.

Choleskyn hajotus voidaan toteuttaa NumPy:ssä kutsumalla funktiota cholesky(). Funktio palauttaa vain L:n, koska voimme helposti käyttää L:n transpoosia tarpeen mukaan.

Alla olevassa esimerkissä määritellään 3×3 symmetrinen ja positiivisesti definiittinen matriisi ja lasketaan Cholesky-dekompositio, minkä jälkeen alkuperäinen matriisi rekonstruoidaan.

1
2
3
4
5
6
7
8
9
10
11
12
# Choleskyn hajotus
from numpy import array
from numpy.linalg import cholesky
# define a 3×3 matrix
A = array(, , ])
print(A)
# Cholesky decomposition
L = cholesky(A)
print(L)
# reconstruct
B = L.dot(L.T)
print(B)

Esimerkin suorittaminen tulostaa ensin symmetrisen matriisin, sitten alemman kolmion matriisin dekompositiosta ja sen jälkeen rekonstruoidun matriisin.

1
2
3
]
]
]

Laajennukset

Tässä osiossa on lueteltu joitakin ideoita opetusohjelman laajentamiseksi, joita voit halutessasi tutkia.

  • Luo 5 esimerkkiä käyttäen kutakin operaatiota omilla tiedoillasi.
  • Hae koneoppimisen artikkeleita ja löydä 1 esimerkki, jossa kutakin operaatiota käytetään.

Jos tutkit jotakin näistä laajennuksista, otan mielelläni yhteyttä.

Lisälukemista

Tässä osiossa on lisää resursseja aiheesta, jos haluat syventyä aiheeseen.

Kirjat

  • Luku 6.6 Matriisien hajotukset. No Bullshit Guide To Linear Algebra, 2017.
  • Lecture 7 QR Factorization, Numerical Linear Algebra, 1997.
  • Section 2.3 LU Decomposition and Its Applications, Numerical Recipes: The Art of Scientific Computing, Third Edition, 2007.
  • Luku 2.10 QR Decomposition, Numerical Recipes: The Art of Scientific Computing, Third Edition, 2007.
  • Luku 2.9 Cholesky Decomposition, Numerical Recipes: The Art of Scientific Computing, Third Edition, 2007.
  • Lecture 23, Cholesky Decomposition, Numerical Linear Algebra, 1997.

API

  • scipy.linalg.lu() API
  • numpy.linalg.qr() API
  • numpy.linalg.cholesky() API

Artikkelit

  • Matriisin hajotus Wikipediassa
  • LU hajotus Wikipediassa
  • QR hajotus Wikipediassa
  • Cholesky hajotus Wikipediassa

Yhteenveto

Tämässä ohjeessa, tutustuit matriisien dekompositioihin ja niiden laskemiseen Pythonilla.

Kohtaisesti opit:

  • Mitä matriisipurku on ja miksi tämäntyyppiset operaatiot ovat tärkeitä.
  • Miten lasketaan LU- jaQR-matriisipurku Pythonissa.
  • Miten lasketaan Cholesky-matriisipurku Pythonissa.

Onko sinulla kysymyksiä?
Kysy kysymyksesi alla olevissa kommenteissa ja teen parhaani vastatakseni.

Ota haltuun lineaarialgebra koneoppimista varten!

Lineaarialgebraa koneoppimista varten

Kehitä lineaarialgebran toimiva ymmärrys

….kirjoittamalla rivejä koodia pythonissa

Tutustu siihen uudessa Ebookissani:
Linear Algebra for Machine Learning

Se tarjoaa itseopiskeluoppaita muun muassa seuraavista aiheista:
Vektorinormit, matriisien monistaminen, tensorit, Eigendekompositio, SVD, PCA ja paljon muuta…

Ymmärrä vihdoinkin datan matemaattiset periaatteet

Läpäise akateemiset opinnot. Just Results.

See What’s Inside

Tweet Share Share Share

By: adminPosted on

Vastaa

Sähköpostiosoitettasi ei julkaista.