Complete Guide to Technical AI Interview Questions 2025

🎯 Complete Interview Preparation

Real interview questions and comprehensive preparation strategies from top AI companies

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs

class KMeans:
    def __init__(self, k=3, max_iters=100, tol=1e-4, random_state=None):
        """
        K-Means clustering algorithm implementation
        
        Parameters:
        k: number of clusters
        max_iters: maximum number of iterations
        tol: tolerance for convergence
        random_state: for reproducible results
        """
        self.k = k
        self.max_iters = max_iters
        self.tol = tol
        self.random_state = random_state
        
    def _initialize_centroids(self, X):
        """Initialize centroids using K-means++ for better convergence"""
        np.random.seed(self.random_state)
        n_samples, n_features = X.shape
        
        # Choose first centroid randomly
        centroids = [X[np.random.randint(n_samples)]]
        
        # Choose remaining centroids with probability proportional to squared distance
        for _ in range(1, self.k):
            distances = np.array([min([np.linalg.norm(x - c)**2 for c in centroids]) 
                                for x in X])
            probabilities = distances / distances.sum()
            cumulative_probabilities = probabilities.cumsum()
            r = np.random.rand()
            
            for i, p in enumerate(cumulative_probabilities):
                if r < p:
                    centroids.append(X[i])
                    break
                    
        return np.array(centroids)
    
    def _assign_clusters(self, X, centroids):
        """Assign each point to the nearest centroid"""
        distances = np.sqrt(((X - centroids[:, np.newaxis])**2).sum(axis=2))
        return np.argmin(distances, axis=0)
    
    def _update_centroids(self, X, labels):
        """Update centroids to be the mean of assigned points"""
        centroids = np.zeros((self.k, X.shape[1]))
        for k in range(self.k):
            if np.sum(labels == k) > 0:  # Avoid division by zero
                centroids[k] = X[labels == k].mean(axis=0)
        return centroids
    
    def fit(self, X):
        """Fit K-means to the data"""
        # Initialize centroids
        self.centroids = self._initialize_centroids(X)
        
        # Store history for visualization
        self.centroid_history = [self.centroids.copy()]
        
        for iteration in range(self.max_iters):
            # Assign points to clusters
            labels = self._assign_clusters(X, self.centroids)
            
            # Update centroids
            new_centroids = self._update_centroids(X, labels)
            
            # Check for convergence
            if np.allclose(self.centroids, new_centroids, atol=self.tol):
                print(f"Converged after {iteration + 1} iterations")
                break
                
            self.centroids = new_centroids
            self.centroid_history.append(self.centroids.copy())
            
        self.labels_ = labels
        self.inertia_ = self._calculate_inertia(X, labels)
        return self
    
    def predict(self, X):
        """Predict cluster labels for new data"""
        return self._assign_clusters(X, self.centroids)
    
    def _calculate_inertia(self, X, labels):
        """Calculate within-cluster sum of squares"""
        inertia = 0
        for k in range(self.k):
            cluster_points = X[labels == k]
            if len(cluster_points) > 0:
                inertia += np.sum((cluster_points - self.centroids[k])**2)
        return inertia

# Example usage and visualization
if __name__ == "__main__":
    # Generate sample data
    X, y_true = make_blobs(n_samples=300, centers=4, cluster_std=0.60, 
                          random_state=42)
    
    # Fit K-means
    kmeans = KMeans(k=4, random_state=42)
    kmeans.fit(X)
    
    # Predict labels
    y_pred = kmeans.predict(X)
    
    print(f"Final inertia: {kmeans.inertia_:.2f}")
    print(f"Centroids:\n{kmeans.centroids}")

💡 Interview Tips for This Question

• Start Simple: Begin with basic implementation, then add optimizations
• Discuss Trade-offs: K-means++ vs random initialization, handling empty clusters
• Mention Limitations: Assumes spherical clusters, sensitive to initialization
• Follow-up Questions: Be ready to discuss how to choose K, alternatives like hierarchical clustering

import numpy as np
import matplotlib.pyplot as plt

class GradientDescent:
    def __init__(self, learning_rate=0.01, max_iters=1000, tol=1e-6):
        self.learning_rate = learning_rate
        self.max_iters = max_iters
        self.tol = tol
        self.cost_history = []
        
    def _add_intercept(self, X):
        """Add bias term to features"""
        intercept = np.ones((X.shape[0], 1))
        return np.concatenate((intercept, X), axis=1)
    
    def _cost_function(self, h, y):
        """Calculate mean squared error"""
        return (1 / (2 * len(y))) * np.sum((h - y) ** 2)
    
    def fit(self, X, y):
        """Fit linear regression using gradient descent"""
        # Add intercept term
        X = self._add_intercept(X)
        
        # Initialize weights randomly
        self.weights = np.random.normal(0, 0.01, X.shape[1])
        
        for i in range(self.max_iters):
            # Forward pass
            predictions = X.dot(self.weights)
            
            # Calculate cost
            cost = self._cost_function(predictions, y)
            self.cost_history.append(cost)
            
            # Calculate gradients
            gradients = (1/len(y)) * X.T.dot(predictions - y)
            
            # Update weights
            self.weights -= self.learning_rate * gradients
            
            # Check for convergence
            if i > 0 and abs(self.cost_history[-2] - self.cost_history[-1]) < self.tol:
                print(f"Converged after {i} iterations")
                break
                
        return self
    
    def predict(self, X):
        """Make predictions on new data"""
        X = self._add_intercept(X)
        return X.dot(self.weights)

Step-by-Step Solution Framework

📚 8-Week Preparation Plan

🚀 Ready to Ace Your AI Interviews?

Access our complete interview preparation program with comprehensive practice questions, mock interviews with industry experts, and personalized feedback to maximize your success.