BUET M.Sc. Admission — Department of CSE — April: 2024প্রশ্ন ও সমাধান

Overfitting occurs when a machine learning model learns the training data too well — including its noise and random fluctuations — so it performs excellently on training data but poorly on new, unseen data.

Why it happens:

• The model is too complex (too many parameters/features) relative to the amount of training data.
• Training runs for too long, letting the model memorize specific examples instead of learning general patterns.
• The training data is too small or not representative of the real-world distribution.

flowchart LR
A[Model Complexity Increases] --> B[Training Error: keeps decreasing]
A --> C[Validation Error: decreases, then rises]
C --> D[Rising point = Overfitting begins]

How to avoid it:

Technique	How it helps
Cross-validation (k-fold)	Detects overfitting early by testing on held-out folds
Regularization (L1/L2)	Penalizes large weights, discouraging overly complex fits
Dropout (neural networks)	Randomly disables neurons during training to prevent co-dependency
Early stopping	Stops training when validation error starts rising
Pruning (decision trees)	Removes overly specific branches that fit noise
More/augmented training data	Gives the model a broader, more general pattern to learn
Simpler model	Reduces capacity to memorize noise

Exam takeaway: Overfitting means low training error but high validation/test error — the fix is always some form of reducing model complexity or increasing effective data, never simply training longer.

A functional interface in Java is an interface that contains exactly one abstract method (it may have any number of default/static methods). It is the foundation that makes lambda expressions and method references possible in Java.

• Annotated (optionally, but recommended) with @FunctionalInterface, which lets the compiler flag an error if a second abstract method is accidentally added.
• Since it has only one abstract method, a lambda expression can be used directly as its implementation — the compiler infers which method the lambda implements.
• Java's java.util.function package ships many ready-made functional interfaces: Function<T,R>, Predicate<T>, Supplier<T>, Consumer<T>.

Example:

@FunctionalInterface
interface Calculator {
    int operate(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;        // lambda implements operate()
        Calculator multiply = (a, b) -> a * b;
        System.out.println(add.operate(3, 4));       // 7
        System.out.println(multiply.operate(3, 4));   // 12
    }
}

Exam takeaway: Functional interface = exactly one abstract method, which enables lambdas; Runnable, Comparator<T>, and Callable<V> are classic built-in examples besides the java.util.function package.