De um tradutor: esta é uma tradução do material de Rakshit Vasudev, que estuda o DataScience há muito tempo e usa a linguagem Python nele. O autor fala sobre a poderosa biblioteca Numpy, que permite implementar muitos recursos de aprendizado de máquina e trabalhar com big data.
Numpy é uma biblioteca de matemática para Python. Permite realizar todos os tipos de cálculos de maneira eficiente e rápida. Ele expande bastante a funcionalidade do Python, graças às soluções especiais usadas nele. Este artigo fala sobre os recursos básicos do Numpy, e esta é apenas a primeira parte; outros serão publicados um pouco mais tarde. Este artigo é para aqueles que estão começando a aprender o Numpy, entrando no valente mundo da matemática em Python.
A Skillbox recomenda: O desenvolvedor Python desde o início do curso prático .
Lembramos que: para todos os leitores de "Habr" - um desconto de 10.000 rublos ao se inscrever em qualquer curso Skillbox usando o código promocional "Habr".
Biblioteca de importação
import numpy as np
Neste ponto, dizemos ao Python que np é a referência para o Numpy, que continuará sendo usado.
Agora crie uma matriz python e uma matriz np.
Não há muita diferença na retirada.
print(a) print(A) ==================================================================== [1, 2, 3, 4, 5, 6, 7, 8, 9] [1 2 3 4 5 6 7 8 9]
Bem, por que é melhor usar uma matriz numpy em vez da usual? A resposta é que o np nos permitirá acelerar os cálculos e modificar a arquitetura geral do aplicativo.
np.arange ()
np.arange(0,10,2) ==================================================================== array([0, 2, 4, 6, 8])
([iniciar], parar, [passo]) ordena os números. Isto é o que isso significa para um carro.
Criamos uma lista de np, começando de 0 a 10, mas não inclui 10, além de aumentar os números em 2 a cada vez.
Assim, obtemos o seguinte:
matriz ([0, 2, 4, 6, 8])
É importante lembrar que o último dígito não está incluído na lista.
Outro exemplo:
np.arange(2,29,5) ==================================================================== array([2, 7, 12, 17, 22, 27])
Essa matriz também pode ser chamada de matriz ou vetor. Portanto, não se preocupe quando digo, por exemplo: "A forma da matriz é 2 * 3." Tudo isso significa que nossa matriz acabará parecida com esta:
array([2, 7, 12], [17, 22, 27])
Agora vamos falar sobre um parâmetro como shape para a matriz np padrão. Forma aqui é um atributo. Um exemplo de seu uso está abaixo.
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.shape ==================================================================== (9,)
Esta é uma matriz de números, onde em uma fileira existem apenas 9 elementos. Em princípio, uma matriz 1 * 9 é ideal, certo?
Basicamente, sim, e para isso, reformular () entra em jogo. Este é um método que redimensiona a matriz original como gostaríamos.
Aqui está um exemplo do uso de reshape () na prática.
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.reshape(1,9) ==================================================================== array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])
Observe que remodelar retorna uma matriz multidimensional. Isso é indicado por dois colchetes no início. [[1, 2, 3, 4, 5, 6, 7, 8, 9]] é uma matriz potencialmente multidimensional, diferente de [1, 2, 3, 4, 5, 6, 7, 8, 9].
Outro exemplo:
B = [1, 2, 3, 4, 5, 6, 7, 8, 9] B.reshape(3,3) ==================================================================== array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
Se pegarmos o parâmetro shape para B, então será (3.3):
B.shape ==================================================================== (3,3)
Vamos para np.zeros ()
O que está escrito neste código?
np.zeros((4,3)) ==================================================================== ???????????
Ou seja: aqui é fornecida uma matriz de formato 3 * 4 preenchida com zeros. Aqui está a conclusão:
np.zeros((4,3)) ==================================================================== array([[0., 0., 0.], [0., 0., 0.], [0., 0., 0.], [0., 0., 0.]])
np.zeros ((n, m)) retorna uma matriz de formato n * m preenchida com zeros. Tudo é simples.
O que o np.eye () faz?
Retorna para nós uma matriz unitária com certas características.
np.eye(5) ==================================================================== array([[1., 0., 0., 0., 0.], [0., 1., 0., 0., 0.], [0., 0., 1., 0., 0.], [0., 0., 0., 1., 0.], [0., 0., 0., 0., 1.]])
Como multiplicar duas matrizes?
Não há problema: np.dot () é usado para isso.Esta função é um produto escalar se vetores e o produto da matriz (o mais comum) forem passados para ele.
Exemplo: A = (2,3) & B = (3,2). Aqui, o número de colunas em A é 3. O número de linhas em B é 3. Como as características coincidem, a multiplicação é possível.
Nós preparamos matrizes para multiplicação. Em seguida - agimos.
Agora vamos adicionar os elementos individuais à matriz.
np.sum () adiciona elementos à matriz.
No entanto, temos duas opções.
1. Dobre em linhas
6 - a soma da primeira linha (1, 2, 3).
15 segundos (4, 5, 6).
24 - terceiro (7, 8, 9).
2. Dobre em colunas
12 - a soma da primeira coluna (1, 4, 7).
15 - segundo o segundo (2, 5, 7).
18 - de acordo com o terceiro (3, 6, 9).
Abaixo está um vídeo criado pelo autor, onde tudo descrito acima é explicado novamente, mais claramente.
A Skillbox recomenda: