Insightimate: Enhancing Software Effort Estimation Accuracy Using Machine Learning Across Three Schemas (LOC/FP/UCP)

Insightimate: Enhancing Software Effort Estimation Accuracy Using Machine Learning Across Three Schemas (LOC/FP/UCP) | Research Square window.SnipcartSettings = { analytics: { enabled: false } }; (function() { var accessVector = localStorage.getItem('access_vector') || ''; window.dataLayer = window.dataLayer || []; if (accessVector) { window.dataLayer.push({ user: { profile: { profileInfo: { snid: accessVector } } } }); } })(); (function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src='https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);})(window,document,'script','dataLayer','GTM-K279D39R'); Browse Preprints In Review Journals COVID-19 Preprints AJE Video Bytes Research Tools Research Promotion AJE Professional Editing AJE Rubriq About Preprint Platform In Review Editorial Policies Our Team Advisory Board Help Center Sign In Submit a Preprint Cite Share Download PDF Research Article Insightimate: Enhancing Software Effort Estimation Accuracy Using Machine Learning Across Three Schemas (LOC/FP/UCP) Nguyen Nhat Huy, Duc Man Nguyen, Dang Nhat Minh, Nguyen Thuy Giang, and 2 more This is a preprint; it has not been peer reviewed by a journal. https://doi.org/ 10.21203/rs.3.rs-8623983/v1 This work is licensed under a CC BY 4.0 License Status: Posted Version 1 posted You are reading this latest preprint version Abstract Accurate estimation of software development effort remains a longstanding challenge in project management, particularly as contemporary projects exhibit greater heterogeneity in scale, methodology, and complexity. While traditional parametric models such as COCOMO II offer interpretability, their fixed functional forms often underfit diverse modern datasets. This paper proposes a unified machine-learning–based framework designed to improve estimation accuracy across three widely used sizing schemas: Lines of Code (LOC), Function Points (FP), and Use Case Points (UCP). The framework integrates standardized preprocessing, schema-specific feature engineering, and a set of representative regression models, including Linear Regression, Decision Tree, Random Forest, and Gradient Boosting. Using publicly available datasets collected from prior studies spanning 1993–2022, we conduct a comprehensive evaluation based on established effort-estimation metrics (MMRE, PRED(25), MAE, RMSE, and \(\:{R}^{2}\) ). Experimental results show that Random Forest achieves the best overall performance (MMRE \(\:\approx\:0.647\) ; PRED(25) \(\:\approx\:0.395\) ), substantially outperforming COCOMO II, which exhibits poor predictive accuracy on heterogeneous datasets (MMRE \(\:\approx\:2.790\) ; PRED(25) \(\:\approx\:0.012\) ). In addition, we perform a schema-by-schema comparison to highlight the sensitivity of different models to LOC, FP, and UCP representations. The findings demonstrate that data-driven approaches generalize more effectively across diverse project contexts, offering actionable insights for practitioners seeking reliable and scalable software effort estimation. Effort estimation COCOMO II machine learning Random Forest Gradient Boosting LOC FP UCP Background and Methods COCOMO II Recap COCOMO II (Constructive Cost Model II) extends the original COCOMO 81 model to better accommodate modern development practices, including component reuse, iterative processes, and object-oriented architectures. The model estimates the development effort \(\:E\) (in person-months) using a power-law function of project size: $$\:E=A\times\:{\left(\text{Size}\right)}^{B}\times\:\prod\:_{i=1}^{m}E{M}_{i},$$ where is commonly expressed in KLOC, \(\:A\) and \(\:B\) are calibration constants derived from historical data, and \(\:E{M}_{i}\) represents effort multipliers capturing project-specific characteristics such as team experience, product complexity, and tool support. The project schedule is then computed as: $$\:\text{Time}=C\times\:{E}^{D},$$ with constants \(\:C\) and \(\:D\) similarly obtained through calibration. Although COCOMO II remains influential due to its transparency and ease of interpretation, its rigid parametric structure often struggles to accommodate heterogeneous datasets found in contemporary software projects. This limitation has motivated the exploration of machine-learning approaches that can flexibly capture complex, non-linear relationships present in real-world estimation scenarios. $$\:\text{Time}=C\times\:{E}^{D},$$ with constants \(\:C,D\) calibrated on historical datasets. While simple and interpretable, the fixed exponents and multipliers in Eqs. [eq:cocomo-effort]–[eq:cocomo-time] often underfit heterogeneous, contemporary datasets, motivating the exploration of machine learning methods that adapt more flexibly to diverse data sources. Workflow comparison between (a) the traditional COCOMO II pipeline (Eqs. [eq:cocomo-effort]–[eq:cocomo-time]) and (b) the proposed multi-schema ML framework. Multi-Schema ML Framework We introduce a unified machine-learning framework that trains a separate regressor for each sizing schema—Lines of Code (LOC), Function Points (FP), and Use Case Points (UCP)—and compares their predictive performance with COCOMO II. For each schema \(\:s\in\:\{\text{LOC},\text{FP},\text{UCP}\}\) , the framework learns a mapping $$\:{\widehat{E}}^{\left(s\right)}={f}^{\left(s\right)}\left({x}^{\left(s\right)}\right),$$ where \(\:{x}^{\left(s\right)}\) includes the size metric (KLOC/FP/UCP) and, when available, supplementary predictors such as project duration or team size. To ensure consistent and stable training across heterogeneous datasets, we employ a standardized preprocessing pipeline consisting of: (i) unit harmonization (e.g., normalizing effort to person-months and converting LOC to KLOC); (ii) outlier mitigation via interquartile-range (IQR) capping; and (iii) distribution reshaping using \(\:\text{l}\text{o}\text{g}1p\) transformations to reduce skewness and improve model fit. We evaluate four representative machine-learning models: Linear Regression , including a log–log variant to capture multiplicative relationships. Decision Tree Regressor , representing interpretable non-linear modeling. Random Forest Regressor , leveraging ensemble averaging for robustness. Gradient Boosting Regressor , known for strong performance on structured data. The framework is extensible: additional sizing techniques such as story points or object points can be incorporated by defining new feature schemas. Prior reviews highlight the growing interest in multi-schema and ensemble-based estimation methods. Our framework contributes to this direction by unifying preprocessing, model training, and evaluation under a reproducible and comparable experimental setting. Evaluation Metrics We report standard effort-estimation metrics widely used in prior work. For each metric, we present its definition and interpretation. Mean Magnitude of Relative Error (MMRE). $$\:\text{M}\text{M}\text{R}\text{E}=\frac{1}{n}\sum\:_{i=1}^{n}\frac{\left|{y}_{i}-{\widehat{y}}_{i}\right|}{{y}_{i}}$$ MMRE calculates the average relative error between the actual effort \(\:{y}_{i}\) and the predicted effort \(\:{\widehat{y}}_{i}\) . It is simple and widely adopted, but several studies have criticized MMRE for bias, especially in small projects . Prediction at 25% (PRED(25)). $$\:\text{P}\text{R}\text{E}\text{D}\left(25\right)=\frac{1}{n}\sum\:_{i=1}^{n}1\left(\frac{\left|{y}_{i}-{\widehat{y}}_{i}\right|}{{y}_{i}}\le\:0.25\right)$$ PRED(25) measures the proportion of predictions whose relative error is within 25% of the actual effort. It provides an intuitive sense of robustness, but depends on the arbitrary 25% threshold and may be unstable with small datasets . Mean Absolute Error (MAE). $$\:\text{M}\text{A}\text{E}=\frac{1}{n}\sum\:_{i=1}^{n}|{y}_{i}-{\widehat{y}}_{i}|$$ MAE expresses the average absolute deviation (in person-months) between predicted and actual effort. It is interpretable in absolute units and less sensitive to outliers than RMSE, making it a practical complement to relative-error metrics. Root Mean Square Error (RMSE). $$\:\text{R}\text{M}\text{S}\text{E}=\sqrt{\frac{1}{n}\sum\:_{i=1}^{n}({y}_{i}-{\widehat{y}}_{i}{)}^{2}}$$ RMSE penalizes larger errors more strongly because of the squaring term. It is useful when large deviations are particularly costly, but its sensitivity to outliers can distort performance comparisons. Coefficient of Determination ( \(\:{R}^{2}\) ). $$\:{R}^{2}=1-\frac{\sum\:_{i=1}^{n}({y}_{i}-{\widehat{y}}_{i}{)}^{2}}{\sum\:_{i=1}^{n}({y}_{i}-\stackrel{⃐}{y}{)}^{2}}$$ \(\:{R}^{2}\) measures the proportion of variance in the actual effort \(\:{y}_{i}\) explained by the predictions \(\:{\widehat{y}}_{i}\) . Higher values generally indicate better explanatory power. However, in effort estimation, a high \(\:{R}^{2}\) does not guarantee practical accuracy, since a model may fit variance well but still produce large relative errors . Datasets and Preprocessing Sources and Schema Partitioning We aggregated publicly available datasets and peer-reviewed research conducted between 1993–2022. To ensure comparability, all datasets were ingested with a common ingestion policy defined by: (i) logging the provenance, (ii) normalizing the schema, and (iii) de-duplicating artifacts across datasets. The records were then partitioned into three self-consistent schemas according to the predominant sizing methodology employed. Data sources and provenance. For each of the datasets aggregated, we collected (a) classic LOC/COCOMO datasets and GitHub-hosted estimation datasets, (b) re-coded FP (Albrecht-style) samples, and (c) UCP datasets with UAW/UUCW along with TCF/ECF. For each item we retained the original source name, year of the source, and the URL/DOI (if available) for auditability. Inclusion criteria. A record was eligible if it contained: ( 1 ) a valid size measure for one of the schemas and ( 2 ) a ground-truth effort value (hours or person-months). Optional attributes (duration in months, number of developers, sector, language, methodology, etc.) were preserved when present. Exclusion and de-duplication. We removed (i) exact duplicates across files (matched on project_no, title, size, effort), (ii) corrupted or unit-ambiguous rows (e.g., missing both size and effort), and (iii) entries with obviously inconsistent units (e.g., duration in days mislabeled as months) when they could not be reconciled unambiguously. When the same project appeared in multiple compilations, we kept the earliest, most complete version. Schema definitions. LOC schema ( \(\:n\approx\:947\) ): core fields {KLOC, Effort (PM)}; optional {Time (months), Developers}. FP schema ( \(\:n=24\) , Albrecht set): core fields {FP / FP_adj, Effort (PM)}; optional {Time (months), Developers}. UCP schema ( \(\:n=71\) ): raw fields {UAW, UUCW, TCF, ECF, Real Effort (hours), meta}; we compute $$\:\text{U}\text{C}\text{P}=\left(\text{U}\text{A}\text{W}+\text{U}\text{U}\text{C}\text{W}\right)\times\:\text{T}\text{C}\text{F}\times\:\text{E}\text{C}\text{F},$$ and convert effort hours to person-months in Sec. 3.2. Unit Harmonization To enable cross-source learning and ensure comparability across heterogeneous datasets, we performed a systematic unit harmonization process. Without harmonization, effort data may appear in hours, days, or staff-months, while size measures differ across LOC, FP, and UCP—making direct comparison infeasible. Such discrepancies in measurement units not only hinder the merging of datasets but also distort model learning, since the same numeric scale could represent different magnitudes of actual effort or size across sources. Specifically, we applied the following standardization rules: Lines of Code (LOC) values are converted to KLOC by dividing by 1000. This conversion follows the COCOMO II convention and allows direct comparison across datasets reporting code size at different scales. Function Points (FP) and Use Case Points (UCP) are kept in their standardized forms. Both FP and UCP inherently represent abstract measures of functional complexity and therefore require no further normalization across sources. Effort values are converted into Person-Months (PM), assuming \(\:1\hspace{0.17em}\text{PM}=160\hspace{0.17em}\text{hours}=20\hspace{0.17em}\text{days}\) . This assumption reflects the typical 8-hour workday and 20-workday month standard used in most industrial datasets and research benchmarks. Developer count is inferred as \(\:\lceil\:\text{Effort}/\text{Time}\rceil\:\) when project duration ( Time ) is available. This provides an approximate measure of team size, ensuring that effort-related ratios (e.g., productivity) are comparable across studies. Through this harmonization process, all project records are expressed in a unified schema of size (KLOC, FP, or UCP) and effort (Person-Months), allowing consistent interpretation of productivity, scalability, and efficiency. Comprehensive reference of unit conversions used in the harmonization process. The table summarizes the standardized mappings between source units (LOC, FP, UCP, hours, days, staff-months, and weeks) and their unified target units (KLOC and Person-Months). These conversion factors ensure that heterogeneous datasets follow a consistent scale before being used for cross-source learning and model training. Missing Values and Outliers After harmonizing measurement units across datasets, we addressed data completeness and noise to ensure statistical validity. Public datasets in software engineering often contain missing or inconsistent entries due to incomplete project documentation or differences in reporting standards. Handling missing values. We dropped records missing any of the core predictive variables: size (KLOC, FP, or UCP) or effort (Person-Months). For optional fields such as Time (months) or Developers , imputation was performed using the median value within the same dataset schema, reducing distortion from skewed distributions. Outlier detection and capping. Outliers were identified using the Interquartile Range (IQR) rule per feature dimension: $$\:\begin{array}{rr}\text{lower}&\:={Q}_{1}-1.5\times\:\text{IQR},\\\:\text{upper}&\:={Q}_{3}+1.5\times\:\text{IQR},\\\:{x}_{c}&\:\leftarrow\:\text{c}\text{l}\text{i}\text{p}\left(x,\text{lower},\text{upper}\right)\end{array}$$ where \(\:{Q}_{1}\) and \(\:{Q}_{3}\) are the first and third quartiles, respectively. Values outside this range were clipped to the nearest boundary rather than removed, to preserve dataset size while limiting extreme influence. Scatter and boxplot visualizations showing (top) size–effort relationships before and after unit harmonization, and (bottom) productivity and team size trends across data sources. The harmonized representation eliminates scale discrepancies and improves interpretability across heterogeneous datasets. Feature contribution matrices before and after harmonization via Principal Component Analysis (PCA). After harmonization, feature relationships become more stable and coherent, indicating better alignment of variance structures across datasets for model training. Interpretation. As shown in Fig. 4, harmonization and outlier handling collectively improve the coherence of data distributions. Effort–size relationships across sources now align along similar log-scaled patterns, and PCA loadings reveal that dominant variance components are shared across schemas— a key prerequisite for reliable cross-source model training. Distribution Shaping and Correlation Software project variables often exhibit right-skewed distributions, particularly in effort, size, and duration. Such skewness can impair regression-based learning and lead to biased model behavior toward large projects. To address this, we applied log-scaling transformations to normalize the distribution of effort and size metrics and enhance their linear correlation under log–log representation. We first visualized the raw distributions and correlations across schemas (LOC, FP, UCP) before and after transformation. As illustrated in Figure [fig:size-effort-corr], the log–log transformation reveals a clear power-law relationship between software size and development effort, indicating scale invariance commonly observed in empirical software engineering studies. Experimental Setup Train–Test Protocol For each schema (LOC, FP, UCP), we construct an independent evaluation loop. Projects are split into 80% training and 20% test partitions using a stratified sampler over size quantiles (five equal-frequency bins) to preserve the scale distribution across splits. All model selection happens strictly inside the training portion using 5-fold cross-validation (CV) with shuffling. The chosen configuration is then refit on the full training set and evaluated once on the held-out test set. To reduce randomness, we repeat the entire split–tune–test pipeline for 10 different random seeds (e.g., \(\:\{1,11,21,\dots\:,91\}\) ). For any metric \(\:m\) , we report the mean and standard deviation across seeds: $$\:\stackrel{⃐}{m}=\frac{1}{S}\sum\:_{s=1}^{S}{m}^{\left(s\right)},\:\:\text{s}\text{d}\left(m\right)=\sqrt{\frac{1}{S-1}\sum\:_{s=1}^{S}({m}^{\left(s\right)}-\stackrel{⃐}{m}{)}^{2}},$$ with \(\:S=10\) . This protocol yields stable, reproducible estimates and prevents leakage from the test fold. (See Fig. 5 for a high-level flow.) High-level experimental pipeline (per schema). Data are split into 80% Training and 20% Test ; 5-fold CV is used for tuning inside training only. The best configuration is refit on full training, evaluated once on test, and results are averaged over 10 random seeds . Modeling Details Common Preprocessing. Data harmonization follows Section 3: (i) convert effort to Person-Months (PM) and LOC to KLOC ; (ii) median imputation for optional fields ( Time, Developers ); (iii) IQR-based outlier capping; and (iv) schema-specific feature transformations. Tree models use raw harmonized values, whereas linear models apply \(\:\text{l}\text{o}\text{g}\left(1+x\right)\) transforms on size and effort with standardization of continuous covariates. For log-transformed regressions, predictions are inverted as \(\:\widehat{E}=\text{e}\text{x}\text{p}\left(\widehat{z}\right)-1\) (PM); smearing correction was tested but negligible. Model Selection. Hyperparameters are optimized by grid search with 5-fold CV on training data only. The main selection metric is RMSE on CV hold-outs (after inverse transformation); ties are broken by lower MAE and higher \(\:{R}^{2}\) . Linear Regression (LR). Two variants are fitted: (i) ordinary least squares on harmonized features, (ii) log–log regression using \(\:\text{l}\text{o}\text{g}\left(1+\text{size}\right)\) and \(\:\text{l}\text{o}\text{g}\left(1+\text{effort}\right)\) . Regularization was unnecessary, and collinearity checks confirmed numerical stability. Decision Tree (DT). To balance bias–variance, the following ranges are explored: max depth \(\:\{2\) – \(\:14\}\) , min samples leaf \(\:\{1,2,5,10\}\) , min samples split \(\:\{2,5,10\}\) , criterion = “squared_error.” Final depth is selected for interpretability and stability. Random Forest (RF). We vary ensemble size and feature sampling: n estimators \(\:\{50\) – \(\:200\}\) , max features \(\:\{0.33,0.67,1.0\}\) , max depth \(\:\{\text{None},6\) – \(\:14\}\) , min samples leaf \(\:\{1,2,5\}\) . Out-of-bag error is tracked as a secondary validation signal. Gradient Boosting (GB). Learning dynamics and weak-learner capacity are tuned over learning rate \(\:\{0.001,0.01,0.1,0.2,0.5\}\) , n estimators \(\:\{50\) – \(\:200\}\) , max depth \(\:\{2,3,4\}\) , subsample \(\:\{0.7,1.0\}\) . Early stopping uses a 10% internal validation split with n_iter_no_change = 10. Evaluation Metrics For each random seed ( \(\:S=10\) ), we compute MMRE , PRED(25) , MAE , RMSE , and \(\:{R}^{2}\) on the held-out test set, reporting mean \(\:\pm\:\) sd. PRED(25) is calculated after back-transforming predictions to PM. These metrics jointly capture scale-sensitive deviation (RMSE), robust central accuracy (MAE), proportional tolerance (MMRE, PRED(25)), and explained variance ( \(\:{R}^{2}\) ). Uncertainty & Significance Testing Performance differences are assessed using the paired Wilcoxon signed-rank test on per-project absolute errors \(\:\left|\widehat{y}-y\right|\) , comparing each model to the baseline ( RF ). This non-parametric test avoids normality assumptions, handles skewed distributions, and accounts for paired evaluations. For each pair \(\:\left(A,B\right)\) , we test: $$\:{H}_{0}:\text{M}\text{e}\text{d}\text{i}\text{a}\text{n}\left(\left|{\widehat{y}}_{A}-y\right|-\left|{\widehat{y}}_{B}-y\right|\right)=0,$$ at \(\:\alpha\:=0.05\) . Multiple comparisons (LR, DT, RF, GB) are corrected via the Holm–Bonferroni procedure. We further compute Cliff’s Delta ( \(\:\delta\:\) ) to quantify effect size: $$\:\delta\:=\frac{{n}_{>}-{n}_{<}}{n},$$ interpreted as negligible ( \(\:\left|\delta\:\right|<0.147\) ), small (0.147–0.33), medium (0.33–0.474), or large ( \(\:\ge\:0.474\) ). Combining significance and effect-size analyses ensures that improvements are both statistically valid and practically meaningful . Implementation & Reproducibility All experiments ran in a reproducible Python 3.10 environment. Core libraries: scikit-learn v1.3.0, NumPy v1.26+, Pandas v2.0+, SciPy v1.11+, and Matplotlib/Seaborn. A deterministic seed set \(\:\{1,11,21,\dots\:,91\}\) controls data splits, CV shuffling, and ensemble bootstraps. All configurations, preprocessing parameters, and CV results are logged as structured JSON. Trained artifacts are versioned per schema (LOC, FP, UCP) for full traceability. Hardware was uniform: 8–16 CPU cores , 32–64 GB RAM , no GPU. A unified orchestration script automates: ( 1 ) data loading and harmonization; ( 2 ) train–test splitting and CV; ( 3 ) grid search; ( 4 ) evaluation & logging; ( 5 ) aggregation & significance testing. All runs are fully deterministic and portable, aligning with reproducibility best practices in empirical software engineering . Results Overall Comparison Table 1 summarizes the mean test performance across all schemas ( LOC , FP , and UCP ) using the evaluation metrics defined in Section 4.3. Among the tested models, the Random Forest (RF) consistently achieved the best overall accuracy, followed by Gradient Boosting (GB) and Decision Tree (DT) . COCOMO II , representing the classical parametric baseline, showed the weakest performance across all error metrics, while Linear Regression (LR) was highly unstable due to multicollinearity and violation of linearity assumptions in the raw feature space. Overall test performance (best in bold ). Model MMRE \(\:\downarrow\:\) PRED(25) \(\:\uparrow\:\) MAE \(\:\downarrow\:\) RMSE \(\:\downarrow\:\) \(\:{R}^{2}\) \(\:\uparrow\:\) COCOMO II 2.790 0.012 45.03 53.70 – Linear Regression 4.500 0.000 107.54 280.27 – Decision Tree 1.371 0.173 18.63 23.62 – Gradient Boosting 1.101 0.198 16.16 21.09 – Random Forest 0.647 0.395 12.66 20.01 – Statistical tests (Section 4.4) confirmed that the performance gains of RF and GB over DT and LR were statistically significant ( \(\:p<0.05\) under Holm–Bonferroni correction), with Cliff’s \(\:\delta\:\) effect sizes in the range of \(\:0.35\) – \(\:0.55\) (medium-to-large). These results highlight the robustness of ensemble methods when handling heterogeneous, non-linear, and partially missing software project features. Schema-Specific Analyses LOC Schema. After log–log transformation (Section 3.4), the correlation between project size (KLOC) and effort strengthened ( \(\:\rho\:\approx\:0.88\) ), supporting the multiplicative nature of software growth patterns. Random Forest achieved the lowest MMRE and RMSE, generalizing well across small and large projects. Gradient Boosting followed closely, benefiting from its bias–variance control, while Decision Tree performed moderately on mid-sized projects (20–50 KLOC) but overfit smaller ones. Linear Regression consistently underestimated small and overestimated large projects, confirming the limitations of linear assumptions for effort prediction. FP Schema. The Function Point (FP) schema exhibited higher variability due to its small sample size ( \(\:n=24\) ) and heterogeneous functional complexity. Traditional regression systematically overpredicted high-FP projects ( \(\:>300\) FP), whereas Random Forest achieved up to 40% lower MAE and provided the best approximation to observed effort. Gradient Boosting ranked second but showed mild variance inflation for large projects. Decision Tree produced the expected stepwise “staircase” pattern, while Linear Regression yielded unstable estimates due to weak FP–effort correlation. Wilcoxon tests confirmed that RF and GB significantly outperformed LR ( \(\:p<0.01\) ; \(\:\left|\delta\:\right|\ge\:0.47\) ). UCP Schema. Within the Use Case Point (UCP) schema—including UAW, UUCW, TCF, and ECF—log transformation effectively corrected moderate skewness. Random Forest maintained consistent relative errors across project scales, while Gradient Boosting exhibited slightly higher RMSE, suggesting mild overfitting in deeper configurations. Decision Tree performed comparably for medium projects ( \(\:100\le\:\text{U}\text{C}\text{P}\le\:300\) ) but degraded for larger ones, and Linear Regression again struggled with non-linear dependencies. Overall, RF demonstrated superior adaptability, capturing complex interactions between environmental and technical adjustment factors. Cross-Schema Discussion. Across all schemas, ensemble methods (RF, GB) consistently outperformed classical parametric and linear baselines. These results support the hypothesis that data-driven approaches benefit from heterogeneous feature representation and variance reduction via bagging and boosting. The reproducibility pipeline (Section 4.5) further ensures stability under multiple random seeds, confirming ensemble learning as a reliable foundation for cross-schema benchmarking. Error Profiles and Visual Analyses To interpret model behavior beyond scalar metrics, we visualize prediction error distributions and learning dynamics across schemas in Figure [fig:error-profiles]. These analyses clarify bias trends, scale sensitivity, and the impact of normalization steps such as log-scaling and IQR-based capping. (a) Overall Performance. The top-left panel aggregates MMRE and PRED(25) across schemas. Random Forest achieved the lowest relative error (MMRE) and highest accuracy fraction (PRED(25) \(\:\approx\:40\text{\%}\) ), followed by Gradient Boosting . Linear Regression and COCOMO II showed strong bias and underfitting under heteroscedastic noise. (b) LOC Error Behavior. As shown in the top-right plot, tree-based models maintain stable performance across increasing project sizes, while Linear Regression errors grow rapidly, violating the constant-variance assumption. Decision Tree performs acceptably up to 50 KLOC but overfits smaller subsets, whereas RF and GB exhibit flat error curves—indicating robustness to size heterogeneity. (c) FP Effort Trends. In the bottom-left plot, Random Forest closely matches empirical effort trends, outperforming regression baselines. Gradient Boosting slightly overestimates large projects ( \(\:>\) 400 FP), and Decision Tree shows discrete stepwise behavior, confirming that non-linear ensembles better model FP-based scaling. (d) Impact of Log and Outlier Control. The bottom-right panel quantifies the benefit of normalization. Raw effort–size correlations ( \(\:r=0.83\) ) improve slightly after \(\:\text{l}\text{o}\text{g}\left(1+x\right)\) scaling ( \(\:r=0.84\) ) and stabilize post IQR-capping ( \(\:r=0.81\) ). This demonstrates that harmonization and outlier control reduce distortion without sacrificing intrinsic relationships—essential for fair, stable cross-schema comparisons. Discussion and Practical Implications Random Forest Superiority. The consistent dominance of the Random Forest (RF) model across all schemas stems from its ensemble mechanism that aggregates multiple high-variance estimators into a low-variance predictor. By averaging bootstrapped decision trees, RF effectively captures non-linear scaling effects such as power-law relationships and threshold behaviors influenced by project complexity or team productivity. Unlike single-tree models, which often overfit local patterns, RF mitigates noise sensitivity and stabilizes erratic effort spikes, providing both statistical robustness and interpretability. Alternative Model Preferences. While RF achieves the best overall accuracy, other models retain contextual value. Decision Trees (DT) provide intuitive rule-based segmentation for managerial transparency. Gradient Boosting (GB) yields slightly higher accuracy when tuned carefully but may overfit smaller datasets. Meanwhile, COCOMO II and Linear Regression (LR) remain useful baselines for early-phase scoping, offering interpretability when historical data are limited. Guidelines for Adoption. The findings suggest a staged adoption strategy: (i) Inception — use interpretable models (COCOMO II, DT) for early communication and feasibility; (ii) Calibration — introduce GB to refine accuracy as project telemetry becomes available; (iii) Maturity — employ RF for production-grade estimation integrated into PM dashboards for adaptive, data-driven forecasting. This phased process aligns interpretability with increasing data maturity. Practical Insights and Validity. Ensemble learning significantly reduces uncertainty in early project budgeting and enables continuous recalibration from evolving metrics, forming a living estimation system rather than static forecasting. Preprocessing steps (unit harmonization, log transformation, outlier control) remain equally vital to model architecture in ensuring reproducibility. Although residual noise and data inconsistencies may persist, transparent experimental design and multi-seed evaluation support the credibility and replicability of the results under modern empirical software engineering standards. Threats to Validity Despite rigorous experimentation and reproducibility controls, several validity threats may affect the interpretation and generalizability of our findings. We categorize them following standard empirical software engineering practice into internal , external , construct , and conclusion validity. Internal Validity. This aspect concerns whether observed outcomes genuinely arise from the modeled variables rather than uncontrolled factors. Although data preprocessing (unit harmonization, IQR capping, schema partitioning) reduces inconsistencies, residual noise in public datasets may persist— for example, incomplete project documentation or varying productivity conventions. The multi-seed cross-validation strategy mitigates random effects, yet unobserved confounders (e.g., domain-specific tools) could still influence effort distributions. External Validity. Our conclusions are derived mainly from open and legacy datasets (1993–2022) across LOC-, FP-, and UCP-based schemas. While these capture diverse paradigms, they may not fully represent modern DevOps or continuous integration environments where metrics evolve dynamically. Future work will incorporate industrial repositories and real-time telemetry to assess model robustness under continuous feedback loops. Construct Validity. Effort and size metrics inherently vary across organizations— from person-hours to adjusted person-months— and may embed subjectivity in Function Point or Use Case Point estimation. Although the harmonization framework (Section 3.2) standardizes units, measurement bias remains possible. To address metric limitations (e.g., MMRE, PRED(25)), we complement them with absolute-error (MAE, RMSE) and variance-explained ( \(\:{R}^{2}\) ) measures. Conclusion Validity. Statistical inference reliability was reinforced through Wilcoxon signed-rank tests with Holm–Bonferroni correction and effect-size reporting via Cliff’s \(\:\delta\:\) (Section 4.4). Nevertheless, multiple comparisons can increase Type II error risk, especially for small-sample schemas (e.g., FP, \(\:n=24\) ). Hence, significance should be interpreted as indicative rather than definitive. Summary. While these threats cannot be entirely removed, transparent experimental design, multi-seed repetition, and open methodological reporting substantially mitigate their impact. Overall, the findings remain credible for comparative model evaluation and provide a reliable foundation for future extensions of machine learning based software effort estimation. Related Work Evolution of Software Effort Estimation Methods Software Effort Estimation (SEE) has evolved over four decades, transitioning from rule based and parametric approaches to hybrid and data-driven paradigms. The seminal COCOMO model by Boehm (1981) established an empirically grounded estimation framework, followed by Function Points (Albrecht, 1979) and Use Case Points (Karner, 1993), which extended measurement granularity to functional and behavioral complexity. Since the 2000s, studies have introduced early ML models—linear regression, decision trees, neural networks, and SVMs—gradually shifting toward ensemble learning and deep models (e.g., Random Forest, Gradient Boosting, and hybrid ensembles ). Despite improved accuracy, issues of reproducibility and cross-schema comparability (LOC, FP, UCP) remain insufficiently explored. Comparison of Estimation Paradigms Figure [fig:related-work] (top-right) contrasts four major paradigms: (i) traditional parametric, (ii) early ML, (iii) ensemble learning, and (iv) the proposed Enhanced COCOMO II . Parametric models prioritize interpretability but lack adaptability. Basic ML models improve accuracy yet often lose transparency. Ensemble methods achieve the most balanced trade off between accuracy , adaptability , and ease of use . Our Enhanced COCOMO II retains COCOMO’s explainable structure while embedding data-driven residual corrections, bridging classical transparency and modern predictive robustness. Validity Gaps in Prior Studies Prior SEE research often overlooked systematic validation and reproducibility analysis. Reviews such as Kitchenham et al. and Foss et al. identify internal and construct validity as recurring risks, stemming from inconsistent data curation and subjective FP/UCP sizing. Recent studies emphasize transparency and open science, yet few works implement explicit unit harmonization or standardized evaluation pipelines. Research Gap and Contribution Across the SEE literature, research has advanced through four dimensions theory formation , model development , empirical validation , and industry adoption . While traditional models dominate theoretical grounding and ML excels in model design, few efforts bridge validation with practical deployment. Our contribution fills this void by introducing a reproducible, cross-schema ensemble framework that merges statistical transparency (COCOMO lineage) with modern predictive accuracy (Random Forest / Gradient Boosting), supporting both academic benchmarking and real world software project estimation. Conclusion and Reproducibility Summary of Findings. This study introduced a unified cross-schema framework for software effort estimation, enabling systematic benchmarking across LOC-, FP-, and UCP-based representations. Through harmonized preprocessing and a comprehensive model comparison, ensemble learners—most notably Random Forest — demonstrated consistently superior predictive performance relative to classical parametric approaches such as COCOMO II and single-model baselines. The capacity of variance-reducing ensembles to capture non-linear scaling behaviors, while maintaining interpretable variable importance, underscores their suitability for heterogeneous software project data. Meanwhile, the Enhanced COCOMO II configuration achieved competitive accuracy with full transparency, highlighting a practical middle ground between interpretability and performance. These results corroborate findings in recent literature on hybrid and ensemble-based effort estimation . Reproducibility Framework. Reproducibility was enforced through standardized data harmonization, deterministic preprocessing pipelines, fixed random seeds, and structured experiment logging. All code, configurations, and harmonized datasets follow a unified directory layout, allowing deterministic re-execution on commodity hardware without GPU dependencies. This design aligns with recommended best practices in empirical software engineering for conducting transparent and repeatable experimental studies. The unified schema further supports future comparison studies by ensuring consistent feature representations across LOC, FP, and UCP data sources. Future Directions. Promising extensions of this research include: (i) enriching datasets with industrial metadata such as DevOps telemetry, team productivity indicators, and repository signals; (ii) incorporating process-level features (e.g., issue churn, code volatility); (iii) adopting transfer learning and domain adaptation to enhance cross-organizational robustness; and (iv) deploying ensemble estimators in real project management environments for continuous calibration and real-time forecasting. Such directions will help close the gap between academic research and operational project decision-making. Closing Remarks. The unified framework proposed in this study provides a reproducible, transparent, and extensible foundation for cross-schema benchmarking in software effort estimation. By integrating methodological rigor, schema harmonization, and comprehensive evaluation, this work moves toward a living estimation system —one that evolves with new telemetry and real-world project dynamics. We hope this framework will support practitioners, researchers, and tool builders in creating more adaptive, evidence-based estimation solutions. Data Availability All datasets used in this study are publicly available and were collected from open-access software engineering repositories. No proprietary or private data were used. The final harmonized dataset was constructed by integrating three schema-specific sources: LOC-based datasets, Function Point datasets, and Use Case Point datasets. Public sources include: DASE – Data Analysis in Software Engineering https://github.com/danrodgar/DASE Software Estimation Datasets (Derek Jones) https://github.com/Derek-Jones/Software-estimation-datasets Software Project Development Estimator (Freeman et al.) https://github.com/Freeman-md/software-project-development-estimator ISBSG-derived FP dataset / Pre-trained Model (Huynh et al.) https://github.com/huynhhoc/effort-estimation-by-using-pre-trained-model Each repository provides schema-specific project records (LOC, FP, or UCP) with effort values in hours or person-months. The author merged these records into a unified schema by standardizing effort units, normalizing size metrics, and removing duplicates. Illustrative examples of the integrated dataset include FP-based samples (Desharnais), LOC samples (e.g., project_id/loc/kloc/effort_pm), and UCP samples (Silhavy et al.). The harmonized dataset and preprocessing scripts can be obtained from the corresponding author upon reasonable request. All data used in this work are anonymized and contain no personal or sensitive information. Declarations Competing Interests The authors declare that they have no competing interests. Ethics Approval and Consent to Participate This study uses only publicly available, fully anonymized datasets. No human participants or personal data were involved; therefore, ethics approval and formal consent were not required. Consent for Publication Not applicable. Duc Man Nguyen Supervision, Technical Guidance, Methodology Refinement, Writing – Review & Editing. Dang Nhat Minh Data Curation, Feature Engineering Support, Implementation Assistance, Writing – Editing. Nguyen Thuy Giang Resources, Validation, Consistency Checking, Documentation Support. P. W. C. Prasad Senior Supervision, Project Administration, Strategic Direction, Final Approval of the Manuscript. Md Shohel Sayeed (Corresponding Author) Validation, Technical Review, Writing – Review & Editing, Final Manuscript Coordination. Funding This research received no specific grant from any funding agency in the public, commercial, or not-for-profit sectors. Author Contribution **Nguyen Nhat Huy** : Conceptualization, Dataset Preparation, Methodology, Software Development, Experiments, Formal Analysis, Visualization, Writing – Original Draft.**Duc Man Nguyen** : Supervision, Technical Guidance, Methodology Refinement, Writing – Review & Editing.**Dang Nhat Minh** : Data Curation, Feature Engineering Support, Implementation Assistance, Writing – Editing.**Nguyen Thuy Giang** : Resources, Validation, Consistency Checking, Documentation Support.**P. W. C. Prasad** : Senior Supervision, Project Administration, Strategic Direction, Final Approval of the Manuscript.**Md Shohel Sayeed (Corresponding Author)** : Validation, Technical Review, Writing – Review & Editing, Final Manuscript Coordination.All authors read and approved the final manuscript. Data Availability All datasets used in this study are publicly available and were collected from open-access software engineering repositories. No proprietary or private data were used. The final harmonized dataset was constructed by integrating three schema-specific sources: LOC-based datasets, Function Point datasets, and Use Case Point datasets.Public sources include:- **DASE – Data Analysis in Software Engineering** [https://github.com/danrodgar/DASE](https:/github.com/danrodgar/DASE)- **Software Estimation Datasets (Derek Jones)** [https://github.com/Derek-Jones/Software-estimation-datasets](https:/github.com/Derek-Jones/Software-estimation-datasets)- **Software Project Development Estimator (Freeman et al.)** [https://github.com/Freeman-md/software-project-development-estimator](https:/github.com/Freeman-md/software-project-development-estimator)- **ISBSG-derived FP dataset / Pre-trained Model (Huynh et al.)** [https://github.com/huynhhoc/effort-estimation-by-using-pre-trained-model](https:/github.com/huynhhoc/effort-estimation-by-using-pre-trained-model)Each repository provides schema-specific project records (LOC, FP, or UCP) with effort values in hours or person-months. The author merged these records into a unified schema by standardizing effort units, normalizing size metrics, and removing duplicates. Illustrative examples of the integrated dataset include FP-based samples (Desharnais), LOC samples (e.g., project_id/loc/kloc/effort_pm), and UCP samples (Silhavy et al.).The harmonized dataset and preprocessing scripts can be obtained from the corresponding author upon reasonable request. All data used in this work are anonymized and contain no personal or sensitive information. References Barry Boehm. COCOMO II Model Definition Manual. USC; 2000. Muhammad Tanveer I, Hussain N, Zahid, et al. A survey on machine learning techniques for software effort estimation: Trends, challenges, and opportunities. J Syst Softw. 2023;200:111618. Mohammad Azzeh and Ali Bou Nassif. Cross-company effort estimation using ensemble learning and feature selection. Empir Softw Eng. 2019;24(6):3821–48. Kitchenham B, Pickard L, MacDonell S, Shepperd M. Evaluating software engineering prediction systems. ‎Inf Softw Technol. 2001;43(11):733–43. Tore Foss E, Stensrud B, Kitchenham, Myrtveit I. A simulation study of the model evaluation criterion mmre. IEEE Trans Software Eng. 2003;29(11):985–95. Frank Wilcoxon. Individual comparisons by ranking methods. Biometrics Bull. 1945;1(6):80–3. Leo Breiman. Random forests. Mach Learn. 2001;45(1):5–32. Sture Holm. A simple sequentially rejective multiple test procedure. Scand J Stat. 1979;6(2):65–70. Macbeth G. Esteban Razumiejczyk, and Rubén Ledesma. Cliff’s delta calculator: A non-parametric effect size program for two groups of observations. Universitas Physiol. 2011;10(2):545–55. Janez Demšar. Statistical comparisons of classifiers over multiple data sets. J Mach Learn Res. 2006;7:1–30. Garcia S, Fernandez A, Luengo J, Herrera F. Advanced nonparametric tests for multiple comparisons in computational intelligence and data mining. Inf Sci. 2010;180(10):2044–64. Fabian, Pedregosa, et al. Scikit-learn: Machine learning in python. J Mach Learn Res. 2011;12:2825–30. Luis Cruz and Rui Abreu. Open science in software engineering research: The case for open data and replication. Empir Softw Eng. 2019;24(6):3829–49. Belen Lopez JC, Rodriguez, Garcia S. Empirical software engineering reproducibility: A systematic review. ‎Inf Softw Technol. 2021;136:106579. Jerome H, Friedman. Greedy function approximation: A gradient boosting machine. Ann Stat, pages 1189–232, 2001. Pandey P, Sharma T, Saha S. Hybrid ensemble learning for software effort estimation using meta-heuristic optimization. Appl Soft Comput. 2023;135:110054. Alqadi A, Abran A. Deep learning models for software effort estimation: An empirical study. IEEE Access. 2021;9:135012–26. Vineeth Nair and Tim Menzies. Open problems in reproducibility, replication, and transparency in software engineering. In Proceedings of the 42nd International Conference on Software Engineering: New Ideas and Emerging Results , pages 1–4. IEEE, 2020. Muhammad Tanveer I, Hussain N, Zahid, et al. A comprehensive analysis of ensemble learning models for software effort estimation. IEEE Access. 2023;11:76590–608. Xia YYX, Lo D, Ahmed E, Hassan. Transfer learning in software engineering: A systematic mapping study. Empir Softw Eng. 2021;26(3):1–46. Unsectioned Paragraphs Introduction Accurately estimating software development effort is a critical factor in determining the success of software projects. Reliable estimates support effective planning, budgeting, resource allocation, and risk management. Conversely, inaccurate estimates often result in cost overruns, schedule delays, and even project failure, as widely acknowledged in the empirical software engineering literature. As modern software projects continue to grow in diversity—varying in size, methodology, domain, and team structure—the challenge of producing consistent and trustworthy effort estimates becomes increasingly pronounced. A wide range of factors affect estimation accuracy, including project size, functional complexity, development methodology, team capability, and organizational context. Traditional parametric models such as COCOMO II provide interpretability and have historically been adopted in industrial settings, yet their fixed functional forms struggle to generalize across heterogeneous contemporary datasets. This motivates the exploration of more flexible, data-driven approaches capable of capturing non-linear patterns and adapting to diverse project characteristics. In this work, we address these challenges by designing a unified machine-learning framework for software effort estimation. Specifically, this study pursues three objectives: (i) to develop an integrated estimation framework that supports three major sizing schemas—Lines of Code (LOC), Function Points (FP), and Use Case Points (UCP); (ii) to empirically compare the performance of multiple machine-learning regressors against the widely used COCOMO II model using standard evaluation metrics such as MMRE, PRED(25), MAE, RMSE, and \(\:{R}^{2}\) ; and (iii) to analyze the behavior of each model within individual sizing schemas in order to provide practical insights for software project managers. The contributions of this paper are summarized as follows: We propose a unified multi-schema machine-learning framework that harmonizes preprocessing, feature construction, model training, and evaluation across LOC, FP, and UCP. We conduct a comprehensive empirical comparison involving four representative ML models and the COCOMO II baseline on publicly available datasets spanning 1993–2022. We provide schema-specific analyses to examine how input representation (KLOC, FP, UCP) influences predictive accuracy. We offer practical implications for applying machine-learning-based effort estimation in real-world software engineering environments. All authors read and approved the final manuscript. Additional Declarations No competing interests reported. Cite Share Download PDF Status: Posted Version 1 posted You are reading this latest preprint version Research Square lets you share your work early, gain feedback from the community, and start making changes to your manuscript prior to peer review in a journal. As a division of Research Square Company, we’re committed to making research communication faster, fairer, and more useful. We do this by developing innovative software and high quality services for the global research community. Our growing team is made up of researchers and industry professionals working together to solve the most critical problems facing scientific publishing. Also discoverable on Platform About Our Team In Review Editorial Policies Advisory Board Help Center Resources Author Services Accessibility API Access RSS feed Manage Cookie Preferences © Research Square 2026 | ISSN 2693-5015 (online) Privacy Policy Terms of Service Do Not Sell My Personal Information {"props":{"pageProps":{"initialData":{"identity":"rs-8623983","acceptedTermsAndConditions":true,"allowDirectSubmit":true,"archivedVersions":[],"articleType":"Research Article","associatedPublications":[],"authors":[{"id":583660867,"identity":"9c3bef86-88c5-4e28-8f01-5ad1529a7523","order_by":0,"name":"Nguyen Nhat Huy","email":"","orcid":"","institution":"Duy Tan University","correspondingAuthor":false,"prefix":"","firstName":"Nguyen","middleName":"Nhat","lastName":"Huy","suffix":""},{"id":583660868,"identity":"205e912b-c8c0-4060-838d-bed93935c16c","order_by":1,"name":"Duc Man Nguyen","email":"","orcid":"","institution":"Duy Tan University","correspondingAuthor":false,"prefix":"","firstName":"Duc","middleName":"Man","lastName":"Nguyen","suffix":""},{"id":583660869,"identity":"7e57ac98-8f2a-44d2-8116-2278f30b842f","order_by":2,"name":"Dang Nhat Minh","email":"","orcid":"","institution":"Duy Tan University","correspondingAuthor":false,"prefix":"","firstName":"Dang","middleName":"Nhat","lastName":"Minh","suffix":""},{"id":583660870,"identity":"e2817539-f991-4418-8f60-3d9de6a2b8c7","order_by":3,"name":"Nguyen Thuy Giang","email":"","orcid":"","institution":"Duy Tan University","correspondingAuthor":false,"prefix":"","firstName":"Nguyen","middleName":"Thuy","lastName":"Giang","suffix":""},{"id":583660871,"identity":"83ab0405-ee1c-4402-8aa8-5e3746cea1e7","order_by":4,"name":"P. W. C. Prasad","email":"","orcid":"","institution":"Duy Tan University","correspondingAuthor":false,"prefix":"","firstName":"P.","middleName":"W. C.","lastName":"Prasad","suffix":""},{"id":583660875,"identity":"14447ca9-0838-4d7e-8ad6-ebaee0d4a520","order_by":5,"name":"Md Shohel Sayeed","email":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAAyAQMAAABI0h/eAAAABlBMVEX///8AAABVwtN+AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAA/UlEQVRIiWNgGAWjYDACCQY2BoYCKIenAiZIUIsBTMsZkrXwthGhRX5287EHHwwY7PlnJB988HbetmiDA8wHb/MwbEtswKHF4M6xdMMZBgyJM26kJRvO3XY7d8MBtmRrHobbuLVI5JhJ8xgwJDDcADJ4wVp4gCJ4tMjPAKr8A3SY/I38779554C08H/DqwVsOND7jBtu5LAx8zaAbWHDq8XgRlqaZI+BROLGM8+MJeccu5078zCbseUcg9vGuB2WfEziR4WNvdzx5Icf3tTczu073vzwxpuK27I4HQYBwIgQSICymcG2MzgS0AIE/AdQ+fYEdYyCUTAKRsFIAQAZllsqb6JGmwAAAABJRU5ErkJggg==","orcid":"","institution":"Multimedia University","correspondingAuthor":true,"prefix":"","firstName":"Md","middleName":"Shohel","lastName":"Sayeed","suffix":""}],"badges":[],"createdAt":"2026-01-17 06:53:20","currentVersionCode":1,"declarations":"","doi":"10.21203/rs.3.rs-8623983/v1","doiUrl":"https://doi.org/10.21203/rs.3.rs-8623983/v1","draftVersion":[],"editorialEvents":[],"editorialNote":"","failedWorkflow":false,"files":[],"financialInterests":"No competing interests reported.","formattedTitle":"Insightimate: Enhancing Software Effort Estimation Accuracy Using Machine Learning Across Three Schemas (LOC/FP/UCP)","fulltext":[{"header":"Background and Methods","content":"\u003cdiv id=\"Sec2\" class=\"Section2\"\u003e \u003ch2\u003eCOCOMO II Recap\u003c/h2\u003e \u003cp\u003eCOCOMO II (Constructive Cost Model II) extends the original COCOMO 81 model to better accommodate modern development practices, including component reuse, iterative processes, and object-oriented architectures. The model estimates the development effort \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:E\\)\u003c/span\u003e\u003c/span\u003e (in person-months) using a power-law function of project size:\u003cdiv id=\"Equa\" class=\"Equation\"\u003e\u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equa\" name=\"EquationSource\"\u003e\n$$\\:E=A\\times\\:{\\left(\\text{Size}\\right)}^{B}\\times\\:\\prod\\:_{i=1}^{m}E{M}_{i},$$\u003c/div\u003e\u003c/div\u003e\u003c/p\u003e \u003cp\u003ewhere is commonly expressed in KLOC, \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:A\\)\u003c/span\u003e\u003c/span\u003e and \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:B\\)\u003c/span\u003e\u003c/span\u003e are calibration constants derived from historical data, and \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:E{M}_{i}\\)\u003c/span\u003e\u003c/span\u003e represents effort multipliers capturing project-specific characteristics such as team experience, product complexity, and tool support.\u003c/p\u003e \u003cp\u003eThe project schedule is then computed as:\u003cdiv id=\"Equb\" class=\"Equation\"\u003e\u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equb\" name=\"EquationSource\"\u003e\n$$\\:\\text{Time}=C\\times\\:{E}^{D},$$\u003c/div\u003e\u003c/div\u003e\u003c/p\u003e \u003cp\u003ewith constants \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:C\\)\u003c/span\u003e\u003c/span\u003e and \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:D\\)\u003c/span\u003e\u003c/span\u003e similarly obtained through calibration. Although COCOMO II remains influential due to its transparency and ease of interpretation, its rigid parametric structure often struggles to accommodate heterogeneous datasets found in contemporary software projects. This limitation has motivated the exploration of machine-learning approaches that can flexibly capture complex, non-linear relationships present in real-world estimation scenarios.\u003cdiv id=\"Equc\" class=\"Equation\"\u003e\u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equc\" name=\"EquationSource\"\u003e\n$$\\:\\text{Time}=C\\times\\:{E}^{D},$$\u003c/div\u003e\u003c/div\u003e\u003c/p\u003e \u003cp\u003ewith constants \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:C,D\\)\u003c/span\u003e\u003c/span\u003e calibrated on historical datasets.\u003c/p\u003e \u003cp\u003eWhile simple and interpretable, the fixed exponents and multipliers in Eqs. [eq:cocomo-effort]\u0026ndash;[eq:cocomo-time] often underfit heterogeneous, contemporary datasets, motivating the exploration of machine learning methods that adapt more flexibly to diverse data sources.\u003c/p\u003e \u003cp\u003e \u003c/p\u003e \u003cp\u003eWorkflow comparison between (a) the traditional COCOMO II pipeline (Eqs. [eq:cocomo-effort]\u0026ndash;[eq:cocomo-time]) and (b) the proposed multi-schema ML framework.\u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec3\" class=\"Section2\"\u003e \u003ch2\u003eMulti-Schema ML Framework\u003c/h2\u003e \u003cp\u003eWe introduce a unified machine-learning framework that trains a separate regressor for each sizing schema\u0026mdash;Lines of Code (LOC), Function Points (FP), and Use Case Points (UCP)\u0026mdash;and compares their predictive performance with COCOMO II. For each schema \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:s\\in\\:\\{\\text{LOC},\\text{FP},\\text{UCP}\\}\\)\u003c/span\u003e\u003c/span\u003e, the framework learns a mapping\u003cdiv id=\"Equd\" class=\"Equation\"\u003e\u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equd\" name=\"EquationSource\"\u003e\n$$\\:{\\widehat{E}}^{\\left(s\\right)}={f}^{\\left(s\\right)}\\left({x}^{\\left(s\\right)}\\right),$$\u003c/div\u003e\u003c/div\u003e\u003c/p\u003e \u003cp\u003ewhere \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{x}^{\\left(s\\right)}\\)\u003c/span\u003e\u003c/span\u003e includes the size metric (KLOC/FP/UCP) and, when available, supplementary predictors such as project duration or team size.\u003c/p\u003e \u003cp\u003eTo ensure consistent and stable training across heterogeneous datasets, we employ a standardized preprocessing pipeline consisting of: (i) unit harmonization (e.g., normalizing effort to person-months and converting LOC to KLOC); (ii) outlier mitigation via interquartile-range (IQR) capping; and (iii) distribution reshaping using \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\text{l}\\text{o}\\text{g}1p\\)\u003c/span\u003e\u003c/span\u003e transformations to reduce skewness and improve model fit.\u003c/p\u003e \u003cp\u003eWe evaluate four representative machine-learning models:\u003c/p\u003e \u003cp\u003e \u003cul\u003e \u003cli\u003e \u003cp\u003e \u003cb\u003eLinear Regression\u003c/b\u003e, including a log\u0026ndash;log variant to capture multiplicative relationships.\u003c/p\u003e \u003c/li\u003e \u003cli\u003e \u003cp\u003e \u003cb\u003eDecision Tree Regressor\u003c/b\u003e, representing interpretable non-linear modeling.\u003c/p\u003e \u003c/li\u003e \u003cli\u003e \u003cp\u003e \u003cb\u003eRandom Forest Regressor\u003c/b\u003e, leveraging ensemble averaging for robustness.\u003c/p\u003e \u003c/li\u003e \u003cli\u003e \u003cp\u003e \u003cb\u003eGradient Boosting Regressor\u003c/b\u003e, known for strong performance on structured data.\u003c/p\u003e \u003c/li\u003e \u003c/ul\u003e \u003c/p\u003e \u003cp\u003eThe framework is extensible: additional sizing techniques such as story points or object points can be incorporated by defining new feature schemas. Prior reviews highlight the growing interest in multi-schema and ensemble-based estimation methods. Our framework contributes to this direction by unifying preprocessing, model training, and evaluation under a reproducible and comparable experimental setting.\u003c/p\u003e \u003c/div\u003e"},{"header":"Evaluation Metrics","content":"\u003cp\u003eWe report standard effort-estimation metrics widely used in prior work. For each metric, we present its definition and interpretation.\u003c/p\u003e \u003cp\u003e \u003cem\u003eMean Magnitude of Relative Error (MMRE).\u003c/em\u003e \u003cdiv id=\"Eque\" class=\"Equation\"\u003e \u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Eque\" name=\"EquationSource\"\u003e\n$$\\:\\text{M}\\text{M}\\text{R}\\text{E}=\\frac{1}{n}\\sum\\:_{i=1}^{n}\\frac{\\left|{y}_{i}-{\\widehat{y}}_{i}\\right|}{{y}_{i}}$$\u003c/div\u003e \u003c/div\u003e \u003c/p\u003e \u003cp\u003eMMRE calculates the average relative error between the actual effort \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{y}_{i}\\)\u003c/span\u003e\u003c/span\u003e and the predicted effort \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{\\widehat{y}}_{i}\\)\u003c/span\u003e\u003c/span\u003e. It is simple and widely adopted, but several studies have criticized MMRE for bias, especially in small projects .\u003c/p\u003e \u003cp\u003e \u003cem\u003ePrediction at 25% (PRED(25)).\u003c/em\u003e \u003cdiv id=\"Equf\" class=\"Equation\"\u003e \u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equf\" name=\"EquationSource\"\u003e\n$$\\:\\text{P}\\text{R}\\text{E}\\text{D}\\left(25\\right)=\\frac{1}{n}\\sum\\:_{i=1}^{n}1\\left(\\frac{\\left|{y}_{i}-{\\widehat{y}}_{i}\\right|}{{y}_{i}}\\le\\:0.25\\right)$$\u003c/div\u003e \u003c/div\u003e \u003c/p\u003e \u003cp\u003ePRED(25) measures the proportion of predictions whose relative error is within 25% of the actual effort. It provides an intuitive sense of robustness, but depends on the arbitrary 25% threshold and may be unstable with small datasets .\u003c/p\u003e \u003cp\u003e \u003cem\u003eMean Absolute Error (MAE).\u003c/em\u003e \u003cdiv id=\"Equg\" class=\"Equation\"\u003e \u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equg\" name=\"EquationSource\"\u003e\n$$\\:\\text{M}\\text{A}\\text{E}=\\frac{1}{n}\\sum\\:_{i=1}^{n}|{y}_{i}-{\\widehat{y}}_{i}|$$\u003c/div\u003e \u003c/div\u003e \u003c/p\u003e \u003cp\u003eMAE expresses the average absolute deviation (in person-months) between predicted and actual effort. It is interpretable in absolute units and less sensitive to outliers than RMSE, making it a practical complement to relative-error metrics.\u003c/p\u003e \u003cp\u003e \u003cem\u003eRoot Mean Square Error (RMSE).\u003c/em\u003e \u003cdiv id=\"Equh\" class=\"Equation\"\u003e \u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equh\" name=\"EquationSource\"\u003e\n$$\\:\\text{R}\\text{M}\\text{S}\\text{E}=\\sqrt{\\frac{1}{n}\\sum\\:_{i=1}^{n}({y}_{i}-{\\widehat{y}}_{i}{)}^{2}}$$\u003c/div\u003e \u003c/div\u003e \u003c/p\u003e \u003cp\u003eRMSE penalizes larger errors more strongly because of the squaring term. It is useful when large deviations are particularly costly, but its sensitivity to outliers can distort performance comparisons.\u003c/p\u003e \u003cp\u003e \u003cem\u003eCoefficient of Determination (\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e \u003cspan class=\"mathinline\"\u003e\\(\\:{R}^{2}\\)\u003c/span\u003e \u003c/span\u003e \u003cem\u003e).\u003c/em\u003e \u003cdiv id=\"Equi\" class=\"Equation\"\u003e \u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equi\" name=\"EquationSource\"\u003e\n$$\\:{R}^{2}=1-\\frac{\\sum\\:_{i=1}^{n}({y}_{i}-{\\widehat{y}}_{i}{)}^{2}}{\\sum\\:_{i=1}^{n}({y}_{i}-\\stackrel{⃐}{y}{)}^{2}}$$\u003c/div\u003e \u003c/div\u003e \u003c/p\u003e \u003cp\u003e \u003cspan class=\"InlineEquation\"\u003e \u003cspan class=\"mathinline\"\u003e\\(\\:{R}^{2}\\)\u003c/span\u003e \u003c/span\u003e measures the proportion of variance in the actual effort \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{y}_{i}\\)\u003c/span\u003e\u003c/span\u003e explained by the predictions \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{\\widehat{y}}_{i}\\)\u003c/span\u003e\u003c/span\u003e. Higher values generally indicate better explanatory power. However, in effort estimation, a high \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{R}^{2}\\)\u003c/span\u003e\u003c/span\u003e does not guarantee practical accuracy, since a model may fit variance well but still produce large relative errors .\u003c/p\u003e"},{"header":"Datasets and Preprocessing","content":"\u003cdiv id=\"Sec6\" class=\"Section2\"\u003e \u003ch2\u003eSources and Schema Partitioning\u003c/h2\u003e \u003cp\u003eWe aggregated publicly available datasets and peer-reviewed research conducted between 1993\u0026ndash;2022. To ensure comparability, all datasets were ingested with a common ingestion policy defined by: (i) logging the provenance, (ii) normalizing the schema, and (iii) de-duplicating artifacts across datasets. The records were then partitioned into three self-consistent schemas according to the predominant sizing methodology employed.\u003c/p\u003e \u003cp\u003e \u003cem\u003eData sources and provenance.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eFor each of the datasets aggregated, we collected (a) classic LOC/COCOMO datasets and GitHub-hosted estimation datasets, (b) re-coded FP (Albrecht-style) samples, and (c) UCP datasets with UAW/UUCW along with TCF/ECF. For each item we retained the original source name, year of the source, and the URL/DOI (if available) for auditability.\u003c/p\u003e \u003cp\u003e \u003cem\u003eInclusion criteria.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eA record was eligible if it contained: (\u003cspan citationid=\"CR1\" class=\"CitationRef\"\u003e1\u003c/span\u003e) a valid size measure for one of the schemas and (\u003cspan citationid=\"CR2\" class=\"CitationRef\"\u003e2\u003c/span\u003e) a ground-truth effort value (hours or person-months). Optional attributes (duration in months, number of developers, sector, language, methodology, etc.) were preserved when present.\u003c/p\u003e \u003cp\u003e \u003cem\u003eExclusion and de-duplication.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eWe removed (i) exact duplicates across files (matched on project_no, title, size, effort), (ii) corrupted or unit-ambiguous rows (e.g., missing both size and effort), and (iii) entries with obviously inconsistent units (e.g., duration in days mislabeled as months) when they could not be reconciled unambiguously. When the same project appeared in multiple compilations, we kept the earliest, most complete version.\u003c/p\u003e \u003cp\u003e \u003cem\u003eSchema definitions.\u003c/em\u003e \u003c/p\u003e \u003cp\u003e \u003cul\u003e \u003cli\u003e \u003cp\u003e \u003cb\u003eLOC schema\u003c/b\u003e (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:n\\approx\\:947\\)\u003c/span\u003e\u003c/span\u003e): core fields {KLOC, Effort (PM)}; optional {Time (months), Developers}.\u003c/p\u003e \u003c/li\u003e \u003cli\u003e \u003cp\u003e \u003cb\u003eFP schema\u003c/b\u003e (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:n=24\\)\u003c/span\u003e\u003c/span\u003e, Albrecht set): core fields {FP / FP_adj, Effort (PM)}; optional {Time (months), Developers}.\u003c/p\u003e \u003c/li\u003e \u003cli\u003e \u003cp\u003e \u003cb\u003eUCP schema\u003c/b\u003e (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:n=71\\)\u003c/span\u003e\u003c/span\u003e): raw fields {UAW, UUCW, TCF, ECF, Real Effort (hours), meta}; we compute\u003c/p\u003e \u003c/li\u003e \u003c/ul\u003e \u003cdiv id=\"Equj\" class=\"Equation\"\u003e \u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equj\" name=\"EquationSource\"\u003e\n$$\\:\\text{U}\\text{C}\\text{P}=\\left(\\text{U}\\text{A}\\text{W}+\\text{U}\\text{U}\\text{C}\\text{W}\\right)\\times\\:\\text{T}\\text{C}\\text{F}\\times\\:\\text{E}\\text{C}\\text{F},$$\u003c/div\u003e \u003c/div\u003e \u003c/p\u003e \u003cp\u003e \u003cul\u003e \u003cli\u003e \u003cp\u003eand convert effort hours to person-months in Sec. 3.2.\u003c/p\u003e \u003c/li\u003e \u003c/ul\u003e \u003c/p\u003e \u003c/div\u003e"},{"header":"Unit Harmonization","content":"\u003cp\u003eTo enable cross-source learning and ensure comparability across heterogeneous datasets, we performed a systematic unit harmonization process. Without harmonization, effort data may appear in hours, days, or staff-months, while size measures differ across LOC, FP, and UCP\u0026mdash;making direct comparison infeasible. Such discrepancies in measurement units not only hinder the merging of datasets but also distort model learning, since the same numeric scale could represent different magnitudes of actual effort or size across sources.\u003c/p\u003e \u003cp\u003eSpecifically, we applied the following standardization rules:\u003c/p\u003e \u003cp\u003e \u003col\u003e \u003cspan\u003e \u003cli\u003e \u003cp\u003eLines of Code (LOC) values are converted to KLOC by dividing by 1000. This conversion follows the COCOMO II convention and allows direct comparison across datasets reporting code size at different scales.\u003c/p\u003e \u003c/li\u003e \u003c/span\u003e \u003cspan\u003e \u003cli\u003e \u003cp\u003eFunction Points (FP) and Use Case Points (UCP) are kept in their standardized forms. Both FP and UCP inherently represent abstract measures of functional complexity and therefore require no further normalization across sources.\u003c/p\u003e \u003c/li\u003e \u003c/span\u003e \u003cspan\u003e \u003cli\u003e \u003cp\u003eEffort values are converted into Person-Months (PM), assuming \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:1\\hspace{0.17em}\\text{PM}=160\\hspace{0.17em}\\text{hours}=20\\hspace{0.17em}\\text{days}\\)\u003c/span\u003e\u003c/span\u003e. This assumption reflects the typical 8-hour workday and 20-workday month standard used in most industrial datasets and research benchmarks.\u003c/p\u003e \u003c/li\u003e \u003c/span\u003e \u003cspan\u003e \u003cli\u003e \u003cp\u003eDeveloper count is inferred as \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\lceil\\:\\text{Effort}/\\text{Time}\\rceil\\:\\)\u003c/span\u003e\u003c/span\u003e when project duration (\u003cem\u003eTime\u003c/em\u003e) is available. This provides an approximate measure of team size, ensuring that effort-related ratios (e.g., productivity) are comparable across studies.\u003c/p\u003e \u003c/li\u003e \u003c/span\u003e \u003c/ol\u003e \u003c/p\u003e \u003cp\u003eThrough this harmonization process, all project records are expressed in a unified schema of size (KLOC, FP, or UCP) and effort (Person-Months), allowing consistent interpretation of productivity, scalability, and efficiency.\u003c/p\u003e \u003cp\u003e \u003c/p\u003e \u003cp\u003eComprehensive reference of unit conversions used in the harmonization process. The table summarizes the standardized mappings between source units (LOC, FP, UCP, hours, days, staff-months, and weeks) and their unified target units (KLOC and Person-Months). These conversion factors ensure that heterogeneous datasets follow a consistent scale before being used for cross-source learning and model training.\u003c/p\u003e \u003cdiv id=\"Sec8\" class=\"Section2\"\u003e \u003ch2\u003eMissing Values and Outliers\u003c/h2\u003e \u003cp\u003eAfter harmonizing measurement units across datasets, we addressed data completeness and noise to ensure statistical validity. Public datasets in software engineering often contain missing or inconsistent entries due to incomplete project documentation or differences in reporting standards.\u003c/p\u003e \u003cp\u003e \u003cem\u003eHandling missing values.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eWe dropped records missing any of the core predictive variables: \u003cem\u003esize\u003c/em\u003e (KLOC, FP, or UCP) or \u003cem\u003eeffort\u003c/em\u003e (Person-Months). For optional fields such as \u003cem\u003eTime\u003c/em\u003e (months) or \u003cem\u003eDevelopers\u003c/em\u003e, imputation was performed using the median value within the same dataset schema, reducing distortion from skewed distributions.\u003c/p\u003e \u003cp\u003e \u003cem\u003eOutlier detection and capping.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eOutliers were identified using the Interquartile Range (IQR) rule per feature dimension:\u003cdiv id=\"Equk\" class=\"Equation\"\u003e\u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equk\" name=\"EquationSource\"\u003e\n$$\\:\\begin{array}{rr}\\text{lower}\u0026amp;\\:={Q}_{1}-1.5\\times\\:\\text{IQR},\\\\\\:\\text{upper}\u0026amp;\\:={Q}_{3}+1.5\\times\\:\\text{IQR},\\\\\\:{x}_{c}\u0026amp;\\:\\leftarrow\\:\\text{c}\\text{l}\\text{i}\\text{p}\\left(x,\\text{lower},\\text{upper}\\right)\\end{array}$$\u003c/div\u003e\u003c/div\u003e\u003c/p\u003e \u003cp\u003ewhere \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{Q}_{1}\\)\u003c/span\u003e\u003c/span\u003e and \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{Q}_{3}\\)\u003c/span\u003e\u003c/span\u003e are the first and third quartiles, respectively. Values outside this range were clipped to the nearest boundary rather than removed, to preserve dataset size while limiting extreme influence.\u003c/p\u003e \u003cp\u003e \u003c/p\u003e \u003cp\u003eScatter and boxplot visualizations showing (top) size\u0026ndash;effort relationships before and after unit harmonization, and (bottom) productivity and team size trends across data sources. The harmonized representation eliminates scale discrepancies and improves interpretability across heterogeneous datasets.\u003c/p\u003e \u003cp\u003e \u003c/p\u003e \u003cp\u003eFeature contribution matrices before and after harmonization via Principal Component Analysis (PCA). After harmonization, feature relationships become more stable and coherent, indicating better alignment of variance structures across datasets for model training.\u003c/p\u003e \u003cp\u003e \u003cem\u003eInterpretation.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eAs shown in Fig.\u0026nbsp;4, harmonization and outlier handling collectively improve the coherence of data distributions. Effort\u0026ndash;size relationships across sources now align along similar log-scaled patterns, and PCA loadings reveal that dominant variance components are shared across schemas\u0026mdash; a key prerequisite for reliable cross-source model training.\u003c/p\u003e \u003c/div\u003e"},{"header":"Distribution Shaping and Correlation","content":"\u003cp\u003eSoftware project variables often exhibit right-skewed distributions, particularly in effort, size, and duration. Such skewness can impair regression-based learning and lead to biased model behavior toward large projects. To address this, we applied log-scaling transformations to normalize the distribution of effort and size metrics and enhance their linear correlation under log\u0026ndash;log representation.\u003c/p\u003e \u003cp\u003eWe first visualized the raw distributions and correlations across schemas (LOC, FP, UCP) before and after transformation. As illustrated in Figure [fig:size-effort-corr], the log\u0026ndash;log transformation reveals a clear power-law relationship between software size and development effort, indicating scale invariance commonly observed in empirical software engineering studies.\u003c/p\u003e \u003cp\u003e \u003c/p\u003e \u003cp\u003e \u003c/p\u003e \u003cp\u003e \u003c/p\u003e"},{"header":"Experimental Setup","content":"\u003cdiv id=\"Sec11\" class=\"Section2\"\u003e \u003ch2\u003eTrain\u0026ndash;Test Protocol\u003c/h2\u003e \u003cp\u003eFor each schema (LOC, FP, UCP), we construct an \u003cb\u003eindependent\u003c/b\u003e evaluation loop. Projects are split into \u003cb\u003e80% training\u003c/b\u003e and \u003cb\u003e20% test\u003c/b\u003e partitions using a stratified sampler over \u003cem\u003esize quantiles\u003c/em\u003e (five equal-frequency bins) to preserve the scale distribution across splits.\u003c/p\u003e \u003cp\u003eAll model selection happens strictly inside the training portion using \u003cb\u003e5-fold cross-validation (CV)\u003c/b\u003e with shuffling. The chosen configuration is then refit on the \u003cem\u003efull\u003c/em\u003e training set and evaluated once on the held-out test set.\u003c/p\u003e \u003cp\u003eTo reduce randomness, we repeat the entire split\u0026ndash;tune\u0026ndash;test pipeline for \u003cb\u003e10 different random seeds\u003c/b\u003e (e.g., \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{1,11,21,\\dots\\:,91\\}\\)\u003c/span\u003e\u003c/span\u003e). For any metric \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:m\\)\u003c/span\u003e\u003c/span\u003e, we report the mean and standard deviation across seeds:\u003cdiv id=\"Equl\" class=\"Equation\"\u003e\u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equl\" name=\"EquationSource\"\u003e\n$$\\:\\stackrel{⃐}{m}=\\frac{1}{S}\\sum\\:_{s=1}^{S}{m}^{\\left(s\\right)},\\:\\:\\text{s}\\text{d}\\left(m\\right)=\\sqrt{\\frac{1}{S-1}\\sum\\:_{s=1}^{S}({m}^{\\left(s\\right)}-\\stackrel{⃐}{m}{)}^{2}},$$\u003c/div\u003e\u003c/div\u003e\u003c/p\u003e \u003cp\u003ewith \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:S=10\\)\u003c/span\u003e\u003c/span\u003e. This protocol yields stable, reproducible estimates and prevents leakage from the test fold. (See Fig.\u0026nbsp;5 for a high-level flow.)\u003c/p\u003e \u003cp\u003e \u003c/p\u003e \u003cp\u003eHigh-level experimental pipeline (per schema). Data are split into \u003cb\u003e80% Training\u003c/b\u003e and \u003cb\u003e20% Test\u003c/b\u003e; \u003cb\u003e5-fold CV\u003c/b\u003e is used for tuning inside training only. The best configuration is refit on full training, evaluated once on test, and results are averaged over \u003cb\u003e10 random seeds\u003c/b\u003e.\u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec12\" class=\"Section2\"\u003e \u003ch2\u003eModeling Details\u003c/h2\u003e \u003cp\u003e \u003cem\u003eCommon Preprocessing.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eData harmonization follows Section 3: (i) convert effort to \u003cem\u003ePerson-Months (PM)\u003c/em\u003e and LOC to \u003cem\u003eKLOC\u003c/em\u003e; (ii) median imputation for optional fields (\u003cem\u003eTime, Developers\u003c/em\u003e); (iii) IQR-based outlier capping; and (iv) schema-specific feature transformations. Tree models use raw harmonized values, whereas linear models apply \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\text{l}\\text{o}\\text{g}\\left(1+x\\right)\\)\u003c/span\u003e\u003c/span\u003e transforms on size and effort with standardization of continuous covariates. For log-transformed regressions, predictions are inverted as \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\widehat{E}=\\text{e}\\text{x}\\text{p}\\left(\\widehat{z}\\right)-1\\)\u003c/span\u003e\u003c/span\u003e (PM); smearing correction was tested but negligible.\u003c/p\u003e \u003cp\u003e \u003cem\u003eModel Selection.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eHyperparameters are optimized by grid search with 5-fold CV on training data only. The main selection metric is \u003cb\u003eRMSE\u003c/b\u003e on CV hold-outs (after inverse transformation); ties are broken by lower MAE and higher \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{R}^{2}\\)\u003c/span\u003e\u003c/span\u003e.\u003c/p\u003e \u003cp\u003e \u003cem\u003eLinear Regression (LR).\u003c/em\u003e \u003c/p\u003e \u003cp\u003eTwo variants are fitted: (i) ordinary least squares on harmonized features, (ii) log\u0026ndash;log regression using \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\text{l}\\text{o}\\text{g}\\left(1+\\text{size}\\right)\\)\u003c/span\u003e\u003c/span\u003e and \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\text{l}\\text{o}\\text{g}\\left(1+\\text{effort}\\right)\\)\u003c/span\u003e\u003c/span\u003e. Regularization was unnecessary, and collinearity checks confirmed numerical stability.\u003c/p\u003e \u003cp\u003e \u003cem\u003eDecision Tree (DT).\u003c/em\u003e \u003c/p\u003e \u003cp\u003eTo balance bias\u0026ndash;variance, the following ranges are explored: \u003cem\u003emax depth\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{2\\)\u003c/span\u003e\u003c/span\u003e\u0026ndash;\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:14\\}\\)\u003c/span\u003e\u003c/span\u003e, \u003cem\u003emin samples leaf\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{1,2,5,10\\}\\)\u003c/span\u003e\u003c/span\u003e, \u003cem\u003emin samples split\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{2,5,10\\}\\)\u003c/span\u003e\u003c/span\u003e, \u003cem\u003ecriterion\u003c/em\u003e = \u0026ldquo;squared_error.\u0026rdquo; Final depth is selected for interpretability and stability.\u003c/p\u003e \u003cp\u003e \u003cem\u003eRandom Forest (RF).\u003c/em\u003e \u003c/p\u003e \u003cp\u003eWe vary ensemble size and feature sampling: \u003cem\u003en estimators\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{50\\)\u003c/span\u003e\u003c/span\u003e\u0026ndash;\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:200\\}\\)\u003c/span\u003e\u003c/span\u003e, \u003cem\u003emax features\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{0.33,0.67,1.0\\}\\)\u003c/span\u003e\u003c/span\u003e, \u003cem\u003emax depth\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{\\text{None},6\\)\u003c/span\u003e\u003c/span\u003e\u0026ndash;\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:14\\}\\)\u003c/span\u003e\u003c/span\u003e, \u003cem\u003emin samples leaf\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{1,2,5\\}\\)\u003c/span\u003e\u003c/span\u003e. Out-of-bag error is tracked as a secondary validation signal.\u003c/p\u003e \u003cp\u003e \u003cem\u003eGradient Boosting (GB).\u003c/em\u003e \u003c/p\u003e \u003cp\u003eLearning dynamics and weak-learner capacity are tuned over \u003cem\u003elearning rate\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{0.001,0.01,0.1,0.2,0.5\\}\\)\u003c/span\u003e\u003c/span\u003e, \u003cem\u003en estimators\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{50\\)\u003c/span\u003e\u003c/span\u003e\u0026ndash;\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:200\\}\\)\u003c/span\u003e\u003c/span\u003e, \u003cem\u003emax depth\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{2,3,4\\}\\)\u003c/span\u003e\u003c/span\u003e, \u003cem\u003esubsample\u003c/em\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{0.7,1.0\\}\\)\u003c/span\u003e\u003c/span\u003e. Early stopping uses a 10% internal validation split with n_iter_no_change\u0026thinsp;=\u0026thinsp;10.\u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec13\" class=\"Section2\"\u003e \u003ch2\u003eEvaluation Metrics\u003c/h2\u003e \u003cp\u003eFor each random seed (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:S=10\\)\u003c/span\u003e\u003c/span\u003e), we compute \u003cb\u003eMMRE\u003c/b\u003e, \u003cb\u003ePRED(25)\u003c/b\u003e, \u003cb\u003eMAE\u003c/b\u003e, \u003cb\u003eRMSE\u003c/b\u003e, and \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{R}^{2}\\)\u003c/span\u003e\u003c/span\u003e on the held-out test set, reporting mean \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\pm\\:\\)\u003c/span\u003e\u003c/span\u003e sd. PRED(25) is calculated after back-transforming predictions to PM. These metrics jointly capture scale-sensitive deviation (RMSE), robust central accuracy (MAE), proportional tolerance (MMRE, PRED(25)), and explained variance (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{R}^{2}\\)\u003c/span\u003e\u003c/span\u003e).\u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec14\" class=\"Section2\"\u003e \u003ch2\u003eUncertainty \u0026amp; Significance Testing\u003c/h2\u003e \u003cp\u003ePerformance differences are assessed using the \u003cb\u003epaired Wilcoxon signed-rank test\u003c/b\u003e on per-project absolute errors \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\left|\\widehat{y}-y\\right|\\)\u003c/span\u003e\u003c/span\u003e, comparing each model to the baseline (\u003cb\u003eRF\u003c/b\u003e ). This non-parametric test avoids normality assumptions, handles skewed distributions, and accounts for paired evaluations. For each pair \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\left(A,B\\right)\\)\u003c/span\u003e\u003c/span\u003e, we test:\u003cdiv id=\"Equm\" class=\"Equation\"\u003e\u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equm\" name=\"EquationSource\"\u003e\n$$\\:{H}_{0}:\\text{M}\\text{e}\\text{d}\\text{i}\\text{a}\\text{n}\\left(\\left|{\\widehat{y}}_{A}-y\\right|-\\left|{\\widehat{y}}_{B}-y\\right|\\right)=0,$$\u003c/div\u003e\u003c/div\u003e\u003c/p\u003e \u003cp\u003eat \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\alpha\\:=0.05\\)\u003c/span\u003e\u003c/span\u003e. Multiple comparisons (LR, DT, RF, GB) are corrected via the \u003cb\u003eHolm\u0026ndash;Bonferroni\u003c/b\u003e procedure. We further compute \u003cb\u003eCliff\u0026rsquo;s Delta\u003c/b\u003e (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\delta\\:\\)\u003c/span\u003e\u003c/span\u003e) to quantify effect size:\u003cdiv id=\"Equn\" class=\"Equation\"\u003e\u003cdiv format=\"TEX\" class=\"mathdisplay\" id=\"FileID_Equn\" name=\"EquationSource\"\u003e\n$$\\:\\delta\\:=\\frac{{n}_{\u0026gt;}-{n}_{\u0026lt;}}{n},$$\u003c/div\u003e\u003c/div\u003e\u003c/p\u003e \u003cp\u003einterpreted as negligible (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\left|\\delta\\:\\right|\u0026lt;0.147\\)\u003c/span\u003e\u003c/span\u003e), small (0.147\u0026ndash;0.33), medium (0.33\u0026ndash;0.474), or large (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\ge\\:0.474\\)\u003c/span\u003e\u003c/span\u003e). Combining significance and effect-size analyses ensures that improvements are both statistically valid and practically meaningful .\u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec15\" class=\"Section2\"\u003e \u003ch2\u003eImplementation \u0026amp; Reproducibility\u003c/h2\u003e \u003cp\u003eAll experiments ran in a reproducible \u003cb\u003ePython 3.10\u003c/b\u003e environment. Core libraries: scikit-learn v1.3.0, NumPy v1.26+, Pandas v2.0+, SciPy v1.11+, and Matplotlib/Seaborn. A deterministic seed set \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\{1,11,21,\\dots\\:,91\\}\\)\u003c/span\u003e\u003c/span\u003e controls data splits, CV shuffling, and ensemble bootstraps. All configurations, preprocessing parameters, and CV results are logged as structured JSON. Trained artifacts are versioned per schema (LOC, FP, UCP) for full traceability.\u003c/p\u003e \u003cp\u003eHardware was uniform: \u003cb\u003e8\u0026ndash;16 CPU cores\u003c/b\u003e, \u003cb\u003e32\u0026ndash;64 GB RAM\u003c/b\u003e, no GPU. A unified orchestration script automates: (\u003cspan citationid=\"CR1\" class=\"CitationRef\"\u003e1\u003c/span\u003e) data loading and harmonization; (\u003cspan citationid=\"CR2\" class=\"CitationRef\"\u003e2\u003c/span\u003e) train\u0026ndash;test splitting and CV; (\u003cspan citationid=\"CR3\" class=\"CitationRef\"\u003e3\u003c/span\u003e) grid search; (\u003cspan citationid=\"CR4\" class=\"CitationRef\"\u003e4\u003c/span\u003e) evaluation \u0026amp; logging; (\u003cspan citationid=\"CR5\" class=\"CitationRef\"\u003e5\u003c/span\u003e) aggregation \u0026amp; significance testing. All runs are fully deterministic and portable, aligning with reproducibility best practices in empirical software engineering .\u003c/p\u003e \u003c/div\u003e"},{"header":"Results","content":"\u003cdiv id=\"Sec17\" class=\"Section2\"\u003e \u003ch2\u003eOverall Comparison\u003c/h2\u003e \u003cp\u003e \u003cdiv class=\"gridtable\"\u003e\u003ctable float=\"Yes\" id=\"Tab1\" border=\"1\"\u003e \u003ccaption language=\"En\"\u003e \u003cdiv class=\"CaptionNumber\"\u003eTable 1\u003c/div\u003e \u003cdiv class=\"CaptionContent\"\u003e \u003cp\u003esummarizes the mean test performance across all schemas (\u003cem\u003eLOC\u003c/em\u003e, \u003cem\u003eFP\u003c/em\u003e, and \u003cem\u003eUCP\u003c/em\u003e) using the evaluation metrics defined in Section 4.3. Among the tested models, the \u003cb\u003eRandom Forest (RF)\u003c/b\u003e consistently achieved the best overall accuracy, followed by \u003cb\u003eGradient Boosting (GB)\u003c/b\u003e and \u003cb\u003eDecision Tree (DT)\u003c/b\u003e. \u003cb\u003eCOCOMO II\u003c/b\u003e, representing the classical parametric baseline, showed the weakest performance across all error metrics, while \u003cb\u003eLinear Regression (LR)\u003c/b\u003e was highly unstable due to multicollinearity and violation of linearity assumptions in the raw feature space. Overall test performance (best in \u003cb\u003ebold\u003c/b\u003e).\u003c/p\u003e \u003c/div\u003e \u003c/caption\u003e \u003ccolgroup cols=\"6\"\u003e \u003cdiv align=\"left\" class=\"colspec\" colname=\"c1\" colnum=\"1\"\u003e\u003c/div\u003e \u003cdiv align=\"char\" char=\".\" class=\"colspec\" colname=\"c2\" colnum=\"2\"\u003e\u003c/div\u003e \u003cdiv align=\"char\" char=\".\" class=\"colspec\" colname=\"c3\" colnum=\"3\"\u003e\u003c/div\u003e \u003cdiv align=\"char\" char=\".\" class=\"colspec\" colname=\"c4\" colnum=\"4\"\u003e\u003c/div\u003e \u003cdiv align=\"char\" char=\".\" class=\"colspec\" colname=\"c5\" colnum=\"5\"\u003e\u003c/div\u003e \u003cdiv align=\"left\" class=\"colspec\" colname=\"c6\" colnum=\"6\"\u003e\u003c/div\u003e \u003cthead\u003e \u003ctr\u003e \u003cth align=\"left\" colname=\"c1\"\u003e \u003cp\u003eModel\u003c/p\u003e \u003c/th\u003e \u003cth align=\"left\" colname=\"c2\"\u003e \u003cp\u003eMMRE \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\downarrow\\:\\)\u003c/span\u003e\u003c/span\u003e\u003c/p\u003e \u003c/th\u003e \u003cth align=\"left\" colname=\"c3\"\u003e \u003cp\u003ePRED(25) \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\uparrow\\:\\)\u003c/span\u003e\u003c/span\u003e\u003c/p\u003e \u003c/th\u003e \u003cth align=\"left\" colname=\"c4\"\u003e \u003cp\u003eMAE \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\downarrow\\:\\)\u003c/span\u003e\u003c/span\u003e\u003c/p\u003e \u003c/th\u003e \u003cth align=\"left\" colname=\"c5\"\u003e \u003cp\u003eRMSE \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\downarrow\\:\\)\u003c/span\u003e\u003c/span\u003e\u003c/p\u003e \u003c/th\u003e \u003cth align=\"left\" colname=\"c6\"\u003e \u003cp\u003e\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{R}^{2}\\)\u003c/span\u003e\u003c/span\u003e \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\uparrow\\:\\)\u003c/span\u003e\u003c/span\u003e\u003c/p\u003e \u003c/th\u003e \u003c/tr\u003e \u003c/thead\u003e \u003ctbody\u003e \u003ctr\u003e \u003ctd align=\"left\" colname=\"c1\"\u003e \u003cp\u003eCOCOMO\u0026nbsp;II\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c2\"\u003e \u003cp\u003e2.790\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c3\"\u003e \u003cp\u003e0.012\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c4\"\u003e \u003cp\u003e45.03\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c5\"\u003e \u003cp\u003e53.70\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"left\" colname=\"c6\"\u003e \u003cp\u003e\u0026ndash;\u003c/p\u003e \u003c/td\u003e \u003c/tr\u003e \u003ctr\u003e \u003ctd align=\"left\" colname=\"c1\"\u003e \u003cp\u003eLinear Regression\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c2\"\u003e \u003cp\u003e4.500\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c3\"\u003e \u003cp\u003e0.000\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c4\"\u003e \u003cp\u003e107.54\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c5\"\u003e \u003cp\u003e280.27\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"left\" colname=\"c6\"\u003e \u003cp\u003e\u0026ndash;\u003c/p\u003e \u003c/td\u003e \u003c/tr\u003e \u003ctr\u003e \u003ctd align=\"left\" colname=\"c1\"\u003e \u003cp\u003eDecision Tree\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c2\"\u003e \u003cp\u003e1.371\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c3\"\u003e \u003cp\u003e0.173\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c4\"\u003e \u003cp\u003e18.63\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c5\"\u003e \u003cp\u003e23.62\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"left\" colname=\"c6\"\u003e \u003cp\u003e\u0026ndash;\u003c/p\u003e \u003c/td\u003e \u003c/tr\u003e \u003ctr\u003e \u003ctd align=\"left\" colname=\"c1\"\u003e \u003cp\u003eGradient Boosting\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c2\"\u003e \u003cp\u003e1.101\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c3\"\u003e \u003cp\u003e0.198\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c4\"\u003e \u003cp\u003e16.16\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c5\"\u003e \u003cp\u003e21.09\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"left\" colname=\"c6\"\u003e \u003cp\u003e\u0026ndash;\u003c/p\u003e \u003c/td\u003e \u003c/tr\u003e \u003ctr\u003e \u003ctd align=\"left\" colname=\"c1\"\u003e \u003cp\u003e\u003cb\u003eRandom Forest\u003c/b\u003e\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c2\"\u003e \u003cp\u003e\u003cb\u003e0.647\u003c/b\u003e\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c3\"\u003e \u003cp\u003e\u003cb\u003e0.395\u003c/b\u003e\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c4\"\u003e \u003cp\u003e\u003cb\u003e12.66\u003c/b\u003e\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"char\" char=\".\" colname=\"c5\"\u003e \u003cp\u003e\u003cb\u003e20.01\u003c/b\u003e\u003c/p\u003e \u003c/td\u003e \u003ctd align=\"left\" colname=\"c6\"\u003e \u003cp\u003e\u0026ndash;\u003c/p\u003e \u003c/td\u003e \u003c/tr\u003e \u003c/tbody\u003e \u003c/colgroup\u003e \u003c/table\u003e\u003c/div\u003e \u003c/p\u003e \u003cp\u003eStatistical tests (Section 4.4) confirmed that the performance gains of RF and GB over DT and LR were \u003cem\u003estatistically significant\u003c/em\u003e (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:p\u0026lt;0.05\\)\u003c/span\u003e\u003c/span\u003e under Holm\u0026ndash;Bonferroni correction), with Cliff\u0026rsquo;s \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\delta\\:\\)\u003c/span\u003e\u003c/span\u003e effect sizes in the range of \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:0.35\\)\u003c/span\u003e\u003c/span\u003e\u0026ndash;\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:0.55\\)\u003c/span\u003e\u003c/span\u003e (medium-to-large). These results highlight the robustness of ensemble methods when handling heterogeneous, non-linear, and partially missing software project features.\u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec18\" class=\"Section2\"\u003e \u003ch2\u003eSchema-Specific Analyses\u003c/h2\u003e \u003cp\u003e \u003cem\u003eLOC Schema.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eAfter log\u0026ndash;log transformation (Section 3.4), the correlation between project size (KLOC) and effort strengthened (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\rho\\:\\approx\\:0.88\\)\u003c/span\u003e\u003c/span\u003e), supporting the multiplicative nature of software growth patterns. \u003cb\u003eRandom Forest\u003c/b\u003e achieved the lowest MMRE and RMSE, generalizing well across small and large projects. \u003cb\u003eGradient Boosting\u003c/b\u003e followed closely, benefiting from its bias\u0026ndash;variance control, while \u003cb\u003eDecision Tree\u003c/b\u003e performed moderately on mid-sized projects (20\u0026ndash;50 KLOC) but overfit smaller ones. \u003cb\u003eLinear Regression\u003c/b\u003e consistently underestimated small and overestimated large projects, confirming the limitations of linear assumptions for effort prediction.\u003c/p\u003e \u003cp\u003e \u003cem\u003eFP Schema.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eThe Function Point (FP) schema exhibited higher variability due to its small sample size (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:n=24\\)\u003c/span\u003e\u003c/span\u003e) and heterogeneous functional complexity. Traditional regression systematically overpredicted high-FP projects (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\u0026gt;300\\)\u003c/span\u003e\u003c/span\u003e FP), whereas \u003cb\u003eRandom Forest\u003c/b\u003e achieved up to 40% lower MAE and provided the best approximation to observed effort. \u003cb\u003eGradient Boosting\u003c/b\u003e ranked second but showed mild variance inflation for large projects. \u003cb\u003eDecision Tree\u003c/b\u003e produced the expected stepwise \u0026ldquo;staircase\u0026rdquo; pattern, while \u003cb\u003eLinear Regression\u003c/b\u003e yielded unstable estimates due to weak FP\u0026ndash;effort correlation. Wilcoxon tests confirmed that RF and GB significantly outperformed LR (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:p\u0026lt;0.01\\)\u003c/span\u003e\u003c/span\u003e; \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\left|\\delta\\:\\right|\\ge\\:0.47\\)\u003c/span\u003e\u003c/span\u003e).\u003c/p\u003e \u003cp\u003e \u003cem\u003eUCP Schema.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eWithin the Use Case Point (UCP) schema\u0026mdash;including UAW, UUCW, TCF, and ECF\u0026mdash;log transformation effectively corrected moderate skewness. \u003cb\u003eRandom Forest\u003c/b\u003e maintained consistent relative errors across project scales, while \u003cb\u003eGradient Boosting\u003c/b\u003e exhibited slightly higher RMSE, suggesting mild overfitting in deeper configurations. \u003cb\u003eDecision Tree\u003c/b\u003e performed comparably for medium projects (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:100\\le\\:\\text{U}\\text{C}\\text{P}\\le\\:300\\)\u003c/span\u003e\u003c/span\u003e) but degraded for larger ones, and \u003cb\u003eLinear Regression\u003c/b\u003e again struggled with non-linear dependencies. Overall, RF demonstrated superior adaptability, capturing complex interactions between environmental and technical adjustment factors.\u003c/p\u003e \u003cp\u003e \u003cem\u003eCross-Schema Discussion.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eAcross all schemas, ensemble methods (RF, GB) consistently outperformed classical parametric and linear baselines. These results support the hypothesis that data-driven approaches benefit from heterogeneous feature representation and variance reduction via bagging and boosting. The reproducibility pipeline (Section 4.5) further ensures stability under multiple random seeds, confirming ensemble learning as a reliable foundation for cross-schema benchmarking.\u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec19\" class=\"Section2\"\u003e \u003ch2\u003eError Profiles and Visual Analyses\u003c/h2\u003e \u003cp\u003eTo interpret model behavior beyond scalar metrics, we visualize prediction error distributions and learning dynamics across schemas in Figure [fig:error-profiles]. These analyses clarify bias trends, scale sensitivity, and the impact of normalization steps such as log-scaling and IQR-based capping.\u003c/p\u003e \u003cp\u003e \u003cem\u003e(a) Overall Performance.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eThe top-left panel aggregates MMRE and PRED(25) across schemas. \u003cb\u003eRandom Forest\u003c/b\u003e achieved the lowest relative error (MMRE) and highest accuracy fraction (PRED(25)\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\approx\\:40\\text{\\%}\\)\u003c/span\u003e\u003c/span\u003e), followed by \u003cb\u003eGradient Boosting\u003c/b\u003e. \u003cb\u003eLinear Regression\u003c/b\u003e and \u003cb\u003eCOCOMO II\u003c/b\u003e showed strong bias and underfitting under heteroscedastic noise.\u003c/p\u003e \u003cp\u003e \u003cem\u003e(b) LOC Error Behavior.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eAs shown in the top-right plot, tree-based models maintain stable performance across increasing project sizes, while \u003cb\u003eLinear Regression\u003c/b\u003e errors grow rapidly, violating the constant-variance assumption. \u003cb\u003eDecision Tree\u003c/b\u003e performs acceptably up to 50 KLOC but overfits smaller subsets, whereas RF and GB exhibit flat error curves\u0026mdash;indicating robustness to size heterogeneity.\u003c/p\u003e \u003cp\u003e \u003cem\u003e(c) FP Effort Trends.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eIn the bottom-left plot, \u003cb\u003eRandom Forest\u003c/b\u003e closely matches empirical effort trends, outperforming regression baselines. \u003cb\u003eGradient Boosting\u003c/b\u003e slightly overestimates large projects (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\u0026gt;\\)\u003c/span\u003e\u003c/span\u003e400 FP), and \u003cb\u003eDecision Tree\u003c/b\u003e shows discrete stepwise behavior, confirming that non-linear ensembles better model FP-based scaling.\u003c/p\u003e \u003cp\u003e \u003cem\u003e(d) Impact of Log and Outlier Control.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eThe bottom-right panel quantifies the benefit of normalization. Raw effort\u0026ndash;size correlations (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:r=0.83\\)\u003c/span\u003e\u003c/span\u003e) improve slightly after \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\text{l}\\text{o}\\text{g}\\left(1+x\\right)\\)\u003c/span\u003e\u003c/span\u003e scaling (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:r=0.84\\)\u003c/span\u003e\u003c/span\u003e) and stabilize post IQR-capping (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:r=0.81\\)\u003c/span\u003e\u003c/span\u003e). This demonstrates that harmonization and outlier control reduce distortion without sacrificing intrinsic relationships\u0026mdash;essential for fair, stable cross-schema comparisons.\u003c/p\u003e \u003cp\u003e \u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec20\" class=\"Section2\"\u003e \u003ch2\u003eDiscussion and Practical Implications\u003c/h2\u003e \u003cp\u003e \u003cem\u003eRandom Forest Superiority.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eThe consistent dominance of the \u003cb\u003eRandom Forest (RF)\u003c/b\u003e model across all schemas stems from its ensemble mechanism that aggregates multiple high-variance estimators into a low-variance predictor. By averaging bootstrapped decision trees, RF effectively captures \u003cem\u003enon-linear scaling effects\u003c/em\u003e such as power-law relationships and threshold behaviors influenced by project complexity or team productivity. Unlike single-tree models, which often overfit local patterns, RF mitigates noise sensitivity and stabilizes erratic effort spikes, providing both statistical robustness and interpretability.\u003c/p\u003e \u003cp\u003e \u003cem\u003eAlternative Model Preferences.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eWhile RF achieves the best overall accuracy, other models retain contextual value. \u003cb\u003eDecision Trees (DT)\u003c/b\u003e provide intuitive rule-based segmentation for managerial transparency. \u003cb\u003eGradient Boosting (GB)\u003c/b\u003e yields slightly higher accuracy when tuned carefully but may overfit smaller datasets. Meanwhile, \u003cb\u003eCOCOMO II\u003c/b\u003e and \u003cb\u003eLinear Regression (LR)\u003c/b\u003e remain useful baselines for early-phase scoping, offering interpretability when historical data are limited.\u003c/p\u003e \u003cp\u003e \u003cem\u003eGuidelines for Adoption.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eThe findings suggest a staged adoption strategy: (i) \u003cem\u003eInception\u003c/em\u003e \u0026mdash; use interpretable models (COCOMO II, DT) for early communication and feasibility; (ii) \u003cem\u003eCalibration\u003c/em\u003e \u0026mdash; introduce GB to refine accuracy as project telemetry becomes available; (iii) \u003cem\u003eMaturity\u003c/em\u003e \u0026mdash; employ RF for production-grade estimation integrated into PM dashboards for adaptive, data-driven forecasting. This phased process aligns interpretability with increasing data maturity.\u003c/p\u003e \u003cp\u003e \u003cem\u003ePractical Insights and Validity.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eEnsemble learning significantly reduces uncertainty in early project budgeting and enables continuous recalibration from evolving metrics, forming a \u003cem\u003eliving estimation system\u003c/em\u003e rather than static forecasting. Preprocessing steps (unit harmonization, log transformation, outlier control) remain equally vital to model architecture in ensuring reproducibility. Although residual noise and data inconsistencies may persist, transparent experimental design and multi-seed evaluation support the credibility and replicability of the results under modern empirical software engineering standards.\u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec21\" class=\"Section2\"\u003e \u003ch2\u003eThreats to Validity\u003c/h2\u003e \u003cp\u003eDespite rigorous experimentation and reproducibility controls, several validity threats may affect the interpretation and generalizability of our findings. We categorize them following standard empirical software engineering practice into \u003cem\u003einternal\u003c/em\u003e, \u003cem\u003eexternal\u003c/em\u003e, \u003cem\u003econstruct\u003c/em\u003e, and \u003cem\u003econclusion\u003c/em\u003e validity.\u003c/p\u003e \u003cp\u003e \u003cem\u003eInternal Validity.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eThis aspect concerns whether observed outcomes genuinely arise from the modeled variables rather than uncontrolled factors. Although data preprocessing (unit harmonization, IQR capping, schema partitioning) reduces inconsistencies, residual noise in public datasets may persist\u0026mdash; for example, incomplete project documentation or varying productivity conventions. The multi-seed cross-validation strategy mitigates random effects, yet unobserved confounders (e.g., domain-specific tools) could still influence effort distributions.\u003c/p\u003e \u003cp\u003e \u003cem\u003eExternal Validity.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eOur conclusions are derived mainly from open and legacy datasets (1993\u0026ndash;2022) across LOC-, FP-, and UCP-based schemas. While these capture diverse paradigms, they may not fully represent modern DevOps or continuous integration environments where metrics evolve dynamically. Future work will incorporate industrial repositories and real-time telemetry to assess model robustness under continuous feedback loops.\u003c/p\u003e \u003cp\u003e \u003cem\u003eConstruct Validity.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eEffort and size metrics inherently vary across organizations\u0026mdash; from person-hours to adjusted person-months\u0026mdash; and may embed subjectivity in Function Point or Use Case Point estimation. Although the harmonization framework (Section 3.2) standardizes units, measurement bias remains possible. To address metric limitations (e.g., MMRE, PRED(25)), we complement them with absolute-error (MAE, RMSE) and variance-explained (\u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{R}^{2}\\)\u003c/span\u003e\u003c/span\u003e) measures.\u003c/p\u003e \u003cp\u003e \u003cem\u003eConclusion Validity.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eStatistical inference reliability was reinforced through Wilcoxon signed-rank tests with Holm\u0026ndash;Bonferroni correction and effect-size reporting via Cliff\u0026rsquo;s \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\delta\\:\\)\u003c/span\u003e\u003c/span\u003e (Section 4.4). Nevertheless, multiple comparisons can increase Type II error risk, especially for small-sample schemas (e.g., FP, \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:n=24\\)\u003c/span\u003e\u003c/span\u003e). Hence, significance should be interpreted as indicative rather than definitive.\u003c/p\u003e \u003cp\u003e \u003cem\u003eSummary.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eWhile these threats cannot be entirely removed, transparent experimental design, multi-seed repetition, and open methodological reporting substantially mitigate their impact. Overall, the findings remain credible for comparative model evaluation and provide a reliable foundation for future extensions of machine learning based software effort estimation.\u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec22\" class=\"Section2\"\u003e \u003ch2\u003eRelated Work\u003c/h2\u003e \u003cdiv id=\"Sec23\" class=\"Section3\"\u003e \u003ch2\u003eEvolution of Software Effort Estimation Methods\u003c/h2\u003e \u003cp\u003eSoftware Effort Estimation (SEE) has evolved over four decades, transitioning from rule based and parametric approaches to hybrid and data-driven paradigms. The seminal \u003cb\u003eCOCOMO\u003c/b\u003e model by Boehm (1981) established an empirically grounded estimation framework, followed by \u003cb\u003eFunction Points\u003c/b\u003e (Albrecht, 1979) and \u003cb\u003eUse Case Points\u003c/b\u003e (Karner, 1993), which extended measurement granularity to functional and behavioral complexity. Since the 2000s, studies have introduced early ML models\u0026mdash;linear regression, decision trees, neural networks, and SVMs\u0026mdash;gradually shifting toward \u003cb\u003eensemble learning\u003c/b\u003e and \u003cb\u003edeep models\u003c/b\u003e (e.g., Random Forest, Gradient Boosting, and hybrid ensembles ). Despite improved accuracy, issues of \u003cem\u003ereproducibility\u003c/em\u003e and \u003cem\u003ecross-schema comparability\u003c/em\u003e (LOC, FP, UCP) remain insufficiently explored.\u003c/p\u003e \u003c/div\u003e \u003c/div\u003e \u003cdiv id=\"Sec24\" class=\"Section2\"\u003e \u003ch2\u003eComparison of Estimation Paradigms\u003c/h2\u003e \u003cp\u003eFigure [fig:related-work] (top-right) contrasts four major paradigms: (i) traditional parametric, (ii) early ML, (iii) ensemble learning, and (iv) the proposed \u003cb\u003eEnhanced COCOMO II\u003c/b\u003e. Parametric models prioritize interpretability but lack adaptability. Basic ML models improve accuracy yet often lose transparency. Ensemble methods achieve the most balanced trade off between \u003cem\u003eaccuracy\u003c/em\u003e, \u003cem\u003eadaptability\u003c/em\u003e, and \u003cem\u003eease of use\u003c/em\u003e. Our Enhanced COCOMO II retains COCOMO\u0026rsquo;s explainable structure while embedding data-driven residual corrections, bridging classical transparency and modern predictive robustness.\u003c/p\u003e \u003cdiv id=\"Sec25\" class=\"Section3\"\u003e \u003ch2\u003eValidity Gaps in Prior Studies\u003c/h2\u003e \u003cp\u003ePrior SEE research often overlooked systematic validation and reproducibility analysis. Reviews such as Kitchenham et al. and Foss et al. identify \u003cb\u003einternal\u003c/b\u003e and \u003cb\u003econstruct validity\u003c/b\u003e as recurring risks, stemming from inconsistent data curation and subjective FP/UCP sizing. Recent studies emphasize transparency and open science, yet few works implement explicit unit harmonization or standardized evaluation pipelines.\u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec26\" class=\"Section3\"\u003e \u003ch2\u003eResearch Gap and Contribution\u003c/h2\u003e \u003cp\u003eAcross the SEE literature, research has advanced through four dimensions \u003cem\u003etheory formation\u003c/em\u003e, \u003cem\u003emodel development\u003c/em\u003e, \u003cem\u003eempirical validation\u003c/em\u003e, and \u003cem\u003eindustry adoption\u003c/em\u003e. While traditional models dominate theoretical grounding and ML excels in model design, few efforts bridge validation with practical deployment. Our contribution fills this void by introducing a \u003cb\u003ereproducible, cross-schema ensemble framework\u003c/b\u003e that merges statistical transparency (COCOMO lineage) with modern predictive accuracy (Random Forest / Gradient Boosting), supporting both academic benchmarking and real world software project estimation.\u003c/p\u003e \u003cp\u003e \u003c/p\u003e \u003c/div\u003e \u003cdiv id=\"Sec27\" class=\"Section3\"\u003e \u003ch2\u003eConclusion and Reproducibility\u003c/h2\u003e \u003cp\u003e \u003cem\u003eSummary of Findings.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eThis study introduced a unified cross-schema framework for software effort estimation, enabling systematic benchmarking across LOC-, FP-, and UCP-based representations. Through harmonized preprocessing and a comprehensive model comparison, ensemble learners\u0026mdash;most notably \u003cb\u003eRandom Forest\u003c/b\u003e\u0026mdash; demonstrated consistently superior predictive performance relative to classical parametric approaches such as COCOMO II and single-model baselines. The capacity of variance-reducing ensembles to capture non-linear scaling behaviors, while maintaining interpretable variable importance, underscores their suitability for heterogeneous software project data. Meanwhile, the \u003cb\u003eEnhanced COCOMO II\u003c/b\u003e configuration achieved competitive accuracy with full transparency, highlighting a practical middle ground between interpretability and performance. These results corroborate findings in recent literature on hybrid and ensemble-based effort estimation .\u003c/p\u003e \u003cp\u003e \u003cem\u003eReproducibility Framework.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eReproducibility was enforced through standardized data harmonization, deterministic preprocessing pipelines, fixed random seeds, and structured experiment logging. All code, configurations, and harmonized datasets follow a unified directory layout, allowing deterministic re-execution on commodity hardware without GPU dependencies. This design aligns with recommended best practices in empirical software engineering for conducting transparent and repeatable experimental studies. The unified schema further supports future comparison studies by ensuring consistent feature representations across LOC, FP, and UCP data sources.\u003c/p\u003e \u003cp\u003e \u003cem\u003eFuture Directions.\u003c/em\u003e \u003c/p\u003e \u003cp\u003ePromising extensions of this research include: (i) enriching datasets with industrial metadata such as DevOps telemetry, team productivity indicators, and repository signals; (ii) incorporating process-level features (e.g., issue churn, code volatility); (iii) adopting transfer learning and domain adaptation to enhance cross-organizational robustness; and (iv) deploying ensemble estimators in real project management environments for continuous calibration and real-time forecasting. Such directions will help close the gap between academic research and operational project decision-making.\u003c/p\u003e \u003cp\u003e \u003cem\u003eClosing Remarks.\u003c/em\u003e \u003c/p\u003e \u003cp\u003eThe unified framework proposed in this study provides a reproducible, transparent, and extensible foundation for cross-schema benchmarking in software effort estimation. By integrating methodological rigor, schema harmonization, and comprehensive evaluation, this work moves toward a \u003cem\u003eliving estimation system\u003c/em\u003e\u0026mdash;one that evolves with new telemetry and real-world project dynamics. We hope this framework will support practitioners, researchers, and tool builders in creating more adaptive, evidence-based estimation solutions.\u003c/p\u003e \u003cp\u003e \u003c/p\u003e \u003c/div\u003e \u003c/div\u003e \u003cdiv id=\"Sec28\" class=\"Section2\"\u003e \u003ch2\u003eData Availability\u003c/h2\u003e \u003cp\u003eAll datasets used in this study are publicly available and were collected from open-access software engineering repositories. No proprietary or private data were used. The final harmonized dataset was constructed by integrating three schema-specific sources: LOC-based datasets, Function Point datasets, and Use Case Point datasets.\u003c/p\u003e \u003cp\u003ePublic sources include:\u003c/p\u003e \u003cp\u003e \u003cul\u003e \u003cli\u003e \u003cp\u003e \u003cb\u003eDASE \u0026ndash; Data Analysis in Software Engineering\u003c/b\u003e \u003cspan class=\"ExternalRef\"\u003e\u003cspan class=\"RefSource\"\u003ehttps://github.com/danrodgar/DASE\u003c/span\u003e\u003cspan address=\"https://github.com/danrodgar/DASE\" targettype=\"URL\" class=\"RefTarget\"\u003e\u003c/span\u003e\u003c/span\u003e\u003c/p\u003e \u003c/li\u003e \u003cli\u003e \u003cp\u003e \u003cb\u003eSoftware Estimation Datasets (Derek Jones)\u003c/b\u003e \u003cspan class=\"ExternalRef\"\u003e\u003cspan class=\"RefSource\"\u003ehttps://github.com/Derek-Jones/Software-estimation-datasets\u003c/span\u003e\u003cspan address=\"https://github.com/Derek-Jones/Software-estimation-datasets\" targettype=\"URL\" class=\"RefTarget\"\u003e\u003c/span\u003e\u003c/span\u003e\u003c/p\u003e \u003c/li\u003e \u003cli\u003e \u003cp\u003e \u003cb\u003eSoftware Project Development Estimator (Freeman et al.)\u003c/b\u003e \u003cspan class=\"ExternalRef\"\u003e\u003cspan class=\"RefSource\"\u003ehttps://github.com/Freeman-md/software-project-development-estimator\u003c/span\u003e\u003cspan address=\"https://github.com/Freeman-md/software-project-development-estimator\" targettype=\"URL\" class=\"RefTarget\"\u003e\u003c/span\u003e\u003c/span\u003e\u003c/p\u003e \u003c/li\u003e \u003cli\u003e \u003cp\u003e \u003cb\u003eISBSG-derived FP dataset / Pre-trained Model (Huynh et al.)\u003c/b\u003e \u003cspan class=\"ExternalRef\"\u003e\u003cspan class=\"RefSource\"\u003ehttps://github.com/huynhhoc/effort-estimation-by-using-pre-trained-model\u003c/span\u003e\u003cspan address=\"https://github.com/huynhhoc/effort-estimation-by-using-pre-trained-model\" targettype=\"URL\" class=\"RefTarget\"\u003e\u003c/span\u003e\u003c/span\u003e\u003c/p\u003e \u003c/li\u003e \u003c/ul\u003e \u003c/p\u003e \u003cp\u003eEach repository provides schema-specific project records (LOC, FP, or UCP) with effort values in hours or person-months. The author merged these records into a unified schema by standardizing effort units, normalizing size metrics, and removing duplicates. Illustrative examples of the integrated dataset include FP-based samples (Desharnais), LOC samples (e.g., project_id/loc/kloc/effort_pm), and UCP samples (Silhavy et al.).\u003c/p\u003e \u003cp\u003eThe harmonized dataset and preprocessing scripts can be obtained from the corresponding author upon reasonable request. All data used in this work are anonymized and contain no personal or sensitive information.\u003c/p\u003e \u003c/div\u003e"},{"header":"Declarations","content":"\u003cp\u003e \u003ch2\u003eCompeting Interests\u003c/h2\u003e \u003cp\u003eThe authors declare that they have no competing interests.\u003c/p\u003e \u003c/p\u003e \u003cp\u003e \u003cstrong\u003eEthics Approval and Consent to Participate\u003c/strong\u003e \u003cp\u003eThis study uses only publicly available, fully anonymized datasets. No human participants or personal data were involved; therefore, ethics approval and formal consent were not required.\u003c/p\u003e \u003c/p\u003e \u003cp\u003e \u003cstrong\u003eConsent for Publication\u003c/strong\u003e \u003cp\u003eNot applicable.\u003c/p\u003e \u003c/p\u003e\u003cp\u003e \u003ch2\u003eDuc Man Nguyen\u003c/h2\u003e \u003cp\u003eSupervision, Technical Guidance, Methodology Refinement, Writing \u0026ndash; Review \u0026amp; Editing.\u003c/p\u003e \u003c/p\u003e \u003cp\u003e \u003cstrong\u003eDang Nhat Minh\u003c/strong\u003e \u003cp\u003eData Curation, Feature Engineering Support, Implementation Assistance, Writing \u0026ndash; Editing.\u003c/p\u003e \u003c/p\u003e \u003cp\u003e \u003cstrong\u003eNguyen Thuy Giang\u003c/strong\u003e \u003cp\u003eResources, Validation, Consistency Checking, Documentation Support.\u003c/p\u003e \u003c/p\u003e\u003cp\u003e \u003ch2\u003e \u003cb\u003eP. W. C. Prasad\u003c/b\u003e \u003c/h2\u003e \u003cp\u003eSenior Supervision, Project Administration, Strategic Direction, Final Approval of the Manuscript.\u003c/p\u003e \u003c/p\u003e\u003cp\u003e \u003ch2\u003eMd Shohel Sayeed (Corresponding Author)\u003c/h2\u003e \u003cp\u003eValidation, Technical Review, Writing \u0026ndash; Review \u0026amp; Editing, Final Manuscript Coordination.\u003c/p\u003e \u003c/p\u003e\u003ch2\u003eFunding\u003c/h2\u003e \u003cp\u003eThis research received no specific grant from any funding agency in the public, commercial, or not-for-profit sectors.\u003c/p\u003e\u003ch2\u003eAuthor Contribution\u003c/h2\u003e\u003cp\u003e**Nguyen Nhat Huy** : Conceptualization, Dataset Preparation, Methodology, Software Development, Experiments, Formal Analysis, Visualization, Writing \u0026ndash; Original Draft.**Duc Man Nguyen** : Supervision, Technical Guidance, Methodology Refinement, Writing \u0026ndash; Review \u0026amp; Editing.**Dang Nhat Minh** : Data Curation, Feature Engineering Support, Implementation Assistance, Writing \u0026ndash; Editing.**Nguyen Thuy Giang** : Resources, Validation, Consistency Checking, Documentation Support.**P.\u0026nbsp;W.\u0026nbsp;C.\u0026nbsp;Prasad** : Senior Supervision, Project Administration, Strategic Direction, Final Approval of the Manuscript.**Md Shohel Sayeed (Corresponding Author)** : Validation, Technical Review, Writing \u0026ndash; Review \u0026amp; Editing, Final Manuscript Coordination.All authors read and approved the final manuscript.\u003c/p\u003e\u003ch2\u003eData Availability\u003c/h2\u003e\u003cp\u003eAll datasets used in this study are publicly available and were collected from open-access software engineering repositories. No proprietary or private data were used. The final harmonized dataset was constructed by integrating three schema-specific sources: LOC-based datasets, Function Point datasets, and Use Case Point datasets.Public sources include:- **DASE \u0026ndash; Data Analysis in Software Engineering** [https://github.com/danrodgar/DASE](https:/github.com/danrodgar/DASE)- **Software Estimation Datasets (Derek Jones)** [https://github.com/Derek-Jones/Software-estimation-datasets](https:/github.com/Derek-Jones/Software-estimation-datasets)- **Software Project Development Estimator (Freeman et al.)** [https://github.com/Freeman-md/software-project-development-estimator](https:/github.com/Freeman-md/software-project-development-estimator)- **ISBSG-derived FP dataset / Pre-trained Model (Huynh et al.)** [https://github.com/huynhhoc/effort-estimation-by-using-pre-trained-model](https:/github.com/huynhhoc/effort-estimation-by-using-pre-trained-model)Each repository provides schema-specific project records (LOC, FP, or UCP) with effort values in hours or person-months. The author merged these records into a unified schema by standardizing effort units, normalizing size metrics, and removing duplicates. Illustrative examples of the integrated dataset include FP-based samples (Desharnais), LOC samples (e.g., project_id/loc/kloc/effort_pm), and UCP samples (Silhavy et al.).The harmonized dataset and preprocessing scripts can be obtained from the corresponding author upon reasonable request. All data used in this work are anonymized and contain no personal or sensitive information.\u003c/p\u003e"},{"header":"References","content":"\u003col\u003e\u003cli\u003e\u003cspan\u003eBarry Boehm. COCOMO II Model Definition Manual. USC; 2000.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eMuhammad Tanveer I, Hussain N, Zahid, et al. A survey on machine learning techniques for software effort estimation: Trends, challenges, and opportunities. J Syst Softw. 2023;200:111618.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eMohammad Azzeh and Ali Bou Nassif. Cross-company effort estimation using ensemble learning and feature selection. Empir Softw Eng. 2019;24(6):3821\u0026ndash;48.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eKitchenham B, Pickard L, MacDonell S, Shepperd M. Evaluating software engineering prediction systems. \u0026lrm;Inf Softw Technol. 2001;43(11):733\u0026ndash;43.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eTore Foss E, Stensrud B, Kitchenham, Myrtveit I. A simulation study of the model evaluation criterion mmre. IEEE Trans Software Eng. 2003;29(11):985\u0026ndash;95.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eFrank Wilcoxon. Individual comparisons by ranking methods. Biometrics Bull. 1945;1(6):80\u0026ndash;3.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eLeo Breiman. Random forests. Mach Learn. 2001;45(1):5\u0026ndash;32.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eSture Holm. A simple sequentially rejective multiple test procedure. Scand J Stat. 1979;6(2):65\u0026ndash;70.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eMacbeth G. Esteban Razumiejczyk, and Rub\u0026eacute;n Ledesma. Cliff\u0026rsquo;s delta calculator: A non-parametric effect size program for two groups of observations. Universitas Physiol. 2011;10(2):545\u0026ndash;55.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eJanez Demšar. Statistical comparisons of classifiers over multiple data sets. J Mach Learn Res. 2006;7:1\u0026ndash;30.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eGarcia S, Fernandez A, Luengo J, Herrera F. Advanced nonparametric tests for multiple comparisons in computational intelligence and data mining. Inf Sci. 2010;180(10):2044\u0026ndash;64.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eFabian, Pedregosa, et al. Scikit-learn: Machine learning in python. J Mach Learn Res. 2011;12:2825\u0026ndash;30.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eLuis Cruz and Rui Abreu. Open science in software engineering research: The case for open data and replication. Empir Softw Eng. 2019;24(6):3829\u0026ndash;49.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eBelen Lopez JC, Rodriguez, Garcia S. Empirical software engineering reproducibility: A systematic review. \u0026lrm;Inf Softw Technol. 2021;136:106579.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eJerome H, Friedman. Greedy function approximation: A gradient boosting machine. Ann Stat, pages 1189\u0026ndash;232, 2001.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003ePandey P, Sharma T, Saha S. Hybrid ensemble learning for software effort estimation using meta-heuristic optimization. Appl Soft Comput. 2023;135:110054.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eAlqadi A, Abran A. Deep learning models for software effort estimation: An empirical study. IEEE Access. 2021;9:135012\u0026ndash;26.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eVineeth Nair and Tim Menzies. Open problems in reproducibility, replication, and transparency in software engineering. In \u003cem\u003eProceedings of the 42nd International Conference on Software Engineering: New Ideas and Emerging Results\u003c/em\u003e, pages 1\u0026ndash;4. IEEE, 2020.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eMuhammad Tanveer I, Hussain N, Zahid, et al. A comprehensive analysis of ensemble learning models for software effort estimation. IEEE Access. 2023;11:76590\u0026ndash;608.\u003c/span\u003e\u003c/li\u003e \u003cli\u003e\u003cspan\u003eXia YYX, Lo D, Ahmed E, Hassan. Transfer learning in software engineering: A systematic mapping study. Empir Softw Eng. 2021;26(3):1\u0026ndash;46.\u003c/span\u003e\u003c/li\u003e\u003c/ol\u003e"},{"header":"Unsectioned Paragraphs","content":"\u003cp\u003e\u003cb\u003eIntroduction\u003c/b\u003e\u003c/p\u003e\u003cp\u003eAccurately estimating software development effort is a critical factor in determining the success of software projects. Reliable estimates support effective planning, budgeting, resource allocation, and risk management. Conversely, inaccurate estimates often result in cost overruns, schedule delays, and even project failure, as widely acknowledged in the empirical software engineering literature. As modern software projects continue to grow in diversity\u0026mdash;varying in size, methodology, domain, and team structure\u0026mdash;the challenge of producing consistent and trustworthy effort estimates becomes increasingly pronounced.\u003c/p\u003e\u003cp\u003eA wide range of factors affect estimation accuracy, including project size, functional complexity, development methodology, team capability, and organizational context. Traditional parametric models such as COCOMO II provide interpretability and have historically been adopted in industrial settings, yet their fixed functional forms struggle to generalize across heterogeneous contemporary datasets. This motivates the exploration of more flexible, data-driven approaches capable of capturing non-linear patterns and adapting to diverse project characteristics.\u003c/p\u003e\u003cp\u003eIn this work, we address these challenges by designing a unified machine-learning framework for software effort estimation. Specifically, this study pursues three objectives: (i) to develop an integrated estimation framework that supports three major sizing schemas\u0026mdash;Lines of Code (LOC), Function Points (FP), and Use Case Points (UCP); (ii) to empirically compare the performance of multiple machine-learning regressors against the widely used COCOMO II model using standard evaluation metrics such as MMRE, PRED(25), MAE, RMSE, and \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{R}^{2}\\)\u003c/span\u003e\u003c/span\u003e; and (iii) to analyze the behavior of each model within individual sizing schemas in order to provide practical insights for software project managers.\u003c/p\u003e\u003cp\u003eThe contributions of this paper are summarized as follows:\u003c/p\u003e\u003cp\u003e\u003cul\u003e \u003cli\u003e \u003cp\u003eWe propose a unified multi-schema machine-learning framework that harmonizes preprocessing, feature construction, model training, and evaluation across LOC, FP, and UCP.\u003c/p\u003e \u003c/li\u003e \u003cli\u003e \u003cp\u003eWe conduct a comprehensive empirical comparison involving four representative ML models and the COCOMO II baseline on publicly available datasets spanning 1993\u0026ndash;2022.\u003c/p\u003e \u003c/li\u003e \u003cli\u003e \u003cp\u003eWe provide schema-specific analyses to examine how input representation (KLOC, FP, UCP) influences predictive accuracy.\u003c/p\u003e \u003c/li\u003e \u003cli\u003e \u003cp\u003eWe offer practical implications for applying machine-learning-based effort estimation in real-world software engineering environments.\u003c/p\u003e \u003c/li\u003e \u003c/ul\u003e\u003c/p\u003e\u003cp\u003eAll authors read and approved the final manuscript.\u003c/p\u003e"}],"fulltextSource":"","fullText":"","funders":[],"hasAdminPriorityOnWorkflow":false,"hasManuscriptDocX":false,"hasOptedInToPreprint":true,"hasPassedJournalQc":"","hasAnyPriority":false,"hideJournal":true,"highlight":"","institution":"","isAcceptedByJournal":false,"isAuthorSuppliedPdf":true,"isDeskRejected":"","isHiddenFromSearch":false,"isInQc":false,"isInWorkflow":false,"isPdf":false,"isPdfUpToDate":true,"isWithdrawnOrRetracted":false,"journal":{"display":true,"email":"[email protected]","identity":"researchsquare","isNatureJournal":false,"hasQc":true,"allowDirectSubmit":true,"externalIdentity":"","sideBox":"","snPcode":"","submissionUrl":"/submission","title":"Research Square","twitterHandle":"researchsquare","acdcEnabled":true,"dfaEnabled":false,"editorialSystem":"","reportingPortfolio":"","inReviewEnabled":false,"inReviewRevisionsEnabled":true},"keywords":"Effort estimation, COCOMO II, machine learning, Random Forest, Gradient Boosting, LOC, FP, UCP","lastPublishedDoi":"10.21203/rs.3.rs-8623983/v1","lastPublishedDoiUrl":"https://doi.org/10.21203/rs.3.rs-8623983/v1","license":{"name":"CC BY 4.0","url":"https://creativecommons.org/licenses/by/4.0/"},"manuscriptAbstract":"\u003cp\u003eAccurate estimation of software development effort remains a longstanding challenge in project management, particularly as contemporary projects exhibit greater heterogeneity in scale, methodology, and complexity. While traditional parametric models such as COCOMO II offer interpretability, their fixed functional forms often underfit diverse modern datasets. This paper proposes a unified machine-learning\u0026ndash;based framework designed to improve estimation accuracy across three widely used sizing schemas: Lines of Code (LOC), Function Points (FP), and Use Case Points (UCP). The framework integrates standardized preprocessing, schema-specific feature engineering, and a set of representative regression models, including Linear Regression, Decision Tree, Random Forest, and Gradient Boosting. Using publicly available datasets collected from prior studies spanning 1993\u0026ndash;2022, we conduct a comprehensive evaluation based on established effort-estimation metrics (MMRE, PRED(25), MAE, RMSE, and \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:{R}^{2}\\)\u003c/span\u003e\u003c/span\u003e). Experimental results show that Random Forest achieves the best overall performance (MMRE \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\approx\\:0.647\\)\u003c/span\u003e\u003c/span\u003e; PRED(25) \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\approx\\:0.395\\)\u003c/span\u003e\u003c/span\u003e), substantially outperforming COCOMO II, which exhibits poor predictive accuracy on heterogeneous datasets (MMRE \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\approx\\:2.790\\)\u003c/span\u003e\u003c/span\u003e; PRED(25) \u003cspan class=\"InlineEquation\"\u003e\u003cspan class=\"mathinline\"\u003e\\(\\:\\approx\\:0.012\\)\u003c/span\u003e\u003c/span\u003e). In addition, we perform a schema-by-schema comparison to highlight the sensitivity of different models to LOC, FP, and UCP representations. The findings demonstrate that data-driven approaches generalize more effectively across diverse project contexts, offering actionable insights for practitioners seeking reliable and scalable software effort estimation.\u003c/p\u003e","manuscriptTitle":"Insightimate: Enhancing Software Effort Estimation Accuracy Using Machine Learning Across Three Schemas (LOC/FP/UCP)","msid":"","msnumber":"","nonDraftVersions":[{"code":1,"date":"2026-02-02 08:52:00","doi":"10.21203/rs.3.rs-8623983/v1","editorialEvents":[{"type":"communityComments","content":0}],"status":"published","journal":{"display":true,"email":"[email protected]","identity":"researchsquare","isNatureJournal":false,"hasQc":true,"allowDirectSubmit":true,"externalIdentity":"","sideBox":"","snPcode":"","submissionUrl":"/submission","title":"Research Square","twitterHandle":"researchsquare","acdcEnabled":true,"dfaEnabled":false,"editorialSystem":"","reportingPortfolio":"","inReviewEnabled":false,"inReviewRevisionsEnabled":true}}],"origin":"","ownerIdentity":"b1a87005-1069-4ef6-8258-16c2eac1d0bf","owner":[],"postedDate":"February 2nd, 2026","published":true,"recentEditorialEvents":[],"rejectedJournal":[],"revision":"","amendment":"","status":"posted","subjectAreas":[],"tags":[],"updatedAt":"2026-02-18T09:27:54+00:00","versionOfRecord":[],"versionCreatedAt":"2026-02-02 08:52:00","video":"","vorDoi":"","vorDoiUrl":"","workflowStages":[]},"version":"v1","identity":"rs-8623983","journalConfig":"researchsquare"},"__N_SSP":true},"page":"/article/[identity]/[[...version]]","query":{"redirect":"/article/rs-8623983","identity":"rs-8623983","version":["v1"]},"buildId":"XKTyCvWXoU3ODBz1xrDgd","isFallback":false,"isExperimentalCompile":false,"dynamicIds":[84888],"gssp":true,"scriptLoader":[]}