As 20 principais perguntas da entrevista sobre o NumPy: Do básico ao avançado

Perguntas intermediárias da entrevista sobre o NumPy

Essas perguntas aprofundam o uso real do NumPy. Depois de estabelecer uma compreensão fundamental das matrizes do NumPy, você deve explorar sua funcionalidade. A realização de cálculos com o NumPy pode ser esperada no nível intermediário.

6. Como você cria uma matriz de todos os zeros ou todos os uns?

A criação de matrizes preenchidas com zeros ou uns é um requisito comum em muitas tarefas de ciência de dados, como a inicialização de matrizes, a criação de matrizes de máscaras ou a configuração de estruturas de dados de espaço reservado. 

Para criar uma matriz de todos os zeros ou todos os uns no NumPy, você usa as funções np.zeros() ou np.ones():

import numpy as np

# Create a 3x4 array of zeros
zeros_arr = np.zeros((3, 4))
print(zeros_arr)
# Output:
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# Create a 2x2 array of ones
ones_arr = np.ones((2, 2))
print(ones_arr)
# Output:
# [[1. 1.]
#  [1. 1.]]

7. O que é transmissão no NumPy?

A transmissão é um comportamento importante do NumPy que permite operações eficientes em matrizes de tamanhos diferentes. 

Em termos simples, ele permite operações aritméticas entre matrizes de tamanhos diferentes, garantindo que ambas as matrizes tenham formas compatíveis. Isso é feito quando o NumPy replica automaticamente as matrizes menores na matriz maior para que elas tenham formas compatíveis. 

Veja o exemplo a seguir:

import numpy as np

a = np.array([1, 2, 3])b = np.array([[1], [2], [3]])
print(a + b)
# Output:
# [[2 3 4]
#  [3 4 5]
#  [4 5 6]]

8. Como você encontra a média, a mediana e o desvio padrão de uma matriz NumPy?

A média, a mediana e o desvio padrão são as principais estatísticas descritivas comumente usadas para entender nossos dados. O NumPy calcula esses valores com muita facilidade e tem funções criadas especialmente para eles. 

Conhecer esses cálculos é importante para aprimorar nossa capacidade de utilizar o NumPy:

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

# Mean
mean_value = np.mean(arr)
print("Mean:", mean_value)  # Output: 3.0

# Median
median_value = np.median(arr)
print("Median:", median_value)  # Output: 3.0

# Standard deviation
std_value = np.std(arr)
print("Standard deviation:", std_value)  # Output: 1.4142135623730951

9. Como podemos utilizar o NumPy para consultar rapidamente nossos dados numéricos e executar ações com base em uma instrução booleana?

Embora consideremos a finalidade principal do NumPy como um pacote de cálculo, ele também tem recursos avançados de organização de dados. 

O NumPy pode consultar dados facilmente por meio de indexação booleana e realizar operações com base nos resultados. O método where() é particularmente útil quando queremos fazer alterações em nossos dados com base em valores numéricos.

Suponha que você tenha um quadro de dados de pontuações de exames chamado df e queira categorizar os alunos. Um np.where() simples pode ter a seguinte aparência:

df[‘student_cat’] = np.where(df[‘score’] > 80, ‘good’, ‘bad’)

Observe que o método where() usa até 3 entradas: 

• A primeira é a declaração booleana de qualquer tipo
• O segundo é o resultado se for verdadeiro
• O terceiro é o resultado se você for falso

10. Qual é a maneira de utilizar o NumPy para algo como o erro quadrático médio?

A capacidade do NumPy de trabalhar com uma matriz inteira de uma só vez simplifica a implementação de cálculos como o erro quadrático médio (MSE). 

Como ele executa operações simples em uma base de elemento por elemento, ele vetoriza facilmente a operação e fornece uma maneira eficiente de calcular o MSE. 

A seguir, um exemplo de implementação do MSE no NumPy:

# 1. We have two arrays, our prediction, and actual labels
# 2. We take the squared differences and sum them
# 3. We then divide by n, which is the length of the array

n= len(labels)
error = (1/n) * np.sum(np.square(predictions - labels))

Perguntas avançadas sobre NumPy para entrevistas

Agora, é hora de entrar em território avançado! Espera-se que você use o NumPy para resolver problemas mais complexos nesse nível.

11. Como você pode calcular as estatísticas contínuas usando o NumPy, como uma média contínua?

As estatísticas contínuas, como uma média contínua, são muito importantes na ciência de dados. A média móvel é frequentemente usada para suavizar dados ruidosos, especialmente se forem baseados no tempo. 

Uma funcionalidade pouco conhecida do NumPy é a "strides". Uma das formas de implementação do stride é criar uma visualização de janela deslizante do seu array. Usando o site lib.stride_tricks.sliding_window_view(), você pode gerar facilmente subconjuntos de matriz. 

Em seguida, você pode fazer qualquer tipo de resumo, como calcular a média, em cada um desses subconjuntos para obter uma média móvel. Aqui está um exemplo de implementação:

import numpy as np

from numpy.lib.stride_tricks import sliding_window_view
x = np.arange(6)
v = sliding_window_view(x, 3)
# This creates v, an array that contains subarrays of length 3 which reflect the size of the window.

12. Como você executa a indexação avançada para selecionar elementos de uma matriz multidimensional com base em uma condição?

Embora a indexação possa ser uma habilidade fundamental para o NumPy, o uso de técnicas de indexação mais avançadas pode permitir que os cientistas de dados dividam seus dados com mais precisão. 

Ao utilizar a indexação de matriz de números inteiros e a indexação booleana, a criação de conjuntos de dados que atendem a critérios específicos se torna trivial.

import numpy as np

array = np.array([[10, 15, 20, 25],
                  [30, 35, 40, 45],
                  [50, 55, 60, 65]])
print(array)  # Output: 
# [[10 15 20 25]
#  [30 35 40 45]
#  [50 55 60 65]]

# Boolean indexing: Select elements greater than 30
condition = array > 30
print(condition)  # Output:
# [[False False False False]
#  [False  True  True  True]
#  [ True  True  True  True]]

# Apply the condition to get the elements that meet the criteria
filtered_elements = array[condition]
print(filtered_elements)  # Output: [35 40 45 50 55 60 65]

# Integer array indexing: Select specific elements based on row and column indices
row_indices = np.array([0, 1, 2])
col_indices = np.array([1, 2, 3])
selected_elements = array[row_indices, col_indices]
print(selected_elements)  # Output: [15 40 65]

# Combining boolean and integer indexing
# Select elements from the array where the element is greater than 30 and belongs to specific indices
combined_condition = (array > 30) & ((row_indices[:, None] == np.arange(3)).any(axis=0))
filtered_selected_elements = array[combined_condition]
print(filtered_selected_elements)  # Output: [35 40 45 50 55 60 65]

13. Como você pode usar o NumPy para realizar uma operação de álgebra linear, como a decomposição de matrizes, ou resolver um sistema de equações lineares?

A realização da decomposição de matrizes é vital para os cientistas de dados que lidam com grandes volumes de dados. Reduzir os dados a seus componentes principais é uma primeira etapa fundamental para reduzir a complexidade e o ruído.

O módulo linalg do NumPy nos permite executar facilmente a álgebra linear para obter os componentes principais. 

# The underlying signal is a sinusoidally modulated image
img = lena() # This is from scipy.misc import lena
t = np.arange(100)
time = np.sin(0.1*t)
true= time[:,np.newaxis,np.newaxis] * img[np.newaxis,...]

# We add some noise
noisy = real + np.random.randn(*true.shape)*255

# (observations, features) matrix
M = noisy.reshape(noisy.shape[0],-1)

# Singular value decomposition factorizes your data matrix such that:
#   M = U*S*V.T     (where '*' is matrix multiplication)
# * U and V are the singular matrices containing orthogonal vectors of unit length
# * S is a diagonal matrix containing the singular values of M - we can use this to calculate our PCs

# Obtain the results of SVD from our noisy matrix
U, s, Vt = np.linalg.svd(M, full_matrices=False)
# Transpose V to get our PC vectors
V = Vt.T

# PCs are already sorted by descending order of the singular values (i.e. by the proportion of total variance they explain)
# If we use all of the PCs we can reconstruct the noisy signal perfectly
S = np.diag(s)
Mhat = np.dot(U, np.dot(S, V.T))
print(“Using all PCs, MSE = %.6G" %(np.mean((M - Mhat)**2)))

14. Como você pode otimizar o uso da memória ao trabalhar com matrizes grandes no NumPy?

Uma funcionalidade raramente usada do NumPy é memmap(). Isso nos permite armazenar matrizes como um arquivo, o que nos permite ler matrizes maiores do que as que estaríamos puramente na memória. Sua principal vantagem é a leitura preguiçosa de dados, que reduz a necessidade geral de memória e nos permite avaliar todo o conjunto de dados. 

O uso inteligente dessa função permitirá que um cientista de dados trabalhe com grandes volumes de dados de forma mais fácil e conveniente.

​​import numpy as np

# Create a large array and save it to a file using memmap
filename = 'large_array.dat'
large_array_shape = (10000, 10000)
dtype = np.float32  # Specify the data type of the array

# Create a memmap object with the desired shape and dtype
large_array = np.memmap(filename, dtype=dtype, mode='w+', shape=large_array_shape)

# Initialize the array with some values (e.g., fill it with random numbers)
large_array[:] = np.random.rand(*large_array_shape)

# Access a small part of the array without loading the entire array into memory
sub_array = large_array[5000:5010, 5000:5010]
print(sub_array)  # Output: A 10x10 array with random float values

# Clean up and ensure that the changes are written to disk
del large_array

15. Como você pode lidar e manipular matrizes com valores ausentes ou infinitos no NumPy?

Lidar com valores ausentes e infinitos é comum para os cientistas de dados. Primeiro, talvez você queira usar o isnan() ou isinf() do NumPy para encontrar esses valores ausentes e infinitos. 

Se houver um problema sistemático, talvez queiramos avaliar nossos pipelines; caso contrário, talvez queiramos preencher esses valores. 

Embora talvez não usemos o NumPy diretamente para preencher os valores ausentes, geralmente usamos as funções do NumPy em combinação com algo como o pandas fillna() para preencher os dados ausentes. Por exemplo, talvez você queira usar as funções mean() ou median() do NumPy para preencher rapidamente os valores incorretos.

Perguntas da entrevista sobre NumPy para cientistas de dados

Até agora, abordamos questões gerais sobre o NumPy. É claro que as perguntas que analisamos anteriormente podem se aplicar à ciência de dados, mas, nesta seção, compilei perguntas específicas sobre o NumPy para cientistas de dados.

16. Existe uma maneira de aplicar funções de forma rápida e fácil a cada linha e coluna de uma matriz 2D?

Às vezes, precisamos realizar cálculos personalizados em nossa matriz para obter informações sobre cada linha ou coluna. Felizmente, o método NumPy apply_along_axis() pode ser utilizado para aplicar uma função personalizada em uma matriz NumPy. Essas funções são aplicadas em todo o eixo específico de cada matriz. 

import numpy as np

# Create a 2D array
data = np.array([
    [1, 2, 3, 4, 5],
    [10, 15, 20, 25, 30],
    [100, 200, 300, 400, 500]
])

# Define a function to compute the range of a 1D array
def compute_range(arr):
    return np.max(arr) - np.min(arr)

# Apply the compute_range function to each row (axis=1)
ranges = np.apply_along_axis(compute_range, axis=1, arr=data)
print("Range of each row:", ranges)
# Output:
# Range of each row: [  4  20 400]

17. Como você pode aproveitar o NumPy para realizar o dimensionamento de recursos e a normalização de conjuntos de dados para machine learning?

A normalização dos dados garante que estamos treinando adequadamente nossos modelos de machine learning. Sem a normalização, a escala pode afetar os resultados do nosso modelo, especialmente para modelos baseados em distância. 

Você pode usar as funções do NumPy para realizar facilmente o dimensionamento. Aqui está um exemplo de escalonamento mínimo-máximo que é executado para todas as linhas. Certifique-se de que você está escolhendo a dimensão correta ao dimensionar o recurso.

import numpy as np

data = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

# Min-Max Scaling
min_vals = np.min(data, axis=0)
max_vals = np.max(data, axis=0)
scaled_data = (data - min_vals) / (max_vals - min_vals)
print("Scaled Data:\n", scaled_data)
# Output:
# Scaled Data:
# [[0.   0.   0.  ]
#  [0.5  0.5  0.5 ]
#  [1.   1.   1.  ]]

18. Quais são algumas maneiras de classificar e indexar facilmente nossas matrizes NumPy?

Embora tenhamos algo como o DataFrame sort_values(), há certos casos em que queremos encontrar a localização desses valores classificados. 

O site argsort() do NumPy fornece as posições que classificariam uma determinada matriz. Um cenário útil é quando precisamos indexar adequadamente outros conjuntos de dados para que correspondam às nossas matrizes classificadas. Com as posições prontas, podemos utilizar o resultado de argsort() para garantir a consistência em nossos conjuntos de dados.

19. Qual é um aspecto importante do gerador de números aleatórios do NumPy que pode ser utilizado para torná-lo previsível e por quê?

Os geradores de números aleatórios na computação não são genuinamente aleatórios. Eles são baseados em uma semente inicial. Como geralmente queremos testar nossos dados e poder avaliar facilmente os resultados, precisamos minimizar a quantidade de aleatoriedade presente em nosso pipeline. 

Utilizando o método random.seed() do NumPy, podemos definir a semente para um pipeline inteiro, de modo que possamos obter resultados semelhantes todas as vezes. A definição de uma semente específica nos permite avaliar se as melhorias em nossos resultados se baseiam em nossos ajustes de modelo e não na aleatoriedade.

20. Descreva como você pode implementar o K-Means no NumPy.

Durante uma entrevista, você pode ser solicitado a implementar um algoritmo de algum tipo. O foco dessas perguntas é responder com uma compreensão fundamental do modelo e do pacote. 

Você não precisa memorizar todas as linhas de código abaixo, mas deve ser capaz de indicar as principais etapas e métodos necessários. Certifique-se de que você tenha lido sobre o K-Means (e outros algoritmos básicos) e entenda também como o algoritmo funciona.

import numpy as np

# Generate a sample dataset
np.random.seed(42)  # For reproducibility
data = np.vstack([
    np.random.normal(loc=[1, 1], scale=0.5, size=(50, 2)),
    np.random.normal(loc=[5, 5], scale=0.5, size=(50, 2)),
    np.random.normal(loc=[9, 1], scale=0.5, size=(50, 2))
])
def k_means(X, k, max_iters=100, tol=1e-4):
    # Step 1: Initialize centroids randomly
    num_samples, num_features = X.shape
    centroids = X[np.random.choice(num_samples, k, replace=False)]
    
    for i in range(max_iters):
        # Step 2: Assign clusters
        distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
        cluster_assignments = np.argmin(distances, axis=1)
        
        # Step 3: Update centroids
        new_centroids = np.array([X[cluster_assignments == j].mean(axis=0) for j in range(k)])
        
        # Check for convergence
        if np.all(np.linalg.norm(new_centroids - centroids, axis=1) < tol):
            break
        
        centroids = new_centroids
    
    return centroids, cluster_assignments

# Apply k-means clustering
k = 3
centroids, cluster_assignments = k_means(data, k)

Considerações finais

Desenvolver seu conhecimento de entrevista com o NumPy é uma das etapas essenciais para o sucesso em uma carreira na ciência de dados. 

Comece praticando e compreendendo os fundamentos , seguidos da implementação específica. Quanto mais você usar o Numpy, melhor entenderá e internalizará suas funções. Experimente alguns dos cursos e tutoriais do DataCamp, como os seguintes:

• Tutorial de matriz Python Numpy
• Folha de dicas sobre Numpy
• Curso intensivo de Numpy