Supervised learning is when you know the outcome and you are provided with the fully labeled outcome data while in unsupervised you are not 
    provided with labeled outcome data. Fully labeled means that each example in the training dataset is tagged with the answer the algorithm should 
    come up with on its own. So, a labeled dataset of flower images would tell the model which photos were of roses, daisies and daffodils. When shown 
    a new image, the model compares it to the training examples to predict the correct label.

    A learning differs from supervised learning in not needing labelled input/output pairs be presented, and in not needing sub-optimal actions to be
    explicitly corrected. Instead the focus is on finding a balance between exploration (of uncharted territory) and exploitation (of current
    knowledge). In reinforcement learning each learning step involves a penalty criteria whether to give the model positive points or negative points
    and based on that penalizing the model.

    Deep learning is defined as algorithms inspired by the structure and function of the brain called artificial neural networks(ANN).Deep learning 
    most probably focuses on Non Linear Analysis and is recommend for Non Linear problems regarding Artificial Intelligence.

    Deep learning is a subset of machine learning, and both are subsets of AI. The practical difference is where the features come from.

    Classical ML (linear models, trees, gradient boosting, SVMs) learns from features that people design: ratios, counts,
    TF-IDF vectors, aggregates. Deep learning stacks many layers of learned non-linear transformations, so the network
    learns its own features directly from raw inputs such as pixels, audio samples or tokens.

    Neither one "knows on its own" whether a prediction is correct. Both learn by minimising a loss against labels
    (or a self-supervised target) with an optimiser.

    Rules of thumb:
        * Tabular data, small or medium datasets, need for interpretability -> gradient boosting is usually the strong baseline.
        * Images, audio, text, video, very large datasets -> deep learning wins because hand-built features plateau.
        * Deep learning needs more data, more compute (GPUs) and more tuning, and is harder to explain.

    Semi-supervised learning uses a small amount of labeled data combined with a large amount of unlabeled data during training. It sits between
    supervised (fully labeled) and unsupervised (no labels) learning. Common techniques include self-training, label propagation, and generative
    models. Example: training an image classifier with 100 labeled images and 10,000 unlabeled ones.

    Reinforcement learning (RL) is a paradigm where an agent learns by interacting with an environment, receiving rewards or penalties based on its
    actions. Unlike semi-supervised learning which works on a fixed dataset, RL involves sequential decision making. The agent learns a policy that
    maximizes cumulative reward over time. Example: training a robot to walk or an agent to play chess.

    Bias is error from wrong or overly simple assumptions: the model cannot represent the true relationship, so it is
    wrong in the same way on every training set (underfitting). Example: a straight line fitted to a curve.

    Variance is error from sensitivity to the particular training sample: the model fits noise, so retraining on a
    different sample gives a very different model (overfitting). Example: a fully grown decision tree.

    For squared loss, expected test error = Bias^2 + Variance + irreducible noise.

    Reduce bias: a more flexible model, better features, less regularisation, longer training.
    Reduce variance: more data, regularisation, bagging or other ensembles, early stopping, fewer features.
    Diagnose with learning curves: a high train error means high bias; a large gap between train and validation error
    means high variance.

    Linear regression models the target as a weighted sum of the input features plus an intercept:

        y = b0 + b1*x1 + b2*x2 + ... + bp*xp + e        (in vector form: y = X·w + e)

    where e is the noise term the model cannot explain.

    How it is fitted: choose the weights that minimise the mean squared error between predictions and targets
    (ordinary least squares). There are two ways to do this:
        1) Closed form (normal equations): w = (XᵀX)⁻¹ Xᵀy. This is exact, but costs O(p³) and is unstable when features are collinear.
        2) Gradient descent: iteratively step w in the direction of -∇MSE. This scales to large data.

    Classical assumptions, needed for valid confidence intervals rather than for prediction:
    linearity, independent errors, constant error variance (homoscedasticity), normally distributed errors,
    and no perfect multicollinearity.

    Evaluate with RMSE / MAE / R². Add L2 (Ridge) or L1 (Lasso) penalties when there are many or correlated features.

    Poisson regression for count data.
    Logistic regression and probit regression for binary data.
    Multinomial logistic regression and multinomial probit regression for categorical data.
    Ordered logit and ordered probit regression for ordinal data.

    Logistic regression is a statistical technique used to predict probability of binary response based on one or more independent variables. 
    It means that, given a certain factors, logistic regression is used to predict an outcome which has two values such as 0 or 1, pass or fail,
    yes or no etc
    Logistic Regression is used when the dependent variable (target) is categorical.
    For example,
        To predict whether an email is spam (1) or (0)
        Whether the tumor is malignant (1) or not (0)
        Whether the transaction is fraud or not (1 or 0)
    The prediction is based on probabilties of specified classes 
    Works the same way as linear regression but uses logit function to scale down the values between 0 and 1 and get the probabilities.

    The sigmoid and the logit are inverses of each other.

        sigmoid(z) = 1 / (1 + e^-z)        maps any real number z to (0, 1)  -> turns a score into a probability
        logit(p)   = log(p / (1 - p))      maps a probability p in (0, 1) to (-inf, +inf)  -> the "log-odds"

    Logistic regression is linear in the log-odds: logit(P(y=1|x)) = w·x + b, so P(y=1|x) = sigmoid(w·x + b).

    Where they are used:
        * Output layer for binary or multi-label classification (one sigmoid per label).
        * Gates inside LSTMs and GRUs, which need values in (0, 1) to act as soft switches.
        * Calibration (Platt scaling fits a sigmoid on top of model scores).
    In deep networks, avoid sigmoid in hidden layers. It saturates at both ends and causes vanishing gradients, so ReLU-family activations are used instead.
    For numerical stability, train on logits with BCEWithLogitsLoss instead of applying sigmoid and then log.

    For a prediction y_hat = w·x + b and loss MSE = (1/n) Σ (y_hat_i - y_i)²:

        dL/dw = (2/n) Σ (y_hat_i - y_i) * x_i
        dL/db = (2/n) Σ (y_hat_i - y_i)

        Update every step with learning rate α:
        w := w - α * dL/dw
        b := b - α * dL/db

        # numpy version
        for _ in range(epochs):
            err = X @ w + b - y
            w -= lr * (2 / n) * X.T @ err
            b -= lr * (2 / n) * err.sum()

    Scale the features first. Otherwise the loss surface is elongated and gradient descent zig-zags or diverges.

    A Support Vector Machine finds the hyperplane that separates the classes with the maximum margin, meaning the largest
    distance to the nearest training points. Those nearest points are the support vectors, and only they determine the
    boundary. The soft-margin SVM allows some violations, traded off by C (large C gives a narrower margin and fewer
    violations, so more variance). Equivalently, it minimises hinge loss plus an L2 penalty. With the kernel trick
    (RBF, polynomial) it learns non-linear boundaries without computing the high-dimensional features explicitly.
    SVR is the regression variant.

    SVM vs OvR is not a like-for-like comparison. An SVM is a binary classifier. One-vs-Rest (OvR) and One-vs-One (OvO)
    are strategies for turning any binary classifier into a multi-class one:
        * OvR: train K classifiers ("class k vs everything else") and predict the class with the highest score.
          This needs K models, and each one sees imbalanced data.
        * OvO: train K(K-1)/2 classifiers, one per pair of classes, and take a majority vote.
          There are more models, but each is trained on a small subset. scikit-learn's SVC uses OvO internally.
    Models that are natively multi-class need neither strategy: decision trees, random forests, kNN, naive Bayes,
    multinomial logistic regression, and neural networks with a softmax output.

    A kernel K(x, z) computes the dot product of x and z in some feature space without building that space explicitly.

        1) Linear:      K = x·z                      high-dimensional sparse data (text); fastest; use as a baseline
        2) Polynomial:  K = (γ x·z + r)^d            captures feature interactions up to degree d
        3) RBF/Gaussian: K = exp(-γ ||x - z||²)       default choice for non-linear data; γ controls how local the fit is
        4) Sigmoid:     K = tanh(γ x·z + r)          resembles a neural-network unit; rarely used and not always a valid kernel
        5) Laplacian:   K = exp(-γ ||x - z||₁)        similar to RBF, but less smooth

    Tune C and γ together (grid search on a log scale). A large γ with a large C overfits.
    Kernel SVMs scale roughly O(n²) to O(n³) in the number of samples. Above about 100k rows, use a linear SVM or gradient boosting.

    1) MSE  - mean of squared errors. Differentiable and punishes large errors heavily. Units are squared.
    2) RMSE - sqrt(MSE). Same units as the target, so it is easier to explain.
    3) MAE  - mean of absolute errors. Robust to outliers. It is minimised by predicting the median.
    4) R²   - 1 - SS_res / SS_tot: the fraction of variance explained compared with always predicting the mean. It can be negative.
    5) MAPE - mean(|error| / |y|). Scale-free, but undefined at y = 0 and biased towards under-prediction.
    6) sMAPE / WAPE - variants of MAPE that behave better near zero (common in forecasting).
    7) Huber loss - quadratic for small errors and linear for large ones, which makes it a compromise between MSE and MAE.
    8) Quantile (pinball) loss - used when you need prediction intervals or asymmetric costs.

    MAE : Use MAE when you are doing regression and don’t want outliers to play a big role. It can also be useful if you know that your distribution is multimodal, and it’s desirable to have predictions at one of the modes, rather than at the mean of them.
    MSE : use MSE the other way around, when you want to punish the outliers.

    Start from the confusion matrix (TP, FP, TN, FN), then choose metrics that match the business cost of each error:
        * Accuracy: only meaningful when the classes are balanced.
        * Precision, Recall, F1 (or F-beta to weight recall more heavily).
        * ROC-AUC: threshold-independent ranking quality. PR-AUC is better when positives are rare.
        * Log loss / Brier score and a calibration curve, when the probabilities themselves are used.
        * Per-class and per-segment metrics, since an overall score can hide a failing subgroup.
    Use stratified k-fold cross-validation (or a time-based split for temporal data), and compare against a trivial baseline.
    Choose the decision threshold on validation data, based on the cost of an FP compared with an FN.

    Classification is defined as categorizing classes or entities based on the specified categories either that category exists or not in the respectable data. The concept is quite common for Image based classification or Data Based Classification. The answer in form of Yes or No;
    alongside answers in form of types of objects/classes.

    Multi-class: each example belongs to exactly one of K > 2 classes (for example cat OR dog OR bird).
        Output layer: softmax over K classes. Loss: categorical cross-entropy. Predict the argmax.
    Multi-label: each example can have any subset of the labels (a photo tagged "beach" AND "sunset" AND "people").
        Output layer: K independent sigmoids. Loss: binary cross-entropy per label. Threshold each label separately.
    Metrics also differ. Multi-class uses accuracy and macro/micro F1. Multi-label uses per-label F1, Hamming loss,
    subset accuracy, and mAP.

    A confusion matrix, also known as an error matrix, is a specific table layout that allows visualization of
     the performance of an algorithm, typically a supervised learning one (in unsupervised learning it is
      usually called a matching matrix). Each row of the matrix represents the instances in a predicted class
       while each column represents the instances in an actual class (or vice versa).
    The name stems from the fact that it makes it easy to see if the system is confusing two classes
    (i.e. commonly mislabeling one as another).

    Bias comes from the simplifying assumptions a model makes about the shape of the target function.
        High-bias examples: linear regression, logistic regression, LDA, naive Bayes, shallow trees and decision stumps,
        and kNN with a very large k. They assume linear or otherwise simple boundaries, or independent features.
    They underfit when the true relationship is non-linear or has interactions. Fix that with feature engineering
    (polynomial terms, interactions), kernels, or more flexible models.

    Variance is how much the learned function changes when the training data changes.

        1) High variance (flexible, low bias): fully grown decision trees, kNN with small k, SVMs with RBF and a large C or γ,
           high-degree polynomials, and deep neural networks without regularisation.
        2) Low variance (rigid, higher bias): linear and logistic regression, LDA, naive Bayes, kNN with large k.

    Most algorithms have a knob that moves them along this tradeoff: tree depth, k, C and γ, regularisation strength.
    Ensembles cut variance (bagging) or bias (boosting).

    Linear machine learning algorithms often have a high bias but a low variance.
    Nonlinear machine learning algorithms often have a low bias but a high variance.

    Possible root causes of prediction bias are:

    1) Incomplete feature set
    2) Noisy data set
    3) Buggy pipeline
    4) Biased training sample
    5) Overly strong regularization

    Gradient Descent is an iterative method to solve the optimization problem. There is no concept of "epoch" or "batch" in classical gradient decent. The key of gradient decent are
    * Update the weights by the gradient direction.
    * The gradient is calculated precisely from all the data points.
    Stochastic Gradient Descent can be explained as: 
    * Quick and dirty way to "approximate gradient" from one single data point. 
    * If we relax on this "one single data point" to "a subset of data", then the concepts of batch and epoch come.

    A decision tree recursively splits the data on the feature and threshold that most reduce impurity (Gini or entropy for
    classification, variance for regression). Each leaf predicts the majority class or the mean value. Trees are
    interpretable, need no feature scaling, and handle non-linearity. A single deep tree has high variance.

    A random forest is a bagged ensemble of decision trees:
        * each tree is trained on a bootstrap sample of the rows, and
        * each split considers only a random subset of features (about sqrt(p) for classification).
    This decorrelates the trees. Averaging their predictions (a majority vote for classification) cuts variance while
    keeping bias low. Rows left out of each bootstrap sample (out-of-bag) give a free validation estimate.

    Splitting is how a decision tree grows. At each node it tries candidate (feature, threshold) pairs and picks the one
    that most reduces impurity in the child nodes: Gini or entropy for classification, variance (MSE) for regression.
    It then recurses on each child until a stopping rule is reached: max depth, min samples per leaf, or no gain.
    Numeric features are split at thresholds between sorted values. Histogram-based methods (LightGBM) bin the values
    first for speed.
    (In the data sense, "splitting" also means dividing data into train, validation and test sets.)

    The shortening of branches of Decision Trees is termed as pruning. The process is done in order to reach the decision earlier than
    expected, reducing the size of the tree by turning some branch nodes into leaf nodes, and removing the leaf nodes under the original branch.

    Tree selection is mainly done from the following
    1) Entropy 
            A decision tree is built top-down from a root node and involves partitioning the data into subsets that contain instances with similar 
            values (homogeneous). ID 3 algorithm uses entropy to calculate the homogeneity of a sample. If the sample is completely homogeneous the
            entropy is zero and if the sample is an equally divided it has entropy of one.
            Entropy(x) -> -p log(p) - qlog(q)  with log of base 2
    2) Information Gain  
            The information gain is based on the decrease in entropy after a dataset is split on an attribute. Constructing a decision tree is all about finding attribute that returns the highest information gain (i.e., the most homogeneous branches).

            2.1) Calculate entropy of the target.
            2.2) The dataset is then split on the different attributes. The entropy for each branch is calculated. Then it is added proportionally, to get total entropy for the split. The resulting entropy is subtracted from the entropy before the split. The result is the Information Gain, or decrease in entropy.
            2.3) Choose attribute with the largest information gain as the decision node, divide the dataset by its branches and repeat the same process on every branch.

    -* Decision Tree *- A Simple Tree compromising of the process defined in selection of Trees.
    -* RandomForest *- Combination of Multiple N number of Decision Trees and using the aggregation to determine the final outcome.
    The classifier outcome is based on Voting of each tree within random forest while in case of regression it is based on the 
    averaging of the tree outcome.

    The Gini Index is calculated by subtracting the sum of the squared probabilities of each class from one. It favors larger partitions.
    Imagine, you want to draw a decision tree and wants to decide which feature/column you should use for your first split?, this is probably defined
    by your gini index.

    Gini Index:
    for each branch in split:
        Calculate percent branch represents .Used for weighting
        for each class in branch:
            Calculate probability of class in the given branch.
            Square the class probability.
        Sum the squared class probabilities.
        Subtract the sum from 1. #This is the Ginin Index for branch
    Weight each branch based on the baseline probability.
    Sum the weighted gini index for each split.

    Favors larger partitions.
    Uses squared proportion of classes.
    Perfectly classified, Gini Index would be zero.
    Evenly distributed would be 1 - (1/# Classes).
    You want a variable split that has a low Gini Index.
    The algorithm works as 1 - ( P(class1)^2 + P(class2)^2 + … + P(classN)^2)

    Probability treats the parameters as fixed and asks how likely the data is:
    "if the coin is fair (p = 0.5), what is the chance of 7 heads in 10 tosses?"

    Likelihood treats the observed data as fixed and asks how well each parameter value explains it. It is the same formula,
    read as a function of the parameter: L(p | data) = P(data | p). It is not a probability distribution over p,
    because it does not have to sum to 1.

    Binomial example with 7 heads in 10 tosses:
        L(p) = C(10, 7) * p^7 * (1 - p)^3
        L(0.5) = 120 * 0.5^10 ≈ 0.117
        L(0.7) = 120 * 0.7^7 * 0.3^3 ≈ 0.267   <- p = 0.7 explains the data better
    In general, for k successes in n trials: L(p) = C(n, k) * p^k * (1 - p)^(n - k).
    Maximum likelihood estimation picks the p that maximises L, which here is p_hat = k/n = 0.7.

    Entropy measures the impurity or uncertainty of a label distribution:
        H(S) = -Σ p_k * log2(p_k)
    It is 0 for a pure node and 1 bit for a 50/50 binary split.

    Information gain is the reduction in entropy produced by a split:
        IG(S, A) = H(S) - Σ_v (|S_v| / |S|) * H(S_v)
    A decision tree picks the split with the highest information gain.

    The difference: entropy describes one set, while information gain compares a parent set with its children after a split.
    Caveat: information gain favours features with many distinct values (an ID column splits perfectly).
    C4.5 corrects for this with the gain ratio.

    Kullback-Leibler divergence measures how much a distribution Q differs from a reference distribution P:
        KL(P || Q) = Σ P(x) * log(P(x) / Q(x))
    It is always >= 0, and equals 0 only when P = Q. It is not symmetric: KL(P||Q) ≠ KL(Q||P).
    It is not a true distance.

    Relationship to cross-entropy: H(P, Q) = H(P) + KL(P || Q). With P fixed (the labels), minimising cross-entropy is
    the same as minimising KL.

    Use cases:
        * VAEs: a KL term pulls the latent posterior towards the prior.
        * Knowledge distillation: a student matches the teacher's soft output distribution.
        * RLHF / PPO / DPO: a KL penalty keeps the fine-tuned policy close to the reference model.
        * Drift monitoring: compare feature distributions between training and production (often via the symmetric JS divergence).
        * t-SNE minimises KL between neighbour distributions in high and low dimensions.

    Entropy: Randomness of information being processed.

    Cross Entropy: A measure from the field of information theory, building upon entropy and generally calculating the difference between two
    probability distributions. It is closely related to but is different from KL divergence that calculates the relative entropy between two
    probability distributions, whereas cross-entropy can be thought to calculate the total entropy between the distributions.

    Cross-entropy can be calculated using the probabilities of the events from P and Q, as follows:
            H(P, Q) = -sum x in X P(x) * log(Q(x))

    ROC is a probability curve and AUC represents degree or measure of separability. AUC - ROC curve is a performance measurement for classification problem at various thresholds settings.

    It tells how much model is capable of distinguishing between classes. Mainly used in classification problems for measure at different thresholds.
    Higher the AUC, better the model is at predicting 0s as 0s and 1s as 1s. By analogy, Higher the AUC, better the model is at distinguishing between patients with disease and no disease.

    False positive (Type I error): the actual class is negative, but the model predicts positive.
        Example: a legitimate email flagged as spam, or a healthy patient diagnosed as sick.

    False negative (Type II error): the actual class is positive, but the model predicts negative.
        Example: a fraudulent transaction approved, or a sick patient told they are healthy.

    In hypothesis testing, α = P(Type I) (the significance level) and β = P(Type II). Power = 1 - β.
    Lowering the decision threshold trades FNs for FPs, and raising it does the opposite.

    Take a simple Classification example of "Classifying email messages as spam or not spam"

    Precision measures the percentage of emails flagged as spam that were correctly classified, that is, the percentage of dots to the right of the threshold line, it is also defined as % of event being Called at positive rates e.g 
            Precision = True Positive / (True Positive + False positive) 
    
    Recall measures the percentage of actual spam emails that were correctly classified
            Recall = True Postives / (True Positive + False Negative)
    
    There is always a tradeoff between precision and Recall same is the case of Bias and Variance.

    This totally depends on Business Usecase or SME usecase. In case of Fraud Detection Business domains such as banks, online ecommerce websites
    recommends of better recall score than precision. While in other cases such as word suggestions or Multi label Categorization it can be precision.
    In general, totally dependent on your use case.

    F1 = 2 * Precision * Recall / (Precision + Recall), which is the harmonic mean of precision and recall.
    It ranges from 0 to 1. For binary sets it equals the Dice coefficient.

    Intuition: the harmonic mean is dominated by the smaller value. A model with precision 1.0 and recall 0.01 gets
    F1 ≈ 0.02, not 0.5. You only score well if both are reasonable. F1 also ignores true negatives, which suits
    imbalanced problems.

    Limitation: F1 weights precision and recall equally. When the costs differ, use F-beta
    (beta > 1 favours recall, beta < 1 favours precision), or better, pick a threshold from an explicit cost model.
    For multi-class problems, state whether you report macro F1 (every class equal), micro F1, or weighted F1.

    Both are linear classifiers of the form sign(w·x + b). The difference is what they optimise.

        * Perceptron: finds any separating hyperplane. Its update rule only fires on misclassified points.
          The solution depends on the order of the data and never converges if the data is not separable.
        * SVM: finds the maximum-margin hyperplane. It minimises hinge loss plus an L2 penalty,
          which gives a unique solution that generalises better.

    Put another way, SVM ≈ hinge loss + L2 regularisation + a margin, while the perceptron uses a "zero-margin" hinge
    loss with no regularisation. Both can be kernelised. Both can be trained online (a linear SVM with SGD or Pegasos),
    although classic kernel SVM solvers such as SMO are batch methods.

        Linear regression                          | Logistic regression
        ------------------------------------------ | ------------------------------------------
        Predicts a continuous value in (-inf, inf) | Predicts a probability in (0, 1), used for classification
        y = w·x + b                                | P(y=1|x) = sigmoid(w·x + b)
        Loss: mean squared error                   | Loss: log loss (binary cross-entropy)
        Closed-form solution exists                | No closed form; solved iteratively (gradient descent, L-BFGS)
        Coefficient = change in y per unit of x    | Coefficient = change in log-odds per unit of x

    Both are linear models. Logistic regression's decision boundary w·x + b = 0 is a hyperplane.

    An outlier is an observation that lies far from the rest of the data. It can be a data error (sensor glitch, typo)
    or a genuine rare event (fraud, a viral post). Investigate first. Only drop points you can show are errors,
    because in anomaly or fraud problems the outliers are the signal.

    Detection:
        1) IQR rule: flag values outside [Q1 - 1.5*IQR, Q3 + 1.5*IQR]. This is robust and works for skewed data.
        2) Z-score: flag |z| > 3. This assumes roughly normal data, and the outliers themselves inflate the std.
           The modified z-score (based on the median and MAD) is more robust.
        3) Multivariate: Isolation Forest, LOF, Mahalanobis distance.

    Handling (often better than deleting):
        * cap or winsorise at percentiles, or log-transform skewed features
        * use robust models and losses (tree-based models, MAE or Huber loss, RobustScaler)

    Regularization techniques are used to reduce the error by fitting a function appropriately on the given training set and avoid overfitting.
    They add a penalty term (Lambda * weight magnitude) to the loss function to discourage overly complex models.

    1) L1 Regularization (Lasso Regression)
        (Least Absolute Shrinkage and Selection Operator) adds “absolute value of magnitude” of coefficient as penalty term to the loss function.

    2) L2 Regularization (Ridge Regression)
        Adds “squared magnitude” of coefficient as penalty term to the loss function. Here the highlighted part represents L2 regularization element.

    The key difference between these techniques is that Lasso shrinks the less important feature’s coefficient to zero thus, removing some feature
    altogether. So, this works well for feature selection in case we have a huge number of features.

    Data Sampling statistical analysis technique used to select, manipulate and analyze a representative subset of data points to identify patterns and trends in the larger data set being examined.
    There are different techniques of sampling your data
    1) Simple Random Sampling (records are picked at random)
    2) Stratified Sampling (subsets based on common factor with equal ratio distribution)
    3) Cluster Sampling (largest set is breaken down in form of clusters based on defined factors and SRS is applied)
    4) MultiStage Sampling (cluster on Cluster sampling)
    5) Symentaic Sampling (Sample created by setting interval)

    Both rebalance class frequencies in the training set only. Never resample the validation or test set.

    Undersampling removes examples from the majority class. For example, keep 100k of 1M negatives next to 100k positives.
    It is fast, but it throws away information. Variants such as Tomek links and NearMiss remove redundant or borderline points.

    Oversampling adds examples to the minority class, either by duplicating them (random oversampling) or by
    synthesising new ones (SMOTE, ADASYN). It keeps all the data, but duplication can cause overfitting.

    Resampling changes the base rate, so predicted probabilities become miscalibrated. Recalibrate them, or correct
    for the sampling rate, before using the scores as probabilities.

    Imbalancment is when you don't have balance in between classes.
    Imabalnced class is when the normal distribution/support count of multiple classes or classes being considered are not the same or almost same.
    E.G:
        Class A has 1 Million Record
        Class B has 1000 Record
    This is imbalanced data set and Class B is UnderBalanced Class.

        1) Use the right metrics first: PR-AUC, recall at a fixed precision, F1. Never plain accuracy.
        2) Class weights in the loss (class_weight="balanced", scale_pos_weight in XGBoost). This is often the simplest fix.
        3) Resampling of the training data only: undersampling, oversampling, SMOTE.
        4) Tune the decision threshold on validation data instead of using 0.5.
        5) Focal loss (deep learning) to focus training on hard examples.
        6) Collect more minority examples, or use data augmentation.
        7) For extreme imbalance, frame the problem as anomaly detection.
    Use stratified splits so every fold contains positives.

    A moving average smooths a time series by averaging the last n points. A weighted moving average gives each point in
    the window a different weight, usually larger for recent points, so it reacts faster to changes:

        WMA_t = Σ_{i=0..n-1} w_i * x_{t-i} / Σ w_i        e.g. weights n, n-1, ..., 1

    The exponential moving average (EMA) is the most common version. Its weights decay geometrically:
        EMA_t = α * x_t + (1 - α) * EMA_{t-1}
    Use cases: trend smoothing, simple forecasting baselines, technical indicators, and the momentum and Adam optimisers
    (which keep an EMA of gradients).

    ARIMA(p, d, q) = AutoRegressive Integrated Moving Average, a classical univariate forecasting model.
        * AR(p): regress on the last p values of the series.
        * I(d):  difference the series d times to make it stationary (remove the trend).
        * MA(q): regress on the last q forecast errors.
    Choose d with stationarity tests (ADF, KPSS). Choose p and q from the PACF and ACF plots, or by AIC (auto_arima).
    SARIMA adds seasonal terms, and ARIMAX / SARIMAX add external regressors.
    ARIMA is a strong baseline for a single short series. For many related series, gradient boosting on lag features or
    global deep-learning models usually does better.

    Bagging (bootstrap aggregating): train many models independently, in parallel, on bootstrap samples of the data,
    then average or vote. It reduces variance, so it suits high-variance base learners such as deep trees. Example: random forest.

    Boosting: train models sequentially, each one correcting the errors of the ensemble so far. AdaBoost reweights
    misclassified samples. Gradient boosting fits each new tree to the negative gradient of the loss (the residuals).
    It mainly reduces bias and uses shallow trees. Examples: XGBoost, LightGBM, CatBoost.

    XGBoost vs Random Forest:
        * Sequential vs parallel tree building. Shallow trees vs deep trees.
        * XGBoost has a learning rate, L1/L2 regularisation on leaf weights, native missing-value handling,
          and second-order (Hessian) optimisation.
        * XGBoost usually achieves higher accuracy on tabular data, but needs more tuning and can overfit.
          Random forest is robust with default settings and hard to overfit by adding more trees.

    The interquartile range is the spread of the middle 50% of the data: IQR = Q3 - Q1, where
        Q1 = 25th percentile, Q2 = 50th percentile (the median), Q3 = 75th percentile.
    The quartiles are cut points, not ranges.

    Outlier rule (Tukey's fences): flag x < Q1 - 1.5*IQR or x > Q3 + 1.5*IQR. Use 3*IQR for "extreme" outliers.
    The whiskers of a box plot are drawn this way. Because the rule uses percentiles, it is robust to the outliers
    themselves, unlike the z-score.

        q1, q3 = np.percentile(x, [25, 75]); iqr = q3 - q1
        mask = (x >= q1 - 1.5 * iqr) & (x <= q3 + 1.5 * iqr)

    SMOTE (Synthetic Minority Over-sampling TEchnique) creates new minority-class examples instead of duplicating existing ones:
        1) pick a minority sample x
        2) find its k nearest minority-class neighbours (k = 5 by default)
        3) create a synthetic point x_new = x + λ * (neighbour - x), with λ ~ Uniform(0, 1)
    So the new points lie on line segments between minority samples.

    Caveats:
        * Apply it only to the training folds, inside the cross-validation pipeline (imblearn.pipeline). Otherwise it leaks.
        * It can create noisy points in overlapping regions, and it works poorly in very high dimensions.
        * It needs numeric features. For categorical features use SMOTENC.
        * Variants: Borderline-SMOTE, ADASYN, SMOTE-Tomek.
    With strong learners such as gradient boosting, class weights plus threshold tuning often match SMOTE.

    Underfitting (high bias: training error is high):
        1) Use a more complex model, or add capacity (deeper trees, more layers)
        2) Add better features and interactions
        3) Reduce regularisation
        4) Train longer, or fix the learning rate (too high diverges, too low stalls)

    Overfitting (high variance: train error is low but validation error is high):
        1) Get more training data, or use data augmentation
        2) Regularisation: L1/L2 penalties, dropout, weight decay
        3) Early stopping on a validation metric
        4) Simplify the model or remove noisy features
        5) Bagging and ensembles
        6) Use cross-validation to detect it and to tune the hyperparameters above

    1) More data, or data augmentation
    2) L1 / L2 regularisation and weight decay
    3) Dropout (neural networks)
    4) Early stopping
    5) Simpler models: shallower trees, fewer features, pruning
    6) Ensembling (bagging, random forests)
    7) Cross-validation for honest model selection
    8) Batch normalisation and label smoothing (mild regularisers in deep learning)

    A "neuron" in an artificial neural network is a mathematical approximation of a biological neuron.
    It takes a vector of inputs, performs a transformation on them, and outputs a single scalar value.
     It can be thought of as a filter. Typically we use nonlinear filters in neural networks.

    1) Input Layer: Initial input for your neural network
    2) Hiddent layers: a hidden layer is located between the input and output of the algorithm, 
    in which the function applies weights to the inputs and directs them through an activation function as the output.
    In short, the hidden layers perform nonlinear transformations of the inputs entered into the network. 
    Hidden layers vary depending on the function of the neural network, and similarly, the layers may vary depending 
    on their associated weights.

    The output layer turns the last hidden representation into the prediction. Its activation and loss must match the task:
        Regression                 -> linear (no activation), MSE / MAE / Huber loss
        Binary classification      -> 1 unit with sigmoid, binary cross-entropy
        Multi-class classification -> K units with softmax, categorical cross-entropy
        Multi-label classification -> K units with sigmoid each, binary cross-entropy per label
        Positive-only targets      -> softplus or exp (e.g. counts, variances)
    ReLU is a hidden-layer activation. It is rarely the right output activation.
    In PyTorch, output raw logits and use CrossEntropyLoss or BCEWithLogitsLoss, which apply softmax or sigmoid
    internally in a numerically stable way.

    An activation function adds non-linearity after each linear layer. Without it, any stack of linear layers collapses
    into a single linear map, however deep the network is.
    Common choices:
        1) Sigmoid: squashes to (0, 1). Used for binary and multi-label outputs and LSTM gates. It saturates at both
           ends, which causes vanishing gradients in deep hidden layers.
        2) Softmax: turns a vector of logits into a probability distribution that sums to 1. Used for the multi-class
           output layer (mutually exclusive classes).
        3) Tanh: squashes to (-1, 1) and is zero-centred. It also saturates. Used for RNN hidden states.
        4) ReLU: max(0, x). Cheap, and does not saturate for x > 0. The default for hidden layers.
           Units can "die" if they only ever receive negative inputs.
        5) Leaky ReLU / PReLU / ELU: a small slope or smooth curve for x < 0, which avoids dead units.
        6) GELU / SiLU (Swish): smooth ReLU-like functions, standard in transformers and LLMs.

    convolutional-neural-network is a subclass of neural-networks which have at least one convolution layer. 
    They are great for capturing local information (e.g. neighbor pixels in an image or surrounding words in a text) 
    as well as reducing the complexity of the model (faster training, needs fewer samples, reduces the chance of overfitting).
    . A convolution unit receives its input from multiple units from the previous layer which together create a proximity.
    Therefore, the input units (that form a small neighborhood) share their weights.

    A class of artificial neural networks where connections between nodes form a directed graph along a temporal sequence.
    This allows it to exhibit temporal dynamic behavior. Derived from feedforward neural networks, RNNs can use their 
    internal state (memory) to process variable length sequences of inputs. This makes them applicable to tasks such 
    as unsegmented, connected handwriting recognition or speech recognition.

    Long Short-Term Memory (LSTM) is a recurrent neural network cell built to learn long-range dependencies that vanilla
    RNNs forget because of vanishing gradients. It keeps a separate cell state that is updated additively, and three
    sigmoid gates control it: forget (what to erase), input (what to write), and output (what to expose as the hidden
    state). Because the additive path lets gradients flow across many time steps, it can remember information for
    hundreds of steps.
    Use cases: speech recognition, handwriting recognition, time-series forecasting, anomaly detection on sequences,
    and machine translation before transformers. Transformers have largely replaced LSTMs for language, but LSTMs remain
    useful for small, streaming, or on-device sequence models.

    A convolution is the simple application of a filter to an input that results in an activation. Repeated application of the 
    same filter to an input results in a map of activations called a feature map, indicating the locations and strength of a 
    detected feature in an input, such as an image.
    You can use Filters which are based on Horizental Lines or Verticial Lines or Gray Scale conversion or other conversion filters.

    Pooling layers provide an approach to down sampling feature maps by summarizing the presence of features in patches of the feature map.
    Two common pooling methods are average pooling and max pooling that summarize the average presence of a feature and the most activated 
    presence of a feature respectively.      

    This is required to downsize your feature scale (e.g You have detected vertical lines, now remove some of the feature to go in grain)

    Max pooling uses the maximum value found in a considered region. Maximum pooling, or max pooling, is a pooling operation that calculates the maximum, or largest, value in each patch of each feature map.

    The word "kernel" means two different things in ML.

    1) In CNNs, a kernel (filter) is a small learned weight tensor, for example 3x3xC_in. It slides over the input and
       computes a dot product at each position, producing one feature map per filter. Early layers learn edge and texture
       detectors. Deeper layers learn parts and objects.

    2) In kernel methods (SVMs, kernel PCA, Gaussian processes), a kernel K(x, z) = φ(x)·φ(z) is a similarity function
       equal to a dot product in some (possibly infinite-dimensional) feature space. The "kernel trick" lets a linear
       algorithm learn non-linear boundaries without ever computing φ(x). Common kernels are linear, polynomial and RBF.

    Segmentation partitions an input into meaningful regions, at the pixel level for images:
        * Semantic segmentation: a class for every pixel.
        * Instance segmentation: a separate mask for each object instance.
        * Panoptic segmentation: both at once.
    The same word also appears elsewhere: customer segmentation (clustering users), and text or audio segmentation
    (splitting a stream into sentences, speakers, or events).

    Pose estimation predicts the positions of an object's keypoints. For humans these are joints such as shoulders,
    elbows and knees, in 2D image coordinates or in 3D. Top-down methods detect each person and then find keypoints
    (HRNet, ViTPose). Bottom-up methods find all keypoints and then group them into people (OpenPose).
    Keypoints are usually predicted as heatmaps.
    Uses: fitness apps, motion capture, AR, sign language, and action recognition.

    The input data is fed in the forward direction through the network. Each hidden layer accepts the input data,
    processes it as per the activation function and passes to the successive layer.

    Backpropagation computes the gradient of the loss with respect to every weight by applying the chain rule backwards
    through the network, from the output layer to the input (reverse-mode automatic differentiation). It reuses the
    intermediate activations from the forward pass, so the whole gradient costs about as much as a couple of forward passes.

    Backprop only computes the gradients. The optimiser (SGD, Adam) then uses them to update the weights,
    w := w - lr * dL/dw. This happens on every mini-batch, not once per epoch.

    The term “dropout” refers to dropping out units (both hidden and visible) in a neural network.
    Simply put, dropout refers to ignoring units (i.e. neurons) during the training phase of certain 
    set of neurons which is chosen at random. By “ignoring”, I mean these units are not considered during
    a particular forward or backward pass.
    More technically, At each training stage, individual nodes are either dropped out of the net with 
    probability 1-p or kept with probability p, so that a reduced network is left; incoming and 
    outgoing edges to a dropped-out node are also removed.

    A flatten layer collapses the spatial dimensions of the input into the channel dimension. 
    For example, if the input to the layer is an H-by-W-by-C-by-N-by-S array (sequences of images),
    then the flattened output is an (H*W*C)-by-N-by-S array.

    The gradient dL/dw tells each weight which direction increases the loss and by how much. Moving every weight a small
    step in the opposite direction lowers the loss on the current mini-batch. Repeating this over many batches makes the
    network's predictions match the targets better.
    Backprop makes this practical: the chain rule gives all gradients in a single backward pass, instead of perturbing
    each of millions of weights one at a time.
    Better training loss improves generalisation only if overfitting is controlled (validation monitoring, regularisation).

    Covariance measures how two variables vary together:
        cov(X, Y) = E[(X - μx)(Y - μy)]
    Its sign gives the direction of the linear relationship. Its magnitude depends on the units, so it is hard to compare
    across variables.

    Correlation (Pearson) is covariance scaled to [-1, 1]:
        ρ = cov(X, Y) / (σx * σy)
    This makes it unit-free, so it measures both the strength and the direction of the linear relationship.

    Notes:
        * Correlation does not imply causation. A confounder can drive both variables.
        * Pearson only captures linear relationships. Spearman (rank-based) captures monotonic ones and is robust to outliers.
        * A correlation of 0 does not mean the variables are independent (for example, y = x² on symmetric x).

    Analysis of variance (ANOVA) is a collection of statistical models and their associated estimation procedures 
    (such as the "variation" among and between groups) used to analyze the differences among group means in a sample.

    Use a one-way ANOVA when you have collected data about one categorical independent variable and 
    one quantitative dependent variable. The independent variable should have at least three levels
     (i.e. at least three different groups or categories)

    Dimensionality reduction or dimension reduction is the process of reducing the number of random variables 
    under consideration by obtaining a set of principal variables. Approaches can be divided into feature 
    selection and feature extraction.
    The reason we use it is because
            1) Immensive dataset 
            2) Longer Trainnig time/gathering time
            3) Too much complex assumptions/ Model overfitting
    Types of Dimensionality reductions are 
            1) Feature Selection
            2) Feature Projection( transform data from higher dimention to lower space of fewer dimention)
            3) Principle component Analysis
                    Linear Technique for DR, performs linear mapping of data to lower dimention
                    space in such a way variance is maximized.
            4) Non Negative Metrics Factorization
            5) Kernel PCA ( Non linear way of utilization of Kernel Trick)
            6) Graph Based Kernel PCA ( locally linear embedding, Eigen Embeddings)

            7) Linear Discriminant Analysis
                    A method used in statistics, pattern recognition and machine learning to find a 
                    linear combination of features that characterizes or separates two or more 
                    classes of objects or events.
            8) Generalized Discriminant Analysis 
            8) TSNE (is a non-linear dimensionality reduction technique useful for visualization of high-dimensional datasets.)
            9) U-Map
                    Uniform manifold approximation and projection (UMAP) is a nonlinear dimensionality reduction technique. 
                    Visually, it is similar to t-SNE, but it assumes that the data is uniformly distributed on a locally 
                    connected Riemannian manifold and that the Riemannian metric 
                    is locally constant or approximately locally constant.
            10) Autoencoders (can learn from Non Linear dimention reduction function)

    The main linear technique for dimensionality reduction, principal component analysis, performs
     a linear mapping of the data to a lower-dimensional space in such a way that the variance of 
     the data in the low-dimensional representation is maximized. In practice, the covariance (and 
     sometimes the correlation) matrix of the data is constructed and the eigenvectors on this 
     matrix are computed. The eigenvectors that correspond to the largest eigenvalues (the 
     principal components) can now be used to reconstruct a large fraction of the variance of the 
     original data. The original space (with dimension of the number of points) has been reduced 
     (with data loss, but hopefully retaining the most important variance) to the space spanned by 
     a few eigenvectors

    Maximum likelihood estimation is a method that determines values for the parameters of a model. 
    The parameter values are found such that they maximise the likelihood that the process described by the model
    produced the data that were actually observed.

    Naive Bayes is a generative classifier based on Bayes' theorem. It makes the "naive" assumption that features are
    conditionally independent given the class:

        P(class | x1..xn) ∝ P(class) * Π P(xi | class)
        predict  argmax_c  [ log P(c) + Σ log P(xi | c) ]

    Training only requires counting (class priors and per-feature likelihoods), so it is very fast and works with little data.
        * GaussianNB for continuous features, MultinomialNB for word counts, BernoulliNB for binary features.
        * Use Laplace (add-one) smoothing so that a word never seen in training does not zero out the whole product.
        * Work in log space to avoid numerical underflow.
    It is a strong baseline for text classification and spam filtering. Its predicted probabilities are usually poorly
    calibrated, because the independence assumption does not hold.

    Bayes' theorem updates a belief after seeing evidence:

        P(A | B) = P(B | A) * P(A) / P(B)
        posterior = likelihood * prior / evidence

    Classic example: a disease has 1% prevalence, and a test has 99% sensitivity and 5% false-positive rate.
        P(disease | +) = 0.99 * 0.01 / (0.99 * 0.01 + 0.05 * 0.99) ≈ 0.167
    A positive result means only about a 17% chance of disease, because the base rate is low.
    This base-rate effect is why precision collapses on rare-event problems such as fraud.

    Probability is a number between 0 and 1, where, roughly speaking, 0 indicates impossibility and 1 indicates certainty.
    The higher the probability of an event, the more likely it is that the event will occur. 
    Example:
    A simple example is the tossing of a fair (unbiased) 
    coin. Since the coin is fair, the two outcomes ("heads" and "tails") are both equally probable; the probability of "heads" equals the probability 
    of "tails"; and since no other outcomes are possible, the probability of either "heads" or "tails" is 1/2 (which could also be written as 0.5 or 
    50%).

    Joint probability is a statistical measure that calculates the likelihood of two events occurring together and at the same point in time.
            P(A and B) or P (A ^ B) or P(A & B)
            The joint probability is detremeinded as :
            P(A and B) = P(A given B) * P(B)       

    Marginal probability is the probability of one variable on its own, regardless of the values of other variables.
    You get it by summing (or integrating) the joint distribution over the other variables:

        P(A) = Σ_b P(A, B = b)

    Example: if the joint table gives P(rain, weekend) and P(rain, weekday), then
    P(rain) = P(rain, weekend) + P(rain, weekday). It is called "marginal" because these totals used to be written in the
    margins of the table.

    Conditional probability is the probability of A given that B has happened:
        P(A | B) = P(A, B) / P(B),  defined when P(B) > 0
    A and B are independent if and only if P(A | B) = P(A).

    A probability distribution assigns probabilities to every possible value of a random variable.
        * Discrete: a probability mass function (Bernoulli, Binomial, Poisson).
        * Continuous: a probability density function (Normal, Exponential, Uniform).
    The cumulative distribution function F(x) = P(X <= x) exists for both.

    The z-score says how many standard deviations a value lies from the mean: z = (x - μ) / σ.
    Uses: standardising features, outlier flagging (|z| > 3), comparing values on different scales, and
    z-tests in hypothesis testing.
    Under a normal distribution about 68% / 95% / 99.7% of values fall within 1 / 2 / 3 standard deviations.
    The z-score is sensitive to outliers, because they inflate σ. The robust version uses the median and MAD.

    k-Nearest Neighbours is a lazy, instance-based method. Training just stores the data. To predict a new point:
        1) compute its distance to every training point
        2) take the k closest points
        3) classification: majority vote (optionally weighted by 1/distance). Regression: average of their targets.

    The neighbour criterion has two parts, and both can be changed:
        * the distance metric: Euclidean (default), Manhattan, Minkowski-p, cosine (for text and embeddings), Hamming
        * k: a small k gives a noisy boundary (high variance), a large k gives a smooth boundary (high bias).
          Tune k with cross-validation, and use an odd k for binary problems to avoid ties.

    Practical notes: scale the features first, because distances are dominated by large-range features.
    Prediction costs O(n·d) per query, so use KD-trees or ball trees, or approximate nearest-neighbour indexes (FAISS, HNSW)
    at scale. kNN degrades in high dimensions because of the curse of dimensionality.

    Recommended is low FN's, the reason is because if you consider Fraudly Transaction being occured and counting it as not being occured 
    This has huge impact on the Business model.

        KNN                                         | K-Means
        ------------------------------------------- | ------------------------------------------------
        Supervised (classification / regression)    | Unsupervised (clustering)
        k = number of neighbours used to vote        | k = number of clusters to find
        No training; all work happens at prediction | Iterative training: assign points to the nearest
                                                    |   centroid, then recompute centroids until stable
        Needs labels                                | Needs no labels
        Output: a label or value for each query     | Output: k centroids plus a cluster id per point
    The only thing they share is distance computation.

    Attention lets a model compute each output as a weighted average over its inputs, with the weights computed from
    how relevant each input is to the current query:
        Attention(Q, K, V) = softmax(Q·Kᵀ / sqrt(d_k)) · V
    Examples:
        * Machine translation (Bahdanau attention): while generating each target word, the decoder attends to the most
          relevant source words instead of squeezing the whole sentence into one vector.
        * Self-attention in transformers: every token attends to every other token in the same sequence.
          "it" in "The animal didn't cross the street because it was tired" attends strongly to "animal".
        * Image captioning ("Show, Attend and Tell"): the model attends to image regions as it generates each word.
    Soft attention (differentiable weights over all inputs) is the standard. Hard attention picks one location and needs
    sampling or RL to train.

    Autoencoders: an encoder compresses the input into a low-dimensional code (the bottleneck), and a decoder
    reconstructs the input from that code. Training minimises reconstruction loss, so no labels are needed.
        * Uses: dimensionality reduction, denoising (denoising autoencoders), anomaly detection
          (a high reconstruction error flags unusual inputs), and pretraining.
        * A variational autoencoder (VAE) makes the code a probability distribution, which turns the model into a generative model.

    Transformers: a sequence architecture built from self-attention instead of recurrence. Every token attends to every
    other token, with attention weights softmax(QKᵀ / sqrt(d)). Each layer stacks multi-head attention and a feed-forward
    network, with residual connections and layer normalisation. Positional encodings supply word order.
    Transformers process all tokens in parallel and model long-range dependencies well. They are the basis of BERT
    (encoder-only), GPT and other LLMs (decoder-only), T5 (encoder-decoder), and Vision Transformers.
    See deep_learning/intro_transformers.md for the full guide.

    Image Captioning is the process of generating textual description of an image. It uses both Natural Language Processing and Computer Vision to
    generate the captions

    Summarization is the task of condensing a piece of text to a shorter version, reducing the size of the initial text while preserving the meaning.
    Some examples are :
            1) Essay Summarization
            2) Document Summarization
            etc

    Style transfer is a computer vision technique that applies the artistic style of one image to the content of another.
    It uses convolutional neural networks (typically VGG) to separate and recombine the content and style representations
    of two images. The loss function combines a content loss (preserving structure of the content image) with a style loss
    (matching Gram matrix statistics of the style image). Neural Style Transfer was introduced by Gatys et al. (2015).
    Modern approaches use fast style transfer (pre-trained feed-forward networks) for real-time applications.
    Use cases: photo filters, artistic image generation, creative tools.

    Image Segmentation : In digital image processing and computer vision, image segmentation is the process of partitioning a digital image into 
    multiple segments (sets of pixels, also known as image objects). The goal of segmentation is to simplify and/or change the representation of 
    an image into something that is more meaningful and easier to analyze.

    Pose Analysis:
            The process of determining the location and the orientation of a Human Entity (pose).

    Semantic segmentation assigns a class label to every pixel (road, car, person, sky). It does not separate objects:
    two touching people are one "person" region.
    Typical models are encoder-decoders with skip connections (U-Net, DeepLab with atrous convolutions, SegFormer).
    Loss: per-pixel cross-entropy, often combined with Dice loss for imbalanced classes. Metric: mean IoU (mIoU).

    Instance segmentation detects each individual object and gives it its own pixel mask: person #1, person #2, and so on.
    It combines object detection with segmentation. Mask R-CNN, for example, adds a mask head to Faster R-CNN.
    Background classes such as sky or road are ignored.
    Panoptic segmentation combines both: every pixel gets a class, and every countable object also gets an instance ID.
    Metric: mask AP (average precision over IoU thresholds).

    Imperative (define-by-run / eager): each operation executes immediately, as in ordinary Python. PyTorch eager mode and
    TensorFlow 2 eager mode work this way. It is easy to debug with print and pdb, and control flow is plain Python.

    Symbolic (define-then-run / graph): you first build a computation graph, then compile and execute it. TensorFlow 1.x
    graphs, Theano, and JAX's jit tracing work this way. The whole graph is known in advance, which enables optimisations
    such as operator fusion, memory planning, and export to other runtimes. It is harder to debug.

    Modern frameworks mix the two: write eager code, then compile it (torch.compile, tf.function, jax.jit).

    Text classification assigns one or more predefined labels to a piece of text.
    Approaches, from simple to complex: TF-IDF with logistic regression or naive Bayes (a strong baseline),
    fine-tuned transformers (BERT, DeBERTa), and zero-shot or few-shot classification with an LLM.
    Use cases:
            1) Spam and phishing detection
            2) Sentiment analysis of reviews and social posts
            3) Support-ticket routing and intent detection in chatbots
            4) Topic and news categorisation
            5) Toxicity and content moderation
            6) Language identification

    First ask why the data is missing: completely at random (MCAR), at random given other features (MAR), or not at random (MNAR).
        1) Drop rows or columns: only when missingness is rare and MCAR.
        2) Simple imputation: mean or median (numeric), mode or an "unknown" category (categorical).
        3) Add a missing-indicator feature. The fact that a value is missing is often predictive.
        4) Model-based imputation: KNNImputer, IterativeImputer / MICE, MissForest.
        5) Time series: forward fill, backward fill, or interpolation.
        6) Models that handle missing values natively: XGBoost, LightGBM, CatBoost, and HistGradientBoosting learn a default split direction.
    Always fit the imputer on training data only, inside the pipeline, to avoid leakage.

data = b'\xAD\xDE\xDE\xC0'
my_data = bytearray(data)
my_data.reverse()

x_hat = (x - mean_batch) / sqrt(var_batch + eps)
y     = gamma * x_hat + beta

v = β·v + g          # β ≈ 0.9
w = w - lr·v

def get_splits():
    df = pd.DataFrame(...)
    rnd = np.random.rand(len(df))
    train = df[ rnd < 0.8 ]
    valid = df[ rnd >= 0.8 & rnd < 0.9 ]
    test = df[ rnd >= 0.9 ]

    return train, valid, test

#Model 1

from sklearn.tree import DecisionTreeClassifier
train, valid, test = get_splits()
...

#Model 2

from sklearn.linear_model import LogisticRegression
train, valid, test = get_splits()
...