Wektory są podstawowymi elementami składowymi algebry liniowej i odgrywają kluczową rolę w różnych algorytmach uczenia maszynowego. Ten wszechstronny samouczek ma na celu wyposażenie Cię w dogłębne zrozumienie wektorów, obejmujące ich definicję, funkcję, interpretację i implementację w Pythonie. Zdobędziesz biegłość w podstawowych operacjach wektorowych, takich jak algebra i iloczyn skalarny. Zrozumienie algebraicznych i geometrycznych właściwości wektorów jest niezbędne do wykonywania różnych operacji w analizie danych i uczeniu maszynowym, takich jak redukcja wymiarowości, grupowanie i klasyfikacja.

Spis treści:

· Algebraiczny i geometryczny widok wektorów

· Wielkość wektora i wektory jednostkowe

· Dodawanie i odejmowanie wektorów

· Mnożenie wektorowo-skalarne

· Mnożenie wektor-wektor (iloczyn skalarny)

· Wniosek

· Referencje

Algebraiczny i geometryczny widok wektorów

Koncepcje algebry liniowej można skutecznie wyrażać i wizualizować zarówno za pomocą reprezentacji algebraicznych, jak i geometrycznych, oferując potężną dwoistość w zrozumieniu. Dzieje się tak dlatego, że niektóre koncepcje są bardziej intuicyjnie uchwycone poprzez reprezentacje algebraiczne (przechowywanie danych sprzedaży w czasie), podczas gdy inne są lepiej interpretowane za pomocą terminów geometrycznych (geometryczna interpretacja wektora jest przydatna w fizyce i inżynierii) [1]. Wykorzystując to podwójne podejście, można uzyskać pełniejsze zrozumienie koncepcji algebry liniowej i ich praktycznych zastosowań.

Wektor można przedstawić algebraicznie jako uporządkowaną listę składowych, zwykle wartości liczbowych, gdzie kolejność tych składowych ma określone znaczenie [2]. Każda składowa wektora jest określana jako element, a całkowita liczba elementów w wektorze jest określana jako jego wymiarowość (Rysunek 1A). Wektory mogą być reprezentowane w dwóch orientacjach — w kolumnie (stojąc wysoko) lub orientacji w rzędzie (leżąc płasko i szeroko). Standardowa notacja reprezentująca wektory to mała, pogrubiona litera łacińska (czasami uzupełniona symbolem strzałki nad literą).

Patrząc na geometryczną interpretację wektorów, możemy zwizualizować wektor jako linię prostą o określonej długości i kierunku w przestrzeni. Długość wektora reprezentuje jego wielkość (patrz poniżej), podczas gdy kierunek jest wskazywany przez orientację wektora w stosunku do punktu odniesienia lub osi. Chociaż wektory są zazwyczaj rysowane zaczynając od początku wykresu (jest to tak zwana pozycja standardowa), można je umieścić w dowolnym miejscu w przestrzeni bez wpływu na ich właściwości. W rzeczywistości kierunek i wielkość wektora pozostają takie same niezależnie od jego punktu początkowego, o ile jego punkt końcowy pozostaje taki sam (Rysunek 1B). Punkt początkowy wektora jest określany jako ogon, podczas gdy punkt końcowy, zwykle rysowany grotem strzałki, jest określany jako początek wektora.

W Pythonie wektory można wyrażać za pomocą różnych typów danych. Chociaż użycie typu listy może wydawać się prostym podejściem do reprezentacji wektora, może nie być odpowiednie dla niektórych aplikacji wymagających operacji algebry liniowej [1]. Dlatego często preferowane jest tworzenie wektorów jako tablic NumPy, ponieważ pozwalają one na wydajniejsze i efektywniejsze operacje (Rysunek 2).

# Create the vector as NumPy array 
u = np.array([1,3])

# plot the vector
plt.plot([0,u[0]],[0,u[1]], lw=3)
plt.axis('equal')
plt.plot([0, 4],[0, 0],'k-')
plt.plot([0, 0],[0, 4],'k-')
plt.grid(color = 'green', linestyle = '--', linewidth = 0.5)
plt.xticks(np.arange(0, 5, 1))
plt.title("2-dimensional vector ( u=[1,3] ) using NumPy array")

# Annotate the vector
plt.annotate("u = [1,3]", xy=(1+0.3,3), color ="blue")
Output:

      
                

                    
                    
                
            

Wielkość wektora, znana również jako jego długość geometryczna lub norma, jest określona przez odległość od jego ogona do głowy. Oblicza się ją za pomocą standardowego wzoru na odległość euklidesową (Rysunek 3A). W matematyce odległość euklidesowa między dwoma punktami w przestrzeni euklidesowej to długość odcinka między tymi dwoma punktami. Można ją obliczyć ze współrzędnych kartezjańskich punktów za pomocą twierdzenia Pitagorasa i czasami nazywa się ją odległością Pitagorasa [3]. Wielkość wektora jest oznaczona za pomocą podwójnych pionowych kresek wokół wektora, jak w ∥ v ∥ (Rysunek 3A).

W niektórych zastosowaniach potrzebujemy wektora o długości geometrycznej równej jeden, który jest nazywany wektorem jednostkowym (czasami nazywanym wektorem kierunkowym). Przykładowe zastosowania obejmują macierze ortogonalne, macierze rotacji, wektory własne i wektory osobliwe [2]. Wektory jednostkowe są oznaczone symbolem „cap” ^ i są definiowane jako wielkość = ∥ v ∥ = 1. Na przykład wektor u = (1, 3) nie jest wektorem jednostkowym, ponieważ jego wielkość nie jest równa 1 ( tj. ||v|| = √(12+32) ≠ 1) (Rysunek 3A). Każdy wektor może stać się wektorem jednostkowym, jeśli podzielimy go przez wielkość tego samego danego wektora (Rysunek 3B). i oraz j to specjalne wektory jednostkowe (zwane także standardowymi wektorami jednostkowymi), które są równoległe do osi współrzędnych w kierunkach odpowiednio osi x i osi y na płaszczyźnie dwuwymiarowej. tj,

|i| = 1

|j| = 1

W Pythonie normę (wielkość) wektora u obliczamy za pomocą funkcji np.linalg.norm(). Ponadto wektor jednostkowy u_hat oblicza się dzieląc wektor u przez jego normę.

# Create the vector as NumPy array 
u = np.array([1,3])

# Find the norm using np.linalg.norm() function
norm = np.linalg.norm(u)

# Find unit vector
u_hat= u / np.linalg.norm(u)

      
                

                    
                    
                
            

Dodawanie i odejmowanie wektorów to podstawowe operacje w algebrze liniowej. Aby wykonać algebraiczne dodawanie lub odejmowanie dwóch wektorów, musimy upewnić się, że mają one tę samą wymiarowość. Na przykład możemy dodać dwa wektory trójwymiarowe lub dwa wektory dwuwymiarowe, ale nie możemy dodać wektora trójwymiarowego i wektora dwuwymiarowego (Rysunek 4A). Aby algebraicznie dodawać lub odejmować wektory, po prostu dodajemy lub odejmujemy odpowiednie elementy wektorów. Na przykład, jeśli mamy dwa wektory u i v ze składowymi odpowiednio [1, 3] i [3, 2], to ich suma wynosi [4, 5] (Rysunek 4A).

Geometrycznie, aby dodać dwa wektory, najpierw rysujemy je jako strzałki z ogonem jednego wektora na początku drugiego wektora. Suma dwóch wektorów to wektor, który zaczyna się na końcu pierwszego wektora i kończy na początku drugiego wektora. Wynikowy wektor reprezentuje przemieszczenie między punktem początkowym pierwszego wektora a punktem końcowym drugiego wektora. Załóżmy na przykład, że mamy dwa wektory u = [1, 3] i v = [3, 2], które pokazano na rysunku 4B. Aby je dodać, najpierw rysujemy u zaczynając od początku (0,0) i v zaczynając od początku u, jak pokazano. Suma dwóch wektorów jest wektorem, który zaczyna się w początku i kończy na początku v.

W Pythonie dodawanie i odejmowanie wektorów odbywa się za pomocą tablic NumPy.

# Create vectors as NumPy array 
u = np.array([1,3])
v= np.array([3,2])

w =u+v  # addition
z=u-v   # subtraction

# plot the vectors
plt.plot([0,u[0]],[0,u[1]], color="blue")
plt.plot([0,v[0]],[0,v[1]], color="red")
plt.plot([0,w[0]],[0,w[1]], color="yellow")
plt.plot([0,z[0]],[0,z[1]], color="green")

plt.axis('equal')
plt.plot([-6, 6],[0, 0],'k-')
plt.plot([0, 0],[-46, 46],'k-')
plt.grid(color = 'green', linestyle = '--', linewidth = 0.5)
plt.axis((-6, 6, -6, 6))
plt.xticks(np.arange(-7, 8, 1))
plt.yticks(np.arange(-7, 8, 1))

plt.title("Vector addition and subtraction")

# Annotate the vector
plt.annotate("u = [1,3]", xy=(1+0.3,3), color ="blue")
plt.annotate("v = [3,2]", xy=(3+0.3,2), color ="red")
plt.annotate("w = [4,5]", xy=(4+0.3,5), color ="yellow")
plt.annotate("w = [-2,1]", xy=(-2+0.3,1), color ="green")

Output:

      
                

                    
                    
                
            

W algebrze liniowej skalar odnosi się do pojedynczej wartości liczbowej, która nie jest częścią wektora ani macierzy. Te wartości (skalary) są zwykle przedstawiane za pomocą małych liter greckich, takich jak α lub λ. Mnożenie wektora przez skalar, oznaczone jako β * u (u jest wektorem używanym w tym samouczku), jest prostą operacją, w której każdy element wektora jest mnożony przez wartość skalarną. Wynikiem tej operacji jest nowy wektor o tym samym kierunku co pierwotny wektor, ale o zmienionej wielkości/długości (Rysunek 6B). To mnożenie przez skalar można wykorzystać do rozciągania lub zmniejszania wektorów, a także do zmiany ich kierunku. Na przykład pomnożenie wektora przez ujemny skalar (np. -1,5) spowoduje odwrócenie jego kierunku, podczas gdy pomnożenie go przez skalar większy niż 1 spowoduje jego rozciągnięcie.

W Pythonie mnożenie wektorowo-skalarne jest wykonywane przy użyciu biblioteki NumPy.

# Create vectors as NumPy array 
u = np.array([1,3])
α=1.5
λ=-1.5

w =u*α 
z= u*λ  

# plot the vectors
plt.plot([0,u[0]],[0,u[1]], color="blue")
plt.plot([0,w[0]],[0,w[1]], color="black")
plt.plot([0,z[0]],[0,z[1]], color="black")

plt.axis('equal')
plt.plot([-6, 6],[0, 0],'k-')
plt.plot([0, 0],[-46, 46],'k-')
plt.grid(color = 'green', linestyle = '--', linewidth = 0.5)
plt.axis((-6, 6, -6, 6))
plt.xticks(np.arange(-7, 8, 1))
plt.yticks(np.arange(-7, 8, 1))

plt.title("Vector-Scalar Multiplication")
# Annotate the vectors
plt.annotate("u = [1,3]", xy=(1+0.3,3), color ="blue")
plt.annotate("w =  [1.5,4.5]", xy=(1.5+0.3,4.5), color ="black")
plt.annotate("z = [-1.5,-4.5]", xy=(-1.5+0.3,-4.5), color ="black")

Output:

      
                

                    
                    
                
            

Iloczyn skalarny (czasami nazywany iloczynem wewnętrznym) jest jedną z najważniejszych operacji w całej algebrze liniowej. Jest to obliczeniowy element konstrukcyjny, na którym zbudowano wiele algorytmów, począwszy od korelacji, przez splot, aż po transformację Fouriera [2]. Iloczyn skalarny to pojedyncza liczba, która dostarcza informacji o relacji między dwoma wektorami (Rysunek 8). Istnieje kilka sposobów wskazania iloczynu skalarnego między dwoma wektorami, najczęściej używanym zapisem jest uTv (możesz też zobaczyć u · v, < u, v >).

Istnieje wiele sposobów implementacji iloczynu skalarnego w Pythonie.

# Create vectors as NumPy array
u = np.array([1,3])
v= np.array([3,2])

# method 1, using np.dot()
dotp1= np.dot(u,v)

# method 2 using np.matmul()
dotp2= np.matmul(u,v)

# method 3
dotp3= np.sum(np.multiply(u,v))

print(dotp1, dotp2, dotp3)
Output:
9 9 9

Wniosek

Podsumowując, wektory odgrywają znaczącą rolę w wielu dziedzinach, takich jak matematyka, nauka o danych i inżynieria. Można je interpretować zarówno algebraicznie, jak i geometrycznie, co czyni je niezbędnymi do przydatnych obliczeń i transformacji. Pojęcia omówione w tym samouczku, takie jak wielkość wektora, wektory jednostkowe, dodawanie i odejmowanie wektorów oraz mnożenie przez skalar i wektor, są elementami składowymi bardziej zaawansowanych zagadnień z algebry liniowej i analizy danych. Opanowanie tych koncepcji może zapewnić niezbędne umiejętności i narzędzia do rozwiązywania złożonych problemów w takich dziedzinach, jak uczenie maszynowe, wizja komputerowa i fizyka.

Przygotowałem recenzję kodu towarzyszącą temu wpisowi na blogu, którą można obejrzeć na moim GitHubie .

Bibliografia

[1] M. Cohen, Praktyczna algebra liniowa dla nauki o danych: od podstawowych pojęć do aplikacji przy użyciu języka Python , wydanie 1. O'Reilly Media, 2022.

[2] G. Strang, Wprowadzenie do algebry liniowej , wydanie 6. Wellesley-Cambridge Press, 2023.

[3] „Odległość euklidesowa”, Wikipedia . 9 kwietnia 2023 r. Dostęp: 25 kwietnia 2023 r. [Online]. Dostępny:https://en.wikipedia.org/w/index.php?title=Euclidean_distance&oldid=1149051427

Kodowanie na wyższym poziomie

Dziękujemy za bycie częścią naszej społeczności! Zanim pójdziesz:

• Klaskajcie za relację i śledźcie autora
• Zobacz więcej treści w publikacji Level Up Coding
• Bezpłatny kurs rozmowy o kodowaniu ⇒ Zobacz kurs
• Śledź nas: Twitter | LinkedIn | Biuletyn