The proposed system employs a multi-model architecture encapsulated ( Figure 1 ) in the SuperHyperBudgetingModel class, which includes:

Historical and synthetic project data are collected and structured in Excel sheets. Real-world project management records are also incorporated to enhance data authenticity. The data are stored in Excel sheets for easy access and manipulation.

The dataset comprises 39 real-world software development projects spanning 2020-2024, covering domains such as education platforms, internal business tools, and SaaS applications. Each project includes features like team size, estimated cost, duration, and financial metrics (e.g., gross profit, net income). Synthetic records were generated using Gaussian noise and sampling from historical distributions to augment the dataset for model robustness. Basic validation involved checking value ranges, correlation patterns, and visual inspections. All proprietary data were anonymized, and ethical considerations were followed to preserve confidentiality.

The system adopts a hybrid approach that combines traditional machine learning techniques with deep learning architectures to enhance prediction accuracy and flexibility. The core of the system is the SuperHyperBudgetingModel, a unified architecture that integrates multiple AI components into a single modular framework. Each sub-model is trained on specific types of data (e.g., project-level features or financial time-series data) but is managed and deployed through a centralized model class. This design ensures consistent training, inference, and maintainability, without the need for ensemble voting or parallel execution.

All components of the SuperHyperBudgetingModel are encapsulated within a modular codebase, designed for scalability and reusability. The complete implementation, including training procedures and model architecture, is available in Appendix A of this paper.

Trained models predict project budgets based on user inputs. Predictions are automatically saved back into Excel sheets for easy accessibility. The entire solution is deployed as a Django web application interface, allowing users to upload Excel files, perform predictions, and visualize results interactively. Key technologies leveraged include:

Following the framework proposed by Fakhry (2024) [6] , Excel is seamlessly integrated with Python through the Django web framework:

Users initiate prediction requests via Excel. Requests are routed through Django’s urls.py and views.py, where Python functions process the data and invoke the machine learning models. Predictions are returned to Excel for visualization and reporting.

Libraries include pandas, scikit-learn, TensorFlow, seaborn, plotly, and xlwings. The development environment consists of Visual Studio Code, Django Framework, and the Excel Desktop application.

This integration combines Python’s powerful machine learning capabilities with Excel’s familiar user interface, enabling real-time data processing and visualization within Excel. It provides an accessible platform for project managers without deep technical expertise.

Testing is conducted on computers equipped with Visual Studio Code, Excel, Django, and the required Python libraries.

Initial computation times and accuracy are recorded for Excel-only models. Results are then compared with Python-enhanced models to assess performance gains.

A lease cash flow model from the financial domain is used to validate the framework. Resource allocation scenarios are tested with and without AI integration to assess improvements.

Linear programming, neural networks, and genetic algorithms are used to optimize the distribution of personnel and equipment.

Predictive models analyze trends to forecast future resource needs and project costs.

AI models provide real-time project updates, enabling managers to adjust resource allocations dynamically.

Genetic algorithms rank tasks based on importance and constraints, ensuring critical activities receive timely resources.

The Django framework was employed to develop a web-based interface for the AI-powered budget prediction system ( Figure 2 ). The project architecture consists of three main views, each corresponding to a key system component. Django templates were designed to capture user input and display results dynamically. Django’s Object-Relational Mapping (ORM) facilitates efficient interaction with the underlying database, ensuring secure data storage and retrieval.

Integration with Excel ( Figure 3 ) was achieved using the xlwings library, enabling seamless interaction between the Django web application and Excel spreadsheets. This allowed the user to input project parameters and receive predictive outputs without leaving the Excel environment, ensuring accessibility for non-technical users while maintaining a Python backend’s flexibility and computational power.

Experiments were conducted using both real-world and synthetic datasets. The datasets included project features such as project_input_fields and financial_input_fields. The data was split as follows:

Standardization was applied to maintain consistent feature scaling across the datasets.

The dataset was randomly split into training (60%), validation (20%), and testing (20%) subsets using the train_test_split() function from scikit-learn, with a fixed random seed to ensure reproducibility. This randomization was repeated across multiple hyperparameter tuning runs, supported by early stopping and performance tracking, to improve robustness and prevent overfitting. Although cross-validation was not applied, the repeated grid search process offered equivalent reliability in model selection.

Grid search was performed across various hyperparameter ranges, including:

The model achieving the highest R² score on the validation set was selected for final deployment. Early stopping was incorporated to prevent overfitting and enhance model generalization.

Knowledge-Based Expert Systems (KBES) utilize “IF-THEN” logic rules encoded by domain experts to automate decision-making processes. These systems provide project managers with AI-driven insights for:

Examples:

Benefits:

ANNs emulate the human brain’s learning process to predict project outcomes. ANNs have been utilized for:

Applications:

Fuzzy Logic allows systems to handle uncertain or ambiguous data, providing a degree of truth between 0 and 1. In project management, fuzzy logic is crucial for:

Applications:

Benefits:

Several commercial tools demonstrate the successful application of AI in project management:

Features:

Benefits:

A comparative study of traditional vs. AI-enabled resource allocation demonstrated significant improvements ( Table 1 , Figure 4 ):

Table 1. Resource allocation efficiency results.

Interpretation:

The AI-enabled approach resulted in substantial resource savings, particularly in engineering and programming categories, underscoring the efficiency and effectiveness of AI-assisted project management strategies.

After training and fine-tuning the AI-driven budget prediction model using both historical and synthetic project data ( Figure 5 ), several evaluation metrics were applied to assess its performance. The model was tested on a dataset of 39 software projects, each containing estimated and actual cost values. The results demonstrated that the model achieved a Mean Absolute Error (MAE) of $186931.59, a Root Mean Square Error (RMSE) of $260,691.52, and a Coefficient of Determination (R²) of 0.97, indicating that it explains approximately 97% of the variance in actual project costs.

The final evaluation metrics were computed using Python and the scikit-learn library. A full code snippet used for calculating MAE, RMSE, MSE, and R² based on the 39-project dataset is provided in Appendix B. This implementation ensures reproducibility and transparency in the model performance reporting.

These metrics reflect a high level of predictive accuracy, particularly given that most projects in the dataset had costs exceeding one million dollars. The close alignment between MAE and RMSE suggests consistent performance across the dataset, with minimal impact from outlier values. These results also demonstrate a strong correlation between predicted and actual costs, confirming the model’s robustness and reliability.

Moreover, the use of hyperparameter tuning (via grid search) and early stopping during training played a key role in achieving this level of performance. These techniques effectively prevented overfitting and enhanced the model’s ability to generalize to unseen data. Consequently, the SuperHyperBudgetingModel can be considered a highly effective decision-support tool for accurate budget estimation in software project management contexts.

The integration of the trained model into an Excel-Python-Django framework proved highly effective ( Table 2 ):

Observation:

Users could input project data directly through Excel sheets, submit it through the Django interface, and receive immediate, accurate budget predictions.

This approach significantly lowered the entry barrier for project managers unfamiliar with machine learning or programming.

The AI-based resource allocation optimization demonstrated significant efficiency improvements when compared to traditional manual methods ( Table 3 , Figure 6 ):

Overall Resource Savings: Approximately 11.5% across all roles.

Discussion:

The model allowed project managers to reallocate resources more effectively, avoiding overallocation, bottlenecks, and idle time.

In particular, technical teams (engineers and programmers) benefited the most from AI-driven optimization strategies.

Traditional vs AI-Driven Methods ( Table 4 ).

Table 4. Traditional vs AI-Driven methods.

Insights:

User feedback ( Figure 7 , Figure 8 ):

While the proposed system shows promising accuracy and practical usability, there are a few limitations to consider. The inclusion of synthetic data may introduce bias or unrealistic patterns if not carefully validated. There is also a risk of overfitting due to limited access to diverse real-world datasets. Finally, the model has not yet been tested in various organizational contexts beyond software engineering, and future adaptations will be needed for generalizability.

While the current system has demonstrated promising results, there are several opportunities for further enhancement:

1) Expansion to Real-Time Data Integration: Future versions could incorporate real-time data feeds (e.g., from ongoing project management tools like Jira or Trello) to continuously update budget predictions and resource allocations dynamically.

2) Incorporation of Advanced AI Techniques: Techniques such as Reinforcement Learning (RL), ensemble modeling, and explainable AI (XAI) could be explored to improve model transparency, robustness, and adaptability to evolving project environments.

3) Enhanced Risk Prediction and Mitigation: Future research could integrate advanced risk modeling tools using fuzzy logic and Bayesian networks to provide not just budget forecasts but also proactive risk mitigation strategies.

4) Mobile and Cloud Deployment: Extending the Django framework to mobile-friendly interfaces or cloud platforms like AWS, Azure, or Google Cloud would increase accessibility for remote project teams.

5) Cross-Domain Applicability: While the current model focuses on software projects, adapting the system for other industries such as construction, healthcare, and manufacturing could further validate its versatility and scalability.

6) Integration with Popular Project Management Tools: Building plugins or APIs to integrate the system with tools like Microsoft Project, Primavera P6, or Asana could further streamline adoption and workflow integration.

7) User Customization and AutoML: Adding customizable model configuration options and implementing AutoML (Automated Machine Learning) pipelines could allow non-technical users to fine-tune models based on their specific project contexts.

import torch

import torch.nn as nn

from torch.utils.data import DataLoader, TensorDataset

from sklearn.linear_model import LinearRegression

import numpy as np

import pandas as pd

import os

from keras.models import Sequential as KerasSequential

from keras.layers import Dense, LSTM

from keras.optimizers import Adam

class SuperHyperBudgetingModel(nn.Module):

def __init__(self, input_size, dropout_rate=0.3):

super(SuperHyperBudgetingModel, self).__init__()

self.input_size = input_size

self.dropout_rate = dropout_rate

self.project_input_fields = [‘project_name’, ‘team_size’, ‘estimated_cost’, ‘duration’]

self.financial_input_fields = [

‘year_data’, ‘total_revenues’, ‘gross_profit’, ‘operating_income’,

‘net_income’, ‘total_assets’, ‘total_current_liabilities’, ‘total_equity’

]

self.project_model = nn.Sequential(

nn.Linear(self.input_size, 256),

nn.ReLU(),

nn.Linear(256, 128),

nn.ReLU(),

nn.Linear(128, 64),

nn.Dropout(self.dropout_rate),

nn.Linear(64, 32),

nn.ReLU(),

nn.Linear(32, 1)

)

self.linear_model = LinearRegression()

self.dnn_model = self._build_dnn_model()

self.lstm_model = self._build_lstm_model()

def forward(self, x):

return self.project_model(x)

def _build_dnn_model(self):

model = KerasSequential()

model.add(Dense(64, activation=‘relu’, input_shape=(1,)))

model.add(Dense(32, activation=‘relu’))

model.add(Dense(1))

model.compile(optimizer=Adam(), loss=‘mse’)

return model

def _build_lstm_model(self):

model = KerasSequential()

model.add(LSTM(64, input_shape=(1, 1)))

model.add(Dense(1))

model.compile(optimizer=Adam(), loss=‘mse’)

return model

def train_project_model(self, df, target_col=‘actual_cost’, epochs=100, batch_size=8, lr=0.01):

X = df[self.project_input_fields].values

y = df[target_col].values

X_tensor = torch.tensor(X, dtype=torch.float32)

y_tensor = torch.tensor(y, dtype=torch.float32).unsqueeze(1)

dataset = TensorDataset(X_tensor, y_tensor)

dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

optimizer = torch.optim.Adam(self.project_model.parameters(), lr=lr)

criterion = nn.MSELoss()

self.train()

for epoch in range(epochs):

for xb, yb in dataloader:

pred = self.forward(xb)

loss = criterion(pred, yb)

optimizer.zero_grad()

loss.backward()

optimizer.step()

def train_financial_model(self, df, epochs=100):

X = df[[‘Year’]]

y = df[‘Total Revenue’]

X_lstm = X.values.reshape((len(X), 1, 1))

self.linear_model.fit(X, y)

self.dnn_model.fit(X, y, epochs=epochs, verbose=0)

self.lstm_model.fit(X_lstm, y, epochs=epochs, verbose=0)

def predict(self, category, input_data):

if category == ‘Project’:

X = pd.DataFrame(input_data)[self.project_input_fields].values

X_tensor = torch.tensor(X, dtype=torch.float32)

self.eval()

with torch.no_grad():

pred = self.forward(X_tensor).squeeze().numpy()

return {‘Predicted Actual Cost’: pred.tolist()}

elif category == ‘Financial’:

future_years = np.array(input_data).reshape(-1, 1)

linear_pred = self.linear_model.predict(future_years)

dnn_pred = self.dnn_model.predict(future_years).flatten()

lstm_input = future_years.reshape((len(future_years), 1, 1))

lstm_pred = self.lstm_model.predict(lstm_input).flatten()

return {

‘Linear Regression’: linear_pred.tolist(),

‘DNN’: dnn_pred.tolist(),

‘LSTM’: lstm_pred.tolist()

}

else:

return {‘error’: ‘Invalid category selected’}

# import libraries

import pandas as pd

import numpy as np

from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

# Full dataset

estimated_cost = [

3374734, 188744, 2770726, 4321506, 3518550, 4813501, 396610, 1200524, 3540945,

4960650, 389638, 1475748, 4726700, 514769, 2299141, 1515956, 927062, 1542077,

3859553, 2421747, 2116006, 3959029, 2186470, 1767350, 3946250, 903281, 3073283,

571168, 1038309, 119057, 2369431, 3875549, 2285486, 3648985, 3588569, 967096,

4300197, 712937, 4719127

]

actual_cost = [

3022842.468, 180309.0434, 2773681.888, 4157138.808, 3639163.258, 4459133.13,

467719.2452, 1169578.837, 3397907.133, 5126752.171, 373417.4221, 1363256.591,

4714483.822, 468103.6119, 2442491.025, 1597250.415, 983570.1681, 1456584.791,

3767152.778, 2396956.515, 2383149.988, 4661926.803, 2027826.985, 1922344.844,

4045754.838, 892784.1829, 2726295.239, 543916.56, 1164467.916, 120855.1466,

2613120.931, 4636309.959, 2341212.31, 3739796.809, 3897679.954, 969656.6461,

4674880.095, 631824.0353, 5018647.154

]

# Create DataFrame

df = pd.DataFrame({

“estimated_cost”: estimated_cost,

“actual_cost”: actual_cost

})

# Compute metrics

mae = mean_absolute_error(df[“actual_cost”], df[“estimated_cost”])

rmse = np.sqrt(mean_squared_error(df[“actual_cost”], df[“estimated_cost”]))

mse = mean_squared_error(df[“actual_cost”], df[“estimated_cost”])

r2 = r2_score(df[“actual_cost”], df[“estimated_cost”])

mae, rmse, mse, r2