Computer-executed method for training encoder neural network for use by online prediction model, data processing apparatus, and computer program

Abstract

To provide a method for training an encoder neural network of an autoencoder, and the like.SOLUTION: A method including receiving a data stream and incrementally training an encoder neural network of an autoencoder includes: receiving a part of the data stream as input data; performing encoding processing to acquire a latent expression; storing input data generated during the encoding processing in a first memory layer; processing the input data and the stored input data to generate a memory expression; storing the memory expression and the latent expression in a second memory layer; processing the memory expression and the latent expression to update the memory expression; performing decoding processing on the latent expression by using a decoder neural network; storing input data generated during the decoding processing in the second memory layer; processing the input data and the updated memory expression to refine the memory expression; and outputting the refined memory expression to the encoder neural network.SELECTED DRAWING: Figure 3

Description

[Technical Field]

[0001] The present invention relates to a computer-implemented method for training an encoder neural network for use with an online predictive model, and to an associated data processing apparatus, emergency response management system, computer program, and computer-readable medium. [Background technology]

[0002] The need for rich data and up-to-date, accurate information is essential for making informed, real-time decisions in various domains, which has led to an increasing demand for technologies and models that can effectively facilitate real-time processing.

[0003] Traditional offline (batch) processing models face a trade-off between a significant real-time lag and increased computational demands, primarily due to subsequent retraining. The real-time lag occurs due to the time lapse between when data becomes available or collected and when it is processed. Mitigating this real-time lag requires continuous retraining, which can increase computational costs as datasets grow. To balance this trade-off with resource limitations, the frequency of model retraining is sometimes limited. However, this leads to stale data, which is costly and negatively impacts real-time tasks.

[0004] The rise and need for real-time models has made the use of online processing techniques natural. Models employing this approach update their architecture using each data instance or set as soon as it becomes available, or shortly after it becomes available. The goal of this update process is to improve predictive performance for future data instances or sets. This improves precision and accuracy, especially when processing continuous data streams in many real-world applications. Furthermore, these models are more resilient than offline models when data distributions change. While significant progress has been made, especially in the context of real-time tasks, several challenges remain that can hinder overall performance in online learning, especially supervised online learning. These challenges include (i) computational inefficiency, (ii) catastrophic forgetting, and (iii) concept drift.

[0005] Computational efficiency of online models is important for maintaining low real-time latency, responsiveness to concept drift, and the ability to rapidly process and update in real time. However, computational efficiency conflicts with the need to incorporate a comprehensive set of features and drivers to maintain an up-to-date, real-time, real-world view. Balancing these two conflicting demands is critical to ensure that models can provide timely and accurate insights into real-time interactions and dynamics in the real world.

[0006] Although online models can be fine-tuned to significantly reduce real-time delays, this optimization is not without drawbacks. It also reinforces other limitations that significantly affect the model's performance and predictive capabilities. In particular, these vulnerabilities include sensitivity to noise, loss of historical information, and increased complexity as the feature space expands.

[0007] Furthermore, online models tend to lose historical context and be susceptible to noise, both of which can significantly impact the overall performance of the model. This is particularly harmful when historical context is critical to making accurate predictions, or when detecting long-term trends can lead to overlooking important historical insights, reducing the effectiveness of decision-making.

[0008] In an attempt to simultaneously alleviate the first challenge, incremental learning autoencoders have been employed to reduce the feature dimensionality of online models and increase their computational efficiency. Autoencoders provide a mechanism for detecting drift in data distributions. In particular, autoencoders combined with incremental learning and concept drift adaptation significantly outperform baseline and advanced models.

[0009] However, incrementally trained models still suffer from catastrophic forgetting, where the model forgets past context as it learns new information. Efforts to mitigate this limitation include (1) regularization strategies, (2) rehearsal approaches, and (3) memory mechanisms. Among these approaches, regularization strategies offer no clear advantage over fine-tuning and perform relatively poorly compared to rehearsal approaches. However, rehearsal approaches have significant computational overhead, limiting their usefulness. On the other hand, memory mechanisms appear to be a promising approach.

[0010] Various forms of memory mechanisms have been explored in neural models to preserve long-term memories (thus leveraging predictive capabilities) that can mitigate catastrophic forgetting. Examples include memory-augmented autoencoders (MemAE), feedback recurrent autoencoders (FRAE), memory-augmented adversarial autoencoders with deep reconstruction and prediction (MemAAE), variational autoencoder-based memory-augmented networks (MEMVAE), cluster memory-augmented autoencoders via optimal transportation (OTCMA), and clear memory-augmented autoencoders (CMAM). These model developments have been shown to improve model performance, particularly for anomaly detection. MemAE uses encoding to retrieve the most relevant memory items for reconstruction. The memory contents are trained to represent prototypical elements of "normal" data. Reconstructions are obtained from selected memory records of "normal" data, ensuring that the reconstructions tend to be closer to normal samples. Thus, the reconstruction error against anomalies is enhanced. MEMVAE employs an external memory for the latent space that is queried when the most relevant items of input are received and combined before being passed to the decoder. MEMVAE employs a sparse hard-shrink addressing strategy, encouraging the model to efficiently use limited storage and achieve a low average reconstruction error.OTCMA employs a deep clustering method based on optimal transport to enhance the consistency of features among samples in the same category and the discrimination of features among samples in different categories. Instead of reconstructing based on encoding, more consistent features are retrieved from the memory module for reconstruction, which limits the reconstruction ability of the model and prevents reconstruction anomalies.

[0011] Other autoencoder variations, such as adaptive autoencoders and recurrent autoencoders, have been adapted to improve the processing of temporal data, providing the ability to handle complex temporal dependencies and dynamics that can support other tasks. Adaptive autoencoders (V-Coders) were developed based on adaptive resonance theory, which allows them to learn the qualities of each relationship individually while learning new patterns without discarding old information. Specifically, V-Coders are inspired by cognitive science and incorporate inhibitory control and lateral inhibition to achieve better data representation and reconstruction.

[0012] Most of the models discussed above are highly customized for anomaly detection tasks and lack the ability to generalize well to other tasks, especially those requiring memory for temporal understanding and processing. The generalization challenges of these models become apparent when they need to extrapolate beyond the patterns stored in memory. This limitation arises because the models rely heavily on similarity-based updating and readback. This hinders their ability to adapt to entirely new or unexpected patterns beyond their training experience and can result in an insufficient latent representation of the input. For example, MEMVAE was developed to enhance model representation capabilities for both tabular and time-series data, but reconstruction is heavily based on similarity to memory components. Similarly, V-Coder is customized for pattern recognition, where reconstruction is similarity-based. Therefore, models are prone to misinterpreting changes and evolutions occurring in the data and may struggle to capture and adapt to evolving semantics and changes in relationships between entities. Furthermore, models lack an explicit mechanism for retaining information, making them prone to catastrophic forgetting and therefore lack a means to efficiently preserve context over time.

[0013] Temporal tasks benefit from models with "good" memory mechanisms that combine long-term memory with short-term memory (which can be represented in various ways). These models are suitable because they provide a comprehensive context for modeling (i.e., including both old and new information). Similarly, when using autoencoders for temporal tasks, it is desirable to utilize memory mechanisms that generate good, reliable latent representations of the temporal input. Summary of the Invention

[0014] In one embodiment, a computer-implemented method for training an encoder neural network includes receiving a data stream with an autoencoder including an encoder neural network, a decoder neural network, a first memory layer, and a second memory layer; and incrementally training the encoder neural network on the data stream, wherein each training step of the incremental training includes receiving a portion of the data stream as input data with the encoder neural network; performing an encoding operation on the input data by the encoder neural network to obtain (learn) a latent representation of the input data; and storing the encoded input data generated by the encoder neural network during the encoding operation in the first memory layer. processing the coded input data and coded input data stored in a first memory layer from a previous iteration of the training step to generate a memory representation; storing the memory representation and the latent representation in the second memory layer; processing the memory representation and the latent representation to update the memory representation; performing a decoding process on the latent representation by a decoder neural network; storing decoded input data generated by the decoder neural network during the decoding process in the second memory layer; processing the decoded input data and the updated memory representation to refine the updated memory representation; and outputting the refined memory representation to the encoder neural network for use in the next training step.

[0015] In some embodiments, the encoder neural network includes multiple encoder layers, and the encoded input data stored in the first memory layer is from at least the last encoder layer.

[0016] In some embodiments, the decoder neural network includes multiple decoder layers, and the decoded input data stored in the second memory layer is from at least the first decoder layer.

[0017] In some embodiments, the processing comprises a non-linear transformation process, i.e., any one or more of the processing of the encoded input data, the processing of the memory representation and latent representation, and the processing of the decoded input data and updated memory representation may comprise a non-linear transformation process, which may be different, the same, or partially the same.

[0018] In some embodiments, the data stream includes incident-related data.

[0019] In some embodiments, the encoded input data includes learnable parameters.

[0020] In one embodiment, a computer-implemented online prediction method includes training an online prediction model on latent representations received from an encoder neural network incrementally trained according to the method described above, receiving real-time input data by the trained online prediction model, and processing the real-time input data by the trained online prediction model to generate predictions.

[0021] In some embodiments, the online predictive model predicts incidents that require the dispatch of emergency responders.

[0022] In some embodiments, the real-time input data includes sensor data.

[0023] In one embodiment, a data processing apparatus comprises a memory storing computer-executable instructions for performing the above method, and a processor configured to execute the computer-executable instructions.

[0024] In one embodiment, the emergency management system includes a data processing device and a computer-aided dispatch system configured to receive the incident prediction and, in response, at least one of outputting an alert and transmitting a message to a device of emergency responders.

[0025] Embodiments can be implemented in digital electronic circuitry, or in computer hardware, firmware, software, or in combinations of them. The invention can also be implemented as a computer program or computer program product, i.e., a computer program tangibly embodied in a non-transitory information carrier, for example a machine-readable storage medium or in a propagated signal, for execution by, or to control the operation of, one or more hardware modules.

[0026] The computer program may take the form of a stand-alone program, a computer program portion, or more than one computer program, may be written in any type of programming language, including compiled or interpreted languages, and may be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a data processing environment. A computer program may be deployed to be executed in one module or in multiple modules that are at one site or distributed across multiple sites and interconnected by a communication network.

[0027] The methods of the present invention may be performed by one or more programmable processors executing computer programs to perform the functions of the present invention by operating on input data and generating output. Apparatus of the present invention may be implemented as programmed hardware or as dedicated logic circuitry, for example, a Field Programmable Gate Array (FPGA) or an Application-Specific Integrated Circuit (ASIC).

[0028] Processors suitable for the execution of a computer program include, by way of example, both general and special purpose microprocessors, and any one or more processors of any kind of digital computer. Generally, a processor receives instructions and data from a read-only memory or a random-access memory or both. Elements of a computer are a processor that executes instructions coupled to one or more memory devices that store instructions and data.

[0029] The present invention has been described with reference to specific embodiments. Other embodiments are within the scope of the following claims. For example, the steps of the invention can be performed in a different order and still produce desirable results.

[0030] Elements of the present invention have been described using terms such as "processor" and "input device." Those skilled in the art will understand that such functional terms, and their equivalents, may refer to parts of a system that are partially separate but combine to perform the defined functions. Similarly, the same physical part of a system may provide two or more defined functions. For example, separately defined means may be implemented using the same memory and / or processor, if desired.

[0031] Having generally described embodiments of the present invention, reference is now made to the accompanying drawings, which are not necessarily drawn to scale. [Brief explanation of the drawings]

[0032] [Figure 1] FIG. 1 is a schematic block diagram of an autoencoder according to an embodiment. [Figure 2] 2 is a flowchart of a method for incrementally training an encoder neural network of the autoencoder shown in FIG. 1 according to an embodiment. [Figure 3]3 is a flowchart of the incremental training step of the method depicted in FIG. 2 according to an embodiment. [Figure 4] 10 is a schematic overview of two incremental training steps according to an embodiment. [Figure 5] FIG. 1 is a schematic block diagram of a data processing apparatus implementing a trained encoder neural network and an online prediction model according to an embodiment. [Figure 6] 6 is a flowchart of a method of prediction performed by the data processing apparatus depicted in FIG. 5 according to an embodiment. [Figure 7] 6 is a schematic block diagram of an emergency response management system including the data processing device depicted in FIG. 5, according to an embodiment. [Figure 8] FIG. 2 is a block diagram of a computing means for implementing a method according to an embodiment. DETAILED DESCRIPTION OF THE INVENTION

[0033] Certain embodiments of the present invention will now be described more fully hereinafter with reference to the accompanying drawings, in which some, but not all, embodiments of the present invention are shown. Indeed, the present invention may be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. Like numbers refer to like elements throughout.

[0034] 1 is a schematic block diagram of an autoencoder 100 according to an embodiment. The autoencoder 100 is a machine learning model consisting of an encoder 102 and a decoder 104. The encoder 102 is a neural network (encoder neural network) that includes an input layer that receives input data and one or more hidden layers that encode the input data. The bottleneck layer 108 is the last hidden layer of the encoder 102, and its output is a latent representation (latent space). The decoder 104 is also a neural network (decoder neural network) that includes one or more hidden layers that take the output of the bottleneck layer 108 as input (i.e., the bottleneck layer 108 is the first hidden layer of the decoder 104) and reconstruct the original input for output at the output layer 110. For convenience and clarity, the hidden layers of the encoder 102 other than the bottleneck layer 108 are referred to as encoder layers 112, the encoder layer 112-1 immediately after the input layer 106 is referred to as the first encoder layer, and the encoder layer 112-N immediately before the bottleneck layer 108 is referred to as the last encoder layer. Similarly, the hidden layers of the decoder 104 other than the bottleneck layer 108 are referred to as decoder layers 114, the hidden layer of the decoder layer 114-1 immediately after the bottleneck layer 108 is referred to as the first decoder layer, and the decoder 114-N immediately before the output layer 114 is referred to as the last decoder layer.

[0035] The autoencoder 100 aims to minimize the difference between the input and the output (the reconstructed input) (i.e., the reconstruction loss). This can be done by minimizing a loss function. During training, the autoencoder 100 adjusts its parameters (the weights and biases of the neural network layers) to minimize this loss function. Mean squared error (MSE) and binary cross entropy (BCE) loss are two examples of such loss functions.

[0036] It will be understood that the number of encoding layers and decoding layers, and the types and sizes of the encoding layers and decoding layers, may vary (e.g., be user-defined). Thus, the encoder 102 may include at least one encoding layer 112, and the decoder 104 may include at least one decoding layer 114. If the encoder 102 includes multiple encoding layers 112 and the decoder 104 includes multiple decoding layers 114, the number of encoding layers 112 may be the same as the number of decoding layers 114, or may be different.

[0037] As depicted in Figure 1, the autoencoder 100 also includes a memory module 105 that includes a first memory layer 116 and a second memory layer 118. Broadly speaking, the first memory layer 116 stores encoded data 120 obtained over time from the encoder 102 and creates a memory representation 121 that enables the machine learning model to understand patterns in the encoded data over time. The second memory layer 118 stores the interactions between the memory representation 121 and model encodings (latent representations) 122, as well as the interactions between these encodings 121, 122 and decoded data 124 from the decoder 104, informing the encoding process over time (as indicated by arrow 126). These are described in more detail below with further reference to Figures 2 and 3.

[0038] FIG. 2 is a flowchart of a method for incrementally training an encoder neural network, such as the encoder neural network of the autoencoder 100 depicted in FIG.

[0039] In step 202 , a data stream (a sequence of data arriving in a continuous and varying manner) is received by the autoencoder 100 .

[0040] In step 204, the encoder 102 is incrementally trained on the data stream. The goal of incremental training is to allow the autoencoder 100 to retain its existing knowledge while simultaneously adapting to new data. To achieve this, the autoencoder 100 uses a memory module 105. Incremental training can be likened to the memory process in the brain and can be summarized as follows: (i) Encoding: The creation of a new memory in which information of interest is transformed into a configuration for retention. (ii) Retention / Consolidation: The encoded information is then stored / retained. As part of this stage, memory consolidation occurs (i.e., stabilization through long-term potentiation). (iii) Retrieval: Accessing stored information. (iv) Reconsolidation: Memories are accessed and restabilized, during which they can be strengthened, weakened, or updated.

[0041] These processes of step 204 are described in more detail with reference to FIG. 3 in relation to the incremental training step.

[0042] In step 302, a portion of the data stream is received as input data by the encoder 102.

[0043] In step 304, the encoder 102 performs an encoding process on the input data to obtain (or learn) a latent representation of the input data.

[0044] In step 306, the encoded input data generated by the encoder 102 during the encoding process is stored in the first memory layer 116. Generally, the encoded data from any one or more of the encoding layers 112 may be stored in the first memory layer 116. However, in various embodiments, the encoded data from at least the last encoder layer 112-N is stored in the first memory layer 116. Learning to capture the encoded structure over time and capturing relevant features at the end of the encoding (compression) process may enhance memory retention.

[0045] In step 308, the encoded data stored in the first memory layer 116 and the encoded input data generated by the encoder 102 during a previous iteration of the training step and stored in the first memory layer 116 are processed in the first memory layer 116 to generate a memory representation. The processing may include nonlinear transformation processes, i.e., mathematical operations that enable the network to learn patterns and relationships within the data. The memory representation can be thought of as a type of latent representation of the machine learning model over time. Thus, the interaction of various encoded data over time requires the network's ability to store and manipulate new information it receives in combination with information it already possesses. This is conceptually synonymous with the brain's memory process of creating new memories, although it is not entirely "new" because the model does not create new memory components for each new data set, but simply creates a "new" view of the memory.

[0046] At step 310, the memory representations 122 from the first memory layer 116 and the latent representations from the bottleneck layer 108 are stored in the second memory layer 118. Interaction between these representations initiates some form of consolidation in the second memory layer 118. Specifically, at step 312, the memory representations 121 and the latent representations 122 are processed to update (e.g., strengthen or weaken) the memory representations. The processing may include a nonlinear transformation process, which may be the same as or different from the nonlinear transformation process at step 308. Conceptually, this interaction, propagation, and transformation promotes the strengthening and consolidation of information traces to form long-term memories.

[0047] In step 314, the decoder 104 performs a decoding process on the latent representation.

[0048] At step 316 , the decoded input data generated by the decoder 104 during the decoding process is stored in the second memory layer 118 .

[0049] In step 318, the decoded input data and updated memory representation are processed in the second memory layer 118 to refine (i.e., update, e.g., strengthen or weaken) the memory representation. The processing may include a nonlinear transformation process, which may be the same as or different from the nonlinear transformation processes in steps 308 and 310. This step is essentially a memory refinement, as it compares the model's decoded data with the information processed in the second memory layer and highlights important aspects within the data through a nonlinear transformation. As in step 306, the decoded input data may be obtained from any one or more hidden layers of the decoder neural network 104. In embodiments, the decoded data includes decoded data from at least the first decoder layer 114-1 of the decoder 104. Learning to capture relevant features at the beginning of the decoding (reconstruction) process can enhance memory retention. Conceptually, this is synonymous with reconsolidation in the brain, accessing, stabilizing, and storing old memories. This process provides an opportunity to modify seemingly stable memories, even very old ones.

[0050] In step 320, the refined (further updated) memory representation is output to encoder 102 for use in the next training step. In an embodiment, the refined memory representation is accessed by the first coding layer of encoder 102. Conceptually, this is similar to the readout process in the brain, where stored memories are accessed and sent to working memory for conscious thought and decision-making.

[0051] Thus, embodiments mirror the brain's Complementary Learning Systems (CLS) and enable more explicit feature identification and extraction through separation of different data types (encoding in one layer and a second layer for decoding) and iteration (encoded data representations over time, then the encoded data representations and latent representations, and finally combining this with decoded data). Embodiments first extract important aspects for encoding, then support decoding of these aspects as accurately as possible by highlighting relevant features when combined with the model's decoded data. This improves the efficiency of feature extraction and compression, leading to better latent representations and ultimately better predictions when used in conjunction with online prediction models as described with reference to FIGS. 5 and 6.

[0052] To establish how and to what extent data is copied to memory module 105, three different options are provided.

[0053] In one embodiment, static learning parameters are used, where information is copied completely from the encoder / decoder layer.

[0054] In another embodiment, a joint dynamic learning parameter is used. Here, an additional learnable parameter is introduced into the autoencoder 100 (as part of a parallel or hidden layer of the encoder / decoder) to learn the amount of new information needed to supplement the memory and dynamically store historical context. The parameter for updating the memory can be defined as a regularization term and added to the loss function. During training, the model learns to minimize the loss function by adjusting the learnable parameters. The parameters are learned only during training. The learnable parameters are updated directly from the activations of the parallel or hidden layers, or based on the model.

[0055] In another embodiment, a separate dynamic learning parameter is used, where the learnable parameters (not directly included in the model) are randomly initialized to control the amount of new information needed to supplement the memory and dynamically store historical context. The parameters for updating the memory module 105 are defined as regularization terms and added to the loss function. During training, the model learns to minimize the loss function by adjusting the learnable parameters. The parameters are learned during training. The learnable parameters are updated based on the model.

[0056] Thus, embodiments provide an incrementally trained autoencoder with dynamic memory to support online processing models that can mitigate real-time delays, catastrophic forgetting, comprehensive feature extraction, and / or computational efficiency. The formalized memory dynamically determines how information is retained and utilized. More specifically, the employment of the memory module 105 ensures that relevant information can be utilized in a timely and computationally efficient manner while retaining and using relevant historical context for prediction. Different levels of implicit representations or embeddings are assigned various weights, where these weights are not static but are dynamically assigned for dedicated memory copies. The memory structure loosely formalizes four major processes in the brain's memory dynamics and uses self-learning to dynamically update and process information at various layers for storage in memory. Thus, embodiments ensure computational efficiency while minimizing real-time delays for real-time processing and prediction. Note that the emphasis of the training regimen is on how and when information is utilized within the model, rather than on the learning process itself.

[0057] Figure 4 provides an overview of the real-time incremental training process. At training step i, the outputs from the encoder 102, bottleneck layer 108, and decoder 104 are input to memory module 105, as described above with reference to Figure 3. The output from memory module 105 is input to encoder 102 for the next training step i+1.

[0058] FIG. 5 is a schematic block diagram of a data processing apparatus 500 including a trained encoder neural network 502 and an online prediction model 504. In an embodiment, the encoder neural network 502 has been incrementally trained according to the methods described with reference to FIGS. 2 and 3. The online prediction model 504 is trained on the latent representations output by the encoder neural network 502 and can generate predictions from real-time data. Thus, the data processing apparatus 500 can support low-latency and near-real-time representations because the online prediction model 504 does not typically need to be retrained as in the case of offline models, and, when combined with the trained encoder neural network 502, has a robust memory that retains information for longer periods of time. The retention delay and retention cost (computational cost) associated with offline models can therefore be mitigated or reduced. Furthermore, catastrophic forgetting in the online prediction model 504 can also be mitigated or reduced. It should be noted that the trained encoder neural network 502 can be taken offline for incremental training without affecting the functionality of the online prediction model 504.

[0059] In an embodiment, the trained encoder neural network 502 may be incrementally trained on incident-related data, and the predictive model 504 may generate incident predictions. As used herein, the term "incident" refers to any event to which emergency responders may be expected to respond. Examples of incidents include crimes, traffic accidents, fires, medical emergencies, fires, and natural disasters such as earthquakes and tsunamis. Data related to or relating to such incidents, i.e., incident-related data, may be collected in various ways. For example, people needing assistance or who may have observed an incident may report it to emergency services. Such reports are typically referred to as "calls" for emergency services. Incident-related data may be automatically extracted from calls to emergency operators using call analysis software. Incident-related data may also be automatically extracted from other sources, such as social media posts (e.g., text data) and data from sensors (e.g., visual data, audio data, weather data, environmental data, traffic data, location data, time data, etc.).

[0060] FIG. 6 is a flow chart of a method of prediction performed by the data processing apparatus shown in FIG.

[0061] At step 602, a predictive model 504 may be trained on the latent representations 122 received from the trained encoder neural network 502. The encoder neural network 502 may have been incrementally trained according to the methods described with reference to FIGS.

[0062] In step 604, the online predictive model 504 receives real-time data 508. The real-time data may include sensor data. The type of data may depend on the task for which the online predictive model 504 is being used. For example, to predict traffic accidents, the sensor data may include traffic data obtained from any suitable sensor, such as a traffic camera, a GPS-based application, an anemometer sensor, time data, location data, weather data, or any combination thereof.

[0063] In step 606, the online predictive model 504 processes the real-time data to generate a prediction. In some embodiments, the online predictive model 504 generates an incident prediction.

[0064] FIG. 7 is a schematic block diagram of an emergency management system 700 including the data processing device 500 depicted in FIG. 5. The emergency management system 700 supports communication, data collection, data analysis, and decision-making for emergency situations. By incorporating the data processing device 500, the emergency response system 700 can analyze real-time data to predict incidents and act before they occur, rather than simply reacting to them. For example, as shown in FIG. 7, the data processing device 500 can be communicatively coupled to a computer-aided dispatch system 702. The computer-aided dispatch system is used by dispatchers, call handlers, and operators to prioritize and record incident calls, identify the status and location of responders in the field, and effectively dispatch responders. Here, the computer-aided dispatch system 702 can automatically respond in various ways upon receiving an incident prediction from the data processing device 500. For example, the computer-aided dispatch system 702 can generate an alert on the interface of the computer-aided dispatch system 702. Such an alert may be a visual alert on a display, an audible alert over a speaker, and / or any other type of alert indicating a predicted incident. In another example, the computer-aided dispatch system 702 may automatically initiate transmission of a message to emergency responders via a mobile data terminal, radio, cellular phone, etc. (Of course, safeguards such as a human override may also be implemented.) The message may indicate that an incident is predicted. The message may carry information about the predicted incident. For example, the information may include location information. In this case, the message may also carry a request for emergency responders to arrive at the location. Accordingly, the emergency management system 700 may be implemented as a computing device (e.g., a server) connected to various other computing devices and systems (e.g., user interfaces, databases, geographic information systems, vehicle location systems, etc.) and networks (e.g., telecommunications networks).

[0065] Emergency management systems can be considered latency-critical systems in the sense that they may need to collect data, analyze that data, and then determine a course of action as quickly as possible. The combination of the encoder neural network 502 and the online predictive model 504 in the data processing device 500 is well suited to such systems because it can mitigate or reduce latency, as described above. Furthermore, the data processing device 500 also eliminates the call filtering process traditionally used as part of incident prediction, since the model uses internal memory for appropriate and comprehensive historical context. Furthermore, it does not make implicit assumptions between emergency situations. It also reduces the computational overhead associated with managing multiple models. The proposed model prioritizes timeliness and accuracy, making it ideal for capturing the latest and evolving data.

[0066] The present invention aims to enhance modeling by incorporating explicit brain complexity to support the provision of historical context and eliminate the need for periodic retraining. Specifically, memory complexity allows models to adaptively store and retrieve information flexibly. This historical context prepares the model to model complex dynamics. Furthermore, predictive models can be trained to handle any type of emergency, improving their ability to identify interrelationships and interdependencies between various incidents across multiple sectors. This versatility allows models to generalize highly to a variety of incidents while still being specialized for each emergency service.

[0067] 8 is a block diagram of a computing device, such as data processing apparatus 500, that embodies the present invention and may be used to implement an embodiment method for incremental training of a machine learning model and / or an embodiment method for incident prediction. The computing device includes a processor 802 and memory 804. Optionally, the computing device also includes a network interface 806 for communicating with other computing devices, such as other computing devices of the present invention. For example, embodiments may include a network of such computing devices. Optionally, the computing device also includes one or more input mechanisms 808, such as a keyboard and mouse, and a display unit 810, such as one or more monitors. The components may be connected to each other via a bus 812.

[0068] The memory 804 may include a computer-readable medium, which term may refer to a single medium or multiple media configured to carry computer-executable instructions or store data structures (e.g., centralized or distributed databases and / or associated caches and servers). Computer-executable instructions may include, for example, instructions and data that can be accessed by a general-purpose computer, a special-purpose computer, or a special-purpose processing device (e.g., one or more processors) to cause it to perform one or more functions or operations. Accordingly, the term "computer-readable storage medium" may include any medium that can store, encode, or execute a set of instructions that are executed by a machine, causing the machine to perform any one or more of the methods disclosed herein. The term "computer-readable storage medium" may therefore be understood to include, but is not limited to, solid-state memory, optical media, and magnetic media. By way of example, and not limitation, such computer-readable media may include non-transitory computer-readable storage media including random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), compact disc read-only memory (CD-ROM) or other optical disk storage, magnetic disk storage or other magnetic storage devices, flash memory devices (e.g., solid-state memory devices).

[0069] The processor 802 is configured to control a computing device and perform processing operations, such as executing code stored in memory to implement various functions of the machine learning model and its components as described herein and in the claims. The memory 804 stores data that is read from and written to by the processor 802. As referred to herein, a processor may include one or more general-purpose processing devices, such as a microprocessor, a central processing unit, or the like. The processor may include a multiple instruction set computing (CISC) microprocessor, a reduced instruction set computing (RISC) microprocessor, a very long instruction word (VLIW) microprocessor, or a processor implementing other instruction sets or a combination of instruction sets. The processor may also include one or more special-purpose processing devices, such as an ASIC, an FPGA, a digital signal processor (DSP), a network processor, or the like. In one or more embodiments, the processor is configured to execute instructions to perform the operations and steps discussed herein.

[0070] The display unit 810 may display representations of data stored by the computing device, as well as cursors and dialog boxes and screens that allow interaction between a user and programs and data stored on the computing device. The input mechanism 808 may allow a user to input data and instructions into the computing device.

[0071] The network interface (network I / F) 806 can be connected to a network such as the Internet and can be connected to other such computing devices via the network. The network I / F 806 can control data input from or output to other devices via the network. The computing device may also include other peripheral devices such as a microphone, speaker, printer, power supply unit, fan, case, scanner, trackball, etc.

[0072] The autoencoder may include processing instructions stored in a portion of memory 804, a processor 802 that executes the processing instructions, and a portion of memory 804 that stores weights, biases, and other information related to the autoencoder architecture during execution of the processing instructions. The final trained weights and biases of the encoder may be stored in memory 804 and / or a connected storage unit, and may be transmitted, forwarded, or otherwise communicated to further components.

[0073] The predictive model may include processing instructions stored in a portion of memory 804, processor 802 executing the processing instructions, and a portion of memory 804 that stores weights, biases, and other information related to the autoencoder architecture during execution of the processing instructions. The final trained weights and biases of the predictive model may be stored in memory 804 and / or a connected storage unit, and may be transmitted, forwarded, or otherwise communicated to further components.

[0074] Methods embodying the present invention may be performed on a computing device such as that depicted in Figure 8. Such a computing device need not have every component depicted in Figure 8, but may consist of some of these components. Methods embodying the present invention may be performed by a single computing device in communication with one or more data storage servers over a network. The computing device may also be the data storage itself, storing trained weights and / or biases, training datasets, model hyperparameters, etc.

[0075] Methods embodying the present invention may be performed by multiple computing devices operating in coordination with one another, one or more of which may be data storage servers that store at least a portion of the trained model weights and / or biases, training datasets, model hyperparameters, etc.

[0076] The various methods described above may be implemented by a computer program. The computer program may include computer code (e.g., instructions) arranged to instruct a computer to perform one or more functions of the various methods described above. For example, the steps of the methods described with respect to FIGS. 2, 4, and 8 may be performed by the computer code. The steps of the methods may be performed in any suitable order. The computer program and / or code for performing such methods may be provided to an apparatus such as a computer on one or more computer-readable media or, more generally, in a computer program product. The computer-readable medium may be transitory or non-transitory. The one or more computer-readable media may be, for example, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, or a propagation medium for data transmission, for example, downloading code via the Internet. Alternatively, the one or more computer-readable media may take the form of one or more physical computer-readable media, such as a semiconductor or solid-state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk, and an optical disk, such as a CD-ROM, CD-R / W, or DVD. The instructions may also reside, completely or at least partially, within memory 804 and / or within processor 802 during execution by the computing system, with memory 804 and processor 802 also constituting computer-readable storage media.

[0077] In implementation, the modules, components, and other features described herein may be implemented as discrete components or may be incorporated into the functionality of hardware components such as an ASIC, FPGA, DSP, or similar device.

[0078] A "hardware component" is a tangible (e.g., non-transient) physical component (e.g., a set of one or more processors) that can perform specific operations and may be arranged or configured in a specific physical manner. A hardware component may include dedicated circuitry or logic that is permanently configured to perform specific operations. A hardware component may have a dedicated processor such as an FPGA or ASIC. A hardware component may also include programmable logic or circuitry that is temporarily configured by software to perform specific operations.

[0079] The modules and components may also be implemented as firmware or functional circuitry within a hardware device. Further, the modules and components may be implemented with any combination of hardware devices and software components, or solely in software (e.g., code stored or otherwise embodied on a machine-readable medium or a transmission medium).

[0080] Unless specifically stated otherwise, as will be appreciated from the discussion that follows, throughout this specification discussions using terms such as "processing," "executing," "generating," "storing," "receiving," "input," "output," "training," "encoding," "decoding," and the like refer to the operations and processing of a computer system or similar electronic computing device that manipulates and converts data represented as physical (electronic) quantities in the computer system's registers and memory into other data similarly represented as physical quantities in the computer system's memory or registers or other such information storage, transmission, or display device.

[0081] While specific embodiments have been described, these embodiments are presented by way of example only and are not intended to limit the scope of the invention. Indeed, the novel methods and apparatus described herein may be embodied in a variety of other forms, and various omissions, substitutions, and changes may be made in the form of the methods and apparatus described herein.

[0082] Many modifications and other embodiments of what is described herein will come to mind to one skilled in the art to which this invention pertains having the benefit of the teachings presented in the foregoing descriptions and the associated drawings. It is to be understood, therefore, that the invention is not to be limited to the specific embodiments disclosed, and that modifications and other embodiments are intended to be included within the scope of the appended claims. Although specific terms are employed herein, they are used in a generic and descriptive sense only and not for purposes of limitation.

[0083] In addition to the above embodiments, the following supplementary notes are disclosed. (Appendix 1) 1. A computer-implemented method for training an encoder neural network, comprising: receiving a data stream at an autoencoder including the encoder neural network, a decoder neural network, a first memory layer, and a second memory layer; incrementally training the encoder neural network on the data stream; Each training step of said incremental training comprises: receiving a portion of the data stream as input data at the encoder neural network; performing an encoding process on the input data by the encoder neural network to obtain a latent representation of the input data; storing encoded input data generated by the encoder neural network during the encoding process in the first memory layer; processing the coded input data and coded input data stored in the first memory layer from a previous iteration of a training step to generate a memory representation; storing the memory representation and the latent representation in the second memory layer; processing the memory representation and the latent representation to update the memory representation; performing a decoding process on the latent representation by the decoder neural network; storing decoded input data generated by the decoder neural network during the decoding process in the second memory layer; and processing the decoded input data and the updated memory representation to refine the updated memory representation; outputting the refined memory representation to the encoder neural network for use in a next training step; A method comprising: (Appendix 2) the encoder neural network includes multiple encoder layers, and the encoded input data stored in the first memory layer is from at least the last encoder layer. 2. The computer-implemented method of claim 1. (Appendix 3) the decoder neural network includes multiple decoder layers, and the decoded input data stored in the second memory layer is from at least a first decoder layer. 3. The computer-implemented method of claim 1 or 2. (Appendix 4) said processing includes a nonlinear transformation process; 4. The computer-implemented method of any one of claims 1 to 3. (Appendix 5) the data stream includes incident-related data; 5. The computer-implemented method of any one of claims 1 to 4. (Appendix 6) the encoded input data includes trainable parameters; 6. The computer-implemented method of any one of claims 1 to 5. (Appendix 7) 1. A computer-implemented online prediction method comprising: training an online predictive model on the latent representations received from the encoder neural network incrementally trained according to the method of any one of claims 1 to 6; and receiving real-time input data by the trained online predictive model; processing the real-time input data with the trained online predictive model to generate a prediction; and An online prediction method having: (Appendix 8) the online predictive model predicts incidents requiring the dispatch of emergency responders; The online prediction method described in Appendix 7. (Appendix 9) the real-time input data includes sensor data; 9. The online prediction method of claim 7 or 8. (Appendix 10) a memory storing computer-executable instructions for performing the online prediction method of any one of claims 1 to 8; a processor configured to execute the computer-executable instructions; and A data processing device having: (Appendix 11) a data processing device according to claim 10; a computer-aided dispatch system configured to receive the incident prediction and, in response, at least one of outputting an alert and transmitting a message to a device of emergency responders; Emergency management system with (Appendix 12) A computer program comprising instructions, The instructions, when executed by a computer, cause the computer to perform the method of any one of claims 1 to 9. Computer program. (Appendix 13) comprising instructions which, when executed by a computer, cause the computer to perform the method of any one of claims 1 to 9; A non-transitory computer-readable storage medium. [Explanation of symbols]

[0084] 100 Autoencoders 102 Encoder 104 decoder 105 memory modules 116 First Memory Layer 118 Second Memory Layer 120 Encoded Data 121 Memory Representation 122 Model Encoding (Latent Representation) 124 Decrypted Data 500 data processing device 502 trained neural networks 504 Online Prediction Model 700 Emergency Management System 702 Computer-Aided Dispatch System 802 processor 804 memory 806 network interface

Claims

1. 1. A computer-implemented method for training an encoder neural network, comprising: receiving a data stream at an autoencoder including the encoder neural network, a decoder neural network, a first memory layer, and a second memory layer; incrementally training the encoder neural network on the data stream; Each training step of the incremental training comprises: receiving a portion of the data stream as input data at the encoder neural network; performing an encoding process on the input data by the encoder neural network to obtain a latent representation of the input data; storing encoded input data generated by the encoder neural network during the encoding process in the first memory layer; processing the coded input data and coded input data stored in the first memory layer from a previous iteration of a training step to generate a memory representation; storing the memory representation and the latent representation in the second memory layer; processing the memory representation and the latent representation to update the memory representation; performing a decoding process on the latent representation by the decoder neural network; storing decoded input data generated by the decoder neural network during the decoding process in the second memory layer; processing the decoded input data and the updated memory representation to refine the updated memory representation; outputting the refined memory representation to the encoder neural network for use in a next training step; A method comprising:

2. the encoder neural network includes multiple encoder layers, and the encoded input data stored in the first memory layer is from at least the last encoder layer.

10. The computer-implemented method of claim 1.

3. the decoder neural network includes multiple decoder layers, and the decoded input data stored in the second memory layer is from at least a first decoder layer.

10. The computer-implemented method of claim 1.

4. said processing includes a nonlinear transformation process; 10. The computer-implemented method of claim 1.

5. the data stream includes incident-related data; 10. The computer-implemented method of claim 1.

6. the encoded input data includes learnable parameters; 10. The computer-implemented method of claim 1.

7. 1. A computer-implemented online prediction method comprising: training an online prediction model on latent representations received from an encoder neural network incrementally trained according to the method of any one of claims 1 to 6; receiving real-time input data by the trained online predictive model; processing the real-time input data with the trained online predictive model to generate a prediction; and An online prediction method having:

8. the online predictive model predicts incidents requiring the dispatch of emergency responders; The online prediction method of claim 7.

9. the real-time input data includes sensor data; The online prediction method of claim 7.

10. a memory storing computer-executable instructions for executing the online prediction method of claim 7; a processor configured to execute the computer-executable instructions; and A data processing device having:

11. A data processing device according to claim 10; a computer-aided dispatch system configured to receive the incident prediction and, in response, at least one of outputting an alert and transmitting a message to a device of emergency responders; Emergency management system with

12. A computer program comprising instructions, The instructions, when the computer program is executed by a computer, cause the computer to perform the method of any one of claims 1 to 6. Computer program.

13. 7. A method according to claim 1, further comprising: providing a method for generating a plurality of programmable logic circuits, the method comprising: A non-transitory computer-readable storage medium.

Images