Os dados de aprendizado de máquina são representados como matrizes.
Em Python, os dados são quase universalmente representados como arrays NumPy.
Se você é novo no Python, pode ficar confuso com algumas das formas pítônicas de acessar dados, como indexação negativa e divisão de array.
Neste tutorial, você descobrirá como manipular e acessar seus dados corretamente em matrizes NumPy.
Depois de concluir este tutorial, você saberá:
- Como converter seus dados de lista em matrizes NumPy.
- Como acessar dados usando indexação e fatiamento Pythonic.
- Como redimensionar seus dados para atender às expectativas de algumas APIs de aprendizado de máquina.
Comece seu projeto com meu novo livro Linear Algebra for Machine Learning, incluindo tutoriais passo a passo e a Código-fonte Python arquivos para todos os exemplos.
Vamos começar.
- Atualização Jul / 2019: Corrigido pequeno erro de digitação relacionado à remodelagem de dados 1D (obrigado Rodrigue).
Como indexar, dividir e remodelar matrizes NumPy para aprendizado de máquina em Python
Foto de Björn Söderqvist, alguns direitos reservados.
Visão geral do tutorial
Este tutorial é dividido em 4 partes; eles estão:
- Da lista para as matrizes
- Array Indexing
- Fatiamento de matriz
- Array Reshaping
Precisa de ajuda com Linear Algebra for Machine Learning?
Faça meu curso intensivo de e-mail gratuito de 7 dias agora (com código de exemplo).
Clique para se inscrever e também obter uma versão gratuita do Ebook em PDF do curso.
Baixe o seu mini-curso GRÁTIS
1. Da lista para as matrizes
Em geral, eu recomendo carregar seus dados do arquivo usando Pandas ou até mesmo funções NumPy.
Para exemplos, veja a postagem:
Esta seção assume que você carregou ou gerou seus dados por outros meios e agora eles são representados usando listas Python.
Vejamos como converter seus dados em listas em matrizes NumPy.
Lista unidimensional para matriz
Você pode carregar seus dados ou gerar seus dados e ter acesso a eles como uma lista.
Você pode converter uma lista unidimensional de dados em uma matriz chamando a função array () NumPy.
# exemplo unidimensional a partir de entorpecido importar variedade # lista de dados dados = [11, 22, 33, 44, 55] # array de dados dados = variedade(dados) imprimir(dados) imprimir(modelo(dados)) |
Executar o exemplo converte a lista unidimensional em uma matriz NumPy.
[11 22 33 44 55] |
Lista bidimensional de listas a serem arranjadas
É mais provável que no aprendizado de máquina você tenha dados bidimensionais.
Essa é uma tabela de dados onde cada linha representa uma nova observação e cada coluna um novo recurso.
Talvez você tenha gerado os dados ou os carregado usando um código personalizado e agora você tem uma lista de listas. Cada lista representa uma nova observação.
Você pode converter sua lista de listas em um array NumPy da mesma maneira que acima, chamando a função array ().
# exemplo bidimensional a partir de entorpecido importar variedade # lista de dados dados = [[11, 22], [33, 44], [55, 66]] # array de dados dados = variedade(dados) imprimir(dados) imprimir(modelo(dados)) |
A execução do exemplo mostra os dados convertidos com sucesso.
[[11 22] [33 44] [55 66]] |
2. Indexação de matriz
Depois que seus dados são representados usando uma matriz NumPy, você pode acessá-los usando a indexação.
Vejamos alguns exemplos de acesso a dados por meio da indexação.
Indexação unidimensional
Geralmente, a indexação funciona exatamente como você esperaria de sua experiência com outras linguagens de programação, como Java, C # e C ++.
Por exemplo, você pode acessar elementos usando o operador colchete [] especificando o índice de deslocamento zero para o valor a ser recuperado.
# indexação simples a partir de entorpecido importar variedade # define array dados = variedade([11, 22, 33, 44, 55]) # índice de dados imprimir(dados[0]) imprimir(dados[4]) |
A execução do exemplo imprime o primeiro e o último valores da matriz.
Especificar números inteiros muito grandes para o limite da matriz causará um erro.
# indexação simples a partir de entorpecido importar variedade # define array dados = variedade([11, 22, 33, 44, 55]) # índice de dados imprimir(dados[5]) |
Executar o exemplo imprime o seguinte erro:
IndexError: o índice 5 está fora dos limites para o eixo 0 com tamanho 5 |
Uma diferença importante é que você pode usar índices negativos para recuperar valores deslocados do final da matriz.
Por exemplo, o índice -1 se refere ao último item da matriz. O índice -2 retorna o penúltimo item de volta a -5 para o primeiro item no exemplo atual.
# indexação simples a partir de entorpecido importar variedade # define array dados = variedade([11, 22, 33, 44, 55]) # índice de dados imprimir(dados[-1]) imprimir(dados[-5]) |
A execução do exemplo imprime o último e o primeiro item da matriz.
Indexação bidimensional
A indexação de dados bidimensionais é semelhante à indexação de dados unidimensionais, exceto que uma vírgula é usada para separar o índice para cada dimensão.
Isso é diferente das linguagens baseadas em C, onde um operador de colchete separado é usado para cada dimensão.
Por exemplo, podemos acessar a primeira linha e a primeira coluna da seguinte maneira:
# 2d indexação a partir de entorpecido importar variedade # define array dados = variedade([[11, 22], [33, 44], [55, 66]]) # índice de dados imprimir(dados[0,0]) |
Executar o exemplo imprime o primeiro item do conjunto de dados.
Se estivermos interessados em todos os itens da primeira linha, poderíamos deixar o índice da segunda dimensão vazio, por exemplo:
# 2d indexação a partir de entorpecido importar variedade # define array dados = variedade([[11, 22], [33, 44], [55, 66]]) # índice de dados imprimir(dados[0,]) |
Isso imprime a primeira linha de dados.
3. Fatiamento de matriz
Até agora tudo bem; criar e indexar matrizes parece familiar.
Agora chegamos ao corte de matrizes, e este é um recurso que causa problemas para iniciantes em matrizes Python e NumPy.
Estruturas como listas e matrizes NumPy podem ser fatiadas. Isso significa que uma subsequência da estrutura pode ser indexada e recuperada.
Isso é mais útil no aprendizado de máquina ao especificar variáveis de entrada e variáveis de saída ou ao dividir as linhas de treinamento das linhas de teste.
O corte é especificado usando o operador de dois pontos ':' com um 'a partir de' e 'para'índice antes e depois da coluna, respectivamente. A fatia se estende do índice 'de' e termina um item antes do índice 'para'.
Vamos trabalhar com alguns exemplos.
Fatias unidimensionais
Você pode acessar todos os dados em uma dimensão de array especificando a fatia ':' sem índices.
# fatiamento simples a partir de entorpecido importar variedade # define array dados = variedade([11, 22, 33, 44, 55]) imprimir(dados[:]) |
Executar o exemplo imprime todos os elementos do array.
O primeiro item da matriz pode ser fatiado especificando uma fatia que começa no índice 0 e termina no índice 1 (um item antes do índice 'para').
# fatiamento simples a partir de entorpecido importar variedade # define array dados = variedade([11, 22, 33, 44, 55]) imprimir(dados[0:1]) |
Executar o exemplo retorna um subarray com o primeiro elemento.
Também podemos usar índices negativos em fatias. Por exemplo, podemos fatiar os dois últimos itens da lista iniciando a fatia em -2 (o penúltimo item) e não especificando um índice 'para'; que leva a fatia ao final da dimensão.
# fatiamento simples a partir de entorpecido importar variedade # define array dados = variedade([11, 22, 33, 44, 55]) imprimir(dados[-2:]) |
A execução do exemplo retorna um subarray apenas com os dois últimos itens.
Fatias bidimensionais
Vejamos os dois exemplos de fatiamento bidimensional que você provavelmente usará no aprendizado de máquina.
Características de entrada e saída divididas
É comum dividir seus dados carregados em variáveis de entrada (X) e a variável de saída (y).
Podemos fazer isso dividindo todas as linhas e colunas até, mas antes da última coluna e, em seguida, indexando separadamente a última coluna.
Para os recursos de entrada, podemos selecionar todas as linhas e todas as colunas, exceto a última, especificando ':' para no índice de linhas e: -1 no índice de colunas.
Para a coluna de saída, podemos selecionar todas as linhas novamente usando ':' e indexar apenas a última coluna especificando o índice -1.
Juntando tudo isso, podemos separar um conjunto de dados 2D de 3 colunas em dados de entrada e saída da seguinte maneira:
# divide entrada e saída a partir de entorpecido importar variedade # define array dados = variedade([[11, 22, 33], [44, 55, 66], [77, 88, 99]]) # dados separados X, y = dados[:, :-1], dados[:, -1] imprimir(X) imprimir(y) |
Executar o exemplo imprime os elementos X e y separados. Observe que X é uma matriz 2D ey é uma matriz 1D.
[[11 22] [44 55] [77 88]] [33 66 99] |
Dividir o trem e as linhas de teste
É comum dividir um conjunto de dados carregado em conjuntos separados de trem e teste.
Esta é uma divisão de linhas onde uma parte será usada para treinar o modelo e a parte restante será usada para estimar a habilidade do modelo treinado.
Isso envolveria o corte de todas as colunas especificando ':' no índice da segunda dimensão. O conjunto de dados de treinamento seria composto por todas as linhas, desde o início até o ponto de divisão.
conjunto de dados Comboio = dados[:split, :] |
O conjunto de dados de teste seria todas as linhas começando do ponto de divisão até o final da dimensão.
Juntando tudo isso, podemos dividir o conjunto de dados no ponto de divisão planejado de 2.
