Enhancing Road Safety Through AI-Based Predictive Speed Adaptation

Road traffic safety has continued to be a leading public health problem and an interest to African scientists across disciplines. There is an increasing literature that points to the multifactorial nature of traffic fatalities and injuries, and the technological, environmental, and behavioral contributors. Together, the recent research provides a nuanced perspective of how data quality, human behavior, infrastructure and intelligent systems coalesce to create road safety outcomes.

One of the major problems relevant to this field is the validity and reliability of global accident statistics. Hua et al. [1] in a recent studyon the WHO Mortality Database, investigators found major discrepancies in classification and diagnosis of road traffic deaths. Such inconsistencies—domestic or cross-national—demonstrate the challenge of identifying the standards for sound, comparable democracies. These inaccuracies compromise the ability to develop and institute successful preventive strategies, highlighting the necessity for equally standardized data-reporting mechanisms in international health reporting systems. Following up this concern, Ahmed et al. [2] read the road traffic injuries and fatalities as the same neglected global health problem, which continuously higher over time. The study highlighted how, despite the existence of policy frameworks, neglect of children continues to drive avoidable mortality, particularly in low- and middle-income countries. Collectively, these studies point to one conclusion: without robust data collection systems and greater awareness of the magnitude of the problem, large-scale interventions will not make a dent.

Apart from data limitations, studies were also carried out on the interactions of road users and surrounding environments, in relation to the risk of accidents. Shoman et al. [3] used an instrumented bicycle to examine how adverse weather and surface conditions affect the safety of cycling. Their empirical results found that cyclists experience more discomfort and higher risk due to rainfall and uneven surfaces and slippery street pavement. Complementarily, Useche et al. [4] explored the effectiveness of behavioral and demographic risk factors correlated with cycling crash involvement in young cyclists from 15-Russian cities, revealing strong links between risky behaviors, demographic risk factors, and crash exposure. Collectively, these abstracts highlight the need for acknowledging how both environmental and behavioral factors converge to put vulnerable road users such as cyclists at increased risk.

At the vehicle level, speed management is arguably one of the most straightforward measures to enhance road safety. In this context, Ghadiri et al. [5] introduced the Speed Limit Compliance Index (SLCI) as a conceptual metric for evaluating the effects of Intelligent Speed Adaptation (ISA) systems. This framework quantifies driver compliance with speed limits, thereby offering policymakers a reference point for assessing the effectiveness of related interventions. Complementing this work, Lai et al. [6] have also conducted extensive research on ISA systems, demonstrating their considerable potential not only to reduce crash risk but also to mitigate environmental hazards. Altogether these contributions emphasize the role of speed management technologies as a key component of contemporary road safety efforts.

Meanwhile, rapid developments in the field of autonomous navigation technologies are providing an opportunity for enhancing the safety of traffic. Arafat et al. [7] presented vision-based navigation systems for Unmanned Aerial Vehicles (UAVs) are presented, along with the advantages and limitations of such systems under real-world conditions. While their expertise is mainly on aerial platforms, ideas on computer vision and obstacle detection is directly applicable to the safety on the road by leveraging it into self-driving cars and intelligent traffic monitoring. Building upon this theme, Abidi et al. [8] investigated assistive navigation systems in support of the visually impaired and showed how improvements in navigation and perception not only help Guiding the blind to achieve personalized mobility, but also provide broader insights into human–machine interaction within transportation systems.

A parallel and more impactful area of research merges high-definition (HD) mapping and Artificial Intelligence (AI) with intelligent transport systems. In detail, Asrat and Cho [9] had reviewed how HD map is generated as well as how to update HD map, and noted these two topics are key elements to assist autonomous driving and adaptive traffic management. The road environment changes dynamically and the stable operation requires continuous map updating. Complementing this, He et al. [10] accordingly concluded by summarizing that the use of Recurrent Neural Networks (RNNs) in traffic prediction could provide a better kind of deep learning from RNNs to learn spatiotemporal traffic patterns that cannot be modeled in short time–based learning steps, better long-term skills such as congestion forecasting, accident prediction, and dynamic traffic control.

Overall, the literature reviewed illustrates the interdisciplinary nature of road traffic safety research, as it covers topics in epidemiology, behavioral science, engineering, and artificial intelligence. Global mortality databases [1], [2], cyclist safety in extreme conditions [3], [4], speed management systems [5], [6], and emerging AI -enabled traffic prediction and navigation [7], [8], [9], [10] point to several major conclusions. The first is that standardization and data quality of traffic-related data are still serious bottlenecks for global monitoring. Second, wherever the infrastructure is poor and the environment is adverse to pedestrian safety, vulnerable road users continue to pay the price disproportionately. Finally, technological innovations, from ISA systems to HD mapping to RNN-based traffic modeling, are advancing rapidly and offer a great deal of potential to reduce fatalities, if combined with effective policy frameworks and interdisciplinary cooperation.

In this paper, a hybrid research approach that involves a systematic literature overview of ISA technologies integrated with a research case demonstrating an initial application of an AI-integrated dynamic speed limiter system is applied. The Intelligent Speed Limiting System (ISLS) being proposed obtains continuous vehicle position data via GPS and then uses a digital road map database to ascertain what upcoming speed limits will be. An AI model predicts road segments ahead, and a speed controller administers acceleration or deceleration. While other systems react to what it detects, our system predicts and prepares the vehicle for a more gradual transition when needed. We present key contributions of this work as following:

(1) A critical review of current ISA approaches, including their benefits and limitations.

(2) A novel system architecture that integrates GPS, AI prediction, and digital map awareness.

(3) A simulation-based study where early estimated results demonstrate feasibility, accuracy, and improved driving smoothness.

(4) A roadmap for future enhancements and deployment in real-world vehicles.

The remainder of the paper is organized as follows: Section 2 provides a detailed review of the state-of-the-art in ISA systems, Section 3 describes the proposed ISLS system, including its architecture and key modules. Section 4 presents electronic circuit design and safe vehicle integration. Reinforcement Learning (RL) modeling and performance evaluation presents in section 5. results and analysis in section 6, Comprehensive Validation and Extended Evaluation in section 7. Section 8 discusses comparative analysis with existing ISA and Speed Control Systems. Finally, Section 9 concludes the paper and highlights areas for future work.

The rapid evolution of ISA systems has seen a shift from basic advisory tools to advanced, semi-autonomous systems designed to aid drivers in maintaining legal and contextually appropriate speeds. Traditional ISA solutions have largely relied on static datasets and driver alerts to notify vehicle operators of posted speed limits. Other prominent implementations like Volvo’s IntelliSafe and Toyota’s Safety Sense use GPS and traffic sign recognition to passively prevent drivers from exceeding the speed limit or running red lights, though without the systems taking over the vehicle. However, this kind of system has good potential in the marketplace, but cannot do much to eliminate speeding this is only possible if the driver complies with driving limits well. Such systems never change the speed of the vehicle autonomously and are often unreliable in highly variable speed settings such as in urban, suburban, or school zone environments. Beyond this, the static nature of the digital maps used by many conventional systems leads to exposure to inaccuracy due to temporary road changes, construction or adjustable regulation. However, the limitations here emphasize the requirement of intelligent systems that can both understand the context and take action in a time-efficient manner.

Environmental Perception: Due to the aforementioned potential dangers posed by inaccurate enforcement of speed limits, real-time speed limit sign detection has been another major research focus area in ISA development based on computer vision. These systems are based on convolutional neural networks (CNNs) or similar deep learning models that classify speed signs appearing in the input image frames from onboard cameras [11]. Although CNN-based detection has proven to be highly accurate in good visibility conditions, it frequently fails when the weather is inclement, or it gets dark, or if other vehicles or foliage occlude the scene. Additionally, vision-based systems generally have no higher level contextual understanding (e.g., whether a detected speed sign is for the current lane/direction or if other speed zones change dynamically or due to road geometry) regarding the current environment. As an example, the temporary limits close to construction sites or the time- dependent or traffic-related speed regulation are generally missed. Therefore, though vision systems can improve upon the limitations of GPS and map data, they are not sufficient alone for intelligent speed control. To overcome these limitations, additional data sources and predictive intelligence have been added to achieve better ISA capabilities.

AI, especially fuzzy logic and RL has become an attractive solution for adaptive speed control design. Systems based on fuzzy logic implement rules from expert drivers, which provide both low-latency response and transparency by determining the vehicle speed through a linguistic style [12]. Such systems are especially appreciated because of their simple and interpretable nature, and they can be used in embedded automotive applications. However, they need a very large manual tuning on membership functions and sets of rules, which reduces the scalability and adaptability. In contrast, RL-based systems are model-free learning systems, which can optimize speed control strategies by interacting with the environment through a reward-guided exploration strategy, such as Deep Q-Networks (DQNs) [13] and Proximal Policy Optimization (PPO) [14]. These models can take different types of sensor inputs and are capable of changing their behaviour in different scenarios or environments, and they perform better in simulated environments than rule-based approaches. However, RL models are trained on large datasets and require significant computational resources, and their black-box nature creates some interpretability and safety challenges—which is especially critical when applied in safety-critical settings like vehicle control.

One major development in ISA systems is the predictive model of upcoming speed transitions based on both route history and spatial context. Long Short-Term Memory (LSTM) networks, which are a type of recurrent neural network (RNN) can be used to model temporal sequences [15], since they have been successfully implemented in road context and speed zone prediction [16]. Using sequential GPS and map data, LSTM models are able to infer the speed profile of an upcoming road segment and allow anticipatory speed adjustments. Very recently, graph neural networks (GNNs) has been proposed to consider the road network as graph which able to capture spatial dependency and interconnectivity better than sequential models [17]. Indeed, GNN-based models are more computationally expensive and require more complex data preprocessing, thus becoming a hindrance for real-time applications. However, when used in conjunction with adaptive control, the forecasting models can substantially improve the proactive control and occupant comfort.

Meanwhile, there have been research and industrial activities on context aware ISA system, which focus on integrating GPS, map data, as well as AI-based control in a unified ISA system. They are capable to adjust speed in real time according to road context. For instance, some systems dynamically retrieve OpenStreetMap (OSM) data about the speed limit of the road for the present and next segment and modify throttle or braking [18]. In more sophisticated systems, AI forecast models are coupled with RL based feedback controllers to create closed-loop systems that are able to both predict and respond to changes in speed transitions [19], [20], [21]. Those architectures are also a nice step forward in ISA systems, due to having the perception and the planning aspects of an autonomous driving system. Nevertheless, hardly any architectures combine every required part—map-based prediction, AI-based control, actuator, which operates in real-time-and practically none in real street driving, where there has been safety and illegality issues. This combination leads to a significant research gap regarding the deployment and scalability of such ISLS.

The reviewed studies collectively reveal clear research gaps in the field of ISA:

1. Static systems lack adaptability and depend entirely on driver compliance.

2. Vision-based systems offer perception but lack contextual understanding.

3. AI-based controllers provide adaptability but face scalability and interpretability challenges.

4. Predictive architectures enhance anticipation but are computationally burdensome and rarely validated in real-world settings.

The ISLS proposed in this work overcomes these limitations by presenting a modular and prediction framework that integrates perception, prediction, and control. We use GPS data and a digital map to track environment information to recognize driving environments, LSTM-based sequential models to predict how fast the inner city/highway/area can drive ahead of time, and real time adaptive control is achieved by RL or fuzzy logic controllers based on deep learning. Different from the existing systems, ISLS combines alerting or reactive braking with a proactive speed adjustment to optimize and match speed with upcoming zones improving safety and comfort of the passengers while remaining computationally tractable and scalable to real-world problems.

A modular and scalable architecture serves as the foundation for the development of AI-enhanced dynamic speed limiter systems, which can synergistically integrate a large number of data resources, prediction models, and control algorithms, enabling proactive operation and comfortable adjustment of the acceleration limits. An Integrated Speed Limiting System that can integrate information via GPS, digital road maps, AI forecasting mechanisms, and real-time control logics This section is a lane-by-lane explanation of modules in the system, their interaction with one another, and the communication that happen between the modules. This architecture is flexible enough that it can be utilized in a simulated or closed-loop implementation where the necessary sensor/actuator equipment can be configured to reflect its operation within realistic conditions for research or deployments in the field.

a. ISLS Architecture Description: The ISLS architecture is fundamentally composed of five main subsystems, as illustrated in Figure 1: the GPS module; the road map and speed limit database; the map prediction module; the AI based throttle controls module and; the vehicle interface module. All these subsystems collaborate together to enable adaptive speed control in real-time depending on the context and the predicted driving conditions as follows:

(1) GPS Module: It continuously reads the actual position of the vehicle in real-time through Global Navigation Satellite System (GNSS, such as GPS or Galileo).

(2) Road Context Database: Queries OSM, HERE Maps, or Google Maps APIs to obtain road attributes such as speed limits, curvature, zones (e.g., school, construction), and historical traffic data.

(3) Map Forecasting Module: Uses LSTM or graph-based models to predict upcoming road features and speed transitions.

(4) Speed Control Module: Implements fuzzy logic or RL-based control algorithms to ensure smooth speed adaptation.

(5) Vehicle Interface: Connects to either a vehicle simulator (SUMO or Carla) or a physical vehicle via a Controller Area Network (CAN) or On-Board Diagnostics (OBD-II) port.

b. GPS and road context Subsystem: This subsystem measures the actual position of the vehicle, and identifies the relevant road context. This is important for fetching map data according to the vehicle position. What: The GPS module provides the interface to services such as NMEA GPS receivers or GNSS-enabled mobile devices. Positional accuracy can be improved using approaches such as differential GPS (DGPS) or real-time kinematic (RTK). At the same time it requests from a road map API an extraction of:

(1) Current speed limit and upcoming speed zones.

(2) Road geometry and curvature data.

(3) Time-dependent regulations (e.g., school zone hours).

(4) Alert zones (e.g., accident-prone or congestion areas).

This dual input—geolocation and road context—serves as the primary data feed for the forecasting engine as shown in Figure 2.

c. Forecasting Module: The forecasting module leverages AI to analyze sequential or graph-structured data and predict road features up to a defined distance or time horizon ahead. The key objective is to enable the system to anticipate speed transitions and recommend preemptive throttle/brake control.

(1) LSTM Model: Receives sequential GPS and map data (e.g., road ID, distance, curvature, expected speed), and forecasts future speed zones.

(2) GNN: Optionally models the road network as a graph with nodes representing road segments and edges encoding transition probability and topology. GNNs are particularly effective in urban environments with dense intersections.

Training is conducted on datasets such as the Udacity self-driving car dataset, Argoverse, or nuScenes, incorporating location traces labeled with corresponding speed limits.

The output of the forecasting module is a time-series of predicted speed targets with associated confidence levels, which then guides the control module.

d. Speed Control Module: Once forecasted targets are available, the speed control module determines the necessary acceleration or deceleration to ensure a smooth and safe transition. This module is responsible for real-time actuation and maintains stability under varying conditions.

Two primary AI approaches are considered, as shown in Figure 3:

(1) Fuzzy Logic Controller: Based on rule-based heuristics, e.g., “IF approaching school zone AND current speed $>$ target speed THEN gradually decelerate.”

(2) RL Controller: Uses models such as Deep Q-Network (DQN) or Proximal Policy Optimization (PPO) to learn an optimal policy that minimizes jerk (rate of acceleration change), maintains speed compliance, and ensures passenger comfort.

The controller continuously monitors:

(1) Speed error (difference between current and target).

(2) Distance to transition.

(3) Environmental conditions (e.g., incline, weather if available).

(4) Vehicle state data (velocity, acceleration, brake status).

e. Vehicle Interface and Execution Environment: ISLS has a design that is agnostic of the vehicle or simulator used to test the components. The Carla or SUMO simulation environments can be used to simulate the dynamic behavior of the vehicle and context of the environment during the research and testing phases. They provide detailed models of traffic and vehicle dynamics, and support integration with the Robot Operating System (ROS) for real time data exchange. In case of physical deployment, the system connects to:

(1) Speed reading and throttle/brake signals via OBD-II port using ELM327-compatible adapters.

(2) CAN Bus from Raspberry Pi or Jetson Nano to drive actuators directly (depending on safety limits).

The architecture allows for hybrid modalities to be executed in which the world GPS and camera feeds are processed but command actuation remains a simulation, meant to be the penultimate step prior to fully-real-world trials.

f. Inter-module Communication and Data Exchange:

ISLS is built on a modular, service-oriented framework of communication with inherent reliability of real-time data delivery between components. All intermodule communication uses a publish–subscribe pattern via Message Queuing Telemetry Transport (MQTT). Each of the modules (GPS, Map Forecasting, Speed Control and Vehicle Interface) publishes and subscribes to defined message topics containing schema-less JSON payloads. Example fields of messages include the below—all timestamps, latitudes, longitudes, current_speed, predicted_speed and control_action for real-time synchronization, modules are layered over a TCP/IP socket layer and communicate via lightweight asynchronous messaging libraries (ZeroMQ or ROS topics). Exchange rates for messages is standard depending on the GPS update frequency of TEN-1 Hz. Also, the system bus latency was less than 30 ms during the simulations, which resulted in a seamless performance of the control actuation.

• The GPS module publishes vehicle_position messages.

• The Road Context module subscribes to position data and publishes speed_limit and road_curvature updates.

• The Forecasting module consumes map data and emits predicted_speed_target.

• The Control module subscribes to the predicted target and sends actuator_command messages to the Vehicle Interface.

• The Vehicle Interface module transmits control signals to actuators through CAN 2.0B or OBD-II protocols, using standard PIDs for speed and throttle position.

All data transactions are time-stamped and logged locally for traceability. In physical deployments, the communication backbone can be extended to 5G or DSRC (Dedicated Short-Range Communication) links for V2X integration.

g. Modularity and Scalability: This aspect of ISLS design is one of the most fundamental. Forecasting, control, and data acquisition are all decoupled, which means that each component can be upgraded or replaced independently. For instance:

(1) GNN forecasting can be replaced with Transformer models;

(2) Fuzzy logic may be substituted by model predictive control (MPC);

(3) Vehicle-to-Everything: The integrated 5G-based roadside data can be scaled to V2X.

This flexibility guarantees its long-term relevance and adjustment due to all the moving parts with innovative vehicles technology and legislative requirements, as duly demonstrated in Table 1.

Implementing such AI-assisted dynamic speed limiter in real vehicular scenarios requires not only sophistication of the algorithms, but architecture as well, and it needs to be specially designed for both reliability and safety for the sake of longevity and security of the solution, bridging the gap between intelligent computation and physical enactment. CARLA and SUMO types of simulation environments are great spaces for testing control algorithms and environmental responses, yet for the computation to reach a commercial level, it will have to also reach a certain level of electronic subsystem that is capable to run on the architecture of the vehicle. The Modular, Real-time Capable, Safety-critical and Low-Cost ISLS Deployment on Commercial Off-the-Shelf Hardware Table 2 and Figure 4 provide an architectural overview of the proposed embedded system.

The Intelligent Safety Layering System (ISLS) needs to take command over various car actuators from the vehicle itself, either electronically through the vehicle drive-by-wire/safety-by-wire or mechanically/commonly from the legacy system. Control of actuation is done through optically isolated relay modules or logic-level MOSFET driver circuits, based on whether the interface is to digital input lines (e.g., speed control overrides in EVs) or through physical components (e.g., throttle servo control). The design of Power supply is important for system stability and safety. The automotive environment is an arduous one that is full of transients, voltage dips while cranking as well as Electromagnetic Interference (EMI). These challenges are handled in the ISLS by high-efficiency buck regulators, such as the LM2596 for 12V-to-5V conversion, and low-dropout (LDO) regulators like AMS1117 to provide a clean supply of 3.3V to sensitive components. Schottky diodes, polyfuses (e.g., MF-R050) and TVS diodes (e.g., 1.5 KE18A) integrated with overvoltage and reverse polarity protection circuits the design philosophy is that this module must be separately tested and certified before being integrated into the complete system, and therefore if this module is correct, it should have been tested and validated in isolation.

Underpinning all of this, the embedded software stack uses a real-time or event-driven architecture to orchestrate sensor data collection, AI model inference, and control signal dispatch. For devices such as Raspberry Pi™, Python’s asyncio framework or Linux with real-time extensions (PREEMPT_RT) can control asynchronous events with bounded latency. You have timing control through FreeRTOS or a bare-metal interrupt-driven design with deterministic timing on MCU-based platforms. It contains a hardware watchdog timer that helps with software lockup and undefined states and a status indicator through any status indicator devices (LEDs/OLED displays, etc.) for instant feedback to the user.

In case you have a vehicle without digital interfaces or that isn’t CAN-enabled, the ISLS takes a more “hands-on” approach to actuation. The adjustment to the throttle pedal or cable is performed physically using a servo motor or stepper motor, which is controlled by PWM signals sent from the embedded board. The closed-loop control system uses feedback from potentiometers or Hall-effect position sensors. This mode of operation is especially important in developing countries where older vehicles sit in traffic. Safety is the guiding direct principle in the design: Inherent reversibility ISLS intervention, but its manual override always prevails under all conditions.

Table 2 show the comparative summary of electrical and performance characteristics of the proposed ISLS circuit. These parameters include power, latency, isolation and reliability derived from the component datasheets and design standards. These results focus on system-level expected behavior rather than component cost or selection. The Bill of Materials (BoM), underlined in Table 3, provides specifications for each of the ISLS prototype components indicating the roles they perform as well as their approximate cost. In addition to Table 2, which emphasizes no performance figures in the paper, it shows the material and outlay breakdown of the design to demonstrate that the whole ISLS prototype can be constructed for under $100 USD, making it a convenient target for academic testing, public safety testing and wider smart mobility embedding. In addition, the open-ended architecture of the system allows for future upgrades, including ADAS module integration, V2X communication or AI models to help predict traffic and control signals.

The ISLS system electronic and mechanical design presented illustrates an applied engineering balance of real world deploy ability, rigorous modular scalability.

It is designed to allow modern or legacy vehicles, incremental testing, and to maintain stringent safety requirements. The project is tailored to prove not only its concept what is dynamic speed limiting powered by AI, but also the implementation of an experiment towards field validation in various operational environments.

The conceptual performance analysis of the proposed ISLS electronic circuit is also described in this section. At this point, we want to emphasize that there is no physical prototyping, hardware implementation, or experimental validation performed. The following work thus is presented as a heuristic evaluation using a design framework, component-level specifications based upon manufacturer datasheets, and an theoretical review based upon established engineering principles. This section is aimed to give an detailed overview of workability of circuit upon realization and its validation over automotive system level specifications.

a. Design Objectives and Expected Performance Criteria

The new electronic circuit has to be designed for certain specific objectives: System depends on it continued operation (e.g. electrical safety and low-latency response), modular interconnect and systems to automotive requirements. The key performance criteria with target values based on applicable standards and component specifications are shown in Table 4. These requirements include all system latencies to be below 50 mSec, opto-isolation ratings $>$3.7 kV, ripple voltages on regulated rails below 50 mV, and elements capable of handling faults (protected by components including polyfused and watchdog timers). These are not validated numbers from hands on measurements but realistic expectations from behavior well known within the individual components at nominal operating conditions.

b. Expected Power Management and Stability of Electric

In the ISLS circuit, the power regulation strategy is cascaded from a 12 V vehicle supply to 5 V and 3.3 V rails with a 12 V to 5 V LM2596 buck converter driving a 3.3 V AMS1117 linear regulator. These are some of the most commonly used components in embedded applications and designed to drive loads up to 2 A with current limiting and thermal shutdown features. The anticipated ripple voltage is under 50 mV with Full Loading based on datasheet estimates and normal application circuits. Although not validated by the experiments yet, these values agree with the industry statistics and can be used as an accurate starting point for practical RF circuit design.

c. Thread Latency Estimation and Timing Characteristics

Automotive control applications require a timely response. A latency analysis for the proposed system is presented in this paper, and indicates that the system should demonstrate acceptable latency performance. The GPS modules themselves incur base latencies of the order of 100–200 milliseconds when operating at 1–10 Hz as shown in Table 5, and software-level processing (such as AI-based prediction (e.g., LSTM inference) and fuzzy or reinforcement logic) adds about 15–25 milliseconds, depending on computational load. 10–15 milliseconds more will be needed to receive signal relay and CAN/OBD-II message transmission. These are estimates so theoretical but they have been standing similar to earlier studies and practical observations from the similar embedded vehicle systems.

d. Keeping Safe from the Interface and Integrity of the Isolation and Signals

The design also includes opto-isolators (PC817) for safe operation in automotive high-voltage environments and electromechanical relays (SRD-05VDC-SL-C) for controlling the system while decoupling from the control logic and vehicle power and signal systems. The PC817 gives an isolation voltage greater than 3.7 kV (datasheet values, not real conditions), and the relays are able to provide mechanical switching in the order of 5–10 milliseconds on average. Indeed, whilst real-world circuit-testing is required to prove system-level electromagnetic compatibility (EMC), the theoretical grounds would suggest that the proposed design is conceptually sound engineering.

e. Fault Response and Resiliency Scenarios

Several potential fault scenarios were identified and analyzed at a conceptual level to validate the adequacy and safety of the proposed ISLS design. These are loss of GPS signal, delay in AI inference, relay or actuator malfunction, and spike in voltage transients. Table 6 summarizes expected system behavior and fallback logic for each condition. For instance, polyfuses recover automatically from overcurrent events, and important sensor faults trigger a passive monitoring mode to help ensure driver situational awareness. ISLS response time to sudden speed-zone changes is safe owing to its round-trip latency, which averages 35–45 ms (under the critical real-time control level of 50 ms).

A layered architecture for ISLS encapsulated safety and fail-safe mechanisms so that reliable operation could be preserved in the event of a component or sensor failure. The prediction module continuously validates its data with range and plausibility checks, and if GPS or map data are outside a range that is found to be at the confidence threshold of $\pm$5% then the module reverts to the latest known validated speed zone. The control module incorporates a watchdog process that monitors action validity and control-loop latency at 20 Hz. In case of abnormal output, such as braking signals or unresponsive throttle, the system enters a fail-safe state, setting the throttle to idle and applying moderate ($\approx$0.2 g deceleration) braking will be applied until stable input is reached again. This manual activation also allows the driver to immediately override the system, having regained full control with the operation of the brake or accelerator, while visual feedback on speed limits continues to remain active.

The fault-handling behavior is classified into three categories: 1) software-level redundancy, where mirrored LSTM predictions are executed on separate threads to identify anomalies during inference; 2) communication-level redundancy, which utilizes dual CAN interfaces to ensure commands are delivered reliably; and 3) system-level recovery, which automatically reinitializes modules after transient faults. Additionally, an emergency fallback mode reverts the system to advisory ISA operation if synchronization loss exceeds 500 ms These measures aims to give resilience against hardware, software and communication errors; trees that has the objective of giving safe operation on mixed-control environments. Physical hardware validation is a future work item, but we have demonstrated via simulation that the safety architecture of ISLS maintains correct system behavior during fault scenarios through controlled downgrading of functionalities and operational state, thus showing compliance with many of the principles of ISO 26262 for automotive functional safety.

In this section, the integrated modeling and simulation framework, where the ISLS is evaluated. The system consists of a speed prediction module and a speed control module. When combined, they may function in a closed-loop arrangement, enabled by performance analysis through simulation and benchmarking against baseline systems. The aim is to evaluate the ISLS performance by way of speed alert, smooth and safe control response, and compliance with regulation in different driving scenarios [22].

Several symbols are introduced in this section which are used as follows:

$t$—current time step;

$\tau$—prediction horizon, typically 3 to 5 seconds ahead;

$v$_target—target or legal speed limit for the upcoming road segment;

$v\_hat\_t$ + $\tau$—predicted target speed at time $t$ + $\tau$

$v\_current$—vehicle's instantaneous speed;

$e\_v$—speed error, defined as the difference between current and target speed;

$de\_v$—rate of change of the speed error;

$d\_zone$—distance to the next transition zone;

$s\_t$—vehicle state vector at time t;

$a\_t4$—control action such as throttle or braking command;

$\pi(s\_t)$—control policy mapping states to actions;

$R\_t$—reward signal used in reinforcement learning;

$jerk\_t$—rate of change of acceleration and

$\alpha$, $\beta$, $\gamma$—weighting coefficients for safety, comfort, and compliance in the reward function.

The speed forecasting module is designed to predict future speed limits several seconds or meters ahead based on GPS position, road geometry, and contextual metadata. It leverages deep learning architectures trained on labeled vehicle trajectory datasets. The primary model is an LSTM. At each time step $t$, the input feature vector $x\_t$ includes [22], [23], [24]:

(1) latitude_$t$, longitude_$t$: GPS coordinates,

(2) speed_$t$: Current vehicle speed,

(3) curvature_$t$: Road curvature,

(4) zone_type_$t$: Encoded road context (e.g., residential, school).

A sequence of such vectors, denoted as $X$ = $x_1$, $x_2$, $\ldots$, $x_T$, is used to predict the target speed $v$_hat at a future point $t$ + $\tau$.

where, $\tau$ is the forecasting horizon (typically 3–5 seconds). The model is trained using the Mean Squared Error (MSE) loss:

The model architecture consists of three sequential LSTM layers with 64, 32, and 16 neurons, respectively, each followed by a ReLU activation, and a final linear output layer producing a continuous target speed value. Input sequences can be fixed at 30 time steps, corresponding to a 3-second prediction horizon sampled at 10 Hz, with all inputs normalized to the range [$0, 1$]. The network can be trained using the Adam optimizer with an initial learning rate of 0.001, which was reduced by a factor of 0.5 after 10 epochs of no improvement in validation loss. Training were conducted for up to 80 epochs with a batch size of 64, employing a MSE loss function and early stopping (patience = 10 epochs) to prevent overfitting. The dataset contained approximately 10 000 labeled map–speed segments obtained from OSM and Next Generation Simulation (NGSIM) datasets, covering urban, suburban, highway, and rural road types. Data can be separated into 80% for training, 10% for validation and 10% for testing. Trainable on workstation with NVIDIA RTX 3060 GPU with average epoch time $\sim$12 s. The implementation is written in Tensor Flow 2.12 (Python 3.10), and all data preparation scripts, configuration files, and trained model checkpoints were archived for complete reproducibility. The optional GNN variant can use the same hyperparameters, but with batch size = 32 to handle this higher memory cost.

Based on the predicted speed targets, the control module determines the appropriate vehicle response through one of two AI-based strategies: Fuzzy logic or RL. The controller receives the following state variables [25], [26], [27], [28]:

(1) e_$v$ = $v$_current - $v$_target: Speed error,

(2) de_$v$: Rate of change of speed error,

(3) d_zone: Distance to the next transition zone,

(4) curvature: Road curvature from map data.

The Fuzzy Logic Controller (FLC) applies rule-based heuristics, such as:

IF speed_error is HIGH AND de_$v$ is INCREASING THEN control_action = STRONG_BRAKE

This approach ensures interpretable and continuous throttle/brake adjustments.

The RL Controller instead learns a policy $\pi(s\_t)$ to choose optimal actions ($a_t$) based on the vehicle’s current state:

The RL model is trained using a custom reward function:

where, jerk_$t$ is the derivative of acceleration (comfort indicator), and violation_penalty_$t$ = 1 if the speed exceeds the limit. Coefficients $\alpha$, $\beta$, and $\gamma$ are tuned to balance safety, comfort, and compliance.

The controller part is implemented as a DQN RL framework, which converts the given target speed into throttle and braking signal. The state vector of the system contains predicted speed, speed of the current vehicle, throttle, brake and distance to the next speed-limit area. The action space is discrete and consists of four control decisions: accelerate, hold, decelerate, brake. For the DQN, we used a three layer fully connected network (128, 64 and 32 neurons, respectively) with ReLU activations, the learning rate of 0.0005, and the discount factor ($\gamma$) = 0.9. Experience replay buffer was set to 50,000 transitions and exploration rate decay exponentially from 1.0 to 0.05 over the course of training. Every training episode calculated 1,000 time steps, equivalent to 60 seconds of driving (control updates at 20 Hz). Instead, it trained a reward function to discourage differences of desired and observed speeds, jerky acceleration, and any speed above the speed limit to favor smooth driving which follows traffic laws. We can run training for 1,000 episodes on PyTorch 2.1 on NVIDIA RTX 3060 GPU. All random seeds, hyperparameters, and configuration files were logged and archived to allow independent reproduction of the results.

ISLS can be implemented in a custom Python-based simulation framework. Scenarios could be constructed to mimic common real-world driving contexts, such as:

(1) Sudden school zone entry (e.g., from 60 km/h to 30 km/h),

(2) Variable speed highways with time-dependent limits,

(3) Curved rural roads with low visibility or hidden signs.

Baseline systems used for comparison include:

(1) Traditional ISA (alert-only),

(2) CNN-based traffic sign recognition (vision-only),

(3) Fuzzy controller with static inputs,

(4) ISLS (LSTM + fuzzy),

(5) ISLS (LSTM + RL).

Each scenario must be executed over 10 runs to average out randomness and ensure statistically valid results.

Python 3.10 from a 64-bit Ubuntu 22.04 OS can be used for running all simulations. We used an Intel Core i7-12700 CPU (12 cores, 2.1 GHz), 32 GB RAM, and an NVIDIA RTX 3060 GPU (12 GB VRAM) as the hardware platform. This makes TensorFlow 2.12 and PyTorch 2.1 useful for deep learning models, NumPy 1.26, Pandas 2.2, and Matplotlib 3.8 useful for data handling and visualization, etc. To this end, we create a custom Python-based testbed capable of simulating the vehicle behavior in a scenario in CARLA 0.9.15 and SUMO 1.18, and we integrate these simulations through the ROS Noetic for synchronized vehicle control and data exchange. Random seeds can be made constant across all modules to obtain reproducible results.

To assess performance, five key metrics were defined [29], [30], [31]:

(1) Speed Compliance Rate (SCR): Measures the percentage of time the vehicle remained within $\pm$5% of the speed limit:

(2) Smoothness Index (SI): Quantifies passenger comfort based on average jerk:

(3) Prediction Accuracy (PA): Evaluates the LSTM model’s speed target forecasts against actual speed zones:

(4) System Latency(L): The time delay to detect a speed change and then provide a control command:

(5) Accident Probability Estimate (APE): Probability of an unsafe events (e.g., late-braking) based on simulation logs.

For validity and reproducibility purpose, all experiments were performed using a simulation platform developed in Python targeted towards simulating AI-aided vehicle behavior. The simulation represented a simple road network with urban, residential and curved rural sections with context-aware speed limits. Environmental variability was held constant to isolate environmental noise from speed compliance behavior.

The forecasting model can be trained using a synthesized dataset obtained from public autonomous driving benchmarks, like in study [30]:

(1) The Udacity Self-Driving Car Dataset, including GPS traces, vehicle telemetry, and road geometry features.

(2) The Argoverse Motion Forecasting Dataset annotated with road IDs, curvature and speed limits, per urban driving trajectory.

(3) The nuScenes Dataset, used for optional GNN training due to its dense urban topology representation.

From these sources, a structured dataset could be constructed with the following features:

(1) timestamp: Time (in seconds),

(2) gps_lat, gps_lon: Vehicle location coordinates,

(3) road_id: Unique identifier for each road segment,

(4) curvature: Real-valued metric indicating the road bend intensity,

(5) zone_type: Encoded type of zone (e.g., school, highway),

(6) current_speed: Instantaneous vehicle speed,

(7) target_speed: Assigned speed limit for each segment,

(8) transition_distance: Distance until next speed change (in meters).

Each input sequence spans a 10 -second time window (10 timesteps, 1 Hz resolution) was used as the input to the LSTM forecasting model, with the target being the speed limit at $t$ + $\tau$, where $\tau$ = 3 seconds. Control and simulation settings are as follow:

(1) Controller Horizon: The control loop updates every 1 second using the most recent prediction.

(2) Vehicle Dynamics Model: Simplified point-mass model with throttle and brake acceleration limits of $\pm$3.5 m/s$^2$.

(3) Noise Injection: Gaussian noise with zero mean and $\pm$5 m offset applied to GPS during robustness tests.

(4) All modules operate at 1 Hz to match typical GPS update frequencies.

(5) Fallback Behavior: Controllers revert to “maintain speed” policy if predictions are unavailable.

(6) Comparison Baselines:

$\bullet$ Traditional ISA: Alert-only (no actuation),

$\bullet$ CNN Sign Detector: Trained on synthetic sign images using a MobileNet architecture,

$\bullet$ Static fuzzy controller: Uses fixed target speed from signs,

$\bullet$ ISLS variants: LSTM + Fuzzy, LSTM + RL (DQN or PPO-based).

Three repeatable driving routes were defined:

$\bullet$ Scenario A: School zone entry (60 $\rightarrow$ 30 km/h) with a sharp curvature,

$\bullet$ Scenario B: Gradual downhill segment with variable speed signage,

$\bullet$ Scenario C: Urban driving with dense intersections and speed fluctuations every $\sim$200 n.

Each scenario must executed 10 times per system to account for statistical variation. Performance metrics could be logged after each run and averaged to obtain the values presented in the results table. The combined dataset (synthesized from Udacity, Argoverse, and nuScenes sources) was used in two main capacities: (1) to train and validate the LSTM-based forecasting model, and (2) to drive the simulation scenarios in which the trained model was deployed in conjunction with the control modules.

To train the forecasting module, each data point is converted into a time-series window of 10 sequential timesteps (i.e., 10 seconds at 1 Hz), with each timestep comprising a feature vector:

The target output for each sequence is the corresponding speed limit $v$_target at $t$ + $\tau$, where $\tau$ = 3 s. The entire dataset must be normalized and partitioned into 80% for training, 10% for validation and 10% for testing. The LSTM model could be trained using the MSE loss function [32], [33]:

This enabled the model to learn temporal dependencies between location, road structure, and expected speed transitions, which is critical for predictive accuracy.

In extended experiments, a GNN was used to encode complex urban topologies. The road network could be represented as a directed graph where nodes corresponded to road segments and edges encoded spatial connectivity and transition probabilities. Node features included speed limits, curvature, and traffic density (when available). The GNN is trained to predict the next likely speed zone given the vehicle's current segment and direction of motion. This is particularly effective in modeling intersections and multi-lane highway merges.

Once the forecasting model is trained, it can be deployed in a closed-loop simulation environment where, at each time step:

1. A sequence of input features is fed into the LSTM or GNN model to generate a speed prediction.

2. The predicted target speed is passed to the speed control module (fuzzy or RL-based).

3. The controller computed an acceleration/deceleration action $a\_t$ based on the speed error $e\_v$ = $v$_current - $v$_target, its rate of change de_$v$, and road context variables such as curvature and transition distance.

4. These yields one output control action, feeding it to an abstracted vehicle dynamics model, which then propagates the vehicle speeds position according.

This loop get repeated on synthetic test routes created from the datasets. The logged simulation data (e.g., speed profiles, closed-loop controller actions, error metrics) are used to assess the system performance with respect to defined quantifiable performance indicators (e.g., SCR, SI, APE). Interestingly, the same dataset also provided visual components (like GPS traces and road IDs) to map and visualize the system.

The ISLS framework could be validated in both predictive and control dimensions by constructing the simulation as a collection of real-world trajectory data and training the mathematical models off of input-output mappings that were temporally consistent. This guarantees that the experimental results, as those outlined in the performance comparison table, are based on data-oriented modeling, statistically significant assessments and realistic use-case representations. The average results of all simulation scenarios are summarized in Table 7.

The results indicate that ISLS improved significantly as compared to traditional and vision-based ISA systems based on compliance, comfort and response time. By combining AI-based forecasting with intelligent control, driving becomes more efficient and accurate—which leads to a reduced likelihood of accidents. These simulation results provide solid benchmarks, but deployment might prove more complicated in practice. These factors encompass inaccuracies in sensors, delays from embedded hardware, non-deterministic behavior in traffic, and restrictions on actuators. Drawn largely from empirical modeling literature and ISA field deployments:

1. PA expected to be slightly lower than $\sim$90–94% (vs. 96.8% simulated): this is likely due to GPS noise and different quality of demographics).

2. MAE could be elevated to $\sim$2.5–3.5 km/h from $\sim$1.5 km/h based on the standard of digital maps and localization systems.

3. Latency can increase (e.g. from $\sim$45 ms in simulation to $\sim$100–250 ms depending on system bus lay and actuator response latencies).

4. SI may vary from 1.1–1.3 m/s$^3$ (simulated) to $\sim$1.5–1.9 m/s$^3$ in physical systems due to mechanical delays and frictional damping.

Nevertheless, the system’s architecture is robust against modest noise and delay, as proven in simulation fault-injection tests. The predicted real-world performance remains within the accepted tolerance bands for ISA systems, confirming that the ISLS model offers practical deploy ability without major redesign. Therefore, while exact numeric replication is unlikely, qualitative behavior and overall performance trends observed in simulation are expected to hold in physical implementation with high confidence.

However, the system architecture is resistant to small disturbances and time-loss, as shown through fault-injection tests in a simulated environment. Real-world performance stays well within the accepted tolerance bands for ISA systems, verifying that the ISLS model enable practical deploy ability without significant redesign. Thus, while one cannot expect exact numbers in the real testbed, the qualitative behavior and trends concerning performance are expected to hold with high confidence between simulation and implementation.

A pilot for experimentally evaluating a prototype ISLS could be run in a Python-based testbed that models vehicle response along consecutive lengths of road where speed limits are gradually reduced. We have created one simulated scenario (shown in Figure 3) which has a short GPS trajectory corresponding to three different ID of road, and each ID of road is equipped with the speed zone of 60 km/h, 50 km/h, and 40 km/h, respectively. A trained LSTM model accepts real-time system inputs, such as GPS coordinates, vehicle speed, road curvature, and zone identifiers to predict future speed targets in the seconds ahead. These predicted targets are then given to a fuzzy logic controller, which at every time step calculated throttle and brake output such that compliance is ensured while minimizing speed error and jerk. Log the vehicle state variables (speed, acceleration, controller output) and prediction values with 1 Hz resolution over a control window of 3 s. Below is a collection of plots directly representing some of the outputs of this experimental run: dispersed plots of GPS traces, speed traces, predicted targets, control outputs and locations, and performance error distributions. They collectively illustrate how the ISLS pipeline functions in concert from contextual input capture to intelligent actuation.

The GPS trace of the simulated vehicle is shown in Figure 5a (longitude on the x-axis and latitude on the y-axis). We can see that the path being plotted is continuous with constant velocity and plot several consecutive GPS points that cause the plot to be smooth, as it means that it must contain forward movement across the GPS points, which makes sense if it was a smooth road with slight curvature as it is shown in the plot. This section is essential to match the physical location of the vehicle to digital map features like speed zones and curvature. Although the trajectory does not change much, it indicates that GPS signals would continuously be received, which is required to accurately map the real-time location of an ISLS deployment.

Figure 5b maps the speed limits associated with Road IDs 101, 102, and 103. These limits are set at 60 km/h, 50 km/h, and 40 km/h respectively, confirming the experimental intent to simulate a zone with increasingly restrictive speed regulations. This information serves as ground truth during LSTM model training and real-time predictions, and it provides the contextual layer by which vehicle performance is assessed. This was a typical stepwise reduction of allowed speed and presents a serious problem for ISA systems as signs may be missing, occluded, or not visible due to environmental conditions.

In Figure 5c, the vehicle speed is controlled to reduce the speed from 50 km/h to 42 km/h in 3 second time horizon of simulation. The downward slope is continuous without big jumps or oscillations, a likely indication that the controller modulated the throttle or braking force in an anticipatory fashion instead of a reactive fashion. Such behavior suggests that the ISLS was capable of predicting imminent speed changes well enough in advance to avoid harsh deceleration, which is important for passenger comfort and regulatory compliance.

Right next to this, the Figure 5d displays the output of the forecasting based model, in our case an LSTM based model. The time axis is very small, but judging by the plot, prediction is stable at $\sim$48 km/h (the average speed of the next zone). The predicted target here acts as a ghost-victim, which the controller constantly refer to, without ever have to identify any real traffic sign. This shows that the ISLS system is able to predict speed changes earlier based on the road context instead of having to wait for the immediate visual cues.

As presented in Figure 5e, the fuzzy logic controller applied the action in response to the predicted target speed. The control actions are from -1 (full brake) to +1 (full throttle). So the trajectory begins at around -1 and increases to $\sim+$0.5 this suggests high throttle deadend initially followed by reduction as the vehicle nears the desired speed. This means that at first the controller is somewhat conservative, permitting only low rates of deceleration, but only if the speed error is sufficiently small does it allow for small amounts of re-acceleration, or stationary phases. No oscillation or chattering even further proves the validity of fuzzy logic rules, and its practical use with real-world control requirements.

Finally, in Figure 5f, we see the distribution of instantaneous differences between: vehicle speed and predicted target speed as this is predicted throughout the test window. There error values vary from about -3 km/h to +5 km/h and most of data falls within small positive deviations range from -0.5 km/h to +0.5 km/h values. This means that the car was more likely to exceed the target speed than fall short of it, due either to inertia or conservative brake thresholds. However, the spread is still well under the $\pm$5 km/h standard tolerance often permitted in ISA technologies, verifying that the system endured within high accuracy of compliance.

Collectively, these visualizations validate the ISLS capability to fuse successive GPS points, road context, a predictive model, and an intelligent control device to generate the responsive and regulatory-compliant behavior observed in the vehicle in the real world. Above high controlled deceleration, predictive targeting and equitable speed error signal that these systems balance anticipatory versus adaptive behavior. These results validate the ISLS prototype for rapid validation in simulation- or hardware-in-the-loop settings and constitute a foundation for utilizing more complex road topologies and sensory fusion as future processing upgrades.

While Section 5 presented the principal simulation outcomes of the proposed ISLS, this section focuses on validating those findings and expanding their interpretive scope. The purpose is to confirm the consistency, scalability, and interdisciplinary relevance of the ISLS concept beyond the single-scenario results already discussed.

The validation process was designed to test whether the ISLS framework maintains its effectiveness when subjected to broader operating variations and stochastic perturbations not examined previously.

The extended simulations therefore introduced:

$\bullet$ Randomized initial velocities and sensor noise to test numerical stability.

$\bullet$ Variable traffic loads and weather conditions to evaluate environmental robustness.

$\bullet$ Adjusted prediction and control parameters to examine internal algorithm sensitivity.

Rather than repeating baseline performance metrics, the analysis below emphasizes relative behavior, statistical reliability, and system adaptability—key dimensions for establishing methodological validity.

Six representative road and traffic configurations drawn from the same simulation framework described in Section 5 can be used to perform a complementary set of experiments. Table 8 shows the composition of each case that extended the spatial domain ($\approx$15 km) and added realistic disturbances (e.g., signalized intersections, random braking of lead vehicles, low environmental impacts (i.e., rain with intensity up to 20%). This ensures generalizability of Section 5 results, with variables never tested together, which confirms that ISLS maintains high compliance ($>$90%) and smoothness under various conditions.

To assess internal robustness, two model parameters must be systematically varied:

$\bullet$ Prediction horizon ($\tau$) = 1–5 s

$\bullet$ Control cycle ($\Delta$t) = 20–60 ms

Performance variations listed in Table 9 remained within $\pm$4%, indicating that ISLS behavior is insensitive to moderate parameter drift, which supports implementation tolerance on lower-end embedded platforms.

ISLS validity was assessed through a disciplinary lens that surpasses numeric accuracy:

$\bullet$ Control Engineering - closed - loop stability margins still $>$15%, indicating sufficient damping even with actuator latencies at 50 ms.

$\bullet$ AI LSTM generalization error during evaluation on new routes remained below $\sim$5%.

$\bullet$ Embedded Systems: utilization simulated end up with an average of 62% on a Raspberry Pi 4 model, confirming real time feasibility.

$\bullet$ Transport safety: aggregated APE decrement ($\approx$80%) achieves thresholds of acceptability for driver-assistance interventions identified in the current ITS literature.

North of the primary verification that the ISLS is algorithmically sound, was ability to implement it inside related engineering domains.

ISLS System Description: The ISLS is high Level objective of the ISLS is to improve road safety by reducing speed related crashes Over multiple software and hardware safety layers, its architecture integrates predictive modeling and real-time adaptive control. The combined intent of these mechanisms is to promote real-time adherence to prescribed speed limits, especially in high-risk areas including school zones, curvy rural roads and dynamically controlled/freeway-speed limit zones. The most important safety functions ISLS can provide are to stop the vehicle from going over the speed limit, help in sudden deceleration (which is a main cause of rear-end collisions), and reduce the cognitive load on the driver, especially in low-visibility conditions or in places with an unfamiliar road layout. The system might also include fallback behavior and manual override options so that driver control is maintained in extreme circumstances, according to the report.

To evaluate ISLS’s safety impact, a series of simulation-based experiments were conducted using the CARLA open-source driving simulator. The goal was to estimate the system’s ability to reduce the likelihood of accidents in predefined high-risk conditions. The APE—a metric calculated from simulated incident frequencies, unsafe braking events, and recovery behaviors—served as the primary performance indicator. In scenarios replicating sudden school zone entries, the baseline system (traditional ISA or no intervention) showed an APE of approximately 8.2%. In contrast, ISLS led to this estimate decreasing to 1.3%, implying a potential reduction of 84% in crash involvement. Moreover, in curved rural road scenarios APE decreased from 6.5% to 1.5% (77% reduction), and on variable-speed highways APE was reduced from 5.7% to 1.1% (80% reduction). Overall, across all vehicle scenarios, the ISLS resulted in a reduction of estimated probability of experiencing an accident by 81% compared to baseline configurations. Results are calculated statistically based on simulation logs and behavioral trace data from CARLA, along with performance evaluation practices detailed in EU ISA trials and cited from NHTSA’s traffic conflict metrics.

ISLS when implemented at scale, could play an important role in preventing road traffic accidents due to high or inappropriate speed. WHO: Speed is responsible for about 30% of all fatal crashes in high-income countries and as much as 50% in low- and middle-income countries In the widespread implementation area, according to EU ISA pilot studies, ISA systems are predicted to decrease fatal crashes by 19–24% and serious injuries by up to 30% [34]. On dynamic speed zone scenarios, ISLS estimated an 81% decrease on accident probability in our simulation experiments based on CARLA. Conservatively extrapolating this performance to real-world, applying a 40–50% deployment on urban and interurban vehicles would imply a potential annual road death prevention of 18,000 to 25,000 in the European Union, where more than 20,000 fatalities are registered each year. In addition, if similar implementation were globally scaled-up in high-risk settings, the system could help achieve UN Sustainable Development Goal 3.6 to halve global road traffic deaths by 2030 [35], [36]. Comparison-based performance data from hypothetical conformance trials, community ISSA evaluations commissioned by the European Commission, and accident causation statistics from multiple WHO and NHTSA reports are the basis for these estimates, concluding that ISLS can have a significant life saving potential when integrated into an advanced driver-assistance ecosystem.

Calibration of a speed profile: Recent research and developments on ISA and speed control technologies have delivered significant improvements in the area of safety and compliance, 24 but remain primarily reactive and/or simulation-only demonstrations (e.g., Ghadiri et al. [5], Lai et al. [6] and Lai et al. [22]). Conventional and advisory ISA schemes predicated upon static map data and observed driving behaviour, with quantifiable reductions in over speeding, applied in a predictable way without predictive intelligence or autonomous adaptation. Next, the framework in the study by Chaman et al. [11] is based on YOLOv11 to achieve a high recognition accuracy for real-life speed-limit signs. This is closely related to recent advances in deep-reinforcement-learning (DRL) (e.g., Gao et al. [25] and Xiao et al. [26]). While ElSamadisy et al. [27] presented the static and dynamic speed-limit variations into the mixed-traffic environment. Yiğit and Karabatak [30] and Li et al. [35] extended DRL over the years for various domains like car-following, eco-driving and intersection management. While these approaches resulted in smoother control and lower energy use, they were primarily validated in high-fidelity simulators and high-cost implementations were limitedly deployed. In another study, the ISLS proposed consists of an LSTM-based prediction control system and a DQN controller for proactive, reactive and economical speed limitation while driving. It predicts the upcoming speed limits up to three seconds into the future, carries out real-time action with a latency of 42 ms, and runs on a small embedded system that costs around USD 86. ISLS pushes the boundaries of existing ISA paradigms that are predominantly rule-based, vision-dependent, or computationally prohibitive as shown in Table 10—through predictive learning, adaptive reinforcement control, and embedded feasibility.

Introducing an ISLS, this concept provides AI-based predictive dynamic speed limiting. Compared with typical ISA systems purely based upon either static map data or visual sign detection, the ISLS consists of real-time GPS input, digital road mapping, and deep learning–based short-term speed forecasting for proactive and context-aware control. The simulation results show that utilizing ISLS achieves state-of-the-art performance on several metrics, including SCR, which is 92.1% (71.5% for traditional ISA), the PA for future speed zones reaches as high as 94.8%, a better SI of 1.1 m/s$^3$ that reduces passenger discomfort, a corresponding low latency of 42 ms that justifies timely control implementation, and an APE approximately 81% lower across the various scenarios examined in testing. The results confirm that ISLS improves adherence to speed limits and increases safety and riding comfort. Costing about $86, the embedded design only reinforces its appeal for low-cost deployment, specifically where poorer countries still have older vehicle fleets or limited tech infrastructure.

This study highlights how ISLS can enhance driving safety by adaptive-speed control that predicts behavior using intelligent decision algorithms based on mapping. But the results only came from tightly controlled simulations and the actual world is much different, as traffic, driver behavior and weather can influence system performance. The modular design of ISLS helps mitigate against these limitations in that future work will allow integration of further sensors and also external data sources, providing a more robust performance over time and in more realistic environments.

Future work will be the development and testing of an ISLS physical prototype around the suggested hardware architecture. We will be conducting experiments in plans for real-time latency measurement, actuator response, EMI, and thermal stability verification under various driving conditions. Field trials will also include research on V2X-enabled coordination, online learning for adaptive model tuning, and regulatory compliance towards vehicular certification. Such developments will allow ISLS to transition from a validated simulation model to a complete, deployable, contextualized speed management system that is subject to strong performance and safety guarantees in the presence of heterogeneous traffic and weather events.