Las 20 preguntas más frecuentes en una entrevista sobre NumPy: De Básico a Avanzado

Preguntas de la entrevista sobre NumPy intermedio

Estas preguntas profundizan en el uso real de NumPy. Una vez que hayas establecido una comprensión fundamental de las matrices de NumPy, debes explorar su funcionalidad. Realizar cálculos con NumPy puede esperarse a un nivel intermedio.

6. ¿Cómo se crea una matriz de todos ceros o todos unos?

Crear matrices llenas de ceros o unos es un requisito habitual en muchas tareas de la ciencia de datos, como inicializar matrices, crear matrices de máscaras o configurar estructuras de datos de marcadores de posición. 

Para crear una matriz de todos ceros o todos unos en NumPy, utiliza las funciones np.zeros() o 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. ¿Qué es la difusión en NumPy?

La difusión es un comportamiento clave de NumPy que permite realizar operaciones eficientes en matrices de distintos tamaños. 

En pocas palabras, permite realizar operaciones aritméticas entre matrices de distintos tamaños, asegurándose de que ambas matrices tienen formas compatibles. Esto se hace cuando NumPy replica automáticamente las matrices más pequeñas en la matriz más grande para que tengan formas compatibles. 

Mira el siguiente ejemplo:

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. ¿Cómo hallar la media, la mediana y la desviación típica de una matriz NumPy?

La media, la mediana y la desviación típica son estadísticas descriptivas clave utilizadas habitualmente para comprender nuestros datos. NumPy los calcula muy fácilmente y tiene funciones especialmente creadas para ellos. 

Conocer estos cálculos es importante para mejorar nuestra capacidad de utilizar 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. ¿Cómo podemos utilizar NumPy para consultar rápidamente nuestros datos numéricos y realizar acciones basadas en una declaración booleana?

Aunque pensamos que el objetivo principal de NumPy es ser un paquete de cálculo, también tiene potentes funciones de tratamiento de datos. 

NumPy puede consultar datos fácilmente mediante la indexación booleana y realizar operaciones basadas en los resultados. El método where() es especialmente útil cuando queremos hacer cambios en nuestros datos basándonos en valores numéricos.

Supongamos que tenemos un marco de datos de calificaciones de exámenes llamado df y queremos categorizar a los estudiantes. Un simple np.where() puede tener este aspecto:

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

Ten en cuenta que el método where() admite hasta 3 entradas: 

• La primera es la declaración booleana de cualquier tipo
• El segundo es el resultado si es verdadero
• El tercero es el resultado si es falso

10. ¿Cuál es la forma de utilizar NumPy para algo como el error cuadrático medio?

La capacidad de NumPy para trabajar en toda una matriz a la vez hace que implementar cálculos como el Error Cuadrático Medio (ECM ) sea sencillo. 

Como realiza operaciones sencillas elemento a elemento, vectoriza fácilmente la operación y proporciona una forma eficaz de calcular el MSE. 

A continuación se muestra un ejemplo de implementación de MSE en 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))

Preguntas avanzadas de la entrevista sobre NumPy

Ahora, ¡es el momento de entrar en territorio avanzado! En este nivel se espera que utilices NumPy para resolver problemas más complejos.

11. ¿Cómo puedes calcular las estadísticas móviles con NumPy, como la media móvil?

Las estadísticas móviles, como la media móvil, son muy importantes en la ciencia de datos. La media móvil se utiliza a menudo para suavizar datos ruidosos, sobre todo si se basan en el tiempo. 

Una funcionalidad poco conocida de NumPy son las "zancadas". Una de las formas de implementar stride es crear una vista de ventana deslizante de tu matriz. Utilizando lib.stride_tricks.sliding_window_view(), puedes generar fácilmente subconjuntos de matrices. 

Luego puedes hacer cualquier tipo de resumen, como calcular la media, en cada uno de estos subconjuntos para obtener una media móvil. Aquí tienes un ejemplo de aplicación:

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. ¿Cómo realizar una indexación avanzada para seleccionar elementos de una matriz multidimensional en función de una condición?

Aunque la indexación puede ser una habilidad fundamental para NumPy, aprovechar técnicas de indexación más avanzadas puede permitir a los científicos de datos trocear sus datos con mayor precisión. 

Utilizando la indexación de matrices de enteros y la indexación booleana, crear conjuntos de datos que cumplan criterios específicos se convierte en algo 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. ¿Cómo puedes utilizar NumPy para realizar una operación de álgebra lineal como la descomposición de matrices o resolver un sistema de ecuaciones lineales?

Realizar la descomposición de matrices es vital para los científicos de datos que trabajan con grandes volúmenes de datos. Reducir los datos a sus componentes principales es un primer paso fundamental para reducir la complejidad y el ruido.

El módulo linalg de NumPy nos permite realizar fácilmente álgebra lineal para obtener componentes principales. 

# 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. ¿Cómo puedes optimizar el uso de memoria cuando trabajas con matrices grandes en NumPy?

Una funcionalidad poco utilizada de NumPy es memmap(). Esto nos permite almacenar matrices como un archivo, lo que nos permite leer matrices más grandes de lo que lo haríamos puramente en memoria. Su principal ventaja es la lectura perezosa de datos, que reduce la necesidad total de memoria al tiempo que nos permite evaluar todo el conjunto de datos. 

El uso inteligente de esta función permitirá a un científico de datos trabajar con grandes datos de forma más fácil y cómoda.

​​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. ¿Cómo puedes manejar y manipular matrices con valores perdidos o infinitos en NumPy?

Tratar con valores perdidos e infinitos es habitual para los científicos de datos. En primer lugar, puedes utilizar isnan() o isinf() de NumPy para encontrar estos valores perdidos e infinitos. 

Si hay un problema sistemático, tal vez queramos evaluar nuestros conductos; si no, tal vez queramos rellenar estos valores. 

Aunque no utilicemos NumPy directamente para rellenar los valores que faltan, a menudo utilizamos funciones de NumPy en combinación con algo como pandas fillna() para rellenar los datos que faltan. Por ejemplo, puede que queramos utilizar las funciones mean() o median() de NumPy para rellenar rápidamente los valores erróneos.

Preguntas de entrevista sobre NumPy para científicos de datos

Hasta ahora, hemos tratado cuestiones generales sobre NumPy. Por supuesto, las preguntas que hemos revisado antes pueden aplicarse a la ciencia de datos, pero en esta sección he recopilado preguntas específicas de NumPy para científicos de datos.

16. ¿Hay alguna forma de aplicar rápida y fácilmente funciones a cada fila y columna de una matriz 2D?

A veces, necesitamos realizar cálculos personalizados en nuestra matriz para obtener información sobre cada fila o columna. Afortunadamente, se puede utilizar el método NumPy apply_along_axis() para aplicar una función personalizada en una matriz NumPy. Estas funciones se aplican a la totalidad de un eje concreto 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. ¿Cómo puedes aprovechar NumPy para realizar el escalado de características y la normalización de conjuntos de datos para el aprendizaje automático?

La normalización de los datos garantiza que estamos entrenando correctamente nuestros modelos de aprendizaje automático. Sin normalización, la escala puede influir en los resultados de nuestro modelo, especialmente en los modelos basados en la distancia. 

Podemos utilizar las funciones de NumPy para realizar fácilmente el escalado. Aquí tienes un ejemplo de escalado mín-máx que se ejecuta para todas las filas. Asegúrate de que eliges la dimensión correcta al escalar características.

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. ¿Cuáles son algunas formas de ordenar e indexar fácilmente nuestras matrices NumPy?

Aunque tengamos algo como el DataFrame sort_values() hay ciertos casos en los que queremos encontrar la ubicación de estos valores ordenados. 

La página argsort() de NumPy proporciona las posiciones que ordenarían una matriz dada. Una situación útil es cuando necesitamos indexar correctamente otros conjuntos de datos para que coincidan con nuestras matrices ordenadas. Al tener las posiciones preparadas, podemos utilizar la salida de argsort() para garantizar la coherencia entre nuestros conjuntos de datos.

19. ¿Cuál es un aspecto importante del generador de números aleatorios de NumPy que puede utilizarse para hacerlo predecible y por qué?

Los generadores de números aleatorios en informática no son realmente aleatorios. Se basan en una semilla inicial. Como a menudo queremos probar nuestros datos y poder evaluar fácilmente los resultados, debemos reducir al mínimo la cantidad de aleatoriedad presente en nuestra tubería. 

Utilizando el método random.seed() de NumPy, podemos establecer la semilla para toda una cadena, de modo que obtengamos resultados similares cada vez. Establecer una semilla específica nos permite evaluar si las mejoras de nuestros resultados se basan en los ajustes de nuestro modelo y no en el azar.

20. Describe cómo podrías implementar K-Means en NumPy.

Durante una entrevista, es posible que te pidan que pongas en práctica algún tipo de algoritmo. El objetivo de estas preguntas es responder con una comprensión fundamental del modelo y del paquete. 

No es necesario que memorices todas las líneas de código que aparecen a continuación, pero sí que seas capaz de señalar los pasos y métodos clave necesarios. Asegúrate de haber leído sobre K-Means (y otros algoritmos básicos) y de comprender también cómo funciona el algoritmo.

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)

Reflexiones finales

Construir tu conocimiento de la entrevista con NumPy es uno de los pasos críticos para tener éxito en una carrera en la ciencia de datos. 

Empieza por practicar y comprender los fundamentos , seguido de una aplicación específica. Cuanto más utilices Numpy, mejor comprenderás e interiorizarás sus funciones. Prueba algunos de los cursos y tutoriales de DataCamp, como los siguientes:

• Tutorial Python Numpy Array
• Hoja de trucos Numpy
• Curso acelerado de Numpy