Articles

Numpy standard deviation explained

by admin

this tutorial will explain how to use the Numpy standard deviation function (AKA, np.padrao).

a um nível elevado, a função de desvio padrão Numpy é simples. Ele calcula o desvio padrão dos valores em uma matriz Numpy.

mas os detalhes de exatamente como a função funciona são um pouco complexos e requerem alguma explicação.

dito isto, este tutorial irá explicar como usar a função de desvio padrão Numpy.

irá explicar a sintaxe de np.std (), e mostrar-lhe exemplos claros, passo a passo de como a função funciona.

O tutorial está organizado em seções. Você pode clicar em qualquer um dos seguintes links, que irá levá-lo para a seção apropriada.

Índice:

  • uma revisão muito rápida do Numpy
  • Introdução ao desvio-padrão Numpy
  • a sintaxe do np.std
  • Numpy standard deviation examples
  • Numpy standard deviation FAQ

tendo dito que, se você é relativamente novo para Numpy, você pode querer ler todo o tutorial.

a quick review of Numpy

Let’s just start off with a veeery quick review of Numpy.o que é o Numpy?

Numpy é um kit de ferramentas para trabalhar com dados numéricos

Para colocá-lo simplesmente, Numpy é um kit de ferramentas para trabalhar com dados numéricos.

primeiramente, Numpy tem um conjunto de ferramentas para criar uma estrutura de dados chamada de matriz Numpy.

Você pode pensar em uma matriz Numpy como uma linha-e-coluna de números. Matrizes Numpy podem ser 1-dimensional, 2-dimensional, ou mesmo n-dimensional.

uma matriz 2D parece-se com isto:

um exemplo de uma matriz NumPy bidimensional com os números 0 a 7.

por uma questão de simplicidade, neste tutorial, vamos nos ater a matrizes 1 ou 2-dimentivas.

Há uma variedade de maneiras de criar diferentes tipos de arrays com diferentes tipos de números. Algumas outras ferramentas para criar matrizes Numpy incluem numpy arranjo, numpy zeros, numpy uns, numpy tile, e outros métodos.

independentemente de como você cria seu array Numpy, em um alto nível, eles são simplesmente arrays de números.

Numpy fornece ferramentas para manipular matrizes Numpy

Numpy não só fornece ferramentas para criar matrizes Numpy, mas também fornece ferramentas para trabalhar com matrizes Numpy.

algumas das mais importantes destas ferramentas Numpy são funções Numpy para realizar cálculos.

Há um conjunto inteiro de funções Numpy para fazer coisas como:

  • computing the sum of a Numpy array
  • calculando o máximo
  • calculando a exponencial dos números num array
  • computando o valor x para alguma potência, para cada valor num array Numpy

… and uma variedade de outros cálculos.

O desvio padrão Numpy é essencialmente muito parecido com estas Outras ferramentas Numpy. É apenas usado para realizar uma computação (o desvio padrão) de um grupo de números em uma matriz Numpy.

uma introdução rápida ao desvio-padrão Numpy

a um nível muito elevado, o desvio-padrão é uma medida da propagação de um conjunto de dados. Em particular, é uma medida de quão longe os pontos de dados estão da média dos dados.vamos rever brevemente o cálculo básico.o desvio-padrão é calculado como a raiz quadrada da variância.

assim, se tivermos um conjunto de dados com n números, a variância será:

\begin{equation*} \frac{1}{N} \displaystyle\sum_{i=1}^N (x_i - \overline{x})^2 \end{equation*}

E o desvio padrão será a raiz quadrada da variância:

\begin{equation*} \sqrt{\frac{1}{N} \displaystyle\sum_{i=1}^N (x_i - \overline{x})^2} \end{equation*}

Onde:

x_i = valores individuais no conjunto de dados
N = o número de valores do conjunto de dados
\overline{x} = média dos valores x_i

a Maior parte do tempo, calcular o desvio padrão é um pouco difícil, porque você precisa para calcular a média, os desvios de cada ponto de dados a partir da média, então o quadrado dos desvios, etc. Francamente, é um pouco entediante.

no entanto, se estiver a trabalhar em Python, pode usar a função de desvio-padrão Numpy para efectuar o cálculo por si.

uma nota rápida se você é novo nas estatísticas

porque este post é sobre o uso do numpy.função std (), eu não quero entrar muito fundo nas ervas daninhas sobre como o cálculo é realizado à mão. Este tutorial é realmente sobre como usamos a função. Então, se você precisar de uma rápida revisão do que é o desvio padrão, você pode assistir este vídeo.Ok. Tendo revisto rapidamente o que é o desvio padrão, vamos olhar para a sintaxe para np.padrao.

a sintaxe de np.std

a sintaxe da função de desvio padrão Numpy é bastante simples.

eu vou explicar em apenas um segundo, mas primeiro, eu quero dizer-lhe uma nota rápida sobre sintaxe Numpy.

uma nota rápida: a sintaxe exata depende de como você importa Numpy

tipicamente, quando nós escrevemos sintaxe Numpy, nós usamos o pseudônimo “np”. Essa é a convenção comum entre a maioria dos cientistas de dados.

para definir essa alcunha, terá de importar o Numpy desta forma:

import numpy as np

If we import Numpy with this alias, we’ll call the Numpy standard deviation function as np.std().

Ok, dito isto, vamos dar uma olhada mais de perto na sintaxe.

np.Std sintaxe

em um alto nível, a sintaxe para np.std se parece com algo assim:

Como eu mencionei anteriormente, supondo que temos importado Numpy com o alias “np” nós chamamos a função com a sintaxe np.std().

depois, dentro do parêntesis, existem vários parâmetros que lhe permitem controlar exatamente como a função funciona.vamos dar uma olhada nesses parâmetros.

os parâmetros de numpy.std

Existem alguns parâmetros importantes que você deve saber:

  • a
  • axis
  • dtype
  • ddof
  • keepdims
  • out

Vamos dar uma olhada em cada um deles.

a(obrigatório)

a parâmetro especifica a matriz de valores sobre os quais você deseja calcular o desvio padrão.

dito de forma diferente, Isto permite-lhe especificar o array de entrada para a função.

As entradas apropriadas incluem matrizes Numpy, mas também objetos “array like” como listas Python.

importante, você deve fornecer uma entrada para este parâmetro. É necessária uma entrada.

dito isto, o parâmetro em si pode ser implícito ou explícito. O que quero dizer com isso, é que você pode digitar diretamente o parâmetro a=, ou você pode deixar o parâmetro fora de sua sintaxe, e simplesmente digitar o nome de sua matriz de entrada.

vou mostrar exemplos disso no exemplo 1.

axis

O parâmetro do eixo permite-lhe indicar um eixo ao longo do qual será calculado o desvio-padrão.

para entender isso, você realmente precisa entender eixos.

As matrizes Numpy têm eixos.

Você pode pensar em um “eixo” como uma direção ao longo da matriz.

em uma matriz bidimensional, haverá 2 eixos: eixo-0 e eixo-1.

em uma matriz 2D, eixo-0 pontos para baixo ao longo das linhas, e eixo-1 Pontos horizontalmente ao longo das colunas.

visualmente, você pode visualizar os eixos de uma matriz 2D como esta:

a visual example of NumPy array axes.

Usando o parâmetro axis, você pode calcular o desvio padrão em uma determinada direção ao longo da matriz.

isto é melhor ilustrado com exemplos, por isso vou mostrar-lhe um exemplo no exemplo 2.

(para uma explicação completa dos eixos Numpy array, veja o nosso tutorial chamado eixos Numpy explicado.)

dtype

(opcional)
dtype parâmetro permite-lhe especificar o tipo de dados que você deseja usar ao np.std calcula o desvio padrão.

Se os dados na matriz de entrada são inteiros, então isso irá default para float64.

Caso contrário, se os dados na matriz de entrada forem flutuantes, Então Isto irá default para o mesmo tipo de float que a matriz de entrada.

ddof

(opcional)
Isto permite-lhe indicar os “graus de liberdade” para o cálculo.

para entender isso, você precisa olhar para a equação 2 novamente.

\

nesta equação, o primeiro termo é \frac{1}{N}.

lembre – se: N é o número de valores na matriz ou conjunto de dados.mas se estamos a pensar em termos estatísticos, há uma diferença entre calcular um desvio padrão da população versus um desvio padrão da amostra.

Se computarmos um desvio padrão da população, usamos o termo \frac{1}{n} na nossa equação.

no Entanto, quando calculamos o desvio padrão de uma amostra de dados (um exemplo de n pontos de dados), então precisamos modificar a equação para que o líder termo é \frac{1}{n - 1}. Nesse caso, a equação para um desvio padrão da amostra torna-se:

\begin{equation*} s_{exemplo} = \sqrt{\frac{1}{n - 1} \displaystyle\sum_{i=1}^N (x_i - \overline{x})^2} \end{equation*}

Como podemos implementar esta com np.DST?

Podemos fazer isto com o parâmetro ddof, definindo ddof = 1.

E, na verdade, podemos definir o termo ddof de forma mais geral. Quando nós usamos ddof, ele irá modificar o cálculo de desvio padrão para tornar-se:

\begin{equation*} \sqrt{\frac{1}{n - ddof} \displaystyle\sum_{i=1}^N (x_i - \overline{x})^2} \end{equation*}

Para ser honesto, isto é um pouco técnico. Se você precisa aprender mais sobre isso, você deve assistir este vídeo na Academia Khan sobre os graus de liberdade, e população vs desvio padrão amostra.

out

(opcional)
out parâmetro permite-lhe especificar uma alternativa matriz para colocar a saída.

deve ter a mesma forma que a saída esperada.

keepdims

(opcional)
keepdims parâmetro pode ser usado para “manter” o número original de dimensões. Quando você definir keepdims = True, o resultado terá o mesmo número de dimensões que a entrada.

lembre-se: quando computarmos o desvio padrão, a computação irá “colapsar” o número de dimensões.

Por exemplo, se introduzirmos um array bidimensional como uma entrada, então por padrão, np.o std irá emitir um número. Um valor escalar.

mas se queremos que a saída seja um número dentro de um array 2D( ou seja, um array de saída com as mesmas dimensões que a entrada), então podemos definir keepdims = True.

para ser honesto, alguns destes parâmetros são um pouco abstratos, e eu acho que eles farão muito mais sentido com exemplos.

vamos dar uma olhada em alguns exemplos.

exemplos de como usar o desvio padrão Numpy

Aqui, vamos trabalhar através de alguns exemplos. Vamos começar de forma simples e depois aumentar a complexidade.exemplos:

exemplos:

  • calcular o desvio-padrão de uma matriz 1-dimensional
  • calcular o desvio-padrão de uma matriz 2-dimensional
  • Utilizar np.std para calcular OS desvios-padrão das colunas
  • Use np.std para calcular OS desvios-padrão das linhas
  • altera os graus de liberdade
  • Use o parâmetro keepdims em np.std

execute este código primeiro

Antes de executar qualquer um dos códigos de exemplo, terá de importar o Numpy.

Para fazer isso, você pode executar o seguinte código:

import numpy as np

Isto irá import Numpy com o alias “np“.

exemplo 1: Calcular o desvio padrão de uma matriz 1 dimensional

Aqui, vamos começar simples. vamos calcular o desvio padrão da matriz de Numpy 1-dimensional.

Criar array 1D

Primeiro, vamos criar o nosso array 1D:

array_1d = np.array()
Calcular padrão dev

Agora, vamos calcular o desvio padrão desses números.

np.std(array_1d)

OUT: 

30.84369195367723

so what happened here?

O np.a função std acabou de calcular o desvio padrão dos números usando a equação 2 que vimos anteriormente. Cada número é um dos x_i nessa equação.

uma nota rápida

no exemplo acima, não usamos explicitamente o parâmetro a=. Isso é porque np.std entende que, quando nós fornecemos um argumento para a função, como no código np.std(array_1d), a entrada deve ser passado para o a parâmetro.

como Alternativa, você também pode usar explicitamente o a= parâmetro:

np.std(a = array_1d)

FORA

30.84369195367723

EXEMPLO 2: Calcular o desvio padrão de um 2-vetor

Ok. Agora, vamos olhar para um exemplo com uma matriz bidimensional.

crie um array 2-dimensional

Aqui, vamos criar um array 2D, usando o np.aleatorio.função randint.

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

Esta lista tem 3 linhas e 4 colunas.vamos imprimi-lo, para podermos vê-lo.

print(array_2d)

OUT: 

 ]

This is just a 2D array that contains 12 random integers between 0 and 20.

calcula o desvio-padrão com np.std

ok, vamos calcular o desvio padrão.

np.std(array_2d)

OUT:

5.007633062524539

Aqui, numpy.std() é apenas computando o desvio padrão de todos os 12 inteiros.

O desvio-padrão é 5.007633062524539.

EXEMPLO 3: Calcular o desvio padrão das colunas

Agora, vamos calcular o desvio padrão das colunas.

para fazer isso, precisamos usar o parâmetro axis. (You learned about the axis parameter in the section about the parameters of numpy.std)

Especificamente, precisamos definir axis = 0.porquê?

Como mencionei na explicação doaxis parâmetro anterior, as matrizes Numpy têm eixos.em uma matriz bidimensional, eixo-0 é o eixo que aponta para baixo.

uma matriz NumPy mostrando que o eixo = 0 é o eixo abaixo das linhas da matriz.

Quando usamos numpy.std com axis = 0, que irá calcular OS desvios padrão para baixo na direção do eixo-0.

vamos dar uma olhada em um exemplo para que você possa ver o que eu quero dizer.

crie um array 2-dimensional

primeiro, vamos criar um array 2D, usando o np.aleatorio.função randint.

(Este é o mesmo array que nós criamos no exemplo 2, então se você já criou, você não precisa criá-lo novamente.) 

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

Let’s print it out, so we can see it.

print(array_2d)

OUT: 

 ]

This is just a 2D array that contains integers between 0 and 20.

utilizar np.std para calcular o desvio padrão das colunas

Agora, vamos definir axis = 0 dentro do np.std para calcular OS desvios-padrão das colunas.

np.std(array_2d, axis = 0)

OUT: 

array()
explicação

O que se passa aqui?

Quando usamos np.std com axis = 0, Numpy irá calcular o desvio padrão para baixo na direção do eixo-0. Lembre-se, como mencionei acima, eixo-0 pontos para baixo.

isto tem o efeito de calcular o desvio padrão de cada coluna da matriz Numpy.

uma imagem que mostra como usar o desvio-padrão Numpy com axis = 0 para calcular OS desvios-padrão da coluna.

Agora, vamos fazer um exemplo semelhante com os desvios padrão da linha.exemplo 4: utilizar np.std para calcular OS desvios padrão das linhas

Agora, vamos usar np.std para calcular OS desvios-padrão horizontalmente ao longo de um conjunto de numpy 2D.

lembre-se do que eu disse anteriormente: as matrizes numpy têm eixos. Os eixos são como direcções ao longo do conjunto Numpy. Em uma matriz 2D, eixo-1 Pontos horizontalmente, como este:

uma imagem que mostra como o eixo-1 aponta horizontalmente ao longo de uma matriz de Numpy 2D.

assim, se quisermos calcular OS desvios-padrão horizontalmente, podemos definir . Isto tem o efeito de calcular OS desvios padrão da linha.vamos dar uma vista de olhos.

crie um array 2-dimensional

para executar este exemplo, vamos novamente precisar de um array 2D Numpy, então vamos criar um array 2D usando o np.aleatorio.função randint.

(Este é o mesmo array que nós criamos no exemplo 2, então se você já criou, você não precisa criá-lo novamente.) 

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

Let’s print it out, so we can see it.

print(array_2d)

OUT: 

 ]

This is just a 2D array that contains integers between 0 and 20.

utilizar np.std para calcular o desvio padrão das linhas

Agora, vamos usar np.std com para calcular OS desvios-padrão das linhas.

np.std(array_2d, axis = 1)

OUT:

array()
explicação

Se você entendeu o exemplo 3, este novo exemplo deve fazer sentido.

Quando usamos np.std e set , Numpy calculará os desvios-padrão horizontalmente ao longo do eixo-1.

uma imagem que mostra usando np.std com eixo = 1 para calcular OS desvios-padrão da linha.

efetivamente, quando usamos o desvio padrão Numpy com, a função calcula o desvio padrão das linhas.exemplo 5: Mude os graus de liberdade

Agora, vamos mudar os graus de liberdade.

aqui neste exemplo, vamos criar uma grande variedade de números, pegar uma amostra dessa matriz, e calcular o desvio padrão nessa amostra.primeiro, vamos criar as nossas matrizes.

crie um array Numpy

primeiro, vamos apenas criar um array Numpy normalmente distribuído com uma média de 0 e um desvio padrão de 10.

para fazer isso, vamos usar a função normal aleatória Numpy. Note que estamos usando a função Numpy random seed para definir a semente para o gerador de números aleatórios. Para mais informações sobre isso, Leia nosso tutorial sobre np.aleatorio.semente.

np.random.seed(22)population_array = np.random.normal(size = 100, loc = 0, scale = 10)

Ok. Agora temos uma matriz Numpy, population_array, que tem 100 elementos que têm uma média de 0 e um desvio padrão de 10.

crie uma amostra

Agora, vamos usar a escolha aleatória Numpy para tomar uma amostra aleatória do conjunto Numpy, population_array.

np.random.seed(22)sample_array = np.random.choice(population_array, size = 10)

This new array,sample_array, is a random sample of 10 elements frompopulation_array.

usaremos sample_arrayquando calcularmos o nosso desvio-padrão usando o parâmetroddof.

Calcule o desvio padrão da amostra

Agora, vamos calcular o desvio padrão da amostra.

Especificamente, vamos utilizar o Numpy desvio padrão da função com o ddof parâmetro definido para ddof = 1.

np.std(sample_array, ddof = 1)

OUT: 

10.703405562234051
explicação

:

\

E, quando damos ddof = 1, a equação é avaliada como:

\

Para ser mais claro, quando você calcular o desvio padrão de uma amostra, você irá definir o ddof = 1.

ara ser honesto, os detalhes sobre por que são um pouco técnicos (e além do escopo deste post), então para mais informações sobre o cálculo de um desvio padrão de amostra, eu recomendo que você assista este vídeo.

tenha em mente que, para algumas outras instâncias, você pode definir ddof para outros valores além de 1 ou 0. Se você não usar o parâmetro ddof, ele irá por omissão para 0.

Não importa o valor que você selecionar, o Numpy desvio padrão, a função de calcular o desvio padrão com a equação:

\

EXEMPLO 6: o Uso da keepdims parâmetro em np.std

Ok. Finalmente, vamos dar um último exemplo.

Aqui, vamos definir o parâmetrokeepdims para keepdims = True.

crie um array 2-dimensional

primeiro, vamos criar um array 2D, usando o np.aleatorio.função randint.

(Este é o mesmo array que nós criamos no exemplo 2, então se você já criou, você não precisa criá-lo novamente.)

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

Vamos imprimi-lo:

print(array_2d)

FORA

 ]
Confira as dimensões

Agora, vamos dar uma olhada nas dimensões desta matriz.

array_2d.ndim

OUT: 

2

This is a 2D array, just like we intended.

calcula o desvio-padrão e verifica as dimensões

Ok. Agora, vamos calcular o desvio padrão, e verificar as dimensões da saída.

output = np.std(array_2d)

Vamos rapidamente imprimir o resultado:

print(output)

FORA

5.007633062524539

Então, o desvio padrão é 5.007633062524539.

agora, quais são as dimensões da saída?

output.ndim

OUT:

0

a saída tem 0 dimensões (é um valor escalar).porquê?

Quando np.std calcula o desvio padrão, está a calcular uma estatística sumária. Neste caso, a função está tomando um grande número de valores e colapsando-os para uma única métrica.

de modo que a entrada era bidimensional, mas a saída é 0-dimensional.e se quisermos mudar isso?

E se quisermos que a saída tenha tecnicamente 2 dimensões?

Podemos fazer isso com o parâmetrokeepdims.

mantenha as dimensões originais quando usamos np.std

Aqui, vamos definir keepdims = True para fazer a saída as mesmas dimensões que a entrada.

output_2d = np.std(array_2d, keepdims = True)

Agora, vamos olhar para a saída:

print(output_2d)

FORA

]

Repare que a saída, o desvio padrão, é ainda 5.00763306. Mas o resultado está dentro de parênteses duplos.

vamos inspecionar output_2d e dar uma olhada mais de perto.

type(output_2d)

FORA

numpy.ndarray

Então output_2d é um Numpy matriz, não um valor escalar.

let’s check the dimensions: 

output_2d.ndim

OUT:

2

This Numpy array, output_2d, has 2 dimensions.

Este é o mesmo número de dimensões que a entrada.o que aconteceu?

quando definimos keepdims = True, isso causou o np.função std para produzir uma saída com o mesmo número de dimensões que a entrada. Apesar de não existirem quaisquer linhas e colunas na saída, a saída output_2d tem 2 dimensões.

assim, no caso de alguma vez precisar do seu resultado para ter o mesmo número de dimensões que a sua entrada, pode definir keepdims = True.

(isto também funciona quando você usa oaxis parâmetro … experimente!)

Perguntas Frequentes sobre desvio padrão Numpy

Agora que você aprendeu sobre desvio padrão Numpy e viu alguns exemplos, vamos rever algumas perguntas frequentes sobre np.padrao.

Perguntas Mais Frequentes:

  • Porque é que a DST numpy() dá um resultado diferente da DST matlab() ou outra linguagem de programação?

Question 1: Why does numpy std () give a different result than matlab std () or another programing language?

A razão simples é que o matlab calcula o padrão de dev de acordo com o seguinte:

\

(Muitas outras ferramentas usar a mesma equação.)

no Entanto, Numpy calcula, com o seguinte:

\

Observe que a sutil diferença entre o \frac{1}{n - 1} vs \frac{1}{N}.

para corrigir isso, você pode usar o parâmetro ddof em Numpy.se utilizar np.std com o parâmetroddof definido paraddof = 1, você deve obter a mesma resposta que matlab.

deixe suas outras perguntas nos comentários abaixo

você tem outras perguntas sobre a função de desvio padrão Numpy?deixe a sua pergunta na secção de comentários abaixo.

Junte-se ao nosso curso para aprender mais sobre o Numpy

os exemplos que viu neste tutorial devem ser suficientes para o Iniciar, mas se está a falar a sério sobre aprender Numpy, deve inscrever-se no nosso curso premium chamado domínio Numpy.há muito mais a aprender sobre o Numpy, e o domínio Numpy vai ensinar – te tudo, incluindo:

  • Como criar arrays Numpy
  • Como usar o Numpy aleatório funções
  • o Que o “Numpy semente aleatória” função não
  • Como remodelar, dividir e combinar a sua arrays Numpy
  • e muito mais …

Além disso, ele vai ajudam você a dominar a sintaxe dentro de algumas semanas. Você vai descobrir como se tornar “fluente” ao escrever código Numpy.

Saiba mais aqui:

Saiba mais sobre o domínio Numpy