50 Must-Know AI/ML Interview Questions for Freshers: Your Ultimate Guide to success

Machine learning (ML) is a subfield of Artificial Intelligence that facilitates systems to consume data and enhance their performance progressively over time rather than being directly coded to do so. There are three kinds:

Supervised learning is a part of machine learning in which the algorithm is taught from the labeled training data. It aims to learn a function that maps input variables to output variables. The algorithm is “supervised” for accuracy; it is provided with the correct answers (labels) that facilitate the adjusting of the tunable parameters to minimize errors (learning).(ai/ml interview questions)

Supervised Learning: The labeled data is fed into models, hence the models are now able to make predictions based on the data provided.

Unsupervised Learning: Examining data for uncovering the hidden patterns, which are the unknown clusters of data.

Reinforcement Learning: The agent learns from the training set which is formed by interacting with the environment, and the rewards or penalties are obtained from the environment.

Bias-like errors are the ones which are specifically attributed to the overly simple model, whereas variance-like errors are often associated with models that are probably too complex. The tradeoff finding is a balance so the model will not be too simple (high bias) nor too complex (high variance).

A confusion matrix is a table used to determine the performance of a classification model. It has four components:

False Negatives (FN): Incorrectly predicted negatives (Type II error).

True Positives (TP): Correctly predicted positives.

True Negatives (TN): Correctly predicted negatives.

False Positives (FP): Incorrectly predicted positives (Type I error).

Classification: Distinguishing among discrete categories (e.g. spam or not spam).

Regression: Predicting a co continuous parameter (e.g., house price).

Overfitting is a situation when the model learns both the main concepts of the input data and the noise thereof, hence yielding high-quality predictions for the training set and poor ones for the new dataset. It can be avoided by:

Cross-validation: Cross-validation methods such as k-fold cross-validation are used to determine a model’s capability of generalization.

Simplifying the model: Scaling back the number of attributes or parameters.

Regularization: Introducing a penalty for higher coefficients.

Hyperparameters are the parameters set before the learning process begins, controlling the learning process itself (e.g., learning rate, number of trees in a random forest). Adjusting these can have extraordinary effects on a model.

PCA is a dimension reduction technique, where a large set of variables is transformed into a smaller one by the principal components (the directions under which the data vary the most).

“”””
 from sklearn.linear_model import LinearRegression

from sklearn.model_selection import train_test_split

import numpy as np

# Generate sample data

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

y = np.array([2, 4, 5, 4, 5])

# Split data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Create and train the model

model = LinearRegression()

model.fit(X_train, y_train)

# Make predictions

y_pred = model.predict(X_test)

print("Predictions:", y_pred)

print("Actual values:", y_test)

print("Model coefficient:", model.coef_)

print("Model intercept:", model.intercept_)
“”””

“”””

import numpy as np

def linear_regression(X, y):

    X_mean = np.mean(X)

     y_mean = np.mean(y)

     # Calculating coefficients

    numerator = np.sum((X - X_mean) * (y - y_mean))

     denominator = np.sum((X - X_mean) ** 2)

    b1 = numerator / denominator

     b0 = y_mean - (b1 * X_mean)

   return b0, b1

# Example usage:

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

y = np.array([3, 4, 2, 5, 6])

b0, b1 = linear_regression(X, y)

print(f"Intercept: {b0}, Slope: {b1}")

“”””

“”””””

from sklearn.model_selection import train_test_split

X = df.drop('target_column', axis=1)

y = df['target_column']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

“”””

“”””
 from sklearn.model_selection import cross_val_score

from sklearn.linear_model import LogisticRegression

model = LogisticRegression()

scores = cross_val_score(model, X, y, cv=5)  # 5-fold cross-validation

print(f"Cross-validation scores: {scores}")
“”””

Imbalanced Datasets can cause the models being learned to be biased. Here’s how to address it:

Resampling techniques:

Algorithm adjustments: Algorithms such as random forests and decision trees can be used to correct class imbalances.

Using proper evaluation metrics: Aspects like Precision, Recall, F1-score and ROC-AUC which are more analytical than accuracy.

The problem decides which evaluation metric to be employed:

ROC-AUC: Evaluates the model’s ability to discriminate the classes.

Accuracy: It is fit for balanced datasets.

Precision and Recall: These are appropriate for imbalanced datasets.

F1-Score: The measure of the tradeoff that exists between precision and recall.

Check for data quality issues: like Missing Values, Outliers, or Incorrect Data Types.

Feature engineering: features that have been created or improved upon.

Model tuning: Changing hyperparameters.

Try different algorithms: Some algorithms may give better results depending on a particular type of data.

Increase training data: More data can lead to improvement in model performance.

Parametric models, regardless of how much training data we have, have a fixed number of parameters (e.g. linear regression).

Non-parametric models: The number of parameters increases as the amount of training data increases (e.g., decision trees, k-nearest neighbors).

The cold start problem occurs when the system has little to no data on new users or items. Solutions include:

Hybrid approaches: Combination of content-based filtering and collaborative filtering can be useful.

Content-based filtering: Suggest items based on the features of the items themselves.

Collaborative filtering with user profiles: Use demographic or sample behavior to learn the preferences of the users.

A ‘kernel’ is a way in which Support Vector Machines (SVMs) convert the input data to a higher-dimensional space where it is easier to classify with some linear boundary. The SVMs’ kernel functions let them control the non-linear behavior to classify data when there are no straight boundaries available. Common kernels are:

Radial Basis Function (RBF) Kernel: Preferred for its adaptability with non-linear data.

Linear Kernel: For linearly separable data.

Polynomial Kernel: Used for more complex boundaries.

L1 Regularization (Lasso): Adds the absolute value of coefficients as a penalty to the loss function thereby leading to sparse models which makes some coefficients zero in which case some features are essentially dropped.

L2 Regularization (Ridge): Introduces the squared value of coefficients as a penalty for large coefficients, which in turn does not force them to zero, so there is no overfitting. Moreover, the error is distributed across all terms.

This flowchart-like structure called a decision tree shows how each internal node represents a decision of a feature, a branch representing the result of a decision, and each leaf node stands for a class label or continuous value. Each of the tree splits the data into the subsets based on the most significant feature on every step. Thus, it is easy to interpret and visualize. 

Random Forest is a method of ensemble learning that based on the creation of several decision trees and aggregation of them to provide a more accurate and stable prediction. It addresses the weaknesses of the single decision tree sounds like overfitting and high variance by using the method of averaging the predictions from multiple trees and by using random subsets of data and features for each tree. 

Gradient Descent is the algorithm that is used in machine learning to minimize the cost function by iteratively adjusting model parameters. The gradient (slope) of the cost function is calculated and the parameters are moved in the opposite direction of the gradient to get to the minimum value. It is an inseparable part of the training of linear regression, logistic regression, and neural networks.

“””

import numpy as np

def sigmoid(z):

    return 1 / (1 + np.exp(-z))

def logistic_regression(X, y, lr=0.01, iterations=1000):

    m, n = X.shape

    theta = np.zeros(n)

    for _ in range(iterations):

        z = np.dot(X, theta)

        predictions = sigmoid(z)

        gradient = np.dot(X.T, (predictions - y)) / m

        theta -= lr * gradient

    return theta

# Example usage:

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

y = np.array([0, 0, 1, 1])

theta = logistic_regression(X, y)

print(f"Learned coefficients: {theta}")

“””

“””

from sklearn.model_selection import GridSearchCV

from sklearn.ensemble import RandomForestClassifier

param_grid = {

    'n_estimators': [100, 200, 300],

    'max_depth': [None, 10, 20, 30],

    'min_samples_split': [2, 5, 10]

}

model = RandomForestClassifier()

grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5, scoring='accuracy')

grid_search.fit(X_train, y_train)

print(f"Best parameters: {grid_search.best_params_}")

“””

“””

def f1_score(y_true, y_pred):

    tp = np.sum((y_true == 1) & (y_pred == 1))

    fp = np.sum((y_true == 0) & (y_pred == 1))

    fn = np.sum((y_true == 1) & (y_pred == 0))

    precision = tp / (tp + fp)

    recall = tp / (tp + fn)

   return 2 * (precision * recall) / (precision + recall)

# Example usage:

y_true = np.array([0, 1, 1, 0, 1, 0, 1, 1])

y_pred = np.array([0, 1, 0, 0, 1, 1, 1, 0])

score = f1_score(y_true, y_pred)

print(f"F1-Score: {score}")

“””

“””

import numpy as np

from collections import Counter

def euclidean_distance(a, b):

    return np.sqrt(np.sum((a - b) ** 2))

def knn(X_train, y_train, X_test, k=3):

    predictions = []

    for test_point in X_test:

        distances = [euclidean_distance(test_point, x) for x in X_train]

        k_indices = np.argsort(distances)[:k]

        k_nearest_labels = [y_train[i] for i in k_indices]

        most_common = Counter(k_nearest_labels).most_common(1)

        predictions.append(most_common[0][0])

    return predictions

# Example usage:

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

y_train = np.array([0, 0, 0, 1, 1])

X_test = np.array([[4, 2], [5, 5]])

predictions = knn(X_train, y_train, X_test)

print(f"Predictions: {predictions}")

“””

“””

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

“

“””

def accuracy(y_true, y_pred):

    correct_predictions = np.sum(y_true == y_pred)

    return correct_predictions / len(y_true)

# Example usage:

y_true = np.array([0, 1, 1, 0, 1])

y_pred = np.array([0, 1, 0, 0, 1])

acc = accuracy(y_true, y_pred)

print(f"Accuracy: {acc}")

“”””

To Mirror the working system of biological neural networks, ANNs use computational models consisting of interrelated nodes (neurons) that are arranged in layers. Deep Learning is a branch of ANNs that largely involves neural networks with many hidden layers (deep neural networks). Deep Learning models can self-learn high-level representations of data which is the reason why they are more efficient in tasks such as image and speech recognition.

Bagging (Bootstrap Aggregating) and Boosting are both ensemble methods used to improve the accuracy of machine learning models:

Boosting conveys the process of building models in the order they were created and where new models concentrate on improving the mistakes of the old models. AdaBoost and GBM are some examples. Boosting reduces bias and variance, leading to more often better results albeit with some longer training times.

Bagging: Involves training multiple models independently on random subsets of the Bagging: The strategy includes teaching a number of models independently on chosen observation subsets of data (without putting them back), summing their outputs, and averaging the final truth statement. For instance, a Random Forest is a frequent method. Bagging diminishes variance and limitations of overfitting are removed.

Statistical AI: Based on data analysis techniques and probabilistic models such as machine learning and deep learning

Symbolic AI: Applies logical rules and knowledge representation methods (e.g., expert systems, semantic networks)Understanding both approaches is an essential part of a comprehensive interview questions for artificial intelligence machine learning positions.

Activation functions introduce non-linearity into the neural network. Thus, the neural network could learn nonlinear relationships by adding a non-linear activation function to the coefficients. Firstly, here are some common examples of activation functions:

Softmax: Maps logits (raw model outputs) to probabilities that are used in multi-class classification.

Sigmoid: Squashes output to 0 and 1 so that it can be useful in binary classification.

ReLU (Rectified Linear Unit): Performs identity operation for non-negative inputs while setting outputs of zero for negative inputs to avoid the gradient vanishing problem.

Tanh (Hyperbolic Tangent): It produces outputs between -1 and 1 when applied to data. This makes it suitable for data centered around zero.

Random Forests: A set of methods that consists of building several decision trees that exploit samples from the data, and combining their predictions using averaging. It prevents overfitting and makes models stable.

Gradient Boosting: The final model is a decision tree which is built in stages. The subsequent decision trees are added though, they try to correct the errors of previous ones. Unlike Random Forests, it is more liable to overfitting. It can be a rather difficult task but it results in better accuracy.

The loss function determines how well the machine learning model’s predictions correlate with the existing data. Basically, it explains the difference between the two. The goal during training is to minimize that loss of course. Some of them are:

Cross-Entropy Loss: Typically used for classification tasks, it serves a neural network as a measure of error between the predicted probability distribution and the true distribution.

Mean Squared Error (MSE): It is normally used for regression tasks, which computes the average of the squared differences between the predicted values and the actual values.

Regularization is a technique that adds a penalty to the loss function for large coefficients and it is used to prevent overfitting. Regularization seeks to prevent the model from becoming too complex by reducing the magnitude of the coefficients. The two main variations of regularization are:

• L1 Regularization (Lasso): Introduces the absolute value of coefficients to the loss function so that the model would be sparse and some of the coefficients would be zero.
• L2 Regularization (Ridge): Introduces the squared coefficients into the loss function, thus preventing the model from settling on large coefficients and allowing all features to be present.

Regularization is the key factor that ensures that the model is able to generalize well to the new, unseen data.

“””

import tensorflow as tf

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

# Generate sample data

X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)

# Split the data

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Create the model

model = Sequential([

    Dense(64, activation='relu', input_shape=(20,)),

    Dense(32, activation='relu'),

    Dense(1, activation='sigmoid')

])

# Compile the model

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the model

history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_split=0.2, verbose=0)

# Evaluate the model

loss, accuracy = model.evaluate(X_test, y_test)

print(f"Test accuracy: {accuracy:.2f}")

“””

Outliers are elements that significantly impact the performance of machine learning models, as well as those that are particularly sensitive to data distribution, for example, linear regression. Here are a few ways to handle outliers:

Imputation: Substitute outliers with the mean, median, or a value gotten from other statistical measures.

Remove or Cap: Eliminate the outliers if they are mistakes or cap the extreme values if they are legal but extremely.

Transform the Data: Carry out transformations like the log, square root, or Box-Cox to minimize the effect of outliers.

Use Robust Algorithms: Algorithms such as decision trees and ensemble methods are less likely to be influenced by outliers.

Dropout is a technique used in neural networks that is known as regularization. It helps to avoid overfitting. During the training phase, dropout randomly “drops out” (ignores) some fraction of the neurons of each layer, which makes the network force the network not to depend on a certain neuron and this way develops redundancy. It results in the creation of a more resilient model that is more transferable to unseen data.

Generative Model: Models the joint probability distribution ( P(X, Y) ) and a generative model is used for generating new data points. Examples are Naive Bayes and Generative Adversarial Networks (GANs). These models can be used for the classification of new instances as well as for the generation of new data.

Discriminative Model: Models the conditional probability (P (Y | X)) in such a way that the input features are mapped to the output labels. Examples of these are logistic regression, SVM, and neural networks. These methods are commonly employed for classification tasks.

Evaluating the performance of an unsupervised learning model is more daunting, as there are no labeled outputs to compare it to. Common evaluation methods include:

Visual Inspection: Visualizing the outcomes of methods, like PCA or t-SNE, helps obtain insights regarding data structure.

Silhouette Score: It quantifies the similarity of an item within its decisive cluster to those in other communities.

Elbow Method:This method is the appearance of choosing the optimal number of clusters by drawing the line of squared distances for each point to its assigned cluster center over time.

Adjusted Rand Index: It conveys the similarities of two data clusterings by accessing all the paired samples.

High-dimensional data, often referred to as the “curse of dimensionality,” can lead to overfitting and increased computational cost. Some strategies to handle it include:

Use Models that Handle High Dimensions: Algorithms like Random Forests or Gradient Boosting Machines are more robust to high-dimensional data.

Dimensionality Reduction: Techniques like Principal Component Analysis (PCA) or Linear Discriminant Analysis (LDA) can reduce the number of features while retaining most of the information.

Feature Selection: Identify and retain only the most important features using methods like Recursive Feature Elimination (RFE), L1 regularization, or tree-based feature importance.

Type I Error (False Positive): Occurs when the null hypothesis is wrongly rejected when it is actually true. In other words, it indicates detecting an effect or difference when none exists (e.g., a medical test indicating a disease when the patient is healthy).

Type II Error (False Negative): Occurs when the null hypothesis is wrongly accepted when it is actually false. This means failing to detect an effect or difference when one actually exists (e.g., a medical test failing to detect a disease when the patient is actually ill)

Imagine you’re trying to draw a line through a set of points on a graph:

• Overfitting: If you draw a very complex, wiggly line that goes through every single point perfectly, it might look accurate for those points, but it won’t work well for new points that weren’t part of the original set. This is like memorizing answers for a test instead of understanding the material.
  
• Underfitting: If you draw a simple, straight line that doesn’t really match the points well, it misses the pattern in the data entirely. This is like not studying enough and having only a vague idea of the answers.
  

The goal is to find a balance where the line (your model) generalizes well to new data, without being too simple or too complex.

CNN (Convolutional Neural Network): Primarily used for image data, CNNs are designed to automatically and adaptively learn spatial hierarchies of features from input images. They are effective for tasks like image classification, object detection, and image segmentation.

RNN (Recurrent Neural Network): Designed for sequential data, RNNs are used for tasks where the order of data points matters, such as time series prediction, natural language processing, and speech recognition. RNNs have loops that allow information to persist, making them ideal for tasks involving sequences.

Feature selection is crucial to improve model performance and reduce computational cost. Methods include:

Embedded Methods: Perform feature selection during model training (e.g., Lasso regression, feature importance from tree-based models like Random Forest).

Filter Methods: Use statistical techniques to evaluate the relevance of features (e.g., correlation coefficient, chi-square test).

Wrapper Methods: Evaluate feature subsets based on model performance (e.g., Recursive Feature Elimination, Sequential Feature Selection).

Transfer learning involves taking a pre-trained model, typically trained on a large dataset, and fine-tuning it on a new, smaller dataset. This approach is especially useful when the new dataset is too small to train a deep neural network from scratch. By leveraging the knowledge already learned by the pre-trained model, transfer learning can significantly improve performance and reduce training time.

The learning rate in gradient descent controls the size of the steps taken towards the minimum of the loss function. A learning rate that is too high can cause the algorithm to converge too quickly to a suboptimal solution or even diverge, while a learning rate that is too low can make the training process extremely slow and get stuck in local minima. Finding the right learning rate is crucial for effective model training.

Class imbalance occurs when one class is significantly more frequent than others. Strategies to handle it include:

Algorithm Modifications: Use algorithms that can handle class imbalance naturally (e.g., decision trees, ensemble methods) or modify existing algorithms to weight classes differently.

Resampling Techniques:

Oversampling: Increase the number of instances in the minority class (e.g., SMOTE).

Undersampling: Reduce the number of instances in the majority class.

Use Different Evaluation Metrics: Instead of accuracy, use metrics like Precision, Recall, F1-Score, or ROC-AUC that provide better insights in the presence of class imbalance.

Batch Gradient Descent: Computes the gradient of the cost function with respect to the parameters for the entire dataset. It is stable but can be slow and computationally expensive for large datasets.

Stochastic Gradient Descent (SGD): Computes the gradient using only one training example at a time. It is faster and can escape local minima, but its updates can be noisy.

Mini-Batch Gradient Descent: A compromise between batch and stochastic gradient descent, it splits the dataset into small batches and performs updates on each mini-batch. It combines the advantages of both, providing faster convergence and more stable updates.

ROC Curve (Receiver Operating Characteristic Curve): A graphical representation of a classifier’s performance across different threshold settings. It plots the True Positive Rate (Recall) against the False Positive Rate, providing insights into the trade-off between sensitivity and specificity.