EP4662592A1

EP4662592A1 - Processing sequences of data points

Info

Publication number: EP4662592A1
Application number: EP23920979.4A
Authority: EP
Inventors: Saravanan M; Karthikeyan VISWANATHAN; RamKumar N
Original assignee: Telefonaktiebolaget LM Ericsson AB
Current assignee: Telefonaktiebolaget LM Ericsson AB
Priority date: 2023-02-06
Filing date: 2023-02-06
Publication date: 2025-12-17
Also published as: WO2024166119A1; EP4662592A4

Abstract

A computer implemented method of processing a sequence of data points using a Long Short- Term Memory, LSTM, cell in an iterative manner on each data point in the sequence. The method comprises retrieving (402) a first portion of a cell state of the LSTM cell from a resilient data store, RDS. In a second step the method further comprises holding (404) the first portion of the cell state in a stream-based memory, for use as input to the LSTM cell in a first iteration of a first data point through the LSTM cell.

Description

PROCESSING SEQUENCES OF DATA POINTS Technical Field This disclosure relates to methods, nodes and systems in a communications network. More particularly but non-exclusively, the disclosure relates to processing a sequence of data points using a Long Short-Term Memory, LSTM. In Fifth Generation (5G) communications networks, products and services, such as convergent billing, become increasingly complicated. Service providers are gearing up to address varied enterprise models, such as ultra-reliable low-latency communication (URLLC), enhanced mobile broadband (eMBB), and massive machine type communication (mMTC). The rollout of 5G also heralds a revolution in IoT devices and the introduction of the concept of network slicing (and the associated service-level agreements (SLAs)) adds further dimensions that add to the complexity of various processes such as billing. Anomalies are a common issue in many industries, including the telecoms industry. Telecoms anomalies can be related to factors such as network performance, security breaches or fraud and can occur anywhere in a multitude of Telecoms processes. One such area is telecoms invoice anomalies. A periodic bill is a regular billing process, but all other bills or bill requests result in a deviation from the standard process – and may result in anomalies. Telecoms invoices represent one of the most complex types of invoices generated in any industry. The huge number and variety of possible products and services makes errors more likely. Convergent Billing makes it possible to have a single bill for multi-play contract(s) with cross-promotions and volume discounts, which can make billing an even more challenging task. Moreover, many customer organizations have a setup where different departments have different invoice and payment responsibilities which also complicates the billing process. Moreover, the volumes of multi-variate data relevant to the billing process in telecoms is often very high, and as a result it can take many hours to process. In the telecoms industry, billing errors lead to billing disputes, and this is one of the leading causes of customer churn. Fixing billing errors has a significant cost and time impact on service provider financials. Most service providers have a mix of manual and/or automated processes to detect invoice anomalies. The manual process usually relies on sampling techniques based on organizational policies, resource availability, individual skills, and experience. In the paper by Valentino Constantinou and Mori Kabiri entitled: “Detecting Anomalous Invoice Line Items in the Legal Case Lifecycle” (arXiv:2012.14511), anomaly detection in this manner was found to be slow and lacking in coverage across a large set of generated invoices. Generally, therefore, techniques that can sequentially process high volume billing data on short time scales, for processes such as anomaly detection, are an ongoing area of research. Summary In the paper by Varun Chandola, Arindam Banerjee, & Vipin Kumar entitled: “Anomaly detection: A survey” (ACM Computing Surveys Volume 41 Issue 3 July 2009 Article No.: 15 pp 1–58), invoice anomalies were categorized into three types: point, contextual, and collective. By analyzing the different types of invoices and their content (e.g., amounts and service usage patterns), it is possible to detect potential issues before the invoice is sent to customers. Suspicious invoices can be detected, prompting billing teams to run checks and determine if there’s an issue. This should be done before the customer receives an anomalous invoice. With the introduction of IT in business processes, such audits can leverage rule- based automation to find patterns and give insights on larger data sets; however, this also has the challenge of rules being based on encoded experience, which can result in high numbers of false positive alerts and the incorrect flagging of legitimate behaviours as suspicious, as mentioned in the paper by Valentino and Mori, cited above. Rules for identifying errors in encoded systems are written by domain experts. However, the dynamic nature of the telecoms industry also has to be taken into account, and keeping pace (using hard-coded methods) would generally mean slowing down the launches of new products and services in the market; this can lead to customer dissatisfaction. Machine learning (ML)-based solutions can often identify invoice anomalies more accurately than hard-coded solutions and can reduce false positives. ML can also identify non-compliant behaviours more easily with hidden patterns that are difficult for humans to identify. In ML, there are generally two categories of problems based on the number of variables used to make predictions: univariate (one variable) or multivariate (two or more variables). Most common analyses are multivariate due to the complexity of the billing process. In the paper by Valentino Constantinou and Mori Kabiri cited in the background section, this process is used to address the anomaly detection problem, specifically when the characteristics of the anomalies are well known. In the paper by Johannes et al. (2022) entitled: “ELINAC: Autoencoder Approach for Electronic Invoices Data Clustering” (DOI:10.3390/app12063008), ELINAC (Electronic Invoices Autoencoder Clustering), a service for clustering short-text data in electronic invoices is used which uses an automatic encoder to cluster data. In said paper, ELINAC explores how to model the automatic encoder without increasing the calculation costs to suppress a large number of short text data. One limitation of the approaches in the aforementioned papers is that they can only handle known anomalies in billing cycles. As such, two problems remain: localized service degradation can occur due to the distributed nature of the data collection devices; and customer-specific issues that are not reflected in general trends may appear and go undetected. The general variability in data throughput and volume may mask the problems above. Moreover, the anomalies in invoices are often time-dependent; they may occur due to personal error or wrong details being fed into the billing system. Thus, in order to reliably detect telecoms anomalies, a time series-based anomaly detection methodology is needed that can address the above-mentioned issues. Hence, herein, Long-Short-term Memory (LSTM) networks (otherwise referred to herein as LSTM cells) are used to find anomalies in telecoms data such as invoices. LSTM networks excel at finding complex relationships in multivariate time series data. However, the drawback here is it may take more time to process the large data volumes associated with invoices and/or other telecoms data. It is an object of embodiments herein to reduce processing time associated with using LSTM networks. It is further an object of embodiments herein to reduce the processing time associated with the use of LSTM networks to process large time series of data points such as those associated with detecting anomalies in large volumes of sequential data, such as the data involved in invoicing in the telecoms industry. Thus, according to a first aspect herein there is a computer implemented method of processing a sequence of data points using a Long Short-Term Memory, LSTM, cell in an iterative manner on each data point in the sequence. The method comprises retrieving a first portion of a cell state of the LSTM cell from a resilient data store, RDS, and holding the first portion of the cell state in a stream-based memory, for use as input to the LSTM cell in a first iteration of a first data point through the LSTM cell. According to a second aspect there is a computer program comprising instructions which, when executed on at least one processor, cause the at least one processor to: initiate a Long Short-Term Memory, LSTM, cell; and initiate a stream-based memory for use by the LSTM in transferring a cell state of the LSTM cell between the stream-based memory and a Resilient Data Store, RDS. According to a third aspect there is an apparatus for processing a sequence of data points using a Long Short-Term Memory, LSTM, cell in an iterative manner on each data point in the sequence. The apparatus comprises a memory comprising instruction data representing a set of instructions and a processor configured to communicate with the memory and to execute the set of instructions. The set of instructions, when executed by the processor, cause the processor to retrieve a first portion of a cell state of the LSTM cell from a resilient data store, RDS, and hold the first portion of the cell state in a stream-based memory, for use as input to the LSTM cell in a first iteration of a first data point through the LSTM cell. According to a fourth aspect there is a computer program comprising instructions which, when executed on at least one processor, cause the at least one processor to carry out the method of the first aspect. According to a fifth aspect there is a carrier containing a computer program according to the fourth aspect, wherein the carrier comprises one of an electronic signal, optical signal, radio signal or computer readable storage medium. According to a sixth aspect there is a computer program product comprising non transitory computer readable media having stored thereon a computer program according to the fourth aspect. As described above, known LSTM cells tend to consume large amounts of memory, as memory is used for storing both cell state and hidden state for the Long Term and short-term memory. To reduce the memory usage, the aspects above utilise customized LSTM cells having a stream-based flexible data store that is internal to the cell. This data store sends the cell state from an RDS as a stream that is needed on demand rather than loading the whole context. This significantly reduces memory consumption of the LSTM cell, enabling the LSTM cell to process large datasets at high speed. The proposed memory and LSTM cell architectures herein, therefore provide improved processing speeds for processing time-sequence data. The aspects described above, when applied to billing information, may provide enhanced AI assisted methods for billing anomaly detection/prediction. Furthermore, the anomaly detection processes herein are adaptable through the use of learning in order to identify new errors and/or error types which is advantageous in an ever-changing communications network. Brief Description of the Drawings For a better understanding and to show more clearly how embodiments herein may be carried into effect, reference will now be made, by way of example only, to the accompanying drawings, in which: Fig.1 shows a prior art configuration of an LSTM network; Fig.2 shows an apparatus according to some embodiments herein; Fig. 3 shows a stream-based memory architecture according to some embodiments herein; Fig.4 shows a method according to some embodiments herein; Fig.5 shows a LSTM network according to some embodiments herein; Fig.6 shows a LSTM network according to some embodiments herein; Fig.7 shows a signal diagram according to some embodiments herein; Fig. 8 shows a graph of computer memory usage over time for a prior art implementation; and Fig.9 shows computer memory usage for an implementation of an embodiment as described herein. Detailed Description The disclosure herein relates to LSTM networks which are a type of ML model adapted for processing time sequences of data. LSTMs are a complex area of deep learning. LSTM networks are a type of recurrent neural network capable of learning order dependence in sequence prediction problems. LSTMs can solve numerous tasks not solvable by previous learning algorithms for recurrent neural networks (RNNs). Generally, a LSTM network may be trained to take successive data points in a sequence and predict the next data point in the sequence. The general purpose of LSTM is to address the vanishing gradient problem associated with RNNs. This problem occurs when RNNs attempt to evaluate the Long- Term memory. LSTM introduces two memory cells to avoid the above-mentioned deadlock in RNNs, and they are the Cell State (Long Term Memory) and the Hidden State (Cell State from previous iteration). LSTM also introduced the concept of gates to update and remove information from the cell state. The three gates in the LSTM architecture are the Input Gate, the Output Gate and the Forget gate. The skilled person will be familiar with LSTM networks, an example of which is shown in Fig.1. An LSTM network takes three inputs: i) the input data 102, e.g. the data point in the series that is to be processed ii) the cell state 104 and iii) the hidden state 106 from the previous data point in the series. The cell state 104 may be referred to as the long-term memory of the LSTM and contains information or “learnings” from previous data points in the series that have been deemed useful for making predictions about future data points in the series. The hidden state 106 or short term memory contains information or “learnings” from the previous timestamp. In brief, as noted above, the LSTM architecture contains three “gates” each containing a sigmoid function. Forget Gate 108 has a first sigmoid function 110 that takes as input the previous hidden state 106 and current data point 102 (e.g. current input) to add optional information to the cell state 104. A second gate known as the Input Gate 112 has a second sigmoid function 114 that uses the hidden state 106 and cell state 104 to forget, if the information is not relevant to the context. The third gate, Output Gate 118 uses a third sigmoid function 120 that uses the hidden state 106 and the cell state to determine the next hidden state 126 that is used as input to the LSTM to process the next datapoint in the sequence. The other outputs are the updated cell state 124 and the output prediction of the next datapoint in the sequence 122. Forget Gate: The forget gate is used to decide whether the information from the previous timestamp should be transferred to the cell state, or forgotten. The equation for the forget gate, ft, is: ft= Sigmoid (Xt*Uf+Ht-1*Wf) where: Xt: input to the current timestamp (e.g. the first data point in the sequence of data points). Uf: weight associated with the input Ht-1: The hidden state of the previous timestamp Wf: It is the weight matrix associated with hidden state Input gate: Input gate is used to quantify the importance of the new information carried by the input. Here is the equation of the input gate, It. It=Sigmoid (xt*Ui+Ht-1*Wi) * tangent (xt*Ui+Ht-1*Wi) Output gate : Here is the equation of the Output gate, Ot, which is similar to the two previous gates: Ot=sigmoid(Xt*UO+Ht-1*WO); where: Xt: input to the current timestamp (e.g. the first data point in the sequence of data points). UO: weight associated with the input for the output gate Ht-1: The hidden state of the previous timestamp WO: It is the weight matrix associated with hidden state for the output gate The skilled person will appreciate that Fig.1 is merely for illustration purposes and that there are many sources in the art that describe LSTM networks in more detail, see for example, the paper by Hochreiter & Schmidhuber (1997) “Long Short-Term Memory” Neural Computation 9 (8): 1735-1780. As described in the background section above, LSTM networks may be used to pick out anomalies in a sequence of data points. The basic idea of anomaly detection with LSTM networks involves using the LSTM to predict a new data point (e.g. the next data point) from the previous values in a sequence of data points. If the actual value of the new data point is within, for example, a standard deviation of the predicted value for the new data point, then it is classed as a normal data point. If it is more, it is flagged as an anomaly. LSTMs are able to learn trends on a granular level, e.g. in the example of telecoms data, an LSTM may be able to learn trends over time on per customer and per region basis. For reliable anomaly detection, LSTMs may advantageously learn variability on a range of different timescales e.g. hourly, daily, weekly, monthly etc. As described above in the background, one area where LSTMs may be used for anomaly detection is in telecoms data, where they may be used for tasks such as anomaly detection in invoices. Invoice generation uses large amounts of sequential data, and each data point in the sequential data carries context information. Hence the cell state is regularly updated with the new context information. This consumes huge amount of memory to process and execute the cell state. As such, LSTMs lack memory optimization and the in-memory usage can become extremely turbulent. In brief, what is proposed herein is a change to the LSTM architecture in order to use a stream-based memory (as opposed to purely cache-based memory) that interfaces with a Resilient Data Store (RDS). The stream-based memory transfers data (cell state information) from the cell to the RDS and retrieves the data (e.g. the portion of the cell state) needed for each iteration through the LSTM before the iteration is performed. This allows only the data needed at any point to be held in memory (rather than the full cell state), and this reduces memory usage and increases processing speeds. This allows LSTMs to be used to processes larger datasets that would otherwise have high memory overheads. As an example the large datasets used to create invoices in telecoms may be processed using the improved architecture herein in order to detect anomalous bills, thus improving the speed at which billing data may be processed and verified. The skilled person will appreciate that this is merely an example however, and that the architecture herein may be used to efficiently process other large datasets using LSTMs. Other examples include but are not limited to, other anomaly detection processes in telecoms, such as security, where an LSTM may be used to predict anomalies such as vulnerabilities or systems failures in the communications network. Turning now to Fig. 2, in more detail, the methods described herein may be performed by an apparatus such as the apparatus 200 shown in Fig. 2. The apparatus 200 is configured (e.g. adapted, operative, or programmed) to perform any of the embodiments of the method 300 as described below. It will be appreciated that the apparatus 200 may comprise one or more virtual machines running different software and/or processes. The apparatus 200 may therefore comprise one or more servers, switches and/or storage devices and/or may comprise cloud computing infrastructure or infrastructure configured to perform in a distributed manner, that runs the software and/or processes. The apparatus 200 may comprise a processor (e.g. processing circuitry or logic) 202. The processor 202 may control the operation of the apparatus 200 in the manner described herein. The processor 202 can comprise one or more processors, processing units, multi-core processors or modules that are configured or programmed to control the apparatus 200 in the manner described herein. In particular implementations, the processor 202 can comprise a plurality of software and/or hardware modules that are each configured to perform, or are for performing, individual or multiple steps of the functionality of the apparatus 200 as described herein. The apparatus 200 may comprise a memory 204. In some embodiments, the memory 204 of the apparatus 200 can be configured to store program code or instructions 206 that can be executed by the processor 202 of the apparatus 200 to perform the functionality described herein. Alternatively or in addition, the memory 204 of the apparatus 200, can be configured to store any requests, resources, information, data, signals, or similar that are described herein. The processor 202 of the apparatus 200 may be configured to control the memory 204 of the apparatus 200 to store any requests, resources, information, data, signals, or similar that are described herein. In embodiments herein, at least a portion of the memory 104 may be configured as stream-based memory. The skilled person will be familiar with stream-based memory, but briefly, stream-based memory (which may otherwise be referred to herein as a stream or memory stream) is a manner of using RAM memory which provides data to the RAM as a chunk when needed, rather than the traditional Cache where all the data is dumped into the RAM. This way data that is imminently going to be used (and in some examples, only the data that is about to be used) can be streamed into the layer, rather than storing/loading all available data into the RAM and holding it there potentially for a long time. Streaming can be defined as passing the required data rather than loading the whole data, so as to save the memory. In the context of the disclosure herein, this may mean using the stream-based memory to hold at least part of the cell state. Some differences between Stream based memory and (traditional) Cache-based memory that give rise to the advantages herein are as follows. Stream based memory stores and retrieves only the required data needed for the layer being processed, whereas (traditional) cache-based memory stores and retrieves the entire memory state in RAM. In a stream-based memory, the Memory state data is stored in a Resilient Data Store, whereas in a cache-based memory, the memory state data is stored in RAM. In a stream-based system, the memory state retrieves the data in advance of the layer being executed and loaded via the stream layer. In a cache-based system, the memory state is retrieved from the RAM. Stream-based memory usage has effective memory consumption as it stores only the data for the current layer. By contrast, a cache-based memory has a very high memory utilisation as it appends the collection of states retrieved from each layer. Stream-based memory is described in the paper by Zhengrong Wang & Tony Nowatzki (2019), entitled: “Stream-based Memory Access Specialization for general purpose processors” (DOI:10.1145/3352460.3358276). See also the paper by Vaibhav Khadilkar, Murat Kantarcioglu, Latifur Khan, & Bhavani Thuraisingham (2010) entitled “Efficient Processing of large RDF stream using memory management algorithms” (Conference: Proceedings of the ISWC 2010 Posters & Demonstrations Track: Collected Abstracts, Shanghai, China, November 9, 2010). The paper by Zhengrong Wang & Tony Nowatzki (2019) explores the concept of leveraging the inherent structure of streams to specialize the core pipeline, cache interface and cache policies. The method in said paper is used to enable the specification of repeated access patterns in the presence of control flow and indirect memory, opening the door to effective execution-driven prefetching without redundant execution. As described in more detail below, in this disclosure, new opportunities are disclosed for specialization of access and communication at even higher levels of gates within the cache and memory hierarchy, that is established with the use of a Resilient Data Store (RDS). Thus in some embodiments, as illustrated in Fig.3, memory 104 of the apparatus 200 may comprise a stream-based memory 304 having Delta memory states 308 and 312 which may be used to provide “store” 306 and “retrieve” 310 commands for insertion and retrieval of information into the stream-based memory 304 respectively. Stream based memory 304 may interface with a resilient data store 314. A resilient data store is persistent storage. As described in more detail below, in embodiments herein, the stream-based memory 304 may be used to hold (e.g. store, or temporarily store) at least part of a cell state of an LSTM cell. It will be appreciated that the apparatus 200 may comprise other components in addition or alternatively to those indicated in Fig.2. For example, in some embodiments, the apparatus 200 may comprise a communications interface. The communications interface may be for use in communicating with other apparatuses or nodes in a communications network, (e.g. such as other physical or virtual nodes). For example, the communications interface may be configured to transmit to and/or receive from other nodes or network functions requests, resources, information, data, signals, or similar. The processor 202 of node 200 may be configured to control such a communications interface to transmit to and/or receive from other nodes or network functions requests, resources, information, data, signals, or similar. Briefly, in one embodiment, the apparatus 200 may be for processing a sequence of data points using a Long Short-Term Memory, LSTM, cell in an iterative manner on each data point in the sequence. The apparatus 200 may be configured to retrieve a first portion of a cell state of the LSTM cell from a resilient data store, RDS, and hold the first portion of the cell state in a stream-based memory, for use as input to the LSTM cell in a first iteration of a first data point through the LSTM cell. . In some embodiments, the apparatus 200 may be implemented in a communications network which may otherwise be referred to herein as a telecommunications network. A communications network may comprise any one, or any combination of: a wired link (e.g. ASDL) or a wireless link such as Global System for Mobile Communications (GSM), Wideband Code Division Multiple Access (WCDMA), Long Term Evolution (LTE), New Radio (NR), WiFi, Bluetooth or future wireless technologies. The skilled person will appreciate that these are merely examples, and that a communications network may comprise other types of links. A wireless network may be configured to operate according to specific standards or other types of predefined rules or procedures. Thus, particular embodiments of a wireless network may implement communication standards, such as Global System for Mobile Communications (GSM), Universal Mobile Telecommunications System (UMTS), Long Term Evolution (LTE), and/or other suitable 2G, 3G, 4G, or 5G standards; wireless local area network (WLAN) standards, such as the IEEE 802.11 standards; and/or any other appropriate wireless communication standard, such as the Worldwide Interoperability for Microwave Access (WiMax), Bluetooth, Z-Wave and/or ZigBee standards. The apparatus 200 may be comprised in a node (otherwise referred to as a network node) in a communications network. Generally, a node may comprise any component or network function (e.g. any hardware or software module) in a communications network suitable for performing the functions described herein. For example, a node may comprise equipment capable, configured, arranged and/or operable to communicate directly or indirectly with a User Equipment UE (such as a wireless device) and/or with other network nodes or equipment in the communications network to enable and/or provide wireless or wired access to the UE and/or to perform other functions (e.g., administration) in the communications network. Examples of nodes include, but are not limited to, access points (APs) (e.g., radio access points), base stations (BSs) (e.g., radio base stations, Node Bs, evolved Node Bs (eNBs) and NR NodeBs (gNBs)). Further examples of nodes include but are not limited to core network functions such as, for example, core network functions in a Fifth Generation Core network (5GC). As noted above, in some embodiments, the methods and apparatus described herein may be used to detect anomalies in billing data in a communications network. In such embodiments, the apparatus 200 may be comprised in (e.g. form part of) a node in a communications network responsible for charging and billing. As an example, the apparatus 200 may form part of a Policy Control and Charging function (PCF), a Network Exposure Function (NEF) or a Unified Data Management (UDM) in the 5GC. Turning now to Fig. 4 which shows a computer implemented method 400 of processing a sequence of data points using a Long Short-Term Memory, LSTM, cell according to some embodiments herein. In this embodiment, the sequence of data points are processed in an iterative manner on each data point in the sequence in turn. In a first step 402 the method 400 comprises retrieving a first portion of a cell state of the LSTM cell from a resilient data store, RDS. In a second step 404 the method comprises holding the first portion of the cell state in a stream-based memory, for use as input to the LSTM cell in a first iteration of a first data point through the LSTM cell. In some embodiments the stream-based memory is internal to the LSTM cell. As described above, known LSTM cells tend to consume large amounts of memory, as memory is used for storing both cell state and hidden state for the Long Term and short-term memory. To reduce the memory usage, the method 400, utilises customized LSTM cells having a stream-based flexible data store that is internal to the cell. This data store sends the cell state as a stream that is needed on demand rather than loading the whole context. This significantly reduces memory consumption of the LSTM cell, enabling the LSTM cell to process large datasets at high speed. The proposed memory and LSTM cell architectures herein, therefore provide improved processing speeds for processing time-sequence data. In more detail, the sequence of data points may be a time-sequence, e.g. a sequence of time-stamped data points. The first data point may be any data point in the sequence. The time sequence may comprise a first data point and a second data point. As described herein, the second data point may be subsequent to (e.g. after) the first data point in the sequence of data points. As used herein, an iteration refers to the processing of one data point in the sequence of data points. In other words, the steps of providing inputs to, and receiving inputs from the LSTM network. This process is performed in an iterative, e.g. looped manner on each data point (or time stamp) in the sequence (or selected data points in the sequence). When processing a sequence of data points, each LSTM instance or LSTM cell used to process each data point may be referred to as an “LSTM layer”. As such, each layer of the LSTM takes one input time step of data. In some embodiments, the sequence of data points may be billing data, for example, a sequence of time-stamped invoices for services in a communications network. However, it will be appreciated that this is merely an example, and any sequence of data points may be processed in the manner described herein in order to improve processing speeds over traditional LSTMs. For example, the sequence of data points may be time-stamped lists of vulnerabilities in a communications network. In such an example, a LSTM may be used to process the list of vulnerabilities and predict future vulnerabilities. As another example, the sequence of data points may be time-stamped lists of hardware status reports. In such an example, a LSTM may be used to process the lists of hardware status reports and predict future hardware failures in the communications network. In step 402 the method comprises retrieving a first portion of a cell state of the LSTM cell from a resilient data store, RDS. The first portion of the cell state may be used as an input to the first iteration of the first data point through the LSTM. In some embodiments, the first portion of the cell state may be a hidden state of the LSTM as output in a preceding iteration. In step 404, the first portion of the cell state is held (e.g. stored, or stored in a temporary manner) in the stream-based layer. The first portion of the cell state is then provided to the LSTM cell as an input. In this way, the input data to the LSTM cell is retrieved in advance of an iteration and held in the stream-based layer (reducing memory consumption). In some embodiments, the method 400 may further comprise processing the first data point through the LSTM cell. In other words, running the first data point through the LSTM cell. As part of processing the first data point, the processing of an output gate of the LSTM may comprise transferring (or storing), as part of the first iteration of the first data point through the LSTM cell, an updated cell state and/or a hidden state of the LSTM cell to the stream-based memory. The updated cell state may then be transferred from the stream-based memory to the RDS. The method may then comprise retrieving a second portion of the cell state from the resilient data store and storing the second portion of the cell state in the stream-based memory, for use as input to the LSTM in a second iteration of a second data point through the LSTM cell. The second portion of the cell state may be retrieved using the hidden state of the previous layer as a query parameter to obtain the appropriate portion of the cell data with which to initiate the next LSTM layer. In some embodiments, the second portion of the cell state is a hidden state that was output from the first iteration of the first data point through the LSTM cell. This is summarised in the following pseudo-code: Sequential processing ====================== ==> Get The Hidden State from previous Hidden state stored in stream(Ht) ==> Get the cell state from stream (Ct) for that layer alone as data blocks with help of Input Time Step (It) and Hidden State (Ht) ==> Call Input Gate function provided with the cell state and hidden state as input (Ct,It), this step internally add cell state to the stream which in turn synchronized in RDS ==> Call Forget Gate function provided with the cell state and hidden state as input (Ct,It), this step internally removes cell state from the stream which in turn synchronized in RDS ==> Call Output Gate function provided with the Input Time Step ,cell state and hidden state as input (It,Ct,Ht) Input Gate function =================== ==> Input gate takes two input time step input and hidden state ===>Apply Sigmoid function and tangent function to determine if the information is valuable ==> If the information is valuable to context, then call the stream function Forget Gate ================ ==> Input gate takes two input time step input and hidden state ==> Apply sigmoid function to determine if the information is necessary to forget ==> If the information is not adding value to the overall context, then call the stream function Output Gate ================ ==> get Input time step hidden state and cell state ===> Takes the Input Time Step, Hidden Step and cell state and pass it to the stream function ==> Stream function returns an output hidden state Stream Function ================ ==> Stream function takes three input ==> Input time step, hidden state and operation value(Input or forget or output) ===> If the operation is output, then store the value in the stream memory for next processing and store it as (Ht) ==> pass the rest of input to RDS Function RDS Function =============== ==> RDS function take input time step and hidden state ==> Applies intelligence and add or update the RDS data block based on the input context, this data block can be retrieved with input time step and hidden state as primary key == > Entire RDS stores context data as multiple data blocks with each data blocks will be represented as sub context to the overall context == > Each Context will be represented in multiple sub context as different data blocks so the information stored in each data blocks is much lesser than the overall context stored as single memory instance Fig.5 shows an embodiment of an LSTM cell 500 that implements the method 400 according to some embodiments herein. LSTM cell 500 has a stream-based memory 304; 504. The LSTM cell uses a stream-based cell state rather than the existing memory sequential model. The stream-based memory layer may work as follows: - Input gate 112 and forget gate 108 are used to add or remove the sequential context retrieved from the time step data and the hidden state from the cell state respectively. - The above process updates the state intermediately in a stream-based layer 304;504 and then permanently updates the sequential context retrieved from time step data and hidden state in the Resilient Data Store (RDS) 314; 514. - The previous state hidden layer is going to be the input for the next layer, hence this previous hidden state is used as a key to retrieve the state from the stream before the next layer initializes. - Hence the state required for that corresponding layer alone can be fetched as input rather than entire sequence. - This stream is used to provide the data on demand from the RDS 314;514. The new LSTM structure includes a stream-based architecture to retrieve the required cell state information on demand rather than loading the entire cell state in memory. The new architecture reduces the memory usage of the overall LSTM model. Adding a new stream-based memory architecture helps in processing long- running sequential data (e.g. such as that used in anomaly detection) in a much more memory- optimized way by reducing the in-memory cache usage. Generally, the LSTM model is run in a looped manner (e.g. an iterative manner) on successive data points in the sequence of data points. Each loops returns (e.g. provides as output) a hidden state, and this hidden state is used as input for the next LSTM layer (e.g. the next loop in the sequence). Hence the current hidden state used as an input to the next LSTM layer. The hidden state is thus used as input to retrieve a portion of the cell state data from the stream-based memory and it is available before the next LSTM layer gets started. Hence the data required for each layer is made available before the demand is raised from the LSTM cell. Internally, the cell state data is stored in the Resilient Data Store (RDS) and the cell state data from the stream-based memory is loaded from the data set (RDS) via a callback listener protocol. This asynchronous callback listener alters the state of the cell rather than manually modifying the cache. This reduces the Cache usage and allows the memory to perform each epoch (e.g. each loop) much faster, as the cache expansion in memory is reduced during parallel execution. Thus, in some embodiments, the step of transferring, as part of the first iteration of the first data point through the LSTM cell, an updated cell state and a hidden state of the LSTM cell to the stream-based memory, comprises updating the cell state of the LSTM cell held in RDS via the stream-based memory with the output of a forget gate of the LSTM (as illustrated by the vertical grey arrow 510 in Fig. 5), and/or updating the cell state (e.g. all or part of the cell state) of the LSTM cell held in the RDS via the stream-based memory with the output of an input gate (as illustrated by the vertical grey arrow 512 in Fig.5). The method 400 may further comprise transferring the cell state (e.g. all or part of the cell state) from the stream-based memory to a RDS 314; 514, as illustrated by arrow 514 in Fig.5. The LSTM may output a hidden state after each iteration. Thus, the method 400 may further comprise receiving as output from the first iteration the LSTM cell, a first hidden state. The method 400 may further comprise using the first hidden state to retrieve the second portion of the cell state from the RDS via the stream-based memory. The second portion of the cell state may be used as input to the LSTM cell in the second iteration of the second data point though the LSTM cell. In other words, as noted above, a hidden state output from the first iteration as a result of a first layer processing the first data point, may be used to retrieve cell state information from the RDS via the stream-based memory in order to initiate the next iteration (e.g. the next layer) for the processing of the second data point. The hidden state from the first iteration may be used to retrieve the information for the second (e.g. next) iteration as sequential modelling is an AI logic basically used for time series prediction. The time series prediction with LSTM takes the input in each time stamp and applies it to LSTM layer. Each LSTM layer takes input from time stamp along with the hidden state from the previous layer. (This layer saves context information from the whole input dataset or file or text). The purpose of passing the hidden state from the first iteration into the next is to carry the context pattern to understand the inference of the input passed. This Stream based memory cell stores the cell state in the hard disk with the help of resilient Data store or flexible data drive. LSTM can in this manner get the data on demand for a particular gate. In more detail, in some embodiments, the cell state is taken from the stream-based memory (as opposed to the cache). For example, in some embodiments, the equation for the Forget Gate, ft, may be: ft= Sigmoid (xt*Uf+St*Wf); where: xt is a first datapoint from the sequence of data points, provided to the LSTM cell in a particular iteration, Uf is a first weighting value associated with xt, St is the cell state, and Wf is a weighting matrix associated with St. In this equation, St is obtained from the stream-based memory (as opposed to the cache as in traditional implementations). In some embodiments, the input gate, It, of the LSTM cell is described by the following equation: It= Sigmoid (xt*Ui + St*Wi) * tangent (xt*Ui + St*Wi); where: xt is a first datapoint from the sequence of data points, provided to the LSTM cell in a particular iteration, Ui is a first weighting value associated with xt, St is a cell state, and Wi is a weighting matrix associated with St. In this equation, St is obtained from the stream-based memory (as opposed to the cache as in traditional implementations). Fig.6 shows an example in which both the input gate and forget gate contribute to the data modification and removal of cell memory respectively. Fig.6 shows a Forget Gate 602, a Cell State 604, an Input Gate 606, an Output Gate 608, a Hidden State 610, a data point 612 (e.g. the current input data) and a data context 614. In the embodiment shown in Fig.6: - The Forget gate 602 uses the cell state 606 and hidden state to retrieve the next hidden state - Cell state 614 introduced in the new LSTM model acts as a stream-based layer which sends the required information on demand for that particular gate rather than sending the entire cell state. - Adding a new DB (e.g. a RDB) next to a memory cell will create a stream based on demand data driven architecture - Retrieves the needed information for that gate rather than keeping the cell state in cache memory - This helps in loading long running sequential data in a more memory efficient manner. -Tests show that 25% of memory usage has drastically reduced due to this optimization. Turning back to Fig. 4 and the method 400, in some embodiments, the method 400 is for use in detecting anomalies in a sequence of data points. As described above this is performed by inputting the first data point to the LSTM cell, receiving as output from the LSTM cell a prediction of a second data point, and comparing the prediction of the second data point to said second data point (e.g. to the actual/real value of the second data point) in the sequence of data points to determine whether the second data point is anomalous. For example, the second data point may be flagged as anomalous if it is greater than one standard deviation from the predicted value of the second data point. The skilled person will appreciate however that this is merely an example and that other statistical measures may be used to determine whether a second data point has deviated in a statistically significant manner from the prediction thereof. As described above, in some embodiments the method 400 is performed by a node in a communications network. For example the sequence of data points may be a sequence of telecoms data points. In some embodiments herein, the method 400 may be used to determine anomalies in billing information in a telecoms network. For example, the sequence of data points may comprise a sequence of billing information data points for a user in the communications network. As such, in the first iteration, the first data may comprise a first billing information data point, and in the second iteration, the second data point may comprise a second billing information data point. Billing information in this sense may be invoice details and a time stamp. In some examples the billing information may comprise detailed data such as for example, a list of services used by the user, and corresponding usage of each service. The billing information may then comprise a monetary amount associated with each service. The billing information may be provided as a sequence of e.g. daily, weekly or monthly data points. An LSTM may be used to predict the next point in the sequence and to predict anomalies, in the manner described above. Fig.7 is a diagram showing how data flows between different components of the LSTM illustrated in Fig. 6 for an embodiment in which the sequence of data points is a sequence of invoices and the LSTM is used to find anomalies in the invoices. Fig. 7 shows the following signals (or transferals of information between different components in the LSTM cell): 702: Updates the forget gate and removes unnecessary invoice context from the memory cell, internally updates cell state. 704: The input gate is used to add input Billing information if this information adds value to the context, otherwise the memory cell state will not be updated with this new information context, internally updates cell state. 706: Output gate responsible for sending hidden state retrieved from LSTM layer via cell state which contains the Billing Invoice Context retrieved in the previous step. 708: Hidden State acts as an intermediate output state provide the context information of Billing Invoice Details during the intermediate time step. 710: The current data point (e.g. the first data point) 612 from the sequence of data points is sent to the Forget Gate 602. 712, 714: Hidden State and Current Input used as the input to the input gate for each LSTM layer. 716: The Hidden state 610 is sent to the Output Gate 608. 718: The current data point (e.g. the first data point) 612 from the sequence of data points is sent to the Output Gate 608. The current data point and the hidden state update the Output Gate state. 720: The cell state 604 is stored in the Data Context 614 (the data context is otherwise referred to herein as the RDS). The data Context layer is a new layer introduced newly to handle Stream based memory. The input to cell state comes from Data Context. Thus, in summary, the LSTM described herein introduces a new layer which may be referred to as the “Data Context” which is used to store the cell state and retrieve the cell state on demand. The Input Gate and Output Gate inside the LSTM cell updates and removes the information on the cell state respectively. This cell state contains the invoice context which in turn updates the stream data context in synchronized manner. Retrieving the data on demand (DOD) reduces the memory consumption of the LSTM. The recurrent hidden state retrieved as an output from each cell states undergoes back prorogation and reduces the loss which in turn calculates nearest target value to prompt the respective anomalies. Turning now to various test data that has been obtained, Appendix I provides a summary of tests performed that compare memory usage and accuracy of two different methods of anomaly prediction for a sample of 8824 invoices with one independent feature (Date) and one Sequential target feature (Volume). The first test uses a legacy (e.g. prior art) LSTM Sequential Model for the anomaly prediction and the second uses the LSTM described herein, according to the method 400 described above. As can be seen, the accuracy and loss associated with the two models is comparable, but there is a significant memory saving when using the method 400. Both models received the same accuracy 82.20 with same LOSS 3.72E- 06 however the consumption of memory usage in Memory Cell Gate is 640000 bytes in Legacy model however the memory consumption of an LSTM (according to embodiments herein) is 480000. Thus, the use of the method 400 saves 25% of memory. Fig 8 shows a graph 800 of memory usage of a gate (memory in Bytes along the y-axis) and Number of Epochs along the x-axis, for a prior art LSTM configuration, using a traditional prior art memory configuration. Figure 9 shows a graph 900 having the same axes as the graph in Fig.9, but this time, the memory usage is plotted for an LSTM configured to use stream-based memory according to the method 400 described above. From Figs 8 and 9, it can be inferred that within 100 epochs, the memory utilized is low compared to the prior art execution of a gate. Hence the method 400, can be shown to significantly reduce processing time and speed up the process of detecting anomalies in telecom invoices using an LSTM. Further tests were performed on a smaller data set having a sample batch size of 20 with 1000 epoch. In this test the: 1) Contribution of 200 batch size 2) Each Contribute 1000 epochs 3) Contribution of memory in each memory gate in old approach in this one gate alone 200*32*1000=640000 bytes 4) Contribution of memory in each memory gate in new approach in this one gate alone 200*24*1000=480000 bytes 5) percentage of memory optimization in memory gate alone is 25 % Using a traditional Forget Gate, the amount of data contributed to the smaller invoice set during forget gate (Prior Art Approach) was 32 bytes. Using the new equations above, namely, the equation for the Forget Gate, ft= Sigmoid (xt*Uf+St*Wf) where the parameter St is obtained from the stream-based memory as opposed to the cache, the amount of data contributed to the smaller invoice set during forget gate (according to the method 400) was 24 bytes. Thus, the memory saving per 100 epochs is 800 bytes, and the percentage of overall saved memory is of the order of 25 percent. For the input gate, using a traditional LSTM, the amount of data contributed to the smaller invoice set during the Input gate (prior art approach) was 36 bytes. For the input gate using the method 400 described herein, It= Sigmoid (xt*Ui + St*Wi) * tangent (xt*Ui + St*Wi) where St is obtained from the stream-based memory (as opposed to the cache), the amount of data contributed to the smaller invoice set during the input gate is 27 bytes. Thus, the amount of additional memory contributed to every 100 epochs is 900 bytes, which is a percentage of overall saved memory of the order of 25 percent. Although invoice data was used in the tests above, it will be appreciated that similar memory savings may equally be obtained using the method 400 on other types of data. Turning now to other embodiments, in another embodiment, there is provided a computer program product comprising a computer readable medium, the computer readable medium having computer readable code embodied therein, the computer readable code being configured such that, on execution by a suitable computer or processor, the computer or processor is caused to perform the method or methods described herein. The computer program may perform, for example, the method 400. In some embodiments, there is a computer program comprising instructions which, when executed on at least one processor, cause the at least one processor to initiate a Long Short-Term Memory, LSTM, cell, and initiate a stream-based memory for use by the LSTM in storing a cell state of the LSTM cell in the stream-based memory. Thus, it will be appreciated that the disclosure also applies to computer programs, particularly computer programs on or in a carrier, adapted to put embodiments into practice. The program may be in the form of a source code, an object code, a code intermediate source and an object code such as in a partially compiled form, or in any other form suitable for use in the implementation of the method according to the embodiments described herein. It will also be appreciated that such a program may have many different architectural designs. For example, a program code implementing the functionality of the method or system may be sub-divided into one or more sub-routines. Many different ways of distributing the functionality among these sub-routines will be apparent to the skilled person. The sub-routines may be stored together in one executable file to form a self-contained program. Such an executable file may comprise computer-executable instructions, for example, processor instructions and/or interpreter instructions (e.g. Java interpreter instructions). Alternatively, one or more or all of the sub-routines may be stored in at least one external library file and linked with a main program either statically or dynamically, e.g. at run- time. The main program contains at least one call to at least one of the sub-routines. The sub- routines may also comprise function calls to each other. The carrier of a computer program may be any entity or device capable of carrying the program. For example, the carrier may include a data storage, such as a ROM, for example, a CD ROM or a semiconductor ROM, or a magnetic recording medium, for example, a hard disk. Furthermore, the carrier may be a transmissible carrier such as an electric or optical signal, which may be conveyed via electric or optical cable or by radio or other means. When the program is embodied in such a signal, the carrier may be constituted by such a cable or other device or means. Alternatively, the carrier may be an integrated circuit in which the program is embedded, the integrated circuit being adapted to perform, or used in the performance of, the relevant method. Variations to the disclosed embodiments can be understood and effected by those skilled in the art in practicing the claimed invention, from a study of the drawings, the disclosure and the appended claims. In the claims, the word "comprising" does not exclude other elements or steps, and the indefinite article "a" or "an" does not exclude a plurality. A single processor or other unit may fulfil the functions of several items recited in the claims. The mere fact that certain measures are recited in mutually different dependent claims does not indicate that a combination of these measures cannot be used to advantage. A computer program may be stored/distributed on a suitable medium, such as an optical storage medium or a solid-statef medium supplied together with or as part of other hardware, but may also be distributed in other forms, such as via the Internet or other wired or wireless telecommunication systems. Any reference signs in the claims should not be construed as limiting the scope.

Appendix Memory Usage in Memory Cell Sample Size of Time Machine Gate in Model Data Sample Step Configuration Accuracy Loss bytes 12.7 GB RAM Sequential and 107.72 GB 3.72E- Model Invoice 8824 20 Disk 82.20% 06 640000 LSTM (using 12.7 GB RAM method and 107.72 GB 3.72E- 400) Invoice 8824 20 Disk 82.20% 06 480000

Claims

CLAIMS: 1. A computer implemented method (400) of processing a sequence of data points using a Long Short-Term Memory, LSTM, cell in an iterative manner on each data point in the sequence, the method comprising: retrieving (402) a first portion of a cell state of the LSTM cell from a resilient data store, RDS; and holding (404) the first portion of the cell state in a stream-based memory, for use as input to the LSTM cell in a first iteration of a first data point through the LSTM cell.

2. A method as in claim 1 further comprising: processing the first data point through the LSTM cell; and wherein, the processing of an output gate of the LSTM comprises: transferring, as part of the first iteration of the first data point through the LSTM cell, an updated cell state and a hidden state of the LSTM cell to the stream-based memory.

3. A method as in claim 2 wherein the processing of the output gate of the LSTM further comprises: transferring the updated cell state from the stream-based memory to the RDS; and retrieving a second portion of the cell state from the RDS and storing the second portion of the cell state in the stream-based memory, for use as input to the LSTM in a second iteration of a second data point through the LSTM cell.

4. A method as in claim 3 wherein the second portion of the cell state is a hidden state that was output from the first iteration of the first data point through the LSTM cell.

5. A method as in claim 1, 2, 3, or 4 wherein the stream-based memory is internal to the LSTM cell.

6. A method as in claim 2, 3, 4, or 5 wherein the step of transferring, as part of the first iteration of the first data point through the LSTM cell, an updated cell state and a hidden state of the LSTM cell to the stream-based memory comprises: updating the cell state of the LSTM cell held in the stream-based memory with the output of a forget gate of the LSTM; and/or updating the cell state of the LSTM cell held in the stream-based memory with the output of an input gate.

7. A method as in any one of the preceding claims wherein a forget gate, ft, of the LSTM cell is described by the following equation: ft= Sigmoid (xt*Uf+St*Wf); wherein: xt is a datapoint from the sequence of data points, provided to the LSTM cell in a particular iteration; Uf is a first weighting value associated with xt; St is the cell state; and Wf is a weighting matrix associated with St; and wherein St is obtained from the stream-based memory.

8. A method as in any one of the preceding claims wherein the input gate, It, of the LSTM cell is described by the following equation: It= Sigmoid (xt*Ui + St*Wi) * tangent (xt*Ui + St*Wi); wherein: xt is a datapoint from the sequence of data points, provided to the LSTM cell in a particular iteration; Ui is a first weighting value associated with xt; St is the cell state; and Wi is a weighting matrix associated with St; and wherein St is obtained from the stream-based memory.

9. A method as in any one of the preceding claims wherein the method is for use in detecting anomalies in the sequence of data points.

10. A method as in claim 9 wherein the method further comprises: inputting the first data point to the LSTM cell; receiving as output of the first iteration, a prediction of a second data point in the sequence of data points; and comparing the prediction of the second data point to said second data point to determine whether the second data point is anomalous.

11. A method as in any one of the preceding claims wherein the method is performed by a node in a communications network.

12. A method as in claim 11 wherein the sequence of data points comprises a sequence of billing information data points for a user in the communications network and wherein, in the first iteration, the first data comprises a first billing information data point, and wherein, in the second iteration, the second data point comprises a second billing information data point.

13. A computer program comprising instructions which, when executed on at least one processor, cause the at least one processor to: initiate a Long Short-Term Memory, LSTM, cell; and initiate a stream-based memory for use by the LSTM in transferring a cell state of the LSTM cell between the stream-based memory and a Resilient Data Store, RDS.

14. An apparatus (200) for processing a sequence of data points using a Long Short- Term Memory, LSTM, cell in an iterative manner on each data point in the sequence, the apparatus comprising: a memory (204) comprising instruction data representing a set of instructions (206); and a processor (202) configured to communicate with the memory and to execute the set of instructions, wherein the set of instructions, when executed by the processor, cause the processor to: retrieve a first portion of a cell state of the LSTM cell from a resilient data store, RDS; and hold the first portion of the cell state in a stream-based memory, for use as input to the LSTM cell in a first iteration of a first data point through the LSTM cell.

15. An apparatus (200) as in claim 14 wherein the set of instructions (206), when executed by the processor, further cause the processor to perform the method of any one of claims 2 to 12.

16. An apparatus (200) for processing a sequence of data points using a Long Short- Term Memory, LSTM, cell in an iterative manner on each data point in the sequence, the apparatus being configured to perform the method of any one of claims 1 to 12.

17. A computer program comprising instructions which, when executed on at least one processor, cause the at least one processor to carry out a method according to any of claims 1 to 12.

18. A carrier containing a computer program according to claim 17, wherein the carrier comprises one of an electronic signal, optical signal, radio signal or computer readable storage medium.

19. A computer program product comprising non transitory computer readable media having stored thereon a computer program according to claim 17.