Wektoryzacja w Pythonie

Złożoność czasowa dowolnego algorytmu jest bardzo ważna przy podejmowaniu decyzji, czy aplikacja jest niezawodna, czy nie. Jak najszybsze uruchomienie dużego algorytmu jest bardzo ważne, jeśli chodzi o zastosowanie danych wyjściowych w czasie rzeczywistym. Aby to zrobić, Python ma kilka standardowych funkcji matematycznych do szybkiego wykonywania operacji na całych tablicach danych bez konieczności pisania pętli. Jedną z takich bibliotek, która zawiera taką funkcję, jest numpy . Zobaczmy, jak możemy użyć tej standardowej funkcji w przypadku wektoryzacji.

Co to jest wektoryzacja?
Wektoryzacja służy do przyspieszenia kodu Pythona bez użycia pętli. Korzystanie z takiej funkcji może pomóc zminimalizować czas wykonania kodu. Na wektorach wykonywane są różne operacje, takie jak iloczyn skalarny wektorów, który jest również znany jako iloczyn skalarny, ponieważ daje pojedynczy wynik, zewnętrzne iloczyny, w kwadratowej macierzy pomiarowej. równej długości X długości wektorów, mnożenie przez element, co daje iloczyn Element indeksów i wymiar macierzy pozostają niezmienione.

Będziemy zobacz, jak klasyczne metody trwają dłużej niż zwykłe funkcje, obliczając czas ich przetwarzania.

outer (a, b): Oblicz iloczyn zewnętrzny dwóch wektorów.
mnożenie (a, b): iloczyn macierzy dwóch tablic.
kropka (a, b): iloczyn skalarny dwóch tablic.
zera ((n, m)): Zwróć macierz o podanym kształcie i typie wypełnioną zerami.
process_time (): Zwraca wartość (w ułamkach sekund) sumy czasu systemu i czasu procesora użytkownika bieżącego procesu. Nie obejmuje czasu, jaki upłynął podczas snu.

Produkt kropkowy:
Produkt kropkowy — jest to operacja algebraiczna, w której dwa wektory o tej samej długości są mnożone tak, że daje jedną liczbę. Produkt Dot jest często określany jako Produkt wewnętrzny. Ten produkt daje liczbę skalarną. Rozważmy dwie macierze a i b o tej samej długości, iloczyn skalarny jest wykonywany przez transpozycję pierwszej macierzy, a następnie wykonane jest mnożenie macierzy matematycznej za pomocą a ' (transpozycja a) i b,, jak pokazano na poniższym obrazku.

Reprezentacja wizualna iloczynu skalarnego —

Poniżej znajduje się kod Pythona:

# Iloczyn kropkowy

import czas

import numpy

import tablica

# 8 bytes int

a = array.array ( `q` )

for i w zakresie ( 100000 ):

a.append (i);

b = tablica. array ( ` q` )

dla i in zakres ( 100000 , 200000 ):

b.append (i)

# klasyczne wektory implementacji iloczynu skalarnego

tic = czas.process_time ()

kropka = 0.0 ;

for i w range ( len (a)):

kropka + = a [i] * b [i]

toc = czas.process_time ()

print ( "dot_product =" + str (kropka));

print ( "Czas obliczeń =" + str ( 1000 * (toc - tic)) + "ms" )

n_tic = czas .process_time ()

n_dot_product = numpy.dot (a, b)

n_toc = czas.process_time ()

drukuj ( "n_dot_product =" + str (n_dot_product))

print ( "Czas obliczeń =" + str ( 1000 * (n_toc - n_tic)) + "ms" )

Wyjście:

dot_product = 833323333350000.0 Czas obliczeń = 35.59449199999999ms n_dot_p roduct = 833323333350000 Czas obliczeń = 0,1559900000000225ms 

Produkt zewnętrzny:
Iloczyn tensorowy dwóch wektorów współrzędnych nazywa się Praca zewnętrzna . Rozważmy dwa wektory a i b o wymiarach nx 1 i mx 1 to iloczyn zewnętrzny wektora prowadzi do prostokątna macierz nxm . Jeśli dwa wektory mają ten sam wymiar, wynikowa macierz będzie macierzą kwadratową, jak pokazano na rysunku.

Wizualna reprezentacja produktu zewnętrznego —

Poniżej znajduje się kod Pythona:

# Produkt Outdoor import czas import numpy import tablica a = array.array ( `i` ) for i in zakres ( 200 ): a.append (i); b = tablica. array ( ` i` ) dla i in zakres ( 200 , 400 ): b.append (i) # klasyczne implementacje zewnętrznych wektorów produktu tic = czas.process_time () outer_product = numpy.zeros (( 200 , 200 )) for i w range ( len ( a)): for j w zakres ( len (b)): outer_product [i] [j] = a [i] * b [j] toc = czas.process_time () print ( "outer_product =" + str (produkt_zewnętrzny)); print ( "Czas obliczeń =" + str ( 1000 * (toc - tic)) + "ms" ) n_tic = czas.process_time () outer_product = numpy.outer (a, b) n_toc = czas.process_time () print ( "outer_product =" + str (outer_product) ; print ( "Czas obliczeń =" + str ( 1000 * (n_toc - n_tic)) + "ms" ) Wyjście: outer_product = [[0. 0. 0. ... , 0. 0. 0.] [200.201.202. ... , 397. 398. 399.] [400. 402. 404. ... , 794. 796. 798.] ..., [39400. 39597. 39794. ... , 78209. 78406. 78603. ] [39600. 39798. 39996. ... , 78606. 78804. 79002.] [39800. 39999. 40198. ... , 79202. 79401.]] Czas obliczeń = 39.821617ms iloczyn_zewny = [[0 0 0 ..., 0 0 0] [200 201 202 ..., 397 398 399] [400 402 404 ..., 794 79 6 798] ..., [39400 39597 39794 ..., 78209 78406 78603] [39600 39798 39996 ..., 78606 78804 79002] [39800 39999 40198 ..., 79003 79202 79401]] Czas obliczeń = 0,2809480000000031ms Iloczyn elementów: Mnożenie elementów dwóch macierzy — jest to operacja algebraiczna, w której każdy element pierwszej macierzy jest mnożony przez odpowiedni element w późniejszej macierzy. Wymiary macierzy muszą być takie same. Rozważ dwie macierze a i b, indeks elementu w a — to są i i j, następnie a (i, j) należy pomnożyć przez b (i, j) , jak pokazano na poniższym obrazku. Wizualna reprezentacja mądrego produktu Element — Poniżej znajduje się kod Pythona: # Mnożenie elementów import czas import numpy import tablica a = array.array ( `i` ) for i in zakres ( 50000 ): a.append (i); b = tablica. array ( ` i` ) dla i in zakres ( 50000 , 100000 ): b.append (i) # klasycznych implementacji wektorów produktów element po elemencie wektor = numpy.zeros (( 50000 )) tic = czas.process_time () for i in range ( len (a)): wektor [i] = a [i] * b [i] toc = czas.process_time () print ( "Element mądry Produkt = " + str (wektor )); print ( "Czas obliczeń =" + str ( 1000 * (toc - tic)) + "ms" ) n_tic = czas .process_time () wektor = numpy.multiply (a, b) n_toc = czas.process_time () print ( "Element wise Product =" + str (wektor)); print ( "Czas obliczeń =" + str ( 1000 * (n_toc - n_tic)) + "ms" )

Wyjście:

 Element składowy Produkt = [0.000000000e + 00 5.00010000e + 04 1.00004000e + 05 ..., 4.99955001e + 09 4.99970000e + 09 4.99985000e + 09] Czas obliczeń = 23.516678000000013ms Element składowy Produkt = [0 50001 100004 . .. , 704582713 704732708 704882705] Czas obliczeń = 0,2250640000000248ms