शीर्ष 20 NumPy इंटरव्यू प्रश्न: बुनियादी से उन्नत तक

इंटरमीडिएट NumPy इंटरव्यू प्रश्न

ये प्रश्न वास्तव में NumPy का उपयोग करने में गहराई से जाते हैं। एक बार जब आप NumPy ऐरेज़ की बुनियादी समझ बना लेते हैं, तो आपको इसकी कार्यक्षमता का अन्वेषण करना चाहिए। इंटरमीडिएट स्तर पर NumPy के साथ गणनाएँ अपेक्षित होती हैं।

6. आप सभी शून्य या सभी एक वाले ऐरे कैसे बनाते हैं?

कई डेटा साइंस कार्यों में शून्य या एक से भरे ऐरे बनाना आम आवश्यकता है, जैसे मैट्रिसेज़ को इनिशियलाइज़ करना, मास्क ऐरे बनाना, या प्लेसहोल्डर डेटा संरचनाएँ सेट करना। 

NumPy में सभी शून्य या सभी एक का ऐरे बनाने के लिए np.zeros() या 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. NumPy में ब्रॉडकास्टिंग क्या है?

ब्रॉडकास्टिंग NumPy का एक प्रमुख व्यवहार है जो अलग-अलग आकार के ऐरेज़ पर कुशल ऑपरेशंस की अनुमति देता है। 

सीधे शब्दों में, यह अलग आकार वाले ऐरेज़ के बीच अंकगणितीय ऑपरेशंस की अनुमति देता है, बशर्ते दोनों ऐरे के shapes संगत हों। यह तब होता है जब NumPy छोटे ऐरेज़ को बड़े ऐरे में स्वचालित रूप से प्रतिलिपि करता है ताकि उनके shapes संगत हो जाएँ। 

निम्न उदाहरण देखें:

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. आप NumPy ऐरे का mean, median, और standard deviation कैसे निकालते हैं?

Mean, median, और standard deviation हमारे डेटा को समझने के लिए सामान्यतः प्रयुक्त प्रमुख विवर्णात्मक सांख्यिकी हैं। NumPy इन्हें बहुत आसानी से गणना करता है और इनके लिए विशेष रूप से बनाए गए फ़ंक्शंस हैं। 

इन गणनाओं को जानना 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. हम NumPy का उपयोग कैसे करें ताकि संख्यात्मक डेटा को तेज़ी से क्वेरी कर सकें और किसी boolean कथन के आधार पर क्रियाएँ कर सकें?

हालाँकि हम NumPy का प्राथमिक उद्देश्य गणना पैकेज के रूप में सोचते हैं, इसमें शक्तिशाली डेटा-व्रैंगलिंग क्षमताएँ भी हैं। 

NumPy boolean इंडेक्सिंग के माध्यम से डेटा को आसानी से क्वेरी कर सकता है और परिणामों के आधार पर ऑपरेशंस कर सकता है। जब हम संख्यात्मक मानों के आधार पर अपने डेटा में परिवर्तन करना चाहते हैं, तो where() मेथड विशेष रूप से उपयोगी है।

मान लीजिए हमारे पास df नाम का एग्ज़ाम स्कोर का डेटा फ़्रेम है और हम छात्रों को वर्गीकृत करना चाहते हैं। एक सरल np.where() इस प्रकार दिख सकता है:

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

ध्यान दें कि where() मेथड अधिकतम 3 इनपुट लेता है: 

• पहला किसी भी प्रकार का boolean कथन
• दूसरा—यदि सत्य है तो परिणाम
• तीसरा—यदि असत्य है तो परिणाम

10. Mean Squared Error जैसी चीज़ के लिए NumPy का उपयोग करने का एक तरीका क्या है?

पूरे ऐरे पर एक साथ काम करने की NumPy की क्षमता Mean Squared Error (MSE) जैसी गणनाओं को लागू करना सरल बना देती है। 

क्योंकि यह एलीमेंट-बाय-एलीमेंट आधार पर सरल ऑपरेशंस करता है, यह ऑपरेशन को आसानी से वेक्टराइज़ कर देता है और MSE की गणना का एक कुशल तरीका प्रदान करता है। 

NumPy में MSE के एक इम्प्लीमेंटेशन का उदाहरण निम्न है:

# 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))

एडवांस्ड NumPy इंटरव्यू प्रश्न

अब, समय है उन्नत क्षेत्र में प्रवेश करने का! इस स्तर पर आपसे अपेक्षा है कि आप जटिल समस्याओं को हल करने के लिए NumPy का उपयोग करें।

11. आप NumPy का उपयोग करके रोलिंग आँकड़े, जैसे रोलिंग mean, कैसे गणना कर सकते हैं?

रोलिंग आँकड़े, जैसे रोलिंग एवरेज, डेटा साइंस में बहुत महत्वपूर्ण हैं। रोलिंग mean का उपयोग अक्सर शोर वाले डेटा, खासकर समय-आधारित डेटा, को स्मूद करने के लिए किया जाता है। 

NumPy की एक कम-ज्ञात कार्यक्षमता है “strides।” स्ट्राइड को लागू करने के तरीकों में से एक आपके ऐरे का स्लाइडिंग विंडो व्यू बनाना है। lib.stride_tricks.sliding_window_view() का उपयोग करके, आप आसानी से ऐरे सबसेट्स जनरेट कर सकते हैं। 

इसके बाद आप इन प्रत्येक सबसेट पर mean जैसी कोई भी समरी गणना कर सकते हैं ताकि रोलिंग एवरेज प्राप्त हो सके। यहाँ एक उदाहरण इम्प्लीमेंटेशन है:

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. आप किसी शर्त के आधार पर बहु-आयामी ऐरे से तत्व चुनने के लिए उन्नत इंडेक्सिंग कैसे करते हैं?

हालाँकि इंडेक्सिंग NumPy का एक बुनियादी कौशल हो सकता है, अधिक उन्नत इंडेक्सिंग तकनीकों का उपयोग करने से डेटा वैज्ञानिक अपने डेटा को अधिक सटीकता से स्लाइस कर सकते हैं। 

इंटिजर ऐरे इंडेक्सिंग और boolean इंडेक्सिंग का उपयोग करके, विशिष्ट मानदंडों को पूरा करने वाले डेटासेट बनाना आसान हो जाता है।

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. आप NumPy का उपयोग करके मैट्रिक्स डीकंपोज़िशन जैसा रैखिक बीजगणित ऑपरेशन कैसे करते हैं या किसी रैखिक समीकरण प्रणाली को कैसे हल करते हैं?

बड़े डेटा वॉल्यूम से निपटने वाले डेटा वैज्ञानिकों के लिए मैट्रिक्स डीकंपोज़िशन करना महत्वपूर्ण है। डेटा को इसके प्रिंसिपल कंपोनेंट्स तक कम करना जटिलता और शोर को घटाने का एक महत्वपूर्ण पहला कदम है। 

NumPy का linalg मॉड्यूल हमें प्रिंसिपल कंपोनेंट्स प्राप्त करने के लिए रैखिक बीजगणित आसानी से करने देता है। 

# 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. NumPy में बड़े ऐरेज़ पर काम करते समय आप मेमोरी उपयोग को कैसे ऑप्टिमाइज़ कर सकते हैं?

NumPy की एक कम उपयोग की जाने वाली कार्यक्षमता है memmap()। यह हमें ऐरेज़ को एक फ़ाइल के रूप में स्टोर करने देता है, जिससे हम केवल मेमोरी में रखने की तुलना में बड़े ऐरे पढ़ सकते हैं। इसका मुख्य लाभ है लेज़ी डेटा रीडिंग, जो कुल मेमोरी आवश्यकता को कम करती है जबकि हमें पूरे डेटासेट का आकलन करने देती है। 

इस फ़ंक्शन का चतुराई से उपयोग करना डेटा वैज्ञानिक को बड़े डेटा के साथ अधिक आसानी और सुविधा से काम करने देगा।

​​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. आप NumPy में missing या infinite मानों वाले ऐरेज़ को कैसे हैंडल और मैनिप्युलेट कर सकते हैं?

Missing और infinite मानों से निपटना डेटा वैज्ञानिकों के लिए सामान्य है। पहले, आप इन missing और infinite मानों को खोजने के लिए NumPy के isnan() या isinf() का उपयोग करना चाहेंगे। 

यदि कोई व्यवस्थित समस्या है, तो हम अपनी पाइपलाइनों का आकलन करना चाहेंगे; अन्यथा, हम इन मानों को भरना चाह सकते हैं। 

हालाँकि हम missing मान सीधे भरने के लिए हमेशा NumPy का उपयोग नहीं करते, हम अक्सर NumPy फ़ंक्शंस को pandas के fillna() जैसी किसी चीज़ के साथ मिलाकर missing डेटा भरने के लिए उपयोग करते हैं। उदाहरण के लिए, हम NumPy के mean() या median() फ़ंक्शंस का उपयोग करके त्रुटिपूर्ण मानों को जल्दी से भरना चाह सकते हैं।

डेटा वैज्ञानिकों के लिए NumPy इंटरव्यू प्रश्न

अभी तक, हमने सामान्य NumPy प्रश्नों को कवर किया है। बेशक, पहले की समीक्षा किए गए प्रश्न डेटा साइंस पर भी लागू हो सकते हैं, लेकिन इस अनुभाग में, मैंने डेटा वैज्ञानिकों के लिए विशिष्ट NumPy प्रश्न संकलित किए हैं।

16. क्या 2D ऐरे की प्रत्येक पंक्ति और स्तंभ पर जल्दी और आसानी से फ़ंक्शंस लागू करने का कोई तरीका है?

कभी-कभी, हमें प्रत्येक पंक्ति या स्तंभ पर जानकारी प्राप्त करने के लिए अपने ऐरे पर कस्टम गणनाएँ करनी होती हैं। सौभाग्य से, NumPy का apply_along_axis() मेथड NumPy ऐरे पर कस्टम फ़ंक्शन लागू करने में उपयोग किया जा सकता है। ये फ़ंक्शंस प्रत्येक ऐरे में किसी विशेष axis के साथ संपूर्णता में लागू होते हैं। 

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. मशीन लर्निंग के लिए डेटासेट्स का फीचर स्केलिंग और नॉर्मलाइज़ेशन करने में आप NumPy का लाभ कैसे उठा सकते हैं?

डेटा का नॉर्मलाइज़ेशन सुनिश्चित करता है कि हम अपने मशीन लर्निंग मॉडलों को ठीक से प्रशिक्षित कर रहे हैं। नॉर्मलाइज़ेशन के बिना, स्केल हमारे मॉडल परिणामों को प्रभावित कर सकता है, खासकर डिस्टेंस-आधारित मॉडलों में। 

हम NumPy के फ़ंक्शंस का उपयोग करके आसानी से स्केलिंग कर सकते हैं। यहाँ सभी पंक्तियों पर चलने वाले मिन-मैक्स स्केलिंग का उदाहरण है। फीचर स्केलिंग करते समय सही आयाम चुनना सुनिश्चित करें।

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. हम अपने NumPy ऐरेज़ को आसानी से sort और index करने के कुछ तरीके क्या हैं?

हालाँकि हमारे पास DataFrame का sort_values() जैसा कुछ होता है, कुछ मामलों में हम इन सॉर्टेड मानों के स्थान ढूँढना चाहते हैं। 

NumPy का argsort() दिए गए ऐरे को सॉर्ट करने वाली पोज़िशन्स प्रदान करता है। एक उपयोगी परिदृश्य तब होता है जब हमें अपने सॉर्टेड ऐरे से मेल खाने के लिए अन्य डेटासेट्स को ठीक से इंडेक्स करना होता है। पोज़िशन्स तैयार होने पर, हम अपने डेटासेट्स में एकरूपता सुनिश्चित करने के लिए argsort() के आउटपुट का उपयोग कर सकते हैं।

19. NumPy के रैंडम नंबर जनरेटर का एक महत्वपूर्ण पहलू क्या है जिसका उपयोग इसे पूर्वानुमेय बनाने के लिए किया जा सकता है, और क्यों?

कंप्यूटिंग में रैंडम नंबर जनरेटर्स वास्तव में रैंडम नहीं होते। वे एक प्रारंभिक सीड पर आधारित होते हैं। चूँकि हम अक्सर अपने डेटा का परीक्षण करना चाहते हैं और परिणामों का आसानी से आकलन करना चाहते हैं, हमें अपनी पाइपलाइन में मौजूद रैंडमनेस को न्यूनतम करना चाहिए। 

NumPy के random.seed() मेथड का उपयोग करके, हम पूरे पाइपलाइन के लिए सीड सेट कर सकते हैं ताकि हर बार समान परिणाम मिल सकें। एक विशिष्ट सीड सेट करने से हम आकलन कर सकते हैं कि हमारे परिणामों में सुधार हमारे मॉडल समायोजनों पर आधारित है, न कि रैंडमनेस पर।

20. बताएँ कि आप NumPy में K-Means कैसे इम्प्लीमेंट कर सकते हैं।

इंटरव्यू के दौरान, आपसे किसी न किसी एल्गोरिदम को इम्प्लीमेंट करने के लिए कहा जा सकता है। इन प्रश्नों का फोकस मॉडल और पैकेज की बुनियादी समझ के साथ उत्तर देना होता है। 

आपको नीचे दी गई हर कोड लाइन याद रखने की आवश्यकता नहीं है, लेकिन आवश्यक प्रमुख चरणों और मेथड्स की ओर इशारा करने में सक्षम होना चाहिए। सुनिश्चित करें कि आपने K-Means (और अन्य बुनियादी एल्गोरिदम) के बारे में पढ़ा है और एल्गोरिदम कैसे काम करता है, यह समझते हैं।

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)

अंतिम विचार

NumPy के साथ अपने इंटरव्यू ज्ञान का निर्माण करना डेटा साइंस करियर में सफलता के लिए महत्वपूर्ण चरणों में से एक है। 

पहले मूल बातों का अभ्यास और समझ से शुरू करें, उसके बाद विशिष्ट इम्प्लीमेंटेशन पर जाएँ। जितना अधिक आप Numpy का उपयोग करेंगे, उतना ही बेहतर आप इसकी फ़ंक्शंस को समझेंगे और आत्मसात करेंगे। DataCamp में कुछ कोर्स और ट्यूटोरियल आज़माएँ, जैसे निम्न:

• Python Numpy ऐरे ट्यूटोरियल
• Numpy चीट शीट
• Numpy क्रैश कोर्स