Decision Trees and Random Forests: From Parametric Logic to Parallel Ensemble Topologies

Welcome to this high-performance system module of our comprehensive Artificial Intelligence Masterclass. Having optimized structural feature matrices using Data Preprocessing and Feature Engineering and analyzed the geometric properties of continuous spaces in Unsupervised Learning: Clustering and Dimensionality Reduction, we now advance into non-parametric machine learning models: Tree-Based Architectures.

In enterprise software engineering, decision-making systems must handle messy real-world data while remaining explainable. While deep neural networks deliver high accuracy for unstructured perception tasks like audio and video processing, they operate as black boxes, making their internal logic difficult to interpret. Conversely, tree-based algorithms—specifically individual Decision Trees and their parallel ensemble counterpart, Random Forests—are highly effective for structured tabular datasets. They offer an intuitive, white-box approach that scales efficiently across large enterprise systems.

A single Decision Tree splits complex data into simpler subsets by applying conditional logic to its features. However, single trees are highly prone to overfitting, often memorizing training data noise instead of learning generalizable patterns. To resolve this limitation, we use ensemble engineering. By combining many uncorrelated decision trees via bootstrap aggregation and random feature selection, we create a Random Forest. This ensemble minimizes variance without increasing bias, delivering exceptional stability across production workloads.

This guide covers the core mechanics of tree-based models. We will analyze the mathematical functions governing node splits, map structural designs that prevent overfitting, trace parallel ensemble workflows, and implement a complete decision tree partitioning engine from scratch using type-safe Java code.

The Core Mathematical Blueprint of Recursive Space Partitioning

Featured Snippet Optimization Answer:
A Decision Tree is a non-parametric supervised learning algorithm that partitions a feature space $\mathbb{R}^d$ into distinct, non-overlapping hyper-rectangular regions through recursive binary splitting. A Random Forest is an ensemble architecture that constructs a large collection of independent decision trees in parallel. It uses **Bagging** (bootstrap aggregating) and **Feature Randomness** to ensure individual trees remain uncorrelated. During inference, the forest combines predictions using a majority vote for classification or spatial averaging for regression. This process significantly reduces model variance while maintaining structural bias.

To mathematically structure a decision tree, let our training design matrix be represented by a dataset containing feature vectors and corresponding targets:

Where each input observation $\mathbf{x}_i$ is a vector in a $d$-dimensional space ($\mathbf{x}_i \in \mathbb{R}^d$) and $y_i$ represents the target label. The algorithm splits this high-dimensional space into distinct regions ($R_1, R_2, \dots, R_m$). At each node, it selects a feature index $j$ and a split threshold $t$ to divide the current region into two sub-regions:

This splitting process continues recursively from the root node down through decision sub-nodes until the system hits a stopping criterion—such as a maximum depth limit or a minimum sample threshold. When a data point lands in a final leaf node, the model assigns it a prediction based on the majority class (for classification) or the mean value (for regression) of the training samples in that specific region.

1. Node Optimization: Entropy, Information Gain, and Gini Impurity

To create highly accurate decision trees, the algorithm must select splits that maximize the "purity" of the resulting child nodes. A node is completely pure if all its data points belong to a single target class. We use two primary mathematical functions to measure impurity at a node $m$:

Gini Impurity Formulation

Gini Impurity calculates how often a randomly selected element from a node would be incorrectly labeled if it were classified according to the distribution of targets in that subset. It is defined mathematically as:

Where $K$ represents the total number of target classes, and $p_k$ is the proportion of data points in node $m$ that belong to class $k$. The Gini score ranges from $0$ (perfect purity, where all samples belong to one class) to $1 - 1/K$ (maximum impurity, where samples are distributed completely evenly across classes).

Shannon Entropy and Information Gain Formulation

Derived from Information Theory, Shannon Entropy measures the level of uncertainty or disorder within a node's data distribution. The entropy of a node $m$ is written as:

When evaluating a potential split, the algorithm calculates the reduction in entropy, a metric known as **Information Gain**. The system evaluates every feature and split threshold to find the configuration that maximizes this gain:

Where $D$ is the parent node's dataset, while $D_{\text{left}}$ and $D_{\text{right}}$ are the datasets of the resulting child nodes. The algorithm selects the split that delivers the largest reduction in uncertainty.

Mitigating Structural Overfitting via Pruning Strategies

Unconstrained decision trees will continue splitting until every leaf node is completely pure, resulting in a model with 100% training accuracy that overfits to minor data noise. To ensure the model generalizes well to unseen data, engineers use two main pruning techniques:

• Pre-Pruning (Early Stopping): Prevents the tree from growing past specific structural limits. This involves setting caps on hyperparameters like maximum depth (`max_depth`), minimum samples required to split a node (`min_samples_split`), or minimum samples allowed in a leaf node (`min_samples_leaf`).
• Post-Pruning (Cost-Complexity Pruning): Allows the tree to grow to its maximum depth, then prunes away branches that do not contribute significantly to predictive power. This approach optimizes a cost-complexity function that balances validation accuracy against tree size: $$R_\alpha(T) = R(T) + \alpha |T|$$

  Where $R(T)$ is the tree's error rate, $|T|$ represents the total number of leaf nodes, and $\alpha$ is a tuning parameter that controls the penalty for tree complexity.

2. Ensemble Parallelization: Uncorrelated Forest Topologies

While an individual decision tree is highly intuitive, it suffers from high variance and is sensitive to shifts in the training data. Random Forests address this limitation by building an ensemble of many diverse, uncorrelated trees in parallel, significantly reducing variance without increasing bias.

The Mechanics of Bagging (Bootstrap Aggregating)

To make the individual trees uncorrelated, Random Forests use **Bagging** (Bootstrap Aggregating). Given a dataset of $N$ rows, the algorithm creates multiple new training subsets of size $N$ by sampling data points randomly with replacement.

This sampling process leaves about $36.8\%$ of the original data points out of each subset. These unused samples are called **Out-Of-Bag (OOB) data**. Engineers use this OOB data as a built-in validation set to monitor model performance and estimate generalization error without needing a separate cross-validation split.

Feature Randomness and De-Correlation

If multiple features in a dataset are highly dominant, independent bootstrap samples will still produce highly similar decision trees, causing their predictions to be strongly correlated. To break this dependency, Random Forests introduce **Feature Randomness**.

At each node split, the algorithm limits its search to a small, randomly selected subset of features rather than evaluating the entire feature space. For a dataset with $d$ total features, the size of this random subset is typically configured as:

By forcing each tree to split on different subsets of features, the forest ensures its component models remain highly diverse and uncorrelated.

Ensemble Voting Consensus Systems

During inference, the Random Forest passes the new observation vector across all $B$ independent trees within its ensemble. It aggregates their individual predictions to produce a final consensus output:

• Classification Consensus: Uses a majority vote. The final prediction corresponds to the class selected by the largest number of individual trees: $$\hat{y} = \text{mode} \{ \hat{y}_1, \hat{y}_2, \dots, \hat{y}_B \}$$
• Regression Consensus: Calculates the mean output. The final prediction is the average value generated across all individual tree structures: $$\hat{y} = \frac{1}{B} \sum_{b=1}^{B} \hat{y}_b$$

The Production Ensemble Pipeline Lifecycle

The system layout below traces how data moves through a parallel ensemble pipeline, tracking bootstrap data allocation, feature constraint masks, and final consensus resolution:

+--------------------------------------------------------------------------------------------------------------------------+
|                                      PRODUCTION ENSEMBLE TREE ARCHITECTURE LIFECYCLE                                     |
+--------------------------------------------------------------------------------------------------------------------------+
                                                                                                                           
   PHASE 1: INGESTION & SPLITTING        PHASE 2: PARALLEL BOOTSTRAP RESAMPLING      PHASE 3: CONSTRAINED TREE BUILDING     
   +-------------------------------+      +-----------------------------------+      +------------------------------------+
   | Ingest Standardized Tensors   |      | Generate N Random Bootstrap Sets  |      | Apply Random Feature Masks         |
   | Isolate Training Ingest Pools | ---> | Allocate Out-of-Bag Validation   | ---> | Optimize Recursive Node Splits     |
   | Map Target Class Encodings    |      | Feed Isolated Base Tree Workers   |      | Enforce Pre-Pruning Depth Limits   |
   +-------------------------------+      +-----------------------------------+      +------------------------------------+
                                                                                                       |                   
                                                                                                       v                   
   PHASE 6: DEPLOYED TELEMETRY            PHASE 5: CONSENSUS RESOLUTION               PHASE 4: ENSEMBLE INFRASTRUCTURE     
   +-------------------------------+      +-----------------------------------+      +------------------------------------+
   | Monitor Dynamic Drift Vectors |      | Aggregate Distributed Outputs     |      | Consolidate Uncorrelated Forest    |
   | Track Real-Time Prediction    | <--- | Execute Majority Vote Mappings    | <--- | Compute Out-of-Bag Error Matrices |
   | Trigger Scheduled Retraining  |      | Compute Regression Mean Averages  |      | Export Immutable Model Artifacts   |
   +-------------------------------+      +-----------------------------------+      +------------------------------------+
        

Structural Comparison: Single Decision Trees versus Random Forests

To help systems architects select the appropriate architecture for their workloads, the matrix below details the differences between individual trees and parallel forest ensembles:

Common Pitfalls and Production Remediations in Tree-Based Models

• Allowing Single Trees to Grow Unconstrained: Leaving parameters like maximum depth or minimum leaf sample sizes unconfigured allows a decision tree to split until it completely isolates every training instance. This creates a highly complex, brittle model that overfits to noise and performs poorly on unseen validation data. To prevent this, always set explicit pre-pruning limits or use cost-complexity pruning.
• Adding More Trees Beyond the Point of Diminishing Returns: In a Random Forest ensemble, adding more trees generally reduces variance and improves model stability. However, after hitting a certain threshold (typically between $100$ and $500$ trees depending on feature complexity), further additions yield minimal accuracy gains while increasing memory overhead and inference latency. Engineers should run performance sweeps to find the optimal point where tree count balances model accuracy against production system latency.
• Training on Severe Target Class Imbalances: If a training dataset is highly skewed—for example, a fraud detection set where $99.9\%$ of rows are legitimate transactions—tree models can optimize for purity by simply creating a leaf node that classifies everything as the majority class. To fix this, use strategies like synthetic oversampling (SMOTE), class weighting, or tree adjustments that penalize misclassifications on minority targets. For data cleaning techniques, see Data Preprocessing and Feature Engineering.
• Using High-Cardinality Features Incorrectly: High-cardinality features contain a large number of unique values (such as transaction IDs, timestamps, or IP addresses). Tree models can easily isolate target variables by splitting on these highly specific columns, which artificially inflates information gain metrics during training but leads to poor generalization on test data. To prevent this, drop high-cardinality ID strings or replace them with target encoded metrics before training.

Industrial Decision Tree Engine Implementation from Scratch

To demonstrate how these tree structures work in practice, let us build a complete binary classification decision tree engine from scratch using type-safe Java code.

This implementation avoids external dependencies, explicitly coding row-by-row data structures, spatial index splits, Gini impurity evaluations, and recursive child node construction to illustrate the underlying mechanics.

package com.enterprise.ai.models;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.logging.Logger;

/**
 * Encapsulates a structured continuous observation instance vector and its target class assignment.
 */
final class TrainingObservation {
    private final double[] featureVector;
    private final int labelClass;

    public TrainingObservation(double[] features, int label) {
        this.featureVector = Objects.requireNonNull(features, "Input feature arrays cannot be null.");
        this.labelClass = label;
    }

    public double[] getFeatures() { return featureVector; }
    public int getLabelClass() { return labelClass; }
}

/**
 * Architecture layout for an explicit node structure within our decision tree.
 */
final class TreeDecisionNode {
    // Structural layout parameters
    private final boolean isLeaf;
    private int predictedClassLabel = -1;
    
    private int splittingFeatureIndex = -1;
    private double splitThresholdValue = 0.0;
    
    private TreeDecisionNode leftChildNode;
    private TreeDecisionNode rightChildNode;

    private TreeDecisionNode(boolean isLeaf) { this.isLeaf = isLeaf; }

    public static TreeDecisionNode buildLeafNode(int standardClassLabel) {
        TreeDecisionNode node = new TreeDecisionNode(true);
        node.predictedClassLabel = standardClassLabel;
        return node;
    }

    public static TreeDecisionNode buildInternalNode(int featureIndex, double threshold, TreeDecisionNode left, TreeDecisionNode right) {
        TreeDecisionNode node = new TreeDecisionNode(false);
        node.splittingFeatureIndex = featureIndex;
        node.splitThresholdValue = threshold;
        node.leftChildNode = left;
        node.rightChildNode = right;
        return node;
    }

    public boolean isLeaf() { return isLeaf; }
    public int getPredictedClassLabel() { return predictedClassLabel; }
    public int getSplittingFeatureIndex() { return splittingFeatureIndex; }
    public double getSplitThresholdValue() { return splitThresholdValue; }
    public TreeDecisionNode getLeftChildNode() { return leftChildNode; }
    public TreeDecisionNode getRightChildNode() { return rightChildNode; }
}

/**
 * Non-parametric decision tree classification engine built to execute node splitting operations from scratch.
 */
public class CoreDecisionTreeEngine {
    private static final Logger logger = Logger.getLogger(CoreDecisionTreeEngine.class.getName());

    private final int maxAllowedTreeDepth;
    private final int minSamplesRequiredToSplit;
    private TreeDecisionNode rootNodeStructure;

    public CoreDecisionTreeEngine(int maxDepth, int minSamplesSplit) {
        this.maxAllowedTreeDepth = maxDepth;
        this.minSamplesRequiredToSplit = minSamplesSplit;
    }

    /**
     * Calculates the Gini Impurity of a given observation subset.
     */
    private double calculateGiniImpurity(List<TrainingObservation> subset) {
        if (subset.isEmpty()) return 0.0;
        int totalInstances = subset.size();
        
        // Track the count of samples in each class (assuming binary classification: 0 or 1)
        int classZeroCount = 0;
        for (TrainingObservation obs : subset) {
            if (obs.getLabelClass() == 0) classZeroCount++;
        }
        int classOneCount = totalInstances - classZeroCount;

        double p0 = (double) classZeroCount / totalInstances;
        double p1 = (double) classOneCount / totalInstances;

        return 1.0 - (Math.pow(p0, 2) + Math.pow(p1, 2));
    }

    /**
     * Recursively builds the decision tree by evaluating features and threshold splits.
     */
    private TreeDecisionNode developTreeRecursively(List<TrainingObservation> dataset, int currentDepth) {
        int sampleCount = dataset.size();

        // Calculate majority class label fallback for leaf nodes
        int majorityLabel = computeMajorityClass(dataset);

        // Check for stopping criteria: reach pure node, hit max depth, or fall below min sample size
        if (currentDepth >= maxAllowedTreeDepth || sampleCount < minSamplesRequiredToSplit || calculateGiniImpurity(dataset) == 0.0) {
            return TreeDecisionNode.buildLeafNode(majorityLabel);
        }

        int optimalFeatureIndex = -1;
        double optimalSplitThreshold = 0.0;
        double minimumEncounteredGini = Double.MAX_VALUE;
        
        List<TrainingObservation> finalLeftDataset = new ArrayList<>();
        List<TrainingObservation> finalRightDataset = new ArrayList<>();

        int dimensionalWidth = dataset.get(0).getFeatures().length;

        // Iterate across all features to evaluate split options
        for (int f = 0; f < dimensionalWidth; f++) {
            for (TrainingObservation obs : dataset) {
                double currentThreshold = obs.getFeatures()[f];
                
                List<TrainingObservation> leftCandidate = new ArrayList<>();
                List<TrainingObservation> rightCandidate = new ArrayList<>();

                for (TrainingObservation targetRow : dataset) {
                    if (targetRow.getFeatures()[f] <= currentThreshold) {
                        leftCandidate.add(targetRow);
                    } else {
                        rightCandidate.add(targetRow);
                    }
                }

                if (leftCandidate.isEmpty() || rightCandidate.isEmpty()) continue;

                // Calculate weighted Gini impurity for the child nodes
                double leftGini = calculateGiniImpurity(leftCandidate);
                double rightGini = calculateGiniImpurity(rightCandidate);
                double combinedGini = ((double) leftCandidate.size() / sampleCount) * leftGini 
                                    + ((double) rightCandidate.size() / sampleCount) * rightGini;

                // Track the split configuration that delivers the lowest impurity
                if (combinedGini < minimumEncounteredGini) {
                    minimumEncounteredGini = combinedGini;
                    optimalFeatureIndex = f;
                    optimalSplitThreshold = currentThreshold;
                    finalLeftDataset = leftCandidate;
                    finalRightDataset = rightCandidate;
                }
            }
        }

        // Create a leaf node if no valid impurity reduction split is found
        if (optimalFeatureIndex == -1) {
            return TreeDecisionNode.buildLeafNode(majorityLabel);
        }

        // Recursively construct child nodes
        TreeDecisionNode leftSubTree = developTreeRecursively(finalLeftDataset, currentDepth + 1);
        TreeDecisionNode rightSubTree = developTreeRecursively(finalRightDataset, currentDepth + 1);

        return TreeDecisionNode.buildInternalNode(optimalFeatureIndex, optimalSplitThreshold, leftSubTree, rightSubTree);
    }

    private int computeMajorityClass(List<TrainingObservation> dataset) {
        int votesForClassZero = 0;
        for (TrainingObservation obs : dataset) {
            if (obs.getLabelClass() == 0) votesForClassZero++;
        }
        return (votesForClassZero >= (dataset.size() - votesForClassZero)) ? 0 : 1;
    }

    public void fit(List<TrainingObservation> dataset) {
        Objects.requireNonNull(dataset, "Target model dataset cannot be null.");
        if (dataset.isEmpty()) throw new IllegalArgumentException("Dataset cannot be empty.");
        this.rootNodeStructure = developTreeRecursively(dataset, 0);
        logger.info("Decision tree optimization completed successfully.");
    }

    /**
     * Traverses the optimized tree to predict the target class of a new observation.
     */
    public int predict(double[] features) {
        if (rootNodeStructure == null) throw new IllegalStateException("Model must be fitted before running inference.");
        TreeDecisionNode traversalPointer = rootNodeStructure;
        
        while (!traversalPointer.isLeaf()) {
            int fIdx = traversalPointer.getSplittingFeatureIndex();
            if (features[fIdx] <= traversalPointer.getSplitThresholdValue()) {
                traversalPointer = traversalPointer.getLeftChildNode();
            } else {
                traversalPointer = traversalPointer.getRightChildNode();
            }
        }
        return traversalPointer.getPredictedClassLabel();
    }

    public static void main(String[] args) {
        // Simulating an underwriting risk dataset
        // Feature array layout: [0] = Standardized Debt Ratio, [1] = Credit Request Amount in Thousands
        List<TrainingObservation> profilePool = new ArrayList<>();
        profilePool.add(new TrainingObservation(new double[]{ 0.1,  20.0 }, 1)); // Approved Risk Profile
        profilePool.add(new TrainingObservation(new double[]{ 0.2,  45.0 }, 1)); // Approved Risk Profile
        profilePool.add(new TrainingObservation(new double[]{ 0.8, 190.0 }, 0)); // Denied Risk Profile
        profilePool.add(new TrainingObservation(new double[]{ 0.9, 300.0 }, 0)); // Denied Risk Profile

        // Initialize engine with a maximum depth limit of 3 layers
        CoreDecisionTreeEngine tree = new CoreDecisionTreeEngine(3, 2);
        
        System.out.println("--- Executing Recursive Space Splits ---");
        tree.fit(profilePool);

        // Run validation inferences on new, unseen customer data profiles
        double[] prospectiveUserA = new double[]{ 0.15, 30.0 };
        double[] prospectiveUserB = new double[]{ 0.85, 250.0 };

        System.out.println("\n--- Live Inference Validation Predictions ---");
        System.out.printf("Profile A Evaluation Output (Target Label Expected [1]): %d%n", tree.predict(prospectiveUserA));
        System.out.printf("Profile B Evaluation Output (Target Label Expected [0]): %d%n", tree.predict(prospectiveUserB));
    }
}

Operational Troubleshooting and Production Metrics Alignment

When running tree models in high-throughput enterprise environments, performance degradation often shows up as drops in inference accuracy or increased latency rather than standard system errors. Use the matrix below to troubleshoot common production anomalies:

Interview Preparation: Strategic Deep-Dive Focus Notes

When interviewing for senior AI engineering, principal data architect, or core ML platform infrastructure roles, ensure you can confidently explain these technical concepts:

• Why are tree-based algorithms considered scale-invariant? Distance-based models (like KNN or Support Vector Machines) measure distances between coordinate points, requiring inputs to share a uniform scale. Tree models split data by applying independent threshold cuts to individual features (e.g., checking if a single feature value is greater than $50$). Because each split evaluates a single feature on its own, its relative scale has no impact on other features, making feature standardization unnecessary.
• Explain how a Random Forest reduces variance without increasing bias: According to statistical learning theory, averaging predictions across a collection of independent, identically distributed variables reduces variance by a factor of the ensemble size. By constructing multiple diverse trees using bootstrap aggregation and random feature subsets, a Random Forest creates a set of uncorrelated predictions. Averaging these outputs lowers overall model variance while maintaining structural bias.
• Explain the difference between Gini Impurity and Shannon Entropy: Both metrics evaluate node purity, but they rely on different mathematical approaches. Gini Impurity calculates the probability of misclassification based on the target distribution within a node, using simpler squared terms ($1 - \sum p_k^2$). Entropy is rooted in Information Theory and uses logarithmic scales ($- \sum p_k \log_2 p_k$) to measure uncertainty, making it slightly more computationally demanding to calculate during training.

Frequently Asked Questions (People Also Ask Intent)

Can Decision Trees and Random Forests process non-numeric text variables directly?

No. Production machine learning frameworks require categorical text strings (like country names or device types) to be encoded numerically before building splits. While some specialized implementations can handle categorical features internally, standard tree algorithms require text variables to be mapped to numbers using techniques like ordinal or one-hot encoding first.

How does feature selection in Bagging compare to the feature selection used in Boosting?

Bagging (used in Random Forests) builds individual trees in parallel, with each tree independently selecting splits from a random subset of features to minimize variance. Boosting (used in algorithms like XGBoost) constructs trees sequentially; each new tree evaluates the entire feature space but focuses on correcting the prediction errors made by the preceding trees.

What is structural feature importance and how do tree models calculate it?

Feature importance measures the relative predictive power of each variable within a model. In tree architectures, it is calculated by accumulating the total reduction in impurity (Gini or Entropy) delivered by splits on a given feature across all nodes. Features that drive larger purity improvements closer to the root of the trees receive higher importance scores.

Why do individual decision trees exhibit high variance?

Individual decision trees are non-parametric and highly flexible, allowing them to adapt closely to the geometry of the training dataset. Because they split data recursively down to highly specific subsets, minor variations or noise in the training data can alter the root node split configuration, drastically restructuring the downstream branches and making the model sensitive to data shifts.

Can tree-based architectures predict values that fall outside the bounds of the training data?

No. Tree regression models calculate predictions by averaging the target values of the training samples contained within a final leaf node. Because their outputs are bounded by the minimum and maximum target values present in the training set, they cannot extrapolate or predict values that fall outside those original training boundaries.

How do you address missing feature values when building tree splits?

Production tree models handle missing data using alternate paths called **Surrogate Splits**. If a data point is missing the feature required for a primary split, the algorithm evaluates alternative features that mimic the primary split's data distribution to route the point correctly. Alternatively, missing values can be filled during preprocessing, as detailed in Data Preprocessing and Feature Engineering.

Summary

Decision Trees and Random Forests are powerful, highly adaptable algorithms for building enterprise machine learning models on tabular datasets. Individual decision trees offer an intuitive, explainable framework, but their high variance makes them prone to overfitting if left unconstrained. Random Forests address this limitation by combining an ensemble of uncorrelated trees in parallel, using bootstrap aggregation and random feature masks to deliver stable, robust performance across complex production data streams.

Mastering these tree-based structures allows you to design reliable machine learning systems that handle missing attributes, capture non-linear feature interactions, and maintain high performance without requiring extensive data preprocessing or feature scaling. As you continue through this curriculum, these foundational tree architectures will serve as essential building blocks for exploring more advanced sequential boosting methods.

Next Learning Recommendations

To maintain your learning momentum within the Artificial Intelligence Masterclass platform, proceed directly to these closely related training modules:

• To explore how tree architectures can be trained sequentially to minimize residual errors, see our advanced guide: Gradient Boosting Machines and XGBoost Topologies.
• To see how these tree structures are integrated with linear models to build robust, multi-tier classification systems, check out: Supervised Learning: Advanced Multi-Class Classification Platforms.
• To explore unsupervised methods for analyzing high-dimensional tabular data without relying on target labels, visit: Unsupervised Learning: Architectural Optimization of Clustering Mechanics.