Last chance! 50% off DataCamp Premium
Sale ends in
Data science is een interdisciplinair vakgebied dat wiskunde en geavanceerde statistiek gebruikt om voorspellingen te doen. Alle data‑science‑algoritmen gebruiken direct of indirect wiskundige concepten. Een solide begrip van wiskunde helpt je innovatieve data‑science‑oplossingen te bouwen, zoals een aanbevelingssysteem. Als je goed bent in wiskunde, maakt dat je overstap naar data science makkelijker. Als data scientist gebruik je de fundamentele wiskundige concepten om problemen op te lossen.
Naast wiskunde heb je ook domeinkennis, programmeervaardigheden, zakelijke vaardigheden, analytische vaardigheden en een nieuwsgierige mindset nodig. Als data scientist kun je niet om wiskunde heen. Je moet jezelf de basis van wiskunde en statistiek eigen maken om data scientist te worden.
Scalair en vector
- Scalair: Een scalair is een enkel getal dat met een vector in de ruimte werkt via scalaire vermenigvuldiging.
- Vectoren: Een vector V is een geordende verzameling items. Een vector is een array van getallen en kan een rij of kolom zijn. Vectoren kunnen bij elkaar worden opgeteld en kunnen worden vermenigvuldigd met een reëel getal dat een scalair wordt genoemd.
# Import numpy module
import numpy as np
# creating a vector
v = np.array([1, 2, 3, 4, 5])
print(v)
[1 2 3 4 5]
# Vector Operations
# Import numpy module
import numpy as np
# Create two vector
a = np.array([1, 2, 3, 4, 5])
b = np.array([1, 2, 3, 4, 5])
# adding two vectors
add = a + b
print("Addition:",add)
# Vector Subtraction
sub = a - b
print("Subtraction:",sub)
# Vector Multiplication
mul = a * b
print("Multiplication:",mul)
# Vector Division
div = a / b
print("division",div)
Addition: [ 2 4 6 8 10]
Subtraction: [0 0 0 0 0]
Multiplication: [ 1 4 9 16 25]
division [1. 1. 1. 1. 1.]
Matrix en tensor
- Matrixen: Een matrix is een N‑dimensionale array van getallen die transformaties voorstelt. Je kunt een matrix zien als een transformatie zoals "schalen", "roteren", "schuiven" en "spiegelen". Een matrix zet punten in de ruimte om in andere punten in de ruimte.
# Import numpy module
import numpy as np
# create 2*2 matrix
a1=np.array([[1, 2], [3, 4]])
a2=np.array([[1, 2], [3, 4]])
# Dot Product
dot_product = np.dot(a1,a2)
print("Dot Product: \n",dot_product)
# Cross Product
cross_product = np.cross(a1,a2)
print("Cross Product: \n", cross_product)
Dot Product:
[[ 7 10]
[15 22]]
Cross Product:
[0 0]
Het inproduct van twee vectoren stelt de projectie van de ene vector op de andere vector voor, en het kruisproduct van twee vectoren bepaalt een vector loodrecht op het vlak waarin beide vectoren liggen.
- Tensor: Soms heb je een array nodig met meer dan twee dimensies en met verschillende dimensies per as, geordend in een raster: een tensor. De dimensie van een tensor heet de rang. Scalaren en vectoren zijn ook typen tensors. Nulde‑orde tensors zijn scalaren en eerste‑orde tensors zijn vectoren.
Determinant
De determinant is een scalaire waarde die een factor van een matrix weergeeft waarmee lengte (in 1‑D), oppervlakte (2‑D) en volume (3‑D) worden geschaald. Als de determinant 2 is, is het volume (in 3‑D) twee keer zo groot; is de determinant 1, dan verandert het volume niet (in 3‑D). Als de determinant 0 is, heeft de matrix geen inverse, omdat nul keer iets altijd nul is.
Eigenschappen:
-
Het product van matrixen heeft als determinant het product van de determinanten: det(M1M2) = det(M1) det(M2).
-
De determinant van een matrix is gelijk aan het product van de eigenwaarden.
-
Vermenigvuldig je een matrix met een constante c, dan verandert de determinant met det(cM) = c^N det(M). N is de dimensie van de matrix.
Als je matrix een rekbaar speeltje voorstelt, dan geeft de determinant aan hoeveel je het speeltje hebt uitgerekt.
# Import numpy module
import numpy as np
# Create 2*2 matrix
arr=np.array([[1,2],[3,4]])
# Compute Determinant of a matrix
arr_det=np.linalg.det(arr)
# Print the Computed Determinant
print("Determinant:",arr_det)
Determinant: -2.0000000000000004
Eigenwaarden en eigenvectoren
Een eigenvector van een vierkante matrix A is een niet‑nulvector waarvoor vermenigvuldiging met A alleen de schaal van v verandert.
De eigenvector wordt ook wel karakteristieke vector genoemd. Het is een niet‑nulvector die bij een lineaire transformatie alleen met een scalair factor verandert.
Eigenvectoren zijn de rotatieassen van de lineaire transformatie. Deze assen hebben een vaste richting, en de eigenwaarde is de schaalfactor waarmee de matrix wordt uitvergroot of verkleind. Eigenwaarden heten ook wel karakteristieke waarden of karakteristieke wortels. Anders gezegd: eigenvectoren vormen vaste lijnen of vlakken die het gedrag van de lineaire transformatie begrenzen, en de eigenwaarden van een lineaire transformatie zijn de vervormingsfactoren.
De determinant geeft de oppervlakte/inhoud aan van vormen die bij een lineaire transformatie worden uitvergroot of verkleind. Daarom is het product van de eigenwaarden gelijk aan de determinant.
# Import numpy module
import numpy as np
# Create 2*2 matrix
arr=np.array([[1,2],[3,4]])
# Find eigenvalues and eigenvectors
eigenvalues, eigenvectors = np.linalg.eig(arr)
# print the eigenvalues and eigenvectors
print("Eigen Values: \n",eigenvalues)
print("Eigen Vectors:\n", eigenvectors)
Eigen Values:
[-0.37228132 5.37228132]
Eigen Vectors:
[[-0.82456484 -0.41597356]
[ 0.56576746 -0.90937671]]
NORM‑functie
Soms wil je de grootte van een vector meten. De normfunctie helpt je de grootte van een vector te bepalen. Ze kent een strikt positieve lengte toe aan een vector in een vectorruimte, behalve aan de nulvector. Dit omvat de L^p‑norm. Ze beeldt vectoren af op niet‑negatieve waarden. Voor een vector en een matrix komt dit overeen met de Euclidische afstand. Ze is gelijk aan de grootste singuliere waarde.
# import numpy module
import numpy as np
# Create 3*3 Matrix
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
# Compute norm
a_norm = np.linalg.norm(a)
# print the norm of function
print(a_norm)
16.881943016134134
Matrixfactorisatie
Matrixfactorisatie, ook wel matrixdecompositie genoemd, wordt gebruikt om een matrix op te splitsen in samenstellende delen. Matrixfactorisatie is vergelijkbaar met het ontbinden van getallen, zoals 10 = 2 × 5. Het wordt gebruikt om lineaire vergelijkingen op te lossen.
De volgende technieken voor matrixfactorisatie zijn beschikbaar:
- LU‑decompositie is voor vierkante matrixen en ontbindt een matrix in L‑ en U‑componenten.
- QR‑decompositie is voor m × n‑matrixen (niet beperkt tot vierkante matrixen) en ontbindt een matrix in Q‑ en R‑componenten. In tegenstelling tot LU‑decompositie is dit niet beperkt tot vierkante matrixen.
- Cholesky‑decompositie wordt gebruikt voor het oplossen van kleinste‑kwadratenproblemen voor lineaire regressie, evenals in simulatie‑ en optimalisatiemethoden.
- Singular Value Decomposition wordt in de volgende sectie uitgelegd.
Singular Value Decomposition
In de vorige sectie zagen we eigendecompositie van een matrix, die ontbindt in eigenvectoren en eigenwaarden. Singular value decomposition is een type matrixfactorisatie dat ontbindt in singuliere vectoren en singuliere waarden. Het heeft allerlei toepassingen in signaalverwerking, psychologie, sociologie, klimaat‑ en atmosferische wetenschap, statistiek en astronomie.
- M is een m×m‑matrix
- U is een m×n linkersinguliere matrix
- Σ is een n×n diagonale matrix met niet‑negatieve reële getallen.
- V is een m×n rechtersinguliere matrix
- V* is een n×m‑matrix, de getransponeerde van V.
# Import numpy module
import numpy as np
# Create 3*3 matrix
a = np.array([[1, 3, 4], [5, 6, 9], [1, 2, 3], [7, 6, 8]])
# Decomposition of matrix using SVD
U, s, Vh = np.linalg.svd(a, full_matrices=False)
U,s,Vh
(array([[-0.27067357, -0.61678044, 0.69789573],
[-0.65939972, -0.2937857 , -0.62152182],
[-0.20244298, -0.3480035 , -0.06765408],
[-0.67152413, 0.64200111, 0.34939247]]),
array([18.0376394 , 2.34360292, 0.38870323]),
array([[-0.46961711, -0.51018039, -0.72053851],
[ 0.87911451, -0.19502274, -0.43488368],
[-0.08134773, 0.83766467, -0.54009299]]))
# Generate the initial matrix
new_a = np.dot(U, np.dot(np.diag(s), Vh))
# Print original matrix
print(new_a)
[[1. 3. 4.]
[5. 6. 9.]
[1. 2. 3.]
[7. 6. 8.]]
Moore‑Penrose‑pseudoinverse
De pseudoinverse van een matrix is een generalisatie van de inverse matrix. Ze wordt gebruikt bij het berekenen van kleinste‑kwadratenoplossingen. De Moore‑Penrose‑inverse is de meest gebruikte vorm van matrixpseudoinverse.
# Import numpy module
import numpy as np
# Create 3*3 matrix
a = np.array([[1, 3, 4], [5, 6, 9], [1, 2, 3], [7, 6, 8]])
# Compute the (Moore-Penrose) pseudo-inverse of a matrix.
inv=np.linalg.pinv(a)
# Print pseudo-inverse of a matrix.
print(inv)
[[-0.37037037 0.03703704 -0.11111111 0.18518519]
[ 1.56296296 -1.2962963 -0.11111111 0.71851852]
[-0.84444444 0.94444444 0.16666667 -0.57777778]]
Hadamard‑product
Het Hadamard‑product of Schur‑product is een elementgewijze vermenigvuldiging van twee oorspronkelijke matrixen met dezelfde dimensies. Het staat ook bekend als elementgewijze vermenigvuldiging en is eenvoudiger dan het matrixproduct. Het Hadamard‑product wordt gebruikt in JPEG‑compressie met verlies. Het is commutatief, assocatief en distributief. Het maakt het bepalen van de inverse eenvoudiger en vereenvoudigt de berekening van machtige matrixen.
Het Hadamard‑product wordt gebruikt in diverse domeinen zoals foutcorrectie bij satelliettransmissies, informatietheorie, cryptografie, patroonherkenning, neurale netwerken, maximum likelihood‑schatting, JPEG‑compressie met verlies, multivariate statistische analyse en lineaire modellering.
# Import numpy module
import numpy as np
# Create 2*2 matrix a1 and a2
a1=np.array([[1, 2], [3, 4]])
a2=np.array([[1, 2], [3, 4]])
# Element wise multiplication
hadamard_product = np.multiply(a1,a2)
# Print hadamard distance
print("Hadamard Product: \n", hadamard_product)
Hadamard Product:
[[ 1 4]
[ 9 16]]
Entropie
"De entropie van een willekeurige variabele is een functie die probeert de onvoorspelbaarheid van een willekeurige variabele te karakteriseren." (Entropy and Mutual Information) Het wordt gebruikt bij het automatisch bouwen van beslisbomen: op elke stap van de boomopbouw wordt featureselectie gedaan met een entropiecriterium. Modelselectie is gebaseerd op het maximum‑entropieprincipe, dat stelt dat uit conflicterende modellen het model met de hoogste entropie het beste is.
"Als een willekeurige variabele X waarden aanneemt in een verzameling χ={x1, x2,..., xn}, en is gedefinieerd door een kansverdeling P(X), dan schrijven we de entropie van de willekeurige variabele als" (Entropy and Mutual Information)
"Als de log in de bovenstaande vergelijking de basis 2 heeft, wordt de entropie uitgedrukt in bits. Als de log de natuurlijke logaritme is, wordt de entropie uitgedrukt in nats. Meestal wordt entropie uitgedrukt in bits." (Entropy and Mutual Information)
# Import scipy and numpy module
import scipy.stats
import numpy as np
# Create an array
a=np.array([1,1,2,3,1,3,4,2,5,6,3,2,4,3])
# Compute probability distribution
a_pdf=scipy.stats.norm.pdf(a)
# Calculate the entropy of a distribution for given probability values.
entropy = scipy.stats.entropy(a_pdf) # get entropy from probability values
print("Entropy: ",entropy)
Entropy: 1.6688066853941022
Kullback‑Leibler‑divergentie
Kullback–Leibler‑divergentie is de relatieve entropie van twee kansverdelingen. Ze meet de afstand (overeenkomst of verschil) van een verdeling ten opzichte van een referentiekansverdeling. Een waarde 0 voor de Kullback–Leibler‑divergentie geeft aan dat beide verdelingen identiek zijn. Ze kan worden uitgedrukt als:
Het lijkt een afstandsmaat, maar dat is het niet. Dit komt doordat ze asymmetrisch is; de maat is niet commutatief. In het algemeen geldt D(p, q) ≠ D(q, p). KL‑divergentie wordt vaak gebruikt in de unsupervised machine‑learningtechniek "Variational Autoencoders".
# Import scipy.stats and numpy module
import scipy.stats
import numpy as np
# Create numpy arrays
a=np.array([1,1,2,3,1,3,4,2,5,6,3,2,4,3])
b=np.array([1,1,3,4,2,4,5,2,5,6,3,2,4,3])
# Compute probability distribution
a_pdf=scipy.stats.norm.pdf(a)
b_pdf=scipy.stats.norm.pdf(b)
# compute relative entropy or KL Divergence
kl_div=scipy.stats.entropy(a_pdf,b_pdf)
print("KL Divergence: ",kl_div)
KL Divergence: 0.26732496641464365
Gradient descent
Gradient descent is een van de bekendste algoritmen om coëfficiënten en bias te optimaliseren voor lineaire regressie, logistische regressie en neurale netwerken. Het is een iteratief proces dat het minimum van een gegeven functie vindt.
Er zijn drie varianten van het gradient‑descent‑algoritme: full batch, stochastisch en mini‑batch gradient descent. Full batch gebruikt de hele dataset om de gradiënt te berekenen, terwijl stochastisch gradient descent een steekproef van de dataset gebruikt. Mini‑batch gradient descent is een combinatie van stochastisch en batch‑gewijze gradient descent. De trainingsset wordt opgesplitst in kleine groepen, batches genoemd. Deze kleine batches berekenen één voor één het verlies en middelen het uiteindelijke verliesresultaat.
Conclusie
Gefeliciteerd, je bent aan het einde van deze tutorial gekomen!
Je hebt basisbegrippen uit de wiskunde voor deep learning geleerd, zoals scalair, vector, matrix, tensor, determinant, eigenwaarden, eigenvectoren, de NORM‑functie, singular value decomposition (SVD), de Moore‑Penrose‑pseudoinverse, het Hadamard‑product, entropie, Kullback–Leibler‑divergentie en gradient descent.
Onderweg heb je deze concepten ook geoefend in Python met NumPy en SciPy.
Wil je meer leren over Python? Volg dan de volgende DataCamp‑cursussen:
Onderwerpen
