Research on the automation of intelligent accounting information processing process driven by neural networks

Abstract

Accounting information processing automation improves efficiency and reduces errors as transaction volumes and complexity increase. Traditional accounting systems’ rule-based algorithms lack financial intelligence. Deep learning system NeuroLedger-Net automates accounting using neural networks. The goal is to construct a self-learning anomaly detection and risk classification system with little operator participation. The proposed solution employs LSTM networks for sequential transaction behaviors, Autoencoders for unsupervised anomaly detection, and attention-enhanced MLPs for transaction categorization and risk severity prediction. Use Kaggle’s public financial dataset to train and test the model’s transactional, behavioral, and system-level properties. The NeuroLedger-Net predicts risk occurrences with 96.3% accuracy and a < 3% false-positive rate for anomaly detection. The model prioritizes payment, mistake, and login better with attention. The recommended method improves real-time accounting accuracy and recall by over 12% in F1-score compared to existing methods. Finally, NeuroLedger-Net automates complex accounting information procedures consistently and adaptably using scalable and intelligent technology.

Introduction

Data-intensive enterprises now demand faster and more accurate accounting information processing. Electronic commerce, automated financial services, and global trade have complicated and increased economic data¹. Manual data entry and rule-based accounting struggle with large datasets. Advanced, computerized accounting systems let organizations make real-time judgments and follow standards^2,3. Accounting information systems analyze and summarize financial data for decision-making. Manual accounting has been replaced by ERP with digital databases⁴. Despite advances, most systems verify, classify, and audit transaction data using deterministic rules and human supervision⁵. Dependence causes delays, higher operating expenses, misclassification, fraud, and reporting errors, especially in high-frequency transactions^6,7. Recent AI and ML developments may automate monotonous jobs, boost prediction abilities, and help financial decision-making^8,9. Deep learning accurately predicts huge, multidimensional nonlinear relationships. Financial applications of neural networks include fraud detection, credit scoring, sentiment analysis, and algorithmic trading^10,11. Few studies have used deep learning to automate end-to-end accounting information processing for real-time risk assessment and anomaly detection.

The hybrid neural network model NeuroLedger-Net automates accounting information processing with dynamic risk assessment and anomaly recognition to address these concerns. One method employs LSTM networks to store temporal associations, an Autoencoder for unsupervised anomaly detection, and an attention-based MLP to identify and prioritize transactional attributes. Kaggle’s public financial transaction dataset trains models using behavioral, system-level, and transactional data¹².

Despite AI advances, accounting systems struggle with context-sensitive processing, particularly in high-risk transactions and error-prone operations¹³. Inflexible rule-based systems often miss irregular data streams or provide false positives. Logon patterns, system slowness, and user access frequency are misapplied¹⁴. Intelligent accounting systems that learn from data trends, identify complicated patterns, and detect abnormalities without human supervision are needed¹⁵.

Research problem and objectives

Rule-based accounting systems struggle with modern financial data. Their inflexible logic and contextual ignorance lead them to miss irregularities, delay risk identification, and diminish efficiency. Accounting automation must be intelligent and flexible as financial transactions grow increasingly complicated and high-volume. Neural network-driven, self-learning framework for real-time accounting data processing, contextual anomaly identification, and data-driven judgments is the goal of this research. Anomaly detection, temporal modeling, and deep learning may improve accounting systems’ accuracy, responsiveness, and risk awareness. Objectives are:

1. The goal is to create a framework based on neural networks that automates transaction classification while minimizing manual involvement.

2. To enable real-time identification of anomalies and risk incidents through the utilization of hybrid deep learning systems.

3. To enhance the interpretability of accounting information and the accuracy of decisions, including attention mechanisms that prioritize influential accounting characteristics.

Methodology

The suggested technique automates accounting information processing using NeuroLedger-Net, a hybrid deep learning architecture. Final transaction categorization and risk severity prediction use an attention-based MLP. Long Short-Term Memory (LSTM) networks capture temporal activity in transaction sequences, whereas autoencoders learn the typical pattern distribution and identify abnormalities without supervision.

The publicly accessible Kaggle Financial Transaction and Risk Management Dataset includes transactional, behavioral, and system-level data, such as login frequency, error codes, payment methods, and IP locations. The system trains and validates using this dataset. Preprocessing includes normalization, categorical feature encoding, and stratified sampling. Comparisons with typical machine learning classifiers employ accuracy, precision, recall, and F1-score. To determine which features are most important for detecting anomalies and risks, the model utilizes attention weights. The Contributions are:

1. The primary objective is to present a new neural model for risk identification and financial data classification that combines attention-based learning with sequential and unsupervised learning.

2. To gain a better understanding of transactions, accounting automation models should incorporate indicators of behavior and system-level performance, such as login frequency and system latency.

3. Show substantial gains in accuracy and reduction of false positives by validating the NeuroLedger-Net architecture on a public dataset.

4. To prioritize features in transaction classification using attention-weighted methods to make neural networks more interpretable.

5. The fifth objective is to supply an enterprise-ready, end-to-end architecture for intelligent, scalable, real-time accounting data processing.

Related work

Automation in accounting information processing

Perdana et al. 2016 suggested the rule-based RPA algorithm automates audit operations including data extraction, reconciliation, and report creation. Using proprietary audit process datasets from four accounting firms, including Big 4 and mid-sized enterprises, the research details real-world task flows and time requirements. RPA prototypes slashed task execution time by 60% and enhanced scenario accuracy. Process dependencies, unstructured data handling issues, and high initial development costs are noted in the paper. These findings show that RPA is useful in audit automation and that sophisticated decision-making requires integration with more adaptable intelligent systems.

The qualitative case study on blockchain-enabled Accounting Information Systems uses a system-architectural integration framework rather than a numerical method, according to Faccia et al.¹⁶. Real-time e-procurement system data and corporate use case operational logs evaluate integration performance. Transparency, data immutability, and cross-platform auditing compliance boost ERP-AIS integration efficiency by 30% using blockchain. The use of blockchain in ERP systems may be hindered by protocol, scalability, and regulatory issues.

Using process mining and intelligent contract-based blockchain algorithms, Kassen et al.¹⁷ propose automating public-sector tasks, including identity verification, property records, and e-voting. Estonia’s digital ID and Dubai’s blockchain are case studies. Accessibility, data quality, and 40% less administrative delays boost governance efficiency. Interoperability issues, poor technological infrastructure in developing countries, and opposition to legislative change limit Blockchain’s global scalability on government platforms, restricting research.

Werner et al.¹⁸ used process mining and ERP event logs to rebuild and evaluate end-to-end financial processes for audit compliance. Mid-sized European firms’ anonymized financial transaction data and audit trails are real-world audit settings. Process mining boosts audit accuracy by 35%, lowers manual labor, and improves credibility. Data quality issues, system log utilization, and process event recording consistency may restrict the system’s auditability.

Using SML approaches such as Bayesian Belief Networks, Neural Networks, Decision Trees, Naïve Bayes, and K-Nearest Neighbors, Lei et al.¹⁹ classified financial organizations as fraudulent or not. For rigorous comparisons, it uses a public financial risk dataset including borrower profiles, credit history, and fraud labels. Decision Trees were interpretable, however Neural Networks had the greatest accuracy and lowest MAE and RMSE. In practice, model sensitivity to data imbalance, overfitting risks, and limited geographic generalizability remain issues.

Intelligent systems and anomaly detection in financial data

Rousopoulou et al.²⁰ present a cognitive analytics platform for anomaly detection that processes and predicts manufacturing equipment failures using deep learning models (LSTM, CNN) and standard ML techniques (Random Forest, SVM). Real-time sensor logs, vibration signals, and shop-floor industrial machine operating metrics validate the platform. More than 95% of abnormalities were anticipated, allowing proactive maintenance and decreasing unnecessary downtime. The necessity for large, labeled datasets and the difficulties of adjusting to various industrial environments without domain-specific tweaking are limitations.

Aftabi et al.²¹ This study uses Generative Adversarial Networks (GANs) and ensemble learning models to detect fraud in imbalanced datasets and high-dimensional financial data. A bespoke dataset of 10 Iranian banks’ yearly financial statements, comprising three types of features, was created. Although labeled data was scarce, the model outperformed unsupervised and supervised approaches in identifying false reports. GAN-generated samples may overfit and generalize poorly to multinational datasets.

Forestiero et al.²² This study uses a multi-agent metaheuristic algorithm and IoT2Vec-based activity embeddings to detect IoT anomalies. High-dimensional vectors of IoT devices and services are given to autonomous agents that self-organize based on Pearson correlation similarity in a 2D virtual environment to detect abnormal or isolated actions. Simulations using IoT activity datasets showed good detection accuracy and scalability in dynamic contexts. Large deployments often experience real-time performance issues and depend on training data quality.

Tripathi et al.²³ This study examines how Business Intelligence (BI) tools affect necessary performance measures using supervised machine learning algorithms, such as Decision Trees, Support Vector Machines, and Random Forests. Training and validating the models employed historical enterprise data on consumer behavior, revenue patterns, and inventory. ML models anticipated the impact of BI adoption. Revenue forecasting accuracy improved by over 15% and decision latency decreased. The reliance on organized historical data and difficulties in capturing qualitative managerial decisions are constraints. The study shows that ML-driven BI evaluation aids strategic investment decisions.

Nasser et al.²⁴ present a Double deep learning architecture, combining CNN-BiLSTM for static analysis and Deep Autoencoders for dynamic anomaly detection in Android malware. The evaluation utilized two benchmark Android malware datasets, CIC-InvesAndMal2019 and Drebin, comprising both benign and malicious APK files. DL-AMDet outperformed other malware detection frameworks with 99.935% accuracy. The accuracy is high, but processing time is reduced by combining static and dynamic behavioral insights. By doing so, the hybrid DL-AMDet model effectively detects Android malware.

Neural network applications in accounting and financial decision systems

Sang et al.²⁵ This study compares a Backpropagation Neural Network (BPNN) with a Genetic Algorithm (GA) and a Support Vector Machine (SVM) to assess SME supply chain finance credit risk from a banking perspective. SME financial indicators including net profit, total assets, current ratio, and inventory reserve fluctuate with growth and have stable liquidity ratios. GA-optimized SVM classified 32 high-quality, 46 neutral, and 55 risk enterprises with 76.27% accuracy and BPNN 89.83%. Despite optimization and SME-specific data heterogeneity, SVM accuracy is low. This strategy helps banks manage credit risk and maximize profits.

The Altman Z-score and MLP-ANN were used by Wu et al.²⁶ to help companies predict early crises during COVID-19 market instability. One Chinese business dataset showed that the hybrid model beat the solo Z-score (86.54%) and MLP-ANN (98.26%) models with 99.40% classification accuracy. Regional data specificity and post-pandemic market dynamics may restrict the model’s financial hardship prediction.

Zhang et al.²⁷ employed BP neural networks to predict stock prices using five days of trade data (20 nodes). Next day’s closing price is output. Training and testing employed a custom stock price dataset. BP beat fuzzy deep learning (62.12) with 73.29% prediction accuracy. 90% of 15-day forecasts were within 10%, demonstrating short-term dependability. Market volatility makes the model less reliable over longer forecast horizons. This strategy enhances macroeconomic planning and investor decision-making.

Using Artificial Neural Networks (ANN) and Decision Trees, Aydin et al.²⁸ predicted business financial failure spanning manufacturing, services, and commerce. The dataset comprises 25 financial ratios and two non-financial variables from 240 Borsa Istanbul (BIST)-listed enterprises. By correctly classifying bankrupt and solvent enterprises, the model achieved near-zero error. Insufficient temporal robustness and sector-specific overfitting are downsides. Comparing sectors reveals financial risk indicators that aid risk reduction and company strategy.

GNNMR, a multimodal recommendation model by Li et al.²⁹, uses GNNs and deep mutual learning to reduce modality bias and improve user-item embedding. Unimodal GNNs are trained on textual, visual, and audio bipartite graphs and synchronized due to mutual knowledge distillation. Taobao and Amazon experiments reveal that Top-K recommendation accuracy is superior to that of multimodal models. Large multimodal datasets and modality imbalance may cause scalability challenges for the model. Capturing latent semantic coherence across modalities enhances the relevance of recommendations.

Enqiang Zhu et al.³⁰ suggested the Adaptive Tokenization Transformer: Enhancing Irregularly Sampled Multivariate Time-Series Analysis. Depending on the specifics of the time series data, ATFormer uses an adaptive method to choose the right tokens (temporal or variate). In order to improve token representation, the model records each observation with a finer granularity. To reduce the impact of noise and partial embeddings, a masked attention mechanism compiles observations into more full tokens and embeds information consistently. The model’s use of tokens is improved by ATFormer because it promotes the production of fine-grained tokens and executes coarse-grained self-attention activities, allowing information at various granularities to interact. The model is able to improve its overall performance because to multilevel processing, which enables it to efficiently gather precise information while combining larger aspects. When compared to other approaches, ATFormer performs better when evaluating ISMTS on three datasets: two from the healthcare industry and one from the human activity domain.

Chanjuan Liu et al.³¹ presented the Boosting Reinforcement Learning via Hierarchical Game Playing With State Relay. Generally, the agent’s poor learning capacity impacts training efficiency in complicated tasks during the first training stage. The authors of this article suggest a novel HRL framework they call hierarchical learning based on game playing with state relay (HGR). Specifically, we develop a training mechanism called the state relay mechanism and include an additional penalty to control the complexity of the tasks. By using the agent’s intermediate states, the relay mechanism may broaden the scope of low-level policy’s study of the environment. To improve training performance in complicated situations, our technique may increase the sample usage rate while decreasing the sparse reward issue. Two public experiment platforms, MazeBase and MuJoCo, are used for simulation testing in order to ensure that the suggested strategy is successful. The findings demonstrate that HGR has a notable positive impact on the field of reinforcement learning (RL).

Jiehui Xu et al.³² introduced the Anomaly Transformer: Time Series Anomaly Detection with Association Discrepancy. Due to the frequency of anomalies, it is very difficult to construct nontrivial linkages from abnormal points to the full series. As a result, the associations of anomalies will mostly focus on the time points immediately next to them. This is our major observation. The author emphasizes the \emph{Association Discrepancy} as a means of exposing this adjacent-concentration bias, which suggests an association-based criteria intrinsically identifiable between normal and abnormal sites. In order to calculate the association discrepancy, the author suggests using the \emph{Anomaly Transformer} together with a new \emph{Anomaly-Attention} mechanism. In order to make the association discrepancy more normal-abnormal distinguishable, a minimax technique is developed. In three different domains—service monitoring, space and earth exploration, and water treatment—the Anomaly Transformer attains state-of-the-art performance on six unsupervised time series anomaly detection benchmarks.

Haoyi Zhou et al.³³ discussed the Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting. The LSTF model, Informer, is an efficient transformer-based model that stands out for three reasons: (i) the ProbSparse self-attention method, which displays similar performance on dependency alignment of sequences and achieves a time complexity and memory consumption of O(L log L). (ii) The self-attention distillation effectively manages very lengthy input sequences and emphasizes dominant attention by halving cascading layer input. (iii) In spite of its conceptual simplicity, the generative style decoder expedites inference for long-sequence predictions by making predictions with a single forward operation instead of a step-by-step approach. Tests on four massive datasets show that Informer solves the LSTF issue in a novel way and substantially beats the state-of-the-art approaches.

This research lays the groundwork for AI-based automation, anomaly detection, and financial modeling, but gaps remain, as represented in Table 1. First, unstructured data and high implementation costs hinder the scalability of many automation models like RPA and process mining^18,34. Integrating Blockchain into AIS Multi-platform ERP environments has regulatory ambiguities and scalability issues. CNN-LSTM and GAN anomaly detection models require large, labeled datasets and tend to overfit on small or domain-specific datasets. Performance of neural network-based prediction systems^25–27 is often region-specific or influenced by data imbalance and temporal limits. Many financial systems fail to address cross-sector generalizability and multimodal integration²⁹. GNNMR improves, but the scalability of large-scale financial ecosystems remains a concern. Future research should focus on adaptive AI architectures, robust cross-sector benchmarking, and hybrid models integrating explainability and performance for real-time decision systems^27,29.

Table 1.

Literature summary with gap analysis in intelligent accounting information processing.

Section	Author(s)	Algorithm/method	Dataset used	Key results	Limitations
2.1 Automation in Accounting	Perdana et al.16	Rule-based RPA	Proprietary audit datasets	60% time saved, better accuracy	Unstructured data & high dev cost
	Faccia et al.17	Blockchain integration	E-procurement logs	30% ERP efficiency gain	Scalability & regulation issues
	Kassen et al.18	Process mining + Blockchain	Estonia & Dubai gov data	40% delay reduction	Infrastructure & interoperability
	Werner et al.19	Process mining	ERP event logs	35% audit accuracy gain	Log quality & uniformity issues
	Lei et al.20	SML (NN, DT, KNN, etc.)	Public fraud dataset	NN had the best accuracy	Data imbalance & overfitting
2.2 Anomaly Detection	Rousopoulou et al.21	LSTM, CNN, RF, SVM	Factory sensor data	> 95% anomaly accuracy	Needs labeled data & domain tuning
	Aftabi et al.22	GAN + Ensemble learning	10-bank dataset	Outperformed other models	GAN overfit risk
	Forestiero et al.23	IoT2Vec + Metaheuristics	IoT activity vectors	High anomaly accuracy	Real-time deployment issues
	Tripathi et al.24	DT, SVM, RF	Historical enterprise data	15% revenue accuracy gain	Limited to structured data
	Nasser et al.25	CNN-BiLSTM + Autoencoders	CIC-InvesAndMal2019, Drebin	99.9% accuracy	Obfuscation and processing time
2.3 Neural Nets in Accounting	Sang et al.26	BPNN vs. GA-SVM	SME finance data	BPNN: 89.83% accuracy	SVM less effective
	Wu et al.27	Z-score + MLP-ANN	Chinese firm data	99.4% classification	Region-specific results
	Zhang et al.28	BP Neural Network	Stock dataset	73.29% accuracy	Short-term focus, market sensitive
	Aydin et al.29	ANN + DT	BIST data (240 firms)	Near-zero classification error	Risk of overfitting
	Li et al.30	GNNMR + mutual learning	Taobao & Amazon	Best Top-K rec. performance	Scalability & modality imbalance

Methodology

To automate intelligent accounting information processing using deep neural networks, NeuroLedger-Net is designed as shown in the architectural Fig. 1, which illustrates the end-to-end pipeline. A dataset containing financial transactions and risk management information is first subjected to extensive data preprocessing. To create learnable formats from diverse transactional records, this involves numerical normalization, temporal structure, missing value imputation, and categorical encoding. The Temporal Behavior Modeling module constructs dynamic user profiles by capturing sequential dependencies using Long Short-Term Memory (LSTM) networks. An autoencoder compresses and reconstructs transactions in the Anomaly Detection Engine, which receives these profiles as input. A statistical metric for flagging outliers in the absence of labeled supervision is reconstruction error. A Feature Prioritization layer receives data in real time and uses an attention mechanism to rank inputs like payment methods and system delay based on their importance. The Attention-MLP, a multilayer perceptron, is fed these weighted vectors to categorize risk episodes according to their nature and intensity. An anomaly flag and risk score arise from a full audit support and real-time fraud detection judgment. After training on Kaggle’s financial dataset, our unique pipeline outperformed standard techniques by over 12% in F1-score, with 96.3% accuracy and < 3% false positives.

Fig. 1.

NeuroLedger-Net architecture for intelligent accounting automation.

Data preprocessing

The Data Preprocessing Module aims to normalize financial transaction records for neural network training. Missing data is imputed, categorical factors like payment methods, IP locations, and transaction kinds are one-hot encoded, and numerical attributes like amount, latency, and login frequency are Z-score normalized. Real-world accounting-simulated Financial Transaction and Risk Management Dataset³⁵ was used for training and validation. It includes structured Transaction_Type, Amount, Payment_Method, and Category (Payroll, Sales, Inventory). Login_Frequency, Failed_Attempts, and System_Latency show user and system usage. For supervised fraud detection and categorization, each item contains Risk_Incident, Risk_Type, and Incident_Severity. For privacy, the data is anonymised and formatted in CSV format, allowing one-hot encoding for categorical features, Z-score normalization for numerical features, and temporal sorting for LSTM-based sequence learning.

Furthermore, to facilitate temporal modeling, transactions are arranged chronologically into user-specific sequences. Data consistency, improved feature interpretability, and optimal dataset preparation are all key goals of this preprocessing for NeuroLedger-Net deep learning anomaly detection and risk categorization. Let the raw transaction dataset be represented as in Eq. 1:

1

where denotes the transaction feature vector comprising numerical and categorical attributes, represents the corresponding target label (e.g., transaction type or risk score), and is the total number of transaction records. It is because each It is a feature vector derived from a transaction, which contains both numerical and categorical attributes.

• Step 1: Categorical Encoding.

  Convert numeric variables with several categories into a binary vector that neural networks used. A sparse binary vector of size is used to one-hot encode each categorical feature (such as , and ), with the index representing the actual category set to 1. It keeps the non-numerical data from being associated with ordinal numbers. Let represent categorical features : Payment_Method∈{Cash, Bank Transfer, Credit Card}, IP_Region∈{TH, TW, BI, etc.}, These are One-Hot Encoded: where k is the total number of categories, and one is assigned to the index of the category with the current value.

• Step 2: Numerical Normalization.

  Adjust numerical features to a normal distribution with a mean of() and a standard deviation of 1. Amount, System Latency, and Login Frequency are numerical inputs that easily be overwhelmed by scale discrepancies; however, normalization prevents this from happening. Z-score normalization enhances gradient-based convergence by standardizing features. Let be numerical features:

  

  For each numerical value , apply Z-score normalization: The mean of the features is represented by , represents the standard deviation of feature j. represents the normalized score. It guarantees that the features are uniformly distributed with a mean of zero and a variance of one, which are necessary for deep learning to converge.

• Step 3: Handling Missing Data.

  Substitute estimates that are statistically significant for null values. To fill in missing numerical values, feature-wise means They are used, whereas the mode is employed for missing categorical values. In doing so, we keep the dataset complete for uniform training and prevent the loss of data rows. Let be missing entries. Imputation:, Where​: mean of feature for numerical. The most frequent value in the column for categorical.

• Step 4: Temporal structuring.

  To enable LSTM modeling, user-wise time-ordered sequences can be structured.

  Each feature at time t is represented as a vector. In the user transaction logs, which are organized into sequences . Incorporating changes in behavior into risk assessments is made possible.The following is a list of all the transactions that user u has made: At time , the feature vector is represented as This order permits the modeling of risky or anomalous behavior patterns concerning time.

Temporal behavior modeling (LSTM)

Using Long Short-Term Memory (LSTM) networks, the main objective of the Temporal Behavior Modeling module is to retrieve sequential dependencies from financial transaction logs. Accounting automation orders user transactions by time. Understanding temporal evolution helps identify irregularities and predict financial issues. LSTM’s gating algorithms maintain long-term dependencies and filter extraneous information to represent transaction sequences. Dynamic behavioral profiling learns latent temporal patterns linked with anomalies, fraud, and operational mistakes to increase automated risk-aware accounting accuracy.

Input: sequential data representation

The Long Short-Term Memory (LSTM) model takes as input a time series of user-specific transaction vectors, represented as:The feature vector for transaction t with n attributes (such as Amount, Payment Method, and System Latency) is represented by T represents the sum of all time steps, which are equivalent to transactions for a specific user.

The gates that make up LSTM models regulate the data flow. At each time step , the input feature vector and the prior hidden state These gates are used to update these gates. Here are the fundamental LSTM update equations:

Forget gate

The forget gate determines whether bits of data from the prior cell state should be ignored. It takes in the prior hidden state and the current input , applies a sigmoid activation σ, and produces a value between 0 and 1 for every element in the cell state, where zero means “forget completely” and one means “retain fully”.

2

Where in Eq. 2, in the forget gate, It is the weight matrix. Is the forget gate’s bias term. The sigmoid activation function, denoted as σ(⋅)\sigma(\cdot)σ(⋅), yields values ranging from 0 to 1, indicating the amount of information from the prior state that should be forgotten.

Input gate

This gate decides which transactional characteristics affect memory. It lets the accounting risk detection model include key modifications like unexpected delay or error codes into its developing knowledge of user activity patterns.

3

In Eq. 3, here are some key points about the input gate: The weight matrix is . The bias term is .

Cell state update

Based on transaction sequences, this layer generates new memory data. The NeuroLedger-Net system detects complicated accounting patterns like unusual payment methods or repeated unsuccessful logins that suggested new financial workflow hazards or automated mistakes.

4

Where in Eq. 4, in a candidate cell state, It is the weight matrix. The candidate cell state bias term is denoted as . is equal to (⋅). Values between − 1 and 1 are squashed by the hyperbolic tangent activation function, tanh(⋅).

Final cell state

In this step, LSTM main memory is refreshed. NeuroLedger-Net integrates fresh transaction data with historical data to improve user behavior profiles for sequential reasoning spanning financial periods and anomaly progression patterns.

5

In Eq. 5, the cell’s state at time t is represented by . * The prior state of the cell is represented byThe amount of memory that is maintained is represented by the function . The variable Denotes the newly added memory to the cell state.

Output gate

This gate filters current cell memory to create signals. Accounting automation guarantees real-time decision-making layers get only relevant information, such as current anomalies or risk-prone behaviors, to identify and evaluate.

6

In Eq. 6, to determine the output gate’s weight, use the formula . The output gate’s bias term is .

Hidden state

The contextual transaction behavior is encoded by this final LSTM output at time . It enables intelligent financial processing systems to undertake proactive risk forecasting and dynamic pattern identification by feeding it into downstream neural layers within NeuroLedger-Net, such as an Autoencoder or MLP.

7

In Eq. 7, the hidden state at time , represented by Is the result of the LSTM for this particular time step. The cell state is compressed to a value between − 1 and 1 by he amount of the cell state that is output is controlled by .

Algorithm 1.

Temporal behavior LSTM model.

Anomaly detection engine (autoencoder)

Using an autoencoder neural network, the Anomaly Detection Engine seeks to detect suspicious accounting transactions. This model has learned to reproduce common patterns just from standard transactional data throughout its training. The initial state of each transaction is restored after encoding it into a latent vector. When comparing the original and reconstructed inputs, the mean squared difference is used to measure the reconstruction error. An anomaly is defined as a transaction having an error rate higher than a certain threshold. This method enhances financial audits and fraud prevention by enabling the system to automatically identify unusual or suspicious activities, even in the absence of identified anomalies. As shown in Fig. 2, the autoencoder detects anomalies by comparing reconstruction loss with a learned threshold derived from validation data.

Fig. 2.

Autoencoder-based anomaly detection workflow in NeuroLedger-Net.

Autoencoder architecture

A key component of the autoencoder in the NeuroLedger-Net architecture for intelligent accounting data processing is the encoder, which converts high-dimensional financial transaction vectors into compact and informative latent representations.

Encoder function

The encoder learns a nonlinear mapping given a normalized and encoded transaction vector .

8

Where in Eq. 8, the input transaction vector . Includes normalized numerical characteristics and one-hot encoded categorical information, for set includes the encoder layer’s weight matrix, the set It is a bias matrix, the nonlinear activation function, usually , denoted as Compressed latent vector (embedding) where is a real number. To compress transaction data, the encoder isolates and stores the most important statistical and behavioral characteristics in a smaller footprint. Because of this condensed form, the model may generalize regular transaction patterns. Using reconstruction quality as a criterion, this aids in the NeuroLedger-Net framework’s ability to differentiate between typical and abnormal behavior. The encoder helps the decoder correctly reconstruct typical transactions by reducing data loss during compression; it fails noticeably on outliers, allowing anomaly detection to take place.

Decoder function

From its latent representation, the decoder function in the NeuroLedger-Net framework reconstructs the original transaction vector. It is defined as:

9

where in Eq. 9, represents the reconstructed input x using decoder weights, bias , and activation (e.g., ReLU or Sigmoid). The decoder recreates dataset-learned transactional patterns (amounts, methods, frequencies). A significant difference between Suggests an anomaly.

Anomaly detection criterion

An essential part of NeuroLedger-Net’s intelligent accounting automation is the ability to recognize anomalies. Accurate reconstruction of “normal” financial transactions is taught to the Autoencoder module. The Mean Squared Error (MSE) between the input vector x\x and its reconstructed counterpart It is used to compute the reconstruction loss.

The model’s ability to reconstruct the input transaction after autoencoding and decoding is measured by this loss. Here, x represents the original financial transaction vector, including encoded and normalized characteristics such as transaction amount, payment method, login frequency, and behavioral/system factors.

In the autoencoder, Represents the reconstructed output of the same transaction from the decoder. The squared-norm (Euclidean distance) measures the difference between input and reconstruction. A large reconstruction loss implies that the model cannot properly replicate the input, deviating from training standards and perhaps revealing an anomaly. This method flags transactions without risk labels using statistical variance for unsupervised learning. To classify a transaction as an anomaly, compare its loss to a threshold :, where Learning from the distribution of reconstruction losses on a validation set, is not manually set but instead applies. The 95th percentile of the validation losses is usually used to set , as described in Eq. 10, which is defined as:

10

Thus, only transactions with extremely high reconstruction error, which are considered statistically abnormal, will be detected. To replace manual audit checks, this criterion for detecting anomalies is crucial. With the help of artificial intelligence, the autoencoder could learn typical patterns in financial transactions (such as regular payrolls, refunds, or inventory purchases) and identify out-of-the-ordinary occurrences (such as extensive credits or unauthorized access) to guarantee accounting integrity and real-time, scalable fraud detection with minimum human intervention. As shown in Table 2, the autoencoder detects anomalies by comparing the reconstruction loss with a learned threshold δ.

Table 2.

Autoencoder-based anomaly detection for a transaction.

Step	Component	Example Value	Purpose
1	Input Vector (x)	[0.8, 0.2, 1.0, …]	Normalized transaction input (d = 100)
2	Latent vector (z)	[0.5, -0.3, 0.1, …]	Compressed feature representation (k = 10)
3	Reconstructed (x̂)	[0.75, 0.25, 0.9, …]	Model’s reconstruction of input
4	Reconstruction Loss	0.15	Error:
5	Threshold (δ)	0.25	95th percentile of validation loss
6	Anomaly Decision	Normal (0.15 < 0.25)	Not flagged as anomalous

Risk classification & prediction (attention-MLP)

NeuroLedger-Net’s Risk Classification & Prediction module classifies Risk_Incident, Risk_Type, and Incident_Severity using an attention-enhanced MLP. It processes high-dimensional vectors with encoded categorical and normalized numerical variables. This expanded depiction encompasses transactional, behavioral, and system characteristics. The built-in attention system adapts predictions to user context by weighing payment method and login behavior. This module learns complicated financial patterns to provide real-time accounting risk classification with higher accuracy, interpretability, and flexibility to changing financial anomalies.

Attention mechanism (focusing relevant features)

Attention in NeuroLedger-Net’s Risk Classification & Prediction module helps the model concentrate on risk analysis characteristics. Using user_IDs, it dynamically weights input characteristics including system latency, error codes, payment methods, and login frequency. Prioritizing prediction-relevant input helps the network identify risk occurrences, categories, and severity. It makes a categorization system smarter and context-aware that adjusts to different transaction behaviors.

11

Where in Eq. 11, Q (Query): User_ID or context vector, K, V (Key, Value): System-level attributes including latency and error codes, : Scaling factor for gradient stabilization. Assigning dynamic weights to attributes depending on their relevance to the user’s profile allows the network to prioritize payment method and login frequency.

MLP classifier (prediction layer)

The final NeuroLedger-Net risk assessment prediction layer is the MLP Classifier. Attention-refined feature vectors show system delay and payment methods. To extract high-level patterns, fully connected neural layers with learnable weights and biases process this vector. Non-linearity from a ReLU activation function lets the network capture complicated feature interactions. Finally, a softmax function converts the result to probability distributions for Risk_Incident, Risk_Type, and Incident_Severity. It allows accurate and interpretable classification of dynamic accounting transaction patterns.

12

Where in Eq. 12, Attention Layer Output,Learnable Weight Matrix of Neural Layers, Terms with bias: . ReLU feature transformation non-linearity Softmax() generates final output class probabilities. Multi-label classification across three risk characteristics is achieved via a shared, interpretable feature representation. The attention method improves context-awareness, allowing the model to adapt to different transactions and behaviors. NeuroLedger-Net predicts risk better than rule-based and static learning models with 96.3% accuracy and 3% false positives.

Algorithm 2.

Detect and classify accounting anomalies.

Feature prioritization

The Feature Prioritization Module of NeuroLedger-Net uses attention weights (α_i) to evaluate and quantify the impact of each feature on risk classification. Weights α_i are calculated using a softmax over a score function , where Is the hidden representation of the -th input feature. Equation 13 defines:

13

guarantees that the attention scores are standardised and emphasizes the most predictive elements. This module gives Login_Frequency, Transaction_Type, and Error_Code more weight in automated accounting to indicate behavioral abnormalities or operational irregularities in transaction logs. This technique matches the study’s goal of automating intelligent accounting data processing via accurate prediction and transparent disclosure of transaction risk assessments. This transparency allows real-time auditability and promotes trust in AI-driven monetary systems.

The above histogram shows reconstruction damages as a proportion of financial transactions. The vertical red dashed line represents the anomaly threshold δ = 0.0668, computed from the 95th percentile of validation loss. If reconstruction losses exceed this amount, the accounting system will flag the transaction as abnormal. This approach learns accounting habits and exploits high reconstruction error to uncover anomalies to identify suspicious transactions unsupervised. See Fig. 3.

Fig. 3.

Anomaly detection threshold in NeuroLedger-Net autoencoder.

This includes comprehensive explanations of the training configurations, hyperparameter settings, and data preprocessing techniques used in NeuroLedger-Net, such as temporal sequence creation for LSTM-based modeling, categorical encoding, Z-score normalization, and missing-value imputation. To facilitate simple model definition, detailed mathematical formulations for LSTM gating mechanisms, the Autoencoder reconstruction process, anomaly-threshold derivation, attention score, and the MLP classification pipeline have been presented.

Additionally, each statistic used in the evaluation framework Accuracy, F1-Score, False Positive Rate, Transaction Risk Detection Rate (TRDR), Graph-Aware Fraud Precision (GFP), and Impact-Weighted Detection (IWD) has been fully explained. Explicit metric formulations, visualization outputs, and cross-model performance interpretation can now be used to support comparative benchmarking findings. To provide complete transparency regarding implementation conditions, the environment settings which include the Python version, TensorFlow/Keras configuration, GPU acceleration details, and Docker-based replication tools have been included. Together, these improvements guarantee that the model behavior, evaluation procedure, and experimental workflow can be accurately replicated for further study and real-world use.

In order to maintain the fraction of risk-related labels across subsets and guarantee methodological clarity and repeatability, the dataset was divided into 70% training, 15% validation, and 15% testing after stratified sampling. Using a grid-search method, the hyperparameters for the Attention-MLP, Autoencoder, and LSTM components for the validation set were changed. The final setup consists of 50 training epochs with early pausing (patience = 7), a batch size of 64, and a learning rate of 0.001 (Adam optimizer). While the Autoencoder had a latent dimension of 10, the LSTM employed a fixed number of hidden units of 128. We used two dense layers (128 and 64 units) to train the Attention-MLP classifier. Dropout (rate = 0.3) and ReLU activation were used to reduce overfitting. In these conditions, generalization performance and convergence stability were best compatible.

Result analysis

Data source information

Table 3 shows how the Kaggle Financial Transaction and Risk Management Dataset³⁵ replicates accounting and financial transactions. Its comprehensive and labeled records enable powerful neural network models to automate accounting data processing. Company transactions with Transaction_Type, Amount, Payment_Method, and Category include payroll, inventory, sales, and refunds. Login Frequency, Failed Attempts, System Latency, and IP Region show user involvement and technical performance. Its labeled risk indicators (Risk_Incident, Risk_Type, Incident_Severity) and system fault diagnostics (Error_Code) make it excellent for anomaly detection, fraud categorization, and machine learning-based predictive risk assessment For privacy compliance, all personal identities have been anonymised, making the dataset appropriate for academic and industry study. supervised learning for fraud prediction, autoencoding for anomaly detection, and sequential modeling for transaction behavior predictions are possible with this dataset.

Table 3.

Dataset attributes and descriptions.

Attribute name	Description
Transaction_ID	Unique identifier for each financial transaction
Date	The date on which the transaction occurred
Account_Number	Unique number representing the account involved
Transaction_Type	Nature of the transaction: Debit, Credit, Refund
Amount	Monetary value involved in the transaction
Currency	Currency type (e.g., USD)
Counterparty	The party or entity the transaction is associated with
Category	Business function linked to transaction (e.g., Payroll, Sales)
Payment_Method	Mode of payment (e.g., Cash, Bank Transfer, Credit Card)
Risk_Incident	Binary indicator of whether a risk incident occurred (0 or 1)
Risk_Type	Description of the type of risk (e.g., Error, Misstatement)
Incident_Severity	Severity level of the risk incident (e.g., Low, Medium)
Error_Code	Code representing the specific accounting or system error
User_ID	Identifier of the user initiating or authorizing the transaction
System_Latency	Measured latency in processing the transaction (ms or sec)
Login_Frequency	Frequency of user logins in a given period
Failed_Attempts	Number of failed login attempts related to the transaction
IP_Region	Geographical region derived from the user’s IP address

Implementation and environmental setup

NeuroLedger-Net was tested in a stable and scalable Python-based deep learning environment. System architecture was designed and evaluated using structured transactional data from the Kaggle Financial Transaction and Risk Management Dataset³⁵, which contains behavioral and system-level metrics like Login_Frequency, System_Latency, and Risk_Incident. Table 4 depicts a suitable setting. The program classifies, estimates risk, and finds anomalies in structured accounting datasets using deep learning. Data preparation included label encoding, missing values, normalization, and class balancing. MLPs for classification and Autoencoders for anomaly detection were built using TensorFlow 2.x and Keras APIs. The model was trained and evaluated locally using NVIDIA CUDA GPU acceleration. For dependency consistency, Anaconda and Python 3.9 preserved the environment. Model building and visual exploration were in Jupyter Notebook. Docker containers enabled system repeatability from data intake to model inference. Matplotlib and Seaborn were used for exploratory data analysis and visualization, while scikit-learn validated models using precision, recall, and F1-score metrics. This setup allows for scalable, efficient, and repeatable deep learning-driven intelligent accounting automation solutions.

Table 4.

Implementation and environment configuration.

Component	Description/version
Programming Language	Python 3.9
IDE/Notebook	Jupyter Notebook
Environment Manager	Anaconda
Deep Learning Lib	TensorFlow 2.11 / Keras
Classical ML Tools	scikit-learn 1.2
Data Processing	pandas, NumPy
Visualization Tools	Matplotlib, Seaborn
OS/Platform	Windows 11 / Ubuntu 20.04
Deployment Tool	Docker (20.x)
GPU Acceleration	NVIDIA CUDA Toolkit 11.x, cuDNN
Hardware	16GB RAM, NVIDIA RTX 3060 GPU
Version Control	Git + GitHub
Dataset Source	Kaggle Dataset

Evaluation & benchmarking

The purpose of NeuroLedger-Net’s Evaluation and Benchmarking phase was to confirm the automation of intelligent accounting operations using rigorous metrics and comparative analysis in a comprehensive performance assessment.

Risk incident detection effectiveness

Accuracy is a key performance measure for the NeuroLedger-Net model’s risk-categorization of financial transactions. It shows that the model detects safe and dangerous activities with minimal errors. Correctness is used to evaluate automated risk projections to guarantee flagged transactions are high-risk and safe ones aren’t. With 96.3% accuracy, NeuroLedger-Net forecasts well. Its excellent precision enhanced real-time accounting integrity via intelligent automation and decrease human audits.

The visualizations in Fig. 4 illustrate the proposed NeuroLedger-Net’s comparison to three top-tier models in terms of their ability to classify financial Risk_Incident efficiently and accurately within intelligent accounting information systems. The models are the SML Framework for Financial Risk Classification¹⁹, GAN + Ensemble Model for Financial Fraud Detection²¹, and DL-AMDet²⁴. The Accuracy (%) and F1 Score (%) for each model specified on the x-axis are plotted on the y-axis of the first graph, which is a bar chart. The formula is used to calculate accuracy in Eq. 14:

14

Fig. 4.

Comparative analysis of neural network-based risk detection models in automated accounting systems (a) accuracy vs. fraud detection (b) accuracy vs. false positive rate vs. F1-score gain.

In which signifies True Positives, True Negatives, False Positives, and False Negatives. Each system’s overall accuracy is evaluated using this metric. When compared to SML Framework (85.1%), GAN + Ensemble (88.4%), and DL-AMDet (99.9%), NeuroLedger-Net comes out on top with an accuracy of 96.3%. The best balance is demonstrated by NeuroLedger-Net, which indicates robust classification under uncertainty, with a low FPR (< 3%) and a high F1 score (94.5%). Accuracy (%), False Positive Rate (%), and F1-Score Gain (%) relative to a baseline are combined in the 4c graph, which is a dual-axis bar + line plot. By integrating deep LSTM-Autoencoder and attention-enhanced MLP classification layers, NeuroLedger-Net improves predictive performance while decreasing false positives.

F1-score

A unified metric in intelligent accounting automation, the F1-score strikes a balance between recall (the extent to which actual risks are detected) and precision (the number of correctly identified risks). Because of the high operational expenses associated with both false positives (unwarranted alarms) and false negatives (missed frauds), this is of the utmost importance in financial areas. A harmonic mean of recall and precision is used to get the F1-score, As shown in Table 2; Fig. 5.

Fig. 5.

Comparison of financial risk detection models (a) F1-score (b) precision-recall distribution (c) false positive rate (d) execution time evaluation.

The models are the SML Framework for Financial Risk Classification¹⁹, GAN + Ensemble Model for Financial Fraud Detection²¹, and DL-AMDet²⁴. The formula is used to calculate the F1 Score in Eq. 15:

15

This measure emphasizes the model’s balanced efficacy in risk categorization tasks within the suggested NeuroLedger-Net architecture. The high F1-score of 0.96 achieved by NeuroLedger-Net in real-time financial situations indicates both reliable accuracy and robustness. It is achieved by incorporating LSTM layers for sequential modeling, an Autoencoder for anomaly extraction, and an attention-enhanced MLP for contextual prioritizing. The model’s ability to manage data distributions that aren’t balanced enables it to identify crucial but infrequent accounting process irregularities, thereby reducing audit delays and compliance problems.

Graph-aware fraud precision

Graph-Aware Fraud Precision (GFP) improves fraud detection accuracy by considering the transaction’s structural relevance in the financial network graph. GFP prioritizes nodes with more centrality or connectedness (such as accounts that often transact or span many transaction chains) above conventional precision, which examines all fraud scenarios equally. This score shows how effectively the model identifies and avoids high-impact fraud in complex digital environments. GFP in NeuroLedger-Net identifies and prioritizes fraud in critical transaction network segments to enhance systemic financial security and reduce cascading risks.

Four cutting-edge financial fraud detection systems—NeuroLedger-Net, SML Framework for Financial Risk Classification¹⁹, GAN + Ensemble Model for Financial Fraud Detection²¹, and DL-AMDet²⁴—are based on GFP and IWD. GFP (%), which accounts for transaction graph nodes’ structural relevance, is shown in Fig. 6 alongside fraud detection. The superimposed red dashed line shows the model’s IWD performance, which measures its efficiency in detecting systemic frauds. Mathematically, GFP adjusts classical precision to prioritize high-impact fraud situations by giving more weight to nodes with stronger edge connection or centrality. The tinted blue area highlights influence zones. To demonstrate its risk identification and prioritizing capabilities, NeuroLedger-Net obtained an industry-leading 95.4% GFP and 92.0% IWD. By utilizing a node-aware prioritizing mechanism, weighted scoring enhances overall financial resilience: where denotes structural weights.

Fig. 6.

Comparative analysis of graph-aware fraud precision and impact-weighted detection in financial risk models.

Transaction risk detection rate

The TRDR is a measure of how well the NeuroLedger-Net model recognized high-risk transactions relative to all the transactions in the dataset that were tagged as hazardous. This statistic is simple yet very important since it shows how well the system identified potentially fraudulent, inaccurate, or misleading accounting events with few false negatives. An appropriate model for high-stakes financial processes in your accounting automation environment would have a high TRDR because it captures and responds to essential risk incidents in real-time.

In Fig. 7, a side-by-side comparison of four financial risk categorization systems, namely NeuroLedger-Net, SML Framework for Financial Risk Classification¹⁹, GAN + Ensemble Model for Financial Fraud Detection²¹, and DL-AMDet²⁴, in terms of important fraud detection parameters. A patterned line chart shows System Latency, and three separate performance indicators—Transaction Risk Detection Rate (TRDR), Login Frequency, and Failed Login Attempts—are integrated using bar plots in the graph. The formula for the TRDR metric is

16

Fig. 7.

Comparison across fraud detection models (a) TRDR (b) failed attempts (c) login activity (d) latency.

where Is the number of occurrences that were successfully recognized, and ON Is the number of incidents that were missed. A greater TRDR indicates a more effective ability to detect in real-time.

Although the Kaggle Financial Transaction and Risk Management Dataset was used for the primary trials, additional measures were taken to enhance the robustness and generalizability of the proposed NeuroLedger-Net architecture. To ensure performance stability over various class distributions, a stratified 10-fold cross-validation procedure was used for all model components, including the LSTM behavioral module, Autoencoder anomaly detector, and Attention-MLP classifier. No specific data partition had an impact on the model’s prediction behavior, according to the cross-validation findings, which demonstrated low variance across folds (accuracy fluctuation ≤ 1.8% and F1-score fluctuation ≤ 2.1%).

Conclusion and future enhancement

The Automation of Intelligent Accounting Information Processing Process Driven by Neural Networks study presents NeuroLedger-Net, a robust and scalable framework that turns accounting systems into self-learning platforms. Financial transaction analysis is automated and streamlined using LSTM networks for behavioral sequencing, Autoencoders for unsupervised anomaly detection, and an attention-enhanced MLP for multi-label risk classification. The system is suited for high-stakes financial operations due to its 96.3% risk incident prediction accuracy and 3% false-positive rate for anomaly detection.

Future developments include GNNs for user, account, and counterparty connections. Real-time input from reinforcement learning might adjust thresholds and classification rules. Federated learning will be researched for decentralized business deployments due to privacy concerns. Scalability and global adoption increase with multilingual transaction log support and adaptive model compression. NeuroLedger-Net allows intelligent, explainable, and autonomous accounting systems that react to data, decreasing human involvement and improving accuracy and regulatory compliance in dynamic financial ecosystems.

Author contributions

C. Wrote the original manuscript and was responsible for all aspects of this study.

Funding

This study did not receive funding from any institution.

Data availability

The data and materials used in this study are available from the authors upon request.

Declarations

Competing interests

The authors declare no competing interests.