Vetorização em Python

| | | | | | | | | |

A complexidade de tempo de qualquer algoritmo é muito importante para decidir se um aplicativo é confiável ou não. A execução de um algoritmo grande o mais rápido possível é muito importante quando se trata de aplicar a saída em tempo real. Para fazer isso, o Python possui várias funções matemáticas padrão para executar operações rapidamente em matrizes inteiras de dados sem precisar escrever loops. Uma dessas bibliotecas que contém essa função é a numpy . Vamos ver como podemos usar essa função padrão no caso de vetorização.

O que é vetorização?
A vetorização é usada para acelerar o código Python sem usar um loop. Usar essa função pode ajudar a minimizar o tempo de execução do código. Várias operações são executadas em um vetor, como o produto escalar de vetores, que também é conhecido como produto escalar, porque produz uma única saída, produtos externos que resultam em uma matriz quadrada de medidas. igual ao comprimento X do comprimento dos vetores, multiplicação por um elemento, que produz o produto O elemento dos índices e a dimensão da matriz permanecem inalterados.

Vamos veja como os métodos clássicos demoram mais do que as funções comuns, calculando seu tempo de processamento.

externo (a, b): Calcule o produto externo de dois vetores.
multiplicar (a, b): produto matricial de duas matrizes.
ponto (a, b): produto escalar de duas matrizes.
zeros ((n, m)): Retorna uma matriz de forma e tipo fornecidos, preenchida com zeros.
process_time (): Retorna o valor (em segundos fracionários) da soma do tempo de CPU do sistema e do usuário do processo atual. Não inclui o tempo decorrido durante o sono.

Produto escalar:
Produto escalar — é uma operação algébrica na qual dois vetores de igual comprimento são multiplicados para produzir um número. O Produto Dot é frequentemente chamado de Produto Interno . Este produto resulta em um número escalar. Vamos considerar duas matrizes a e b de mesmo comprimento, o produto escalar é realizado pela transposição da primeira matriz, e então é realizada a multiplicação da matriz matemática por a ' (transpor a) e b, conforme mostrado na imagem abaixo.

Representação visual do produto escalar —

Abaixo está o código Python:


# Dot product

import hora

import numpy

import array


# 8 bytes int

a = array.array ( `q` )

para i em intervalo ( 100000 ):

a.append (i);


b = array. array ( ` q` )

para i em intervalo ( 100000 , 200000 ):

b.append (i)


# vetores de implementação de produto escalar clássico

tic = tempo.process_time ()

ponto = 0.0 ;


para i em intervalo ( len (a)):

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


toc = hora.process_time ()


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

print ( "Computation time=" + str ( 1000 * (toc - tic)) + "ms" )



n_tic = hora .process_time ()

n_dot_product = numpy.dot (a, b)

n_toc = hora.process_time ()


print ( "n_dot_product =" + str (n_dot_product))

print ( "Tempo de computação =" + str ( 1000 * (n_toc - n_tic)) + "ms" )

Sair:

dot_product = 833323333350000.0 Tempo de computação = 35,59449199999999ms n_dot_p roduto = 833323333350000 Tempo de computação = 0,1559900000000225ms 

Produto externo:
Produto tensorial de dois vetores de coordenadas é chamado Trabalho externo . Considere dois vetores a e b com dimensões nx 1 e mx 1 então o produto externo do vetor leva a uma matriz retangular nxm . Se dois vetores tiverem a mesma dimensão, a matriz resultante será uma matriz quadrada, conforme mostrado na figura.

Representação visual do produto externo —

Abaixo está o código Python:


# Produto ao ar livre

import time

import numpy

import array


a = array.array ( `i` )

para i em intervalo ( 200 ):

a.append (eu);


b = array. array ( ` i` )

para i em intervalo ( 200 , 400 ):

b.append (i)


# implementações de vetores de produtos externos clássicos

tic = tempo.process_time ()

outer_product = numpy.zeros (( 200 , 200 ))


para i em intervalo ( len ( a)):

for j in intervalo ( len (b)):

outer_product [i] [j] = a [i] * b [j]


toc = hora.process_time ()


print ( "outer_product =" + str (outer_product));

print ( "Tempo de computação =" + str ( 1000 * (toc - tic)) + "ms" )


n_tic = hora.process_time ()

outer_product = numpy.outer (a, b)

n_toc = hora.process_time ()

print ( "outer_product =" + str (outer_product));

print ( "Computation time=" + str ( 1000 * (n_toc - n_tic)) + "ms" )


Sair:

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.]] Tempo de computação = 39,821617ms produto_externo = [[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] Tempo de cálculo = 0,2809480000000031ms 

Produto por elemento:
Multiplicação por elemento de duas matrizes — é uma operação algébrica em que cada elemento da primeira matriz é ‚Äã‚Äãmultiplicado pelo elemento correspondente na matriz posterior. As dimensões das matrizes devem ser as mesmas.
Considere duas matrizes a e b, o índice do elemento em a — estes são i e j, então a (i, j) é multiplicado por b (i, j) , respectivamente, conforme mostrado na figura abaixo.

Representação visual do produto sábio Elemento —

Abaixo está o código Python:


# Multiplicação por elementos

importar hora

importar numpy

importar array

a = array.array ( `i` )

para i em intervalo ( 50000 ):

a.append (i);


b = array. array ( ` i` )

para i em intervalo ( 50000 , 100000 ):

b.append (i)


# implementações clássicas de vetor de produto item por item

vetor = numpy.zeros (( 50000 ))


tic = hora.process_time ()

para i em range ( len (a)):

vetor [i] = a [i] * b [i]

toc = hora.process_time ()


print ( "Element sábio Product = " + str (vetor ));

print ( "Tempo de computação =" + str ( 1000 * (toc - tic)) + "ms" )



n_tic = hora .process_time ()

vector = numpy.multiply (a, b)

n_toc = hora.process_time ()


print ( "Elementwise Product =" + str (vetor));

print ( "Computation time=" + str ( 1000 * (n_toc - n_tic)) + "ms" )

Sair:

< Pré> Elemento Produto Sábio = [0.00000000E + 00 5.00010000E + 04 1.0001004000E + 05 ..., 4.99955001E + 09 4.99970000E + 09 4.999700E + 09 4.99985000E + 09] Tempo de computação = 23.516678000000013ms elemento produto sábio = [0 50001 100004. .. , 704582713 704732708 704882705] Tempo de computação = 0,2250640000000248ms

Shop

Learn programming in R: courses

$

Best Python online courses for 2022

$

Best laptop for Fortnite

$

Best laptop for Excel

$

Best laptop for Solidworks

$

Best laptop for Roblox

$

Best computer for crypto mining

$

Best laptop for Sims 4

$

Latest questions

NUMPYNUMPY

psycopg2: insert multiple rows with one query

12 answers

NUMPYNUMPY

How to convert Nonetype to int or string?

12 answers

NUMPYNUMPY

How to specify multiple return types using type-hints

12 answers

NUMPYNUMPY

Javascript Error: IPython is not defined in JupyterLab

12 answers

News


Wiki

Python OpenCV | cv2.putText () method

numpy.arctan2 () in Python

Python | os.path.realpath () method

Python OpenCV | cv2.circle () method

Python OpenCV cv2.cvtColor () method

Python - Move item to the end of the list

time.perf_counter () function in Python

Check if one list is a subset of another in Python

Python os.path.join () method