2  Vektorer

Vektorer som kjent fra fysikk og mekanikk som størrelser med både lengde og retning, f.eks., posisjonen til en partikkel: \[ \mathbf{r}_1 = (x_1, y_1, z_1) \] andre eksempler fra mekanikk inkluderer:

Dette er vektorer som lever i rommet \(\mathbf{R}^3\).

I lineær algebra utvides begrepet vektor til å være en hvilken som ordnet liste med tall. Her er noen eksempler:

\[T= (T_1, T_2, T_3, T_4, T_5, T_6, T_7, T_8, T_9, T_{10})\]

\[P= (\rho, E, \nu, \alpha, \kappa)\]

Diskretisering av funksjoner er et annet viktig eksempel på vektorer.

Eksempel: Diskretisering av funksjoner: Et annet viktig eksempel er når vi diskretiserer en funksjon \(f(x)\), altså evaluerer den i et sett av punkter. Selve punktene vi evaluerer i kan vi skrive som en vektor:

\[ x_\text{vec} = (x_1, x_2, x_3, \ldots, x_n) \]

Resultatet er en ny vektor med funksjonsverdiene:

\[ f_\text{vec} = (f(x_1), f(x_2), f(x_3), \ldots, f(x_n)) \]

Her bruker vi notasjonen \(f_{\mathrm{vec}}\) for å skille mellom funksjonen\(f(x)\) og vektoren av evaluerte verdier.

Å diskretisere funksjoner på denne måten er svært vanlig i numeriske beregninger. Når vi plotter en funksjon i Python eller Julia, skjer nettopp dette: Vi lager en vektor med \(x\)-verdier og en annen med \(y\)-verdier, der \(y_i = f(x_i)\). Sammen gir de en diskret representasjon av funksjonen.

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2*np.pi, 40)
y = np.cos(x)

plt.plot(x, y, 'o-')
plt.title("Plot av $f(x) = \cos(x)$")
plt.show()
using Plots

x = range(0, 2π, length=40)
y = cos.(x)

plot(x, y, marker = :circle, line = :solid, label = "Plot av f(x)=\cos(x)")

Plot av cosinus

Dette gir to vektorer: en med 100 \(x\)-verdier og en med 100 tilhørende \(y\)-verdier. Sammen beskriver de funksjonen som en liste med tall — en vektor.

2.1 Notasjon og begreper

Vektorer benyttes for mange ulike formål og i mange ulike felt fra fysikk til finans til tekstanalyse og reklame. Ulike notasjoner benyttes i ulike kontekster. For fysiske vektorer i 2 og 3 dimensjoner benyttes vanligvis fet skrift. Et eksempel er en kraft \(\mathbf{F}\) eller et elektrisk felt \(\mathbf{E}\). Et alternativ er også å benytte vektorpil over symbolet \(\vec{E}\). Dette er vanlig med med penn-og-papir og på tavle-utregninger og noen ganger settes bare en strek under symbolet (som er en typografisk måte å indikere fet skrift). Vi kommer derimot for de fleste eksempler bare bruke vanlig kursiv tekst

En vektor med \(n\) elementer kalles en \(n\)-vektor, for eksempel er posisjon til en partikkel i rommet en 3-vektor, \(\mathbf{r_1}\), en romtid \((t, \mathbf{r})\) er en 4-vektor. En serie med 10 temperaturmålinger er en 10-vektor.

2.1.1 Kolonneform av vektorer:

I lineær algebra skrives ofte vektorer på kolonneform \[a=\begin{bmatrix} 3.3 \\ 5.2 \\ 4.1 \\ 3.2 \end{bmatrix}\] Denne konvensjonen gjør det lettere å utføre og visualisere matematiske operasjoner med vektorer. Men det er ofte mer praktisk å skrive ut vektorer på en linje, og da brukes vanlige parenteser og komma mellom tallene:

\[a=( 3.3, 5.2, 4.1, 3.2 )\]

Vi kommer til å bytte fram og tilbake mellom disse måtene å skrive en vektor.

Et annet distinkt begrep er en radvektor, f.eks., \[b=\begin{bmatrix} 2.3 & 1.0 & 2.1 & -1.4 \end{bmatrix}\]

Dette tenkes vanligvis på som en matrise bestående av 1 rad og n-kolonner, her 4. Matriser kommer tilbake i senere kapittel.

2.1.2 Indeksnotasjon:

Subskripter (nedsenktet tekst) bruker til å indikere indeksen til en vektor, for eksempel for vektoren \(a\) introdusert tidligere kan vi skrive \(a_1=3.3\) og \(a_2=5.2\).

Vi begynner normalt å telle indekser fra 1. Dette gjøres også i Julia (og i FORTRAN) :

a = [3.3, 5.2, 4.1, 3.2]

println(a[1])  # Outputs: 3.3
println(a[2])  # Outputs: 5.2

I noen sammenhenger og i noen programmeringsspråk starter man med indeksen 0. Dette benyttes f.eks. i python, hvor

import numpy as np

a = np.array([3.3, 5.2, 4.1, 3.2])

print(a[0])  # Outputs: 3.3
print(a[1])  # Outputs: 5.2

I 2 og 3-dimensions bruker man, f.eks. i fysikk og mekanikk ofte x, y,og z som subscript, f.eks. for en kraft (eller last), f.eks. om vi har \(\mathbf{F}= (2.2, 8.2, 0.1) \, \mathrm{N}\), så er er \(F_y = 8.2 \, \mathrm{N}\)

Subvektorer kan defineres med hjelp av indekser:

\[b = a_{2:3}=\begin{bmatrix}5.2 \\ 4.1 \end{bmatrix}\]

I Julia vil dette skrives på tilsvarende måte (med kolon mellom indeksene)

b = a[1:2] 
println(b)  # Outputs> [3.3, 5.2]

I Python derimot så teller man ikke med indeksen man slutter med, så dette skrives

import numpy as np

b = a[0:2]

print(b)  # Outputs: [3.3, 5.2]

2.1.3 Nullvektor, 1-vektor og standard enhetsvektorer

En nullvektor, altså en vektor uten lengde, men med en dimensjon \(n\) kan skrives \(0_n\) hvor \(n\) indikerer dimensjonen, slik at \(0_4 = (0, 0, 0,0)\). Men ofte skriver man bare 0 (dimensjonen er da implisitt). Når man koder så må man være vevist på at 0_4 og 0 er ulike objekter og noen ganger tolker koden det implissit og andre ganger gjør den det ikke. F.eks. så gir \(0_4 == 0_3\) vil gi en output: False (her vist i pseudokode). Tilsvarende kan man definere en vektor 1-vektor hvor alle elementene har tallet 1, som \(1_n\). Vi vil ofte skrive 1-vektoren med fet skrift 1, for å være sikker på at det tolkes som en vektor.

I Python skriver 0-vekor slik (gitt at numpy er lastet)

np.zeros(4)   # En 0-vektor med lenge 4.
np.ones(4)    # returns  array([0., 0., 0., 0.])

I Julia skrives dette tilsvarende men bare zeros og ones uten at numpy trenger å lastes.

En viktig type vektorer er standard enhetsvektorer. Disse er vektorer vektor hvor ett element tar verdien 1 og resten 0, f.eks, i \(\mathbf{R}^4\), kan man f.eks. skrive:

\[e_1=\begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \end{bmatrix},\quad e_2=\begin{bmatrix} 0 \\ 1 \\ 0\\ 0 \end{bmatrix},\quad e_3=\begin{bmatrix} 0 \\ 0 \\ 1 \\ 0 \end{bmatrix},\quad e_4=\begin{bmatrix} 0 \\ 0 \\ 0 \\ 1 \end{bmatrix}\]

2.2 Vektoralgebra

En viktig egenskap til vektorer er at om de har samme dimensjon, så kan de kan legges sammen. Dette gjøres individuelt for hvert element, f.eks. \[\begin{bmatrix} 3.3 \\ 5.2 \\ 4.1 \end{bmatrix} +\begin{bmatrix} 1.1 \\ 1.2 \\ -1.0 \end{bmatrix} = \begin{bmatrix} 4.4 \\ 6.4 \\ 3.1 \end{bmatrix} \]

Fra dette kan man lett bekrefte følgende formelle egenskaper for addisjon av vektorer:

  • Kommutativ: \(a + b = b + a\)
  • Assosiativ: \((a + b) + c= a + (b + c)\)
  • Et unikt identitetselement er definert med nullvektoren: \(a + 0 = 0 + a = a\)
  • Et unikt inverselement er definert med \(-a\): \(a + (-a) = a -a = 0\)

Formelle egenskaper til algebra studeres i feltet abstrakt algebra. Vi kommer bare til å ta for oss noen slike aspekter. Egenskapene over gjør at summasjon av vektorerer i matematikken definerer en Abelsk gruppe https://en.wikipedia.org/wiki/Group_(mathematics). Men gruppeteori tar vi ikke for oss i dette kompendiet.

En vektor kan multipliseres med en skalar (et vanlig tall): \[ (2) \begin{bmatrix} 2 \\4 \end{bmatrix} = \begin{bmatrix} 4 \\8 \end{bmatrix} \]

Ved å legge sammen vektorer kan man definere vektorer på indeksform med hjelp av standard basisvektorer: \[ a = \sum_i a_i e_i \]

F.eks. kan man skrive vektoren (2, 4, 0, -1) som \(2e_1 + 4e_2 - e_4\).

I \(\mathbf{R}^3\), skriver man noen ganger standard enhetsvektorer som \(\mathbf{i}\) , \(\mathbf{j}\) , \(\mathbf{k}\), eller slik: \(\hat{\mathbf{x}}\), \(\hat{\mathbf{y}}\), \(\hat{\mathbf{z}}\). Altså vektoren \((1, 1, 0)\), kan skrives: \(0.5 \hat{\mathbf{x}} + 0.5 \hat{\mathbf{y}}\) som er det samme som \(0.5 e_1 + 0.5 e_2\).

2.3 Indreprodukt

Et indreprodukt eller (mer uformelt) dot-produktet av to n-vektorer er gitt ved:

\[ a \cdot b = \sum_i a_i b_i \] Det gjør altså en vektor om til en skalar (altså et tall).

For eksempel, om

\[ a= \begin{bmatrix} 2 \\4 \end{bmatrix}, \quad b= \begin{bmatrix} 1 \\ 4 \end{bmatrix} \] så er indreprodukt

\[ \alpha =a \cdot b = (2)(1) + (4)(4) = 18 \]

Her har vi brukt parentes for å skrive multiplikasjon mellom skalarer. Det er litt klønete. Vi kunne også brukt symboler som \(\cdot\) , \(\times\), eller \(*\). I tekst på videregående universitetsnivå, skriver man sjelden ut multiplikasjon av tall i tekst. Det trenger ikke du å gjøre heller for masetroppgaven din. Et unntak er store tall, da bruker man vanligvis \(\times\) for å skille eksponenten og restem som i Avorgados tall: \(6.02214076 \times 10^{23} \text{mol}^{-1}\)  

Et indreprodukt av to vektorer, kan i linear algebra også skrives som et matriseprodukt.

\[ \alpha = a^\top b \]

Her betyr \(\top\) betyr transponering av en vektor (du kan godt bare skive \(T\) i den tekst, men jeg bruker jeg latex-symbolet “”) . For en vektoren \(a\) skrives dette som følger:

\[ c =a^\top = \begin{bmatrix} 2 & 4 \end{bmatrix} \]

Her ser vi at transponering gjør en vanlig kolonnevektor om til en radvektor, og et indreprodukt kan forstås som et matriseprodukt (diskutert senere). I dette kompendiet bruker vi både notasjonen \(a \cdot b\) og \(a^\top b\) (og ofte begge deler) for indreprodukter. >Å hoppe mellom notasjoner er ikke “elegant,” men gjør det lettere å følge ulik notasjon.

I Python tar man et indreprodukt (med resultat alpha) av to n-vektorer slik (gitt at numpy er lastet som tidligere):

alpha = np.dot(a, b)

I Julia, skrives dette på dette viset.

alpha = a'b

Symbolet ’ er en adjugert (som vi kommer tilbake til i slutten av kapittelet), men for reelle er de identiske med \(\top\), et trasponat.

2.3.1 Eksempler på indreprodukt

Indreprodukt med standard enhetsvektor kan brukes til å velge ut en komponent av en vektor:

\[a_i = a \cdot e_i\]

Dette eksempelet er kanskje litt selvsagt, men det kan være nyttig å tenke litt abstrakt rund dette. Dette er et eksempel på en projeksjon på et koordinatsystem og i dette tilfellet får vi projeksjonen av vektoren \(a\) på \(e_i\).

Sum og gjennomsnitt:
Summen av alle tallene i en vektor \(x\) er definert som:

\[ \sum_i x_i \]

Dette kan også uttrykkes som et indreprodukt med en en-vektor:

\[ \mathbf{1}^\top x = \sum_i x_i \]

Tilsvarende er gjennomsnittet (mean) av en vektor er gitt med.

\[ \text{mean}(x) = \frac{1}{n} \sum_i x_i \]

som også kan skrives som

\[ \text{mean}(x) = \frac{1}{n} \mathbf{1}^\top x \]

Noen ganger indikerer man \(\text{mean}(x)\) med symbolet \(\mu\) .

Om man bare er interessert i å ta et gjennomsnitt, så er det bedre å bruke innebygde funksjoner i programmering. I Julia eksempelet viser tre måter å gjøre det på.

# Summen og gjennomsnitt av en vektor i Julia

# Definer en vektor x
x = [3.0, 5.0, 7.0, 9.0]
n = length(x)
onevec = ones(n)  # 1-vektor av samme lengde

# --- Metode 1: Vektorprodukt (ingen ekstra pakker nødvendig)
sum_via_vecprod = onevec' * x                  # Summen som 1ᵀ * x
mean_via_vecprod = (1/n) * (onevec' * x)       # Gjennomsnitt

# --- Metode 2: Dot-produkt
using LinearAlgebra
sum_via_dot = dot(onevec, x)                   # Summen som dot(1, x)
mean_via_dot = (1/n) * dot(onevec, x)          # Gjennomsnitt

# --- Metode 3: Innebygde funksjoner
using Statistics
sum_builtin = sum(x)                           # Summen
mean_builtin = mean(x)                         # Gjennomsnitt

println("Metode 1 (vektorprodukt): sum = $sum_via_vecprod, mean = $mean_via_vecprod")
println("Metode 2 (dot)         : sum = $sum_via_dot, mean = $mean_via_dot")
println("Metode 3 (innebygd)    : sum = $sum_builtin, mean = $mean_builtin")

Vektede summer:
I både maskinlæring og beslutningsstøtte brukes ofte en vektet lineær score:

\[ \text{score} = w^\top x \]

der \(w\) angir viktigheten av hver komponent i \(x\). For eksempel kan en bank beregne kredittscoren din på denne måten. I maskinlæring er \(x\) gjerne en liste med features (egenskaper), og vektvektoren \(w\) optimeres som en del av læringsprosessen.

Vektede summer brukes også i teknisk design, som i eksempelet nedenfor. ### Eksempel: Materialvalg for mekanisk konstruksjon Vi skal velge et materiale til en mekanisk presisjonkomponent, f.eks. en monteringsplate i et måleinstrument, f.eks. et kamera. Komponentens ytelse påvirkes av:

  • Stivhet: komponenten må være stiv og ikke bøye seg under belastning.
  • Tetthet (masse): lav vekt er ønskelig for mobilitet og lettere konstruksjon.
  • Pris: lav pris er en fordel.
  • Termisk utvidelse: komponenten må ikke utvide seg mye ved temperatursvingninger, siden det svekker presisjonen.

Vi vurderer tre alternativer: stål, aluminium, og CFRP (karbonfiberkompositt). For eksempel kan ikke stivhet i GPa og pris i kr/kg legges sammen direkte, vi må først gjøre verdiene sammenlignbare. For å sammenligne dem, kan vi lage en skalert ønskelighetsmatrise der verdiene ligger mellom 0 og 1, hvor 1 betyr best ytelse mens 0 dekker kun minimum. (om materialet var helt uaktuelt ville det ikke blitt vurdert). Man kan f.eks. lande på en slik matrise:

Egenskap (høyere=bedre) Stål Aluminium CFRP
Stivhet 1.00 0.30 0.60
Lav masse 0.00 0.60 1.00
Lav pris 0.90 0.40 0.00
Lav termisk ekspansjon 0.50 0.10 1.00

Vi velger vektene \(w=(0.4,0.2,0.1,0.3)\) for hvor viktig hver egenskap er i akkurat denne anvendelsen. Vektene kan i praksis settes manuelt basert på erfaring, eller bestemmes gjennom en gruppebeslutning, eller man kan lage matematiske formler for å bestemme de (som er er viktig i autonom beslutningstaking).

Da blir totalsummen (eller “score”) gitt av det skalarproduktet \(s=w\cdot x = w^\top x\). Dette kan regens ut i Python, slik:

# Python-kode
import numpy as np

w = np.array([0.5, 0.2, 0.2, 0.1])
steel     = np.array([1.00, 0.00, 0.90, 0.50])
aluminum  = np.array([0.30, 0.60, 0.40, 0.10])
cfrp      = np.array([0.60, 1.00, 0.00, 1.00])
for name, x in [("Stål", steel), ("Aluminium", aluminum), ("CFRP", cfrp)]:
    print(name, np.dot(w, x))

eller i Julia, slik:

# Julia-kode
using LinearAlgebra

w = [0.5, 0.2, 0.2, 0.1]
steel     = [1.00, 0.00, 0.90, 0.50]
aluminum  = [0.30, 0.60, 0.40, 0.10]
cfrp      = [0.60, 1.00, 0.00, 1.00]

for (name, x) in [("Stål", steel), ("Aluminium", aluminum), ("CFRP", cfrp)]
    println(name, " ", dot(w, x))
end

Merk hvordan for-løkken gjøres annerledes i de kodene. Python bruker bare “:” og tab, mens Julia bruker (for og end)

Begge gir samme rangering: Stål 0.730, CFRP 0.6, og Aluminium 0.360.

Denne typen kvantativ beslutningstaking har mange fordeler: * Den kan dokumenteres og er derfor langt mer etterrettelig ovenfor kunder, sjefer, og myndigheter * Den reduserer at magefølelsen skal overkjøre alle andre hensyn. Dette kan for eksempel være viktig i vurdering av jobbsøkere.
* Den kan gjør det lettere å bli enige. Uenighet kan reduseres til ulik vektning av ulike premisser. Og selv om senioringenøren kanskje mener at “stål alltid er best”, så gjør det mulgi å rasjonelt vurdere nye muligheter som kan øke bedriftens lønnsomhet og innovasjonsevne.

Eksemplet her kan selvsagt gjøres i Excel. Men om det var hundrevis av materialvalg-muligheter kan det fort ende opp med å bli rotete og vanskelig å dokumentere.

2.4 Ortogonalitet

Når det indreproduktet av to vektorer er 0 sier vi at de er ortogonale:

\[a\cdot b = a^\top b = 0\] I geometri er dette det samme som at de står vinkelrett på hverandre.

Vektorene

\[ a= \begin{bmatrix} 2 \\ -2 \end{bmatrix}, \quad b= \begin{bmatrix} 1 \\ 1 \end{bmatrix} \]

er et eksempel på ortogonale vektorer.

2.5 Euklidisk vektornorm (2-norm)

I mange sammenhenger snakker man om lengden til en vektor. For eksempel har en kraftvektor \(\mathbf{F}\) både størrelse og retning. Lengden er gitt av Pythagoras sin formel i tre dimensjoner:

\[ F^2 = F_x^2 + F_y^2 + F_z^2 \quad \text{slik at} \quad F = \sqrt{F_x^2 + F_y^2 + F_z^2} \]

I lineær algebra kalles slike lengder en en norm, og helt spesifikt kalles denne normen en Euklidske vektornormen eller en 2-norm. For en en \(n\)-vektor \(a\) skrives kvadraten av normen på formen:

\[ \|a\|^2 = a \cdot a = a^\top a = \sum_i a_i^2 \]

Selve normen er da gitt ved:

\[ \|a\| = \sqrt{\|a\|^2} \]

For eksempel, for vektoren \(a\) definert som tidligere:

\[ \|a\| = \sqrt{2^2 + (-2)^2} = \sqrt{8} = 2\sqrt{2} \]

Et annet eksempel er at normen av standard basisvektorer.

\[||e_i|| =1\]

I Python (med NumPy) kan normen av en vektor regnes ut slik:

import numpy as np

a = np.array([2, -2])
norm = np.linalg.norm(a)
print(norm)  # Output: 2.8284271247461903

I Julia gjøres det slik:

using LinearAlgebra

a = [2, -2]
d = norm(a)
println(d) # Output: 2.8284271247461903

2.5.1 Geometrisk tolking

I trigonometrien har vi at

\[ a \cdot b = \|a\| \, \|b\| \cos \theta, \]

der \(\theta\) er vinkelen mellom vektorene. Dette gjelder også i høyere dimensjoner.

Fra enhetsirkelen og geometriske prinsipper kan man lage en tabell over ulike vinkler: \[ \begin{array}{|c|c|c|c|c|} \hline \textbf{Vinkel} & \textbf{Radianer} & \cos(\theta) & \sin(\theta) & \tan(\theta) \\ \hline 0^\circ & 0 & 1 & 0 & 0 \\ 30^\circ & \frac{\pi}{6} & \frac{\sqrt{3}}{2} \approx 0.87 & \frac{1}{2} \approx 0.50 & \approx 0.58 \\ 45^\circ & \frac{\pi}{4} & \frac{\sqrt{2}}{2} \approx 0.71 & \frac{\sqrt{2}}{2} \approx 0.71 & 1 \\ 60^\circ & \frac{\pi}{3} & \frac{1}{2} \approx 0.50 & \frac{\sqrt{3}}{2} \approx 0.87 & \approx 1.73 \\ 90^\circ & \frac{\pi}{2} & 0 & 1 & \text{Ikke definert} \\ 120^\circ & \frac{2\pi}{3} & -\frac{1}{2} \approx -0.50 & \frac{\sqrt{3}}{2} \approx 0.87 & \approx -1.73 \\ 135^\circ & \frac{3\pi}{4} & -\frac{\sqrt{2}}{2} \approx -0.71 & \frac{\sqrt{2}}{2} \approx 0.71 & -1 \\ 180^\circ & \pi & -1 & 0 & 0 \\ \hline \end{array} \]

Vi kan også set at \(\cos(-\theta) = \cos(\theta)\) og at \(\sin(-\theta) = -\sin(\theta)\). Vi har ellers at \(\tan(\theta) = \frac{\sin(\theta)}{\cos(\theta)}\). Vi har listet tabellen både i vinkler i grader og i radianer.

I numeriske beregninger benyttes vanligvis radianer (inkludert i Julia og Python) . Du kan gå fra vinkel til radianer med å gange med \(\pi\) og dele på 180.

To vektorer er ortogonale (eller vinkelrette) hvis \(a \cdot b = 0\), altså når \(\cos \theta = 0\).

Vi kan bruke dette til å uttrykke normen (kvadrert) av summen av to vektorer \(x\) og \(y\):

\[ \|x + y\|^2 = (x + y) \cdot (x + y) = \|x\|^2 + \|y\|^2 + 2(x \cdot y) = \|x\|^2 + \|y\|^2 + 2\|x\|\|y\|\cos \theta \]

Her kan vi se at om vektorene er vinkelrette (\(\theta = 90^\circ\)), så er \(\cos \theta = 0\) og vi får Pythagoras’ formel:

\[ \|x + y\|^2 = \|x\|^2 + \|y\|^2 \]

Nedenfor viser vi hvordan vi kan regne ut vinkelen mellom to vektorer i Python:

import numpy as np

a = np.array([2.0, 1.0])
b = np.array([1.0, 3.0])

dot_ab = np.dot(a, b)
norm_a = np.linalg.norm(a)
norm_b = np.linalg.norm(b)

cos_theta = dot_ab / (norm_a * norm_b)
theta = np.arccos(cos_theta)

print(f"Vinkelen mellom vektorene er {theta:.2f} radianer eller {np.degrees(theta):.2f} grader.")

# Vinkelen mellom vektorene er 0.79 radianer eller 45.00 grader.

Og med Julia regnes dette ut som følger

using LinearAlgebra

a = [2.0, 1.0]
b = [1.0, 3.0]

dot_ab = dot(a, b)
norm_a = norm(a)
norm_b = norm(b)

cos_theta = dot_ab / (norm_a * norm_b)
theta = acos(cos_theta)

println("Vinkelen mellom vektorene er $(theta) radianer eller $(theta * 180 / π) grader.")
#return: Vinkelen mellom vektorene er 0.7853981633974484 radianer eller 45.00000000000001 grader.

I min utregning oppstod en veldig liten numerisk feil og vi fikk ikke eksakt 45 grader. Det samme skjedde i Python, men her brukte vi {theta:.2f} for å kutte til to desimaler.

For å gjøre det “pent” i Julia, trenger vi å laste inn using Printf

using Printf
@printf "Vinkelen mellom vektorene er %.2f radianer eller %.2f grader.\n" theta theta * 180 / pi

# returns: Vinkelen mellom vektorene er 0.79 radianer eller 45.00 grader.

2.5.2 Trekantulikheten:

Siden \(\cos(\theta) \leq 1\), så gjelder det at:

\[ \|x\|^2 + \|y\|^2 + 2\|x\|\|y\|\cos \theta \leq \|x\|^2 + \|y\|^2 + 2\|x\|\|y\| = (\|x\| + \|y\|)^2 \]

Siden vi tidligere viste at

\[ \|x + y\|^2 = \|x\|^2 + \|y\|^2 + 2\|x\|\|y\|\cos \theta \]

Så følger det at

\[ \|x + y\|^2 \leq (\|x\| + \|y\|)^2 \]

og om vi tar kvardatoten på begge sider får vi:

\[ \|x + y\| \leq \|x\| + \|y\| \]

Dette viser at trekantulikethen (https://snl.no/trekantulikheten) gjelder for vektorerer med euklidisk vektornorm.

2.5.3 Avstand mellom vektorer

Avstanden mellom to vektorer \(a\) og \(b\) i \(\mathbb{R}^n\) defineres som:

\[ \text{dist}(a, b) = \|a - b\| \]

Dette er den vanlige euklidske avstanden, akkurat som i \(\mathbb{R}^2\) og \(\mathbb{R}^3\).

2.5.4 Enhetsvektorer og ortonormalitet

En vektor med lengde (norm) lik 1 kalles en enhetsvektor. Standard enhetsvektorene introdusert er de som går i langs vanlige koordinatakser og vi skriver ofte bare \(e_1, e_2\) etc. spesielt om vi har mer enn 3-dimensjoner.

I \(\mathbb{R}^3\), skriver man dem noen ganger som \(\mathbf{i}\), \(\mathbf{j}\) og \(\mathbf{k}\), eller slik: \(\hat{\mathbf{x}}\), \(\hat{\mathbf{y}}\), \(\hat{\mathbf{z}}\). For eksempel kan vektoren \((1,1, 0)\) skrives som

\[ 0.5 \, \hat{\mathbf{x}} + 0.5 \, \hat{\mathbf{y}} = 0.5 e_1 + 0.5 e_2. \]

Fra en vilkårlig vektor \(a\) kan man lage en enhetsvektor i samme retning ved å dele på lengde (altså den Euklidiske normen):

\[ \hat{a} = \frac{a}{\|a\|} \]

Vi bruker her “hat”-notasjonen \(\hat{a}\) for å indikere at vektoren er normalisert, men man bruker ikke nødvendigvis “hat” for å vise at noe er normalisert, f.eks. bruker man vanligvis, “hat” for standard enhetsvektorer.

To vektorer \(u\) og \(v\) er ortonormale dersom de er ortogonale og normaliserte har lengde lik 1: - \(u \cdot v = 0\) - \(\|u\| = 1\), \(\|v\| = 1\)

Standardenhetsvektorene i \(\mathbb{R}^n\) er et set ortonormale.

2.6 Eksempel: Dokumentanalyse

Gitt at man ønsker å analysere likheten mellom tekniske dokumenter, for eksempel patenter innenfor halvlederteknologi, starter man ofte med å definere en fast ordliste — et vokabular — bestående av innholdsord som faktisk forekommer i dokumentene. Først fjernes såkalte stoppord som “og”, “i”, og “det”, fordi disse ikke så mye ås for innholdet i dokumenet.

Ordlisten kan deretter sorteres alfabetisk, f.eks.: [“amplifier”, “bonding”, “circuit”, “coating”, “cooling”, “device”, “electrode”, “encapsulation”, “heat”, “insulation”, …] Et dokument kan nå representeres som en vektor, der hver komponent angir hvor mange ganger et gitt ord i ordlisten forekommer. Dette gir en vektor i \(n\) dimensjoner (én per ord), som kan brukes til videre analyse.

For eksempel om vi har de to patentene: - Patent A: “Method for thermal regulation in semiconductor devices”
Handler om kjøling og varmespredning i halvlederkomponenter.

  • Patent B: “High-frequency amplifier with multilayer ceramic encapsulation”
    Beskriver forsterkerkretser og avansert innkapslingsteknologi.

og disse kan gi histogram av typen:

Word Patent A Patent B
amplifier 0 4
bonding 1 3
circuit 5 7
coating 0 6
cooling 10 2
device 12 9
electrode 2 8
encapsulation 0 4
heat 17 3
insulation 4 5
… … …

Begge dokumentene kan nå representeres som vektorer i et felles rom, hvor hver komponent svarer til et spesifikt ord i ordlisten. For de viste ordene får vi:

  • \(v_A = 0,\ 1,\ 5,\ 0,\ 10,\ 12,\ 2,\ 0,\ 17,\ 4,\ \dots]\)
  • \(v_B = [4,\ 3,\ 7,\ 6,\ 2,\ 9,\ 8,\ 4,\ 3,\ 5,\ \dots]\)

Om man ønsker å analysere hvor like to dokumenter er, for eksempel for å lage en katalog over relaterte (eller konkurrerende) patenter innen et fagfelt, kan indreproduktet mellom vektorene brukes som et mål på likhet.

Men dette krever forsiktighet: lange dokumenter inneholder naturligvis flere ord, og vil derfor ha høyere komponentverdier i vektoren. Uten justering vil slike dokumenter ofte fremstå som “like” mange andre lange dokumenter — uavhengig av innholdet. Tilsvarende vil korte dokumenter sjelden ligne på noe, bare fordi de er korte.

Derfor er det vanlig å normalisere vektorene til enhetslengde, slik at man sammenligner retning snarere enn størrelse. Det gir et mer rettferdig mål på semantisk likhet mellom dokumenter.

Et slikt likhetsmål kan beregnes som:

\[ s = \frac{v_A \cdot v_B}{\|v_A\| \, \|v_B\|} = \hat{v}_A \cdot \hat{v}_B\, \]

hvor \(\hat{v}_A\) og \(\hat{v}_B\) er normaliserte enhetsvektorer. Merk at bare helt identiske dokumenter, eller omskrivinger av samme tekst, vil gi en verdi nær 1. Relativt lave verdier, for eksempel 0.05, kan likevel indikere høy tematisk relevans. En score under 0.001 kan derimot være en mulig terskel for å vurdere dokumenter som irrelevante.

Denne typen likheter mellom vektorer kalles i mange sammenhenger kosinus-likhet (cosine similarity), av ligningen \(a\cdot b = (||a||) (||b||) \cos\theta\). Wikipedia Man kan altså snakke f.eks. om vinkelen mellom to dokumenter(!) om det forstås som vinkelen mellom slike histogram-vektorer.

I nettbasert reklame brukes slike metoder for å koble annonser til relevante søk, artikler eller produkter. I sosiale medier analyseres vektorrepresentasjoner av innlegg i sanntid for å fange opp trender, f.eks. å analyse pågående konfliktsituasjoner. For eksempel kan X(Twitter)-strømmer eller Facebook-innlegg fra bestemte regioner overvåkes automatisk for signaler om uro, feilinformasjon eller mobilisering.

Selv om slike kvantitative metoder primært har vært brukt av ingeniører, økonomer, og i stadig større grad i samfunnsfag, så har de i det siste årene også begynt å få innpass i humaniora (historie, litteraturanalyse, og språkfag). Denne type teknikker er viktig for analysere historiske kilder, korrespondanse og avisarkiver. Man kan f.eks. undersøke hvordan begreper endres over tid, eller kartlegge likheter og forskjeller i språkbruk mellom epoker eller forfattere. computational thematics

2.7 Ortonormal basis og projeksjon

Om vi har \(n\) ortonormale enhetsvektorer i \(\mathbb{R}^n\) , altså reelle \(n\)-vektorer som står vinkelrett på hverandre og har lengde 1, så sier vi at de danner en ortonormal basis.

Det vil si at de sammen utgjør et naturlig koordinatsystem for hele rommet. Standard enhetsvektorene er et eksempel på dette, men man også ha andre ortonormale basissett.

F.eks., så er et eksempel på to ortonormale vektorer i \(\mathbb{R}^2\)

\[u_1 = \frac{1}{\sqrt{2}} \begin{bmatrix} 1 \\ 1 \end{bmatrix} \quad u_2 = \frac{1}{\sqrt{2}} \begin{bmatrix} -1 \\ 1 \end{bmatrix} \]

Det er fin øvelse å selv sjekke at disse vektorene er både orthogonal og normaliserte.

Til sammen danner settet en ortonormal basis {\(u_1, u_2\)}, på samme måte some {\(e_1, e_2\)}.

Om vi har et sett \(u_1, u_2, \dots, u_n\) ortonormale basisvektorer, så kan envher \(x\) i rommet kan skrives som en lineærkombinasjon av sik vektorer. \[ x = \sum_{i=1}^{n} (x \cdot u_i)\, u_i \]

\((x \cdot u_i)\, u_i\) danner da en projeksjon av \(x\) i retning \(u_i\).

Eksempel: projeksjon i 2D:

For \(x = \begin{bmatrix} 3 \\ 1 \end{bmatrix}\) og vekteroene \(u_1\) og \(u_2\) beskrevet over, \[ x \cdot u_1 = \frac{3 + 1}{\sqrt{2}} = \frac{4}{\sqrt{2}} = 2\sqrt{2} , \quad x \cdot u_2 = \frac{-3 + 1}{\sqrt{2}} = \frac{-2}{\sqrt{2}} = - \sqrt{2} \] slik at

Dermed har vi at

\[ x = 2 \sqrt{2}\, u_1 - \sqrt{2}\, u_2 \]

Å uttrykke en vektor som en sum av projeksjoner på ortonormale basisvektorer er ofte en viktig moment i maskinlæring, og mønstergjenkjenning og vi kommer tilbake til det i kapittelet om minste kvadraters metode.

2.8 Generelle normer:

Vi har tidligere introdusert den Euklidske normen (eller 2-normen), men mange andre typer normer brukes i optimalisering, maskinlæring og numeriske beregninger. Mer generelt kan man definere en \(p\)-norm som:

\[ \|a\|_p = \left( \sum_i |a_i|^p \right)^{1/p} \]

I dette kompendiet holder vi oss for det meste til den Euklidske normen for vektorer, men det er nyttig å kjenne til det mer generelle rammeverket.

En funksjon \(\| \cdot \|\) kan kalles en norm dersom den oppfyller følgende egenskaper:

  1. Ikke-negativitet og nullvektor: \[ \|a\| \geq 0 \quad \text{og} \quad \|a\| = 0 \iff a = 0 \]

  2. Skalering: \[ \|\lambda a\| = |\lambda| \cdot \|a\| \quad \text{for alle } \lambda \in \mathbb{R} \]

  3. Trekantulikheten: \[ \|a + b\| \leq \|a\| + \|b\| \]

I eksempelet med tekstanalyse kan visse ord være mer betydningsfulle enn andre, for eksempel kan “encapsulation” være et spesifikt og viktig begrep, mens “bonding” er mer generisk. For å reflektere dette kan man bruke en vektet norm, der hver komponent \(x_i\) vektes med en positiv faktor \(w_i\):

\[ \|x\|_w = \sqrt{w_1 x_1^2 + w_2 x_2^2 + \dots + w_n x_n^2} \]

eller mer kompakt:

\[ \|x\|_w = \sqrt{\sum_{i=1}^n w_i x_i^2} \]

Her er \(w = [w_1, w_2, \dots, w_n]\) en vektor med vekter, én for hver komponent i \(x\).

Ved å bruke ulike vektfaktorer for ulike typer dokumenter — for eksempel tilpasset ulike teknologiområder — kan man forbedre kvaliteten på søk, klassifisering eller klyngeanalyse. Et bibliotek av vektfaktorer kan til og med være en bedriftshemmelighet i visse bransjer

2.9 Statistikk og vektorer

Mange grunnleggende statistiske størrelser kan uttrykkes effektivt med vektorer. Vi har tidligere sett hvordan gjennomsnittet av en dataserie \(x\) kan uttrykkes som:

\[ \text{mean}(x) = \frac{1}{n} \mathbf{1}^\top x \]

Ofte er det interessant å se på verdien relativt til gjennomsnittet. En sentrert versjon av en dataserie \(x\) kan skrives som

\[ \tilde{x} = x - \text{mean}(x)\,\mathbf{1} \]

En annen viktig størrelse er variansen, som beskriver hvor mye dataene sprer seg rundt gjennomsnittet:

\[ \text{var}(x) = \frac{1}{n} \|x - \text{mean}(x) \mathbf{1}\|^2 = \frac{1}{n} \|\tilde{x}\|^2 \]

Dette er kvadratet av 2-normen til avviket fra gjennomsnittet, delt på antall elementer. Kvadratroten av variansen kalles standardavviket:

\[ \text{std}(x) = \sqrt{\text{var}(x)} = \frac{1}{\sqrt{n}} \|x - \text{mean}(x) \mathbf{1}\| = \frac{\|\tilde{x}\|}{\sqrt{n}} \]

Dette gir et godt mål på hvor langt typiske verdier ligger unna gjennomsnittet og er mye brukt i statistikk.

Standardadviket skrives ofte med symbolet \(\sigma\). Man kan i noen sammenhenger snakke om X-sigma hendlse for noe som er sjeldent. 3-sigma er sjeldent, 5-sigma er ekstremt sjeldent, and 6-sigma kan være slang i visse industrier for ultrasjeldent. NB! Statistisk sigma har ingenting med \(\sigma\)-boy eller Patrick Bateman å gjøre.

Merk at her inneholder standardavviket \(1/\sqrt{n}\) , mens det er også vanlig å bruke \(1/\sqrt{n-1}\) som har bedre formelle matematiske egenskaper, men her holder vi oss til \(1/\sqrt{n}\) .

2.9.1 Standardisering

En måte gjøre dataserier sammenlignbare på er å standardisere dem, altså flytte gjennomsnittet til null og skalere slik at standardavviket blir 1:

\[ z = \frac{x - \text{mean}(x) \mathbf{1}}{\text{std}(x)} = \frac{\tilde{x} }{\text{std}(x)} \]

Da kan man snakke om hvor uvanlig et vist datapunkt er i forhold til fordelingen. En måledata/hendelse med verdien 2 (eller - 2) svarer da til \(\tilde{x} = 2\sigma\) og er relativt uvanlig.

2.9.2 Modellfeil og avviksmål

Standardavvik og gjennomsnitt er egenskaper med en enkelt dataserie, men ofte er det ønskelig å se på relasjonen mellom to dataserier. I ingeniørfag og maskinlæring brukes, f.eks. ofte modeller som er ment å forutsi (eller predikere) observerte verdier. Prediksjonene av en modell (f.eks. på ulike tider), kan da være gitt av en vektor \(x\), mens referansedataene er gitt ved \(x_\text{ref}\).

Den enkleste målestokken for feil er gjennomsnittlig feil (mean error, ME), også kalt bias:

\[ \text{ME} = \text{mean}(x-x_\text{ref})= \frac{1}{n} \mathbf{1}^\top (x - x_\text{ref}) \]

Det er ofte nyttig å definere avviksvektoren

\[ \Delta x = x - x_\text{ref} \]

slik at: \(\text{ME} = \text{mean}(\Delta x)\).

For å måle total størrelse på feilen, uavhengig av fortegn, brukes ofte root mean square error (RMSE): \[ \text{RMSE}(x) = \sqrt{ \frac{1}{n} \|x - x_\text{ref }\|^2 } = \frac{1}{\sqrt{n}} \|x - x_\text{ref}\| ) = \frac{1}{\sqrt{n}} \|\Delta x\| \]

Denne typen aviksberegning er svært vanlig i både modellkalibrering. Kvadratet av RMSE kalles middels kvadratfeil (mean squared error, MSE). \[ \text{MSE} = \frac{1}{n} \|x - x_\text{rm}\|^2 \] RMSE inneholder både variasjon, altså spredning i data, og systematisk feil (bias). Dette kan skrives på formen:

\[ \left(\text{RMSE}(x)\right)^2 = \text{var}(x - x_\text{ref}) + (\text{mean}(x - x_\text{ref}))^2 \]

2.9.2.1 Loss-funksjon i maskinlæring

Den brukes ofte som en loss funksjon. I maskinlæring, spesielt veiledet trening eller supervised learning optimer man ofte hyperparameter \(\lambda\) av en Loss funksjon for å minimere differansen mellom treningsdata \(x_\mathrm{train}\) og modellprediksjon \(x(\lambda)\). MSE kan fungere som en enkel loss funksjon.

\[ \mathcal{L}_0(\lambda) = \frac{1}{n} \|x(\lambda) - x_\text{train}\|^2 \]

I mer komplekse modeller kan man risikere at maskinlæringsmodellen tilpasser seg for godt til treningsdataene, en effekt som kalles overfitting. For å unngå dette benyttes ofte mer avanserte loss-funksjoner som prøver å minimere modellkompleksitet.

2.9.3 Korrelasjon mellom dataserier

Når man vil vurdere om to datasett er forskjellige, kan man bruke gjennomsnittet av forskjellene, \(\text{mean}(x - y)\). Et bedre mål er ofte \(\text{std}(x - y)\) eller \(\text{RMSE}(x)\), om det ene datasettet regnes som referanse.

Men to datasett kan ha ulike gjennomsnitt og standardavvik, og likevel følge samme trend. Dette fanges verken av gjennomsnittet eller standardavviket, men derimot av korrelasjonen.

\[ r = \frac{ \tilde{x}^\top \tilde{y} }{ \|\tilde{x}\| \cdot \|\tilde{y}\| } = \hat{\tilde{x}}^\top \hat{\tilde{y}} \]

Her er \(\hat{\tilde{x}}\) og \(\hat{\tilde{y}}\) ​de normaliserte vektorene , altså enhetsvektorene som svarer til de sentrerte datasettene. Korrelasjon måler cosinus-likheten mellom enhetsvektorene av de sentrerte datasettene. Når \(r=1\), peker de i samme retning. Når \(r=−1\) peker de i motsatt retning. Og når \(r=0\), er det ingen lineær sammenheng. Denne typen korrelasjon kalles ofte Pearson-korrelasjon og er én av flere måter å vurdere hvor god en maskinlæringsmodell.

Nedenfor vises flere eksempler hvor to datasett \(x\) og \(y\) er plottet mot hverandre (og resulterende korrelasjon).

Eksempel

Oppgave: Gitt to vektorer (dataserier) med \(x\) og \(y\), som er relatert vet at \(y = 0.1x + 1\). Hva er korrelasjon mellom de?

Løsning: Intuitivt har disse samme trend, selv om de har ulike gjennomsnitt og størrelser, og derfor bør de ha \(r=1\), men hvordan skal man vise dette? I abstrakte oppgaver som dette er det om å gjøre å kvitte seg med så mange symboler og uavhengige størrelser som mulig. Vi prøver derfor først å uttrykke det sentrerte vektoren \(\tilde{y}\) i terme av \(\tilde{x}\)

Den sentrerte vektoren er gitt ved \(\tilde{x} = x- \mathrm{mean}(x)\), mens \(\tilde{y} = y- \mathrm{mean}(y)\).
Fra definisjonen av gjennomsnitt kan vi se at

\[\mathrm{mean}(y) = 0.1\times \mathrm{mean}(x) +1\]

Korrelasjon trenger vi å uttrykke de sentrere vektorene

\[ \tilde{y} = 0.1x + 1 - (0.1\times \mathrm{mean}(x) +1) \] Dette kan uttrykkes som

\[ \tilde{y} = 0.1 \tilde{x} \]

Fra definisjon av normen (enten den formelle eller 2-normen for vektoren så kan vet vi at \(\| \lambda \tilde{x}\| = \lambda \| \tilde{x}\|\). Anvendt på normen av \(\tilde{y}\) så får vi at \(\|\tilde{y} \| = 0.1 \| \tilde{x} \|\). Vi har da at

\[ \frac{\tilde{y}}{\|\tilde{y} \| } = \frac{\tilde{x}}{\|\tilde{x}\|} \]

Dette er to identiske enhetsvektoren, og indreproduktet er derfor 1.

2.10 Funksjoner som indreprodukt

En funksjon er en regel som tilordner et resultat til hvert punkt i rommet. I denne sammenhengen er det vanlig å tenke på en funksjon som tar inn en vektor \(x \in \mathbb{R}^n\), og returnerer enten et tall (en skalar) eller en ny vektor.

Eksempler på funksjoner som tar inn en vektor i \(\mathbb{R}^2\) : \(x = \begin{bmatrix} x_1 \\ x_2 \end{bmatrix}\) og returnerer et tall i \(\mathbb{R}\) : - \(f(x) = 3x_1 + 2x_2\) - \(f(x) = \|x\|^2 = x_1^2 + x_2^2\) - \(f(x) = a\cdot x = a^T x\), som er et indreprodukt mellom vektoren \(x\) og en vektor \(a\),.

Eksempler på funksjoner som returnerer en ny vektor av samme dimensjon (generelt f: \(\mathbb{R}^n \to \mathbb{R}^n\) ): - \(f(x) = 2x\) : funksjonen skalerer vektoren med en konstant. - \(f(x) = \frac{x}{\|x\|}\) : dette gir en enhetsvektor i samme retning som \(x\). Funksjoner som ikke gir et tall, kalles noen ganger operatorer.

En funksjon \(f: \mathbb{R}^n \to \mathbb{R}\) kalles lineær hvis den oppfyller to krav: 1. \(f(x + y) = f(x) + f(y)\)
2. \(f(\alpha x) = \alpha f(x)\) for alle tall \(\alpha\)

Eksempel: \[f(x) = a\cdot x = a^\top x\] er en lineær funksjon. Den er bygd opp av et indreprodukt, som igjen er en lineær kombinasjon av koordinatene til \(x\).

Et eksempel på en lineær funksjon fra mekanikken er Hookes lov for fjærer: \(F = kx\), der \(k\) er fjærkonstanten, \(F\) er kraften, og \(x\) er utslaget fra likevektsposisjonen.

For funksjon, \(f: \mathbb{R}^n \to \mathbb{R}\), kalles affin funksjon om den kan skrives som en lineær funksjon + en “offset”. \[ f(x) = a\cdot x + b= a^T x + b \]

2.11 Komplekse vektorer

Komplekse tall benyttes i mange anvendelser, som i signalanalyse, elektroteknikk, kontrollteori, robotikk og vibrasjonsanalyse. De gjør det mulig å beskrive vibrasjoner, bølger og stabilitet på en effektiv måte.

Et eksempel på en kompleks vektor er:

\[ u = \begin{bmatrix} 2\\ 1+3i \end{bmatrix} \quad \quad v = \begin{bmatrix} i \\ 2 +i \end{bmatrix} \]

Det komplekse konjugatet av et tall \(z = x + iy\) skrives som \(z^\ast = x - iy\).
Ofte brukes også notasjonen \(\overline{z}\) (som er mest vanlig i lærebøker) strek-symbolet betyr også kan bety gjennomsnitt i noen sammenhenger.

Indreprodukt av av komplekse vektorer er definert ved at man først tar en kompleks konjugasjon av det første elementet før man summer elementene. I matriseform skrives dette som følger:

\[ \gamma = (u^\ast)^T v = \sum_i u_i^\ast v_i \]

Dette skrives ofte med såkalt “dagger”-form \[ \gamma = u^\dagger v = (u^\ast)^T v = \sum_i u_i^\ast v_i \]

For eksempelet vårt over

\[ 2i + (1 - 3i)(2 + i) = 2i + (2 -6i + i - 3i^2) = 5 - 3i \] siden \(i²= -1\).

Dot-notasjonen brukt for indreprodukt av reelle vektorer unngås og man skriver i stedet

\[ \gamma = \langle u, v \rangle \]

I Python (med NumPy) regnes indreprodukt av to komplekse vektorer slik slik:

import numpy as np

u = np.array([2, 1 + 3j])
v = np.array([1j, 2 + 1j])
gamma = np.vdot(u, v)
println(gamma)  #

Merk at vi her bruker vdot, ikke dot. dot gir det vanlige vektoproduktet uten kompleks konjugering.

I Julia regnes indreprodukt ut slik:

u = [2, 1 + 3im]
v = [im, 2 + im]
gamma = u' v
println(gamma)

`