Prediction of Medical Events Based on Health Record Observation Values

Abstract

A computer-implemented method for predicting a medical event time includes receiving an electronic health record (EHR) including a plurality of pairs of observation variables and corresponding time stamps, each of the plurality of pairs including a respective observation variable and a respective corresponding time stamp. The method further includes converting the EHR into a K-dimensional vector representing cumulative dwell time in a finite number of patient medical states, the patient medical states being determined by values ​​of the observation variables. The method also includes processing, by a hardware processor, the K-dimensional vector with a medical event time prediction model to output a prediction of the medical event time. The medical event time prediction model is configured through training to receive and process the converted K-dimensional vector from a historical EHR to output a predicted medical event time.

Description

Technical Field

[0001] The present invention generally relates to a cumulative time residence (CTR) representation for modeling electronic health records in the prediction of diabetes and other medical complications.

[0002] Predicting diabetes complications or some medical event from an electronic health record (EHR) representing a patient's health history is an important task in medical and health management applications. To improve the modeling of the health history, it should correspond to the time series in the EHR.

Summary of the Invention

[0003] According to an aspect of the present invention, a computer-implemented method for predicting a medical event time is provided. The method includes receiving an electronic health record (EHR) including a plurality of pairs of observed value variables and corresponding timestamps. Each of the plurality of pairs includes a respective observed value variable and a respective corresponding timestamp. The method further includes converting the EHR into a K-dimensional vector representing the cumulative time residence in a finite number of patient medical states, where the patient medical state is determined by the value of the observed value variable. The method also includes processing, by a hardware processor, the K-dimensional vector using a medical event time prediction model to output a prediction of the medical event time. The medical event time prediction model is configured through training to receive and process K-dimensional vectors converted from past EHRs and output the predicted medical event time.

[0004] According to another aspect of the present invention, a computer program product for predicting a medical event time is provided. The computer program product includes a non-transitory computer-readable storage medium having program instructions embodied therewith. The program instructions are executable by a computer to cause the computer to execute a method. The method includes receiving an electronic health record (EHR) including a plurality of pairs of observed value variables and corresponding timestamps. Each of the plurality of pairs includes a respective observed value variable and a respective corresponding timestamp. The method includes converting the EHR into a K-dimensional vector representing the cumulative sojourn time in a finite number of patient medical states, where the patient medical state is determined by the value of the observed value variable. The method further includes processing the K-dimensional vector using a medical event time prediction model and outputting a prediction of the medical event time. The medical event time prediction model is configured through training to receive and process K-dimensional vectors converted from past EHRs and output the predicted medical event time.

[0005] According to still another aspect of the present invention, a computer processing system for predicting a medical event time is provided. The computer processing system further includes a memory device for storing program code. The computer processing system also includes a hardware processor operably coupled to the memory device for executing program code for receiving an electronic health record (EHR) including a plurality of pairs of observed value variables and corresponding timestamps. Each of the plurality of pairs includes a respective observed value variable and a respective corresponding timestamp. The hardware processor further executes program code for converting the EHR into a K-dimensional vector representing the cumulative sojourn time in a finite number of patient medical states, where the patient medical state is determined by the value of the observed value variable. The hardware processor also executes program code for processing the K-dimensional vector using a medical event time prediction model and outputting a prediction of the medical event time. The medical event time prediction model is configured through training to receive and process K-dimensional vectors converted from past EHRs and output the predicted medical event time.

[0006] These and other features and advantages will become apparent from the following detailed description of these exemplary embodiments, which should be read in conjunction with the accompanying drawings.

Brief Description of the Drawings

[0007] The following description provides details of the preferred embodiments with reference to the following drawings.

[0008]

Figure 1

[0009]

Figure 2

[0010]

Figure 3

Figure 4

Figure 5

[0011]

Figure 6

[0012]

Figure 7

[0013]

Figure 8

[0014]

Figure 9

[0015]

Figure 10

[0016] Embodiments of the present invention are directed to a cumulative dwell time representation (CTR) for modeling electronic health records in the prediction of diabetes and other medical health complications. In particular, embodiments of the present invention can be used to predict when a patient will develop some disease after an index date from past observations in an electronic health record (EHR).

[0017] For better modeling of the health history, the raw observations in the EHR should be processed, and the raw observations in each patient's EHR should be converted into a representation that is easy to handle as an input for a prediction model. This is because the raw observations are not structured or formatted in a way that is convenient for machine learning-based techniques.

[0018] The normal time series representation is a common and simplest way for this purpose, focusing on modeling the detailed dependencies between consecutive observations.

[0019] On the other hand, the progression of certain diseases and complications, particularly, for example, lifestyle diseases and geriatric diseases, is known to be related to the cumulative residence time in the state of a specific patient, for example, hypertension, hyperglycemia, and hyperlipidemia. Since the cumulative residence time is exactly an example of long-term dependence, the normal time-series representation is rather inefficient for modeling the cumulative residence time. Therefore, for the accurate prediction of diabetes and / or other complications, it is desired to directly model / represent the cumulative residence time in the state of a specific patient.

[0020] Furthermore, the observation interval may change over time. Therefore, it is desirable to process the changing observation interval.

[0021] Therefore, one or more embodiments cumulatively record the residence time for a combination of values of observation value variables representing the health state of a patient as a state. Three types of definitions are derived from the state; the first one individually determines the state assignment of the observed values as non-overlapping segments, and the second and third ones determine it as continuous measurements, based on a kernel function and a neural network, respectively.

[0022] FIG. 1 is a block diagram showing an exemplary computing device 100 according to an embodiment of the present invention. The computing device 100 is configured to provide a cumulative residence time representation (CTR) for the modeling of electronic health records in the prediction of diabetes and / or other complications.

[0023] Computing device 100 may be embodied as any type of computing device or computer device capable of performing the functions described herein. This includes, but is not limited to, computers, servers, rack-based servers, blade servers, workstations, desktop computers, laptop computers, notebook computers, tablet computers, mobile computing devices, wearable computing devices, network appliances, web appliances, distributed computing systems, processor-based systems, and / or consumer electronic devices. Additionally or alternatively, computing device 100 may be embodied as one or more compute threads, memory threads, or other components of other racks, threads, computing chassis, or physically disassembled computing devices. As shown in FIG. 1, computing device 100 illustratively includes a processor 110, an input / output subsystem 120, a memory 130, a data storage device 140, a communication subsystem 150, and / or other components and devices commonly found within a server or similar computing device. Of course, in other embodiments, computing device 100 may include other or additional components, such as components commonly found within a server computer (e.g., various input / output devices). Also, in some embodiments, one or more of these exemplary components may be incorporated into another component or form part of another component. For example, in some embodiments, memory 130 or a portion thereof may be incorporated into processor 110.

[0024] Processor 110 may be embodied as any type of processor capable of executing the functions described herein. Processor 110 may be embodied as a single processor, multiple processors, a central processing unit (CPU), a graphics processing unit (GPU), a single or multi-core processor, a digital signal processor, a microcontroller, or other processor or processing / control circuitry.

[0025] Memory 130 may be embodied as any type of volatile or non-volatile memory or data storage capable of executing the functions described herein. During operation, memory 130 may store various data and software used during the operation of computing device 100, such as an operating system, applications, programs, libraries, and drivers. Memory 130 is communicatively coupled to processor 110 via I / O subsystem 120. I / O subsystem 120 may be embodied as circuitry and / or components for facilitating input / output operations between processor 110, memory 130, and other components of computing device 100. For example, I / O subsystem 120 may be embodied as, or may include, a memory controller hub, an input / output control hub, a platform controller hub, an integrated control circuit, a firmware device, a communication link (e.g., a point-to-point link, a bus link, a wire, a cable, a light guide, a trace on a printed circuit board, etc.), and / or other components and subsystems for facilitating input / output operations. In some embodiments, I / O subsystem 120 may form part of a system-on-chip (SOC) and may be incorporated onto a single integrated circuit chip together with processor 110, memory 130, and other components of computing device 100.

[0026] The data storage device 140 may be embodied as one or more devices of any type configured for short-term or long-term storage of data, such as, for example, memory devices and circuits, memory cards, hard disk drives, solid state drives, or other data storage devices. The data storage device 140 may store program code for providing a cumulative dwell time representation (CTR) for modeling electronic health records (EHRs) in the prediction of diabetes and / or other complications. The communication subsystem 150 of the computing device 100 may be embodied as any network interface controller or other communication circuit, device, or collection thereof that enables communication between the computing device 100 and other remote devices through a network. The communication subsystem 150 may be configured to use any one or more communication technologies (e.g., wired or wireless communication) and associated protocols (e.g., Ethernet®, InfiniBand®, Bluetooth®, Wi-Fi®, WiMAX®, etc.) to perform such communication.

[0027] As shown, the computing device 100 may also include one or more peripheral devices 160. The peripheral devices 160 may include any number of additional input / output devices, interface devices, and / or other peripheral devices. For example, in some embodiments, the peripheral devices 160 may include a display, touch screen, graphics circuit, keyboard, mouse, speaker system, microphone, network interface, and / or other input / output devices, interface devices, and / or peripheral devices.

[0028] Of course, computing device 100 may also include other elements (not shown) as would be readily contemplated by those skilled in the art, and similarly, certain elements may be omitted. For example, as would be readily understood by those skilled in the art, various other input devices and / or output devices may be included in computing device 100 depending on a particular implementation of computing device 100. For example, various types of wireless and / or wired input and / or output devices may be used. Additionally, additional processors, controllers, memories, etc. may also be utilized in various configurations. Further, in another embodiment, a cloud configuration may be used (see, e.g., FIGS. 9 - 10). These and other variations of processing system 100 would be readily contemplated by those skilled in the art given the teachings of the present invention provided herein.

[0029] As used herein, the terms "hardware processor subsystem" or "hardware processor" may refer to a processor, memory (including RAM, cache, etc.), software (including memory management software), or a combination of these that cooperate to perform one or more specific tasks. In useful embodiments, the hardware processor subsystem may include one or more data processing elements (e.g., logic circuits, processing circuits, instruction execution devices, etc.). The one or more data processing elements may be included in a central processing unit, a graphics processing unit, and / or a separate processor or computing element-based controller (e.g., logic gates, etc.). The hardware processor subsystem may include one or more on-board memories (e.g., cache, dedicated memory arrays, read-only memories, etc.). In some embodiments, the hardware processor subsystem may include one or more memories that may be on-board or on-board, or dedicated for use by the hardware processor subsystem (e.g., ROM, RAM, basic input / output system (BIOS), etc.).

[0030] In some embodiments, the hardware processor subsystem may include, or execute, one or more software elements. The one or more software elements may include an operating system and / or one or more applications, and / or specific code to achieve a specified result.

[0031] In other embodiments, the hardware processor subsystem may include dedicated, special circuitry that executes one or more electronic processing functions to achieve a specified result. Such circuitry may include one or more application-specific integrated circuits (ASICs), FPGAs, and / or PLAs.

[0032] These and other variations of the hardware processor subsystem according to embodiments of the present invention are also contemplated.

[0033] FIG. 2 is a block diagram showing an exemplary representation 200 of raw observations as a k-dimensional vector according to one embodiment of the present invention.

[0034] The representation 200 includes patients 1 to 4, an initial observation time 210, a cut-off time 220, an observation window 230, and a prediction window 240. In the prediction window, disease onset 250 may be indicated. The day that is an indicator of the prediction 260 corresponds to the end of the observation window 230. That is, the past observations of each patient are obtained from a window spanning from the initial observation time to the indicator day. A model is constructed to predict the event time of disease onset based on the observations corresponding to the patients.

[0035] FIGS. 3-5 show an exemplary method 300 for predicting and handling medical event times according to one embodiment of the present invention.

[0036] In block 305, an electronic health record (EHR) is formed by converting a patient's blood sample into one or more observation value variables and one or more corresponding timestamps. The EHR may be formed from other data (e.g., blood pressure, body temperature, weight, etc.).

[0037] In block 310, receive an EHR that includes a plurality of pairs of an observed value variable and a corresponding timestamp. Each of the plurality of pairs includes a respective observed value variable and a respective corresponding timestamp.

[0038] In block 320, convert the EHR into a K-dimensional vector representing the cumulative sojourn time in a finite number of patient medical states. The patient medical state is determined by the value of the observed value variable. In one embodiment, the patient medical state can be a discontinuous state that is the value of a non-overlapping segment of the observed value variable.

[0039] In one embodiment, block 320 can include one or more of blocks 320A through 320D.

[0040] In block 320A, in response to a given one of the observed value variables entering the k-th segment, apply the indicator function to the value of the non-overlapping segment of the observed value variable such that only the k-th element of the indicator function is set to 1 and the remaining elements are set to 0.

[0041] In block 320B, represent the patient medical state by a continuous measurement based on a kernel function.

[0042] In one embodiment, block 320B includes one or more of blocks 320B1 through 320B4.

[0043] In block 320B1, calculate a kernel function representing the proximity between past observed values from past observed values.

[0044] In block 320B2, calculate a kernel function representing the proximity between random vectors from random vectors. In one embodiment, the kernel function can be configured to determine a K-dimensional vector representing weights corresponding to the vector ratios assigned to each of the patient medical states.

[0045] In block 320B3, a kernel function is calculated to have k bases corresponding to the k dimensions of a k-dimensional vector.

[0046] In block 320B4, a kernel function is calculated based on a bandwidth parameter optimized by grid search and also based on an observed value normalization coefficient, using an activation set in training data for a medical event time prediction model.

[0047] In one embodiment, the kernel function may include a string kernel for binary features. For that purpose, in block 320B5, a string kernel is calculated based on the sum of cosine similarities between term frequencies and inverse document frequencies.

[0048] In block 320C, a patient's medical state is represented by continuous measurements based on a neural network trained with past observations.

[0049] Block 320C may include block 320C1.

[0050] In block 320C1, a neural network is trained in an end-to-end manner by training a medical event time prediction model with past observations.

[0051] In block 320D, a cumulative residence time is calculated as the sum of the products of a plurality of k-dimensional vectors and the period of residence in a patient's medical state.

[0052] In block 330, a medical event time prediction model is used to process a K-dimensional vector and output a prediction of the medical event time. The medical event time prediction model is configured through training to receive and process K-dimensional vectors converted from past EHRs and output a predicted medical event time.

[0053] In block 340, in response to the prediction of the medical event time, the blood of the patient is tested using a hardware-based medical device to confirm the presence of an undesirable medical event. For example, complications of diabetes such as hyperglycemia and gout can be detected. In one embodiment, the patient's blood and / or vision is tested using a blood analysis device and a vision test device, respectively. The hardware-based medical device can be a centrifuge, a needle, and / or an automated vision test, etc.

[0054] In block 350, in response to the blood test that confirms the presence of an undesirable medical event, a treatment substance is injected into the patient using a patient injection device. The treatment substance can be a pharmaceutical or other substance (e.g., glucose) for treating a specific symptom / complication.

[0055] Here, an exemplary embodiment is provided.

[0056] In an embodiment, the raw observations and timestamps are converted into a k-dimensional vector representing the cumulative residence time in a finite number of states.

Number

[0057] The difference between consecutive times t s is used, and z is defined as

Number

Number

[0058] In addition to the exemplary embodiment, here, an explanation regarding the variation of the state function according to various embodiments of the present invention is provided.

[0059] Here, an explanation regarding the transformation of the state function implemented by the discontinuous state is given.

[0060] In such a case, the state function s can be expressed as follows:

Number

[0061] In such a case, the discontinuous state can be regarded as bins of values of non - overlapping segments of the observed value variables. Each bin is filled with the corresponding sojourn time of the patient.

[0062] Here, an explanation regarding the transformation of the state function implemented by the continuous state using the kernel function is given.

[0063] In such a case, the state function s K can be expressed as follows:

Number

[0064] Since the number of discontinuous states grows exponentially with the number of features D, a kernel with K bases

Number

Number

[0065] Here, an explanation is given regarding a transformation of the state function implemented by a continuous state using a neural network.

[0066] In such a case, the state function s N can be represented as follows:

Equation

[0067] The kernel function can be replaced by a neural network trained in an end-to-end manner, where θ Φ is a parameter for the neural network, and the neural network g also outputs a K-dimensional vector for representing the weight vector for the state.

[0068] It should be understood that the k-dimensional vector z has no time axis but maintains time information as the cumulative sojourn time in each state, which provides a lightweight approach to represent a time series and can be parallelized over the observations. Further, since d is directly encoded, it can naturally handle varying observation intervals.

[0069] Note that normalization is applied to the k-dimensional vector z to handle the variable N that depends on each instance in the current implementation. Also, interpolation can be used to fix the variable N.

[0070] As can be seen, the continuous state including the kernel function and the neural network avoids an exponential increase in the number of states and provides smooth interpolation between states.

[0071] Figure 6 is a diagram showing an exemplary plot 600 for cumulative residence time representation and corresponding data 620 according to an embodiment of the present invention.

[0072] In the plot, the x-axis represents time and the y-axis represents the value of the raw observed variable in the EHR of the m-th patient. As can be seen, the values of the raw observed variable spread anywhere from low values to high values as shown in plot 600.

[0073] The corresponding data, i.e., the cumulative residence time 621 for each state, is calculated as shown in block 620. That is, the cumulative residence time is recorded for each combination of values of the observed variable.

[0074] Figure 7 is a diagram showing exemplary pseudo-code 700 of an algorithm for calculating a cumulative residence time representation according to an embodiment of the present invention.

[0075] The input to the algorithm includes the raw observed values {X, t} and the state function s.

[0076] The output from the algorithm includes the cumulative residence time representation CTR (k-dimensional vector).

[0077] An explanation regarding the use of continuous states by a kernel function according to an embodiment of the present invention is given here.

[0078] As described above, the state function s K can be represented as follows:

Equation

[0079] In one implementation form, φ is an RBF kernel as follows:

Equation

[0080] Other kernels representing proximity between past observations, such as a string kernel for binary features (e.g., tf-idf vectors

Number

Number

[0081] An explanation regarding the use of a continuous state by a kernel function according to an embodiment of the present invention is given here.

[0082] As described above, the state function s N can be expressed as follows:

Number

[0083] To learn g from the data, a multi-layer neural network for g may be used as follows:

Number

Number

[0084] An explanation regarding the prediction of medical event times from EHR according to an embodiment of the present invention is given here.

[0085] Based on the past raw observations in the EHR which are M pairs {X, t} of observed value variables and corresponding timestamps, a model is constructed to predict the event time y > 0 after the index day. The observed value variable is,

Number

Number

Number

Number

[0086] When a machine learning approach is taken, in order to obtain the event time 840 shown in Figure 8, the raw observations {X, t} 810 must be formulated into a tractable representation 820 as input for the subsequent prediction model 830 (e.g., NN including linear model, random forest, and recurrent neural network). Figure 8 is a block diagram showing an exemplary system 800 according to an embodiment of the present invention. The representation is defined as z as a function of {X, t}, i.e., z{X, t}, and its output forms either a vector, a matrix, or a tensor depending on the formulation.

[0087] Once {X,t} is formulated into z, z is used as the input to the prediction model f(x(X,t)), and the prediction model is learned using a general scheme that minimizes the expected loss as follows: [Number] Here, f * is the optimal regression function, and [Number] is the loss function, such as the mean squared error, [Number] the Poisson loss [Number] and the log-normal loss [Number] where E denotes the expectation with respect to p(y,X,t). By using the learned f * y can be predicted for new data as follows: [Number]

[0088] An explanation is given here regarding formulating raw observations into a more manageable representation according to an embodiment of the present invention.

[0089] Here, it is explained how to formulate the raw observations {X,t} into a more manageable representation z in order to predict the event time. By constructing z, the cumulative sojourn time of the state of a specific patient is directly modeled. First, the normal time series representation is considered. Then, the cumulative sojourn time representation CTR is derived.

[0090] An explanation is given here regarding the normal time series representation according to an embodiment of the present invention.

[0091] In the normal time series representation, the raw observation values {X, t} are in the form of a matrix representation,

Number

Number

Number

[0092] Note that this representation is not efficient for dealing with the cumulative sojourn time, which is exactly an example of long-term dependence as discussed in the introduction. Even when using a sophisticated variant of the RNN, the learning cost required to continuously encode each observation value from the training data to the cumulative sojourn time throughout the time series is high. Also, to process this cumulative feature, the RNN needs to remember all the observation values and timestamps over the time series. Since the state in the RNN is not static, this requires a large amount of memory.

[0093] An explanation of CTR-D according to an embodiment of the present invention, that is, the cumulative sojourn time representation in the discontinuous state, is given here.

[0094] The cumulative sojourn time representation CTR is proposed to directly model the cumulative sojourn time of the state of a specific patient as a new formulation of z. The raw observation values (X, t) are k-dimensional vectors z (the k-th element is z kIt is converted into the cumulative residence time in a finite number of K states (where >0). Each state represents a combination of values of the observed value variables and can be regarded as a bin segmented by a grid that defines the value range of each observed value variable in each state. Each bin is cumulatively filled with the residence time whose raw observed value is included in the corresponding value range.

[0095] Input observed value x {m} A state function that outputs a one-hot vector representing the current state for

Number

Number

Number

[0096] The state function s(x {m} ) is defined by the indicator function I, which always outputs a K-dimensional one-hot vector:

Number

Number

Number

Number

Number

Number

Number

[0097] The CTR in Equation (3) with the state function in Equation (4) is called the cumulative residence time representation with discontinuous states (CTR-D). The individually defined state s(x {m} ) is easy to understand. When the number of variables in x is small, the function s(x {m} ) in Equation (3) can be used to calculate z.

[0098] However, since the total number of comprehensive combinations representing the states grows exponentially with the number of observed variables D, it is not possible to handle more than a few variables. In the case of EHR modeling, the states are not essentially simple enough to be modeled in such a low-dimensional space. Also, as defined in Equation (4), adjacent states should represent similar states to each other due to the boundaries shared between them, but the discontinuous boundaries prevent generalization between adjacent states. The function s(x {m} ) is extended to something more practical.

[0099] An explanation is given here regarding CTR-K according to an embodiment of the present invention, that is, the cumulative residence time representation (CTR) with continuous states based on a kernel function.

[0100] To reduce the exponential increase in the number of states, the definition of the state is changed from individual (the variable value that the observed value has) to continuous (how close the observed value is to some basis vector). The continuous states are no longer represented as one-hot vectors corresponding to individual states. They are represented as weight vectors that determine how the present invention allocates the current residence time to each state represented by the basis. In this case, the number of states is limited to the number of bases. This also results in interpolation between states and can smoothly represent intermediate states between states.

[0101] To calculate the continuous state, a kernel function representing the similarity of the observed value to the basis is used, where a vector of continuous values is constructed by assigning different values to multiple elements according to the similarity. The state function

Number

Number

Number

Number

[0102] When the variable is a real value (this also includes exemplary scenarios), the choice of φ is the RBF kernel defined as follows:

Number

[0103] The CTR in Equation (3) with the state function in Equation (6) is called the cumulative sojourn time representation (CTR-K) with the state defined by the kernel.

[0104] An explanation is given here regarding CTR-N according to an embodiment of the present invention, that is, the cumulative sojourn time representation (CTR) having a continuous state based on a neural network.

[0105] Additionally, the requirement for the continuous state s K (x {m} ) can be seen to be for representing similar observation values using a similar weight vector. Such a vector can also be modeled using a neural network.

[0106] Therefore, as follows, by replacing the kernel function with a trainable neural network g that generates a weight vector indicating a state similar to φ, s K (x {m} ) is extended to s N (x {m} ): [Number] Here, θ gis a parameter for the neural network. The final layer of g is a softmax function for normalization as a weight vector. The specific neural network structure of g is shown in the experimental results section.

[0107] The CTR in Equation (3) with the state function in Equation (8) is called the cumulative residence time representation with states defined by a neural network (CTR-N). This representation can be learned from data and thus provides more flexibility in adjusting the definition of states for target data.

[0108] This disclosure includes a detailed description of cloud computing, but it should be understood that the implementation of the teachings described herein is not limited to a cloud computing environment. Rather, embodiments of the present invention can be implemented with any other type of computing environment known now or developed in the future.

[0109] Cloud computing is a service delivery model that enables convenient on-demand network access to a shared pool of configurable computing resources (such as networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and released with minimal management effort or interaction with a service provider. This cloud model can include at least five characteristics, at least three service models, and at least four deployment models.

[0110] The characteristics are as follows.

[0111] On-demand self-service: Cloud consumers can automatically and unilaterally provision computing capabilities such as server time and network storage as needed without the need for human interaction with the service provider.

[0112] Broad network access: The capabilities are available over a network and accessed through standard mechanisms that promote use by heterogeneous thin or thick client platforms (e.g., mobile phones, laptops, and PDAs).

[0113] Resource pooling: The provider's computing resources are pooled to serve multiple consumers using a multi-tenant model, with dynamic allocation and reassignment of a variety of physical and virtual resources according to demand. Consumers generally have a sense of location independence in that they have no control or knowledge over the exact location of the provided resources but can specify location at a higher level of abstraction (e.g., country, state, or data center).

[0114] Rapid elasticity: Capabilities can be rapidly and elastically provisioned, in some cases automatically, to scale out instantly and also released rapidly to scale in instantly. To the consumer, there is often the perception that the capabilities available for provisioning are unlimited and that they can be purchased in any quantity at any time.

[0115] Measured service: By leveraging metering capabilities at some level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts), the cloud system automatically controls and optimizes resource use. Resource utilization is monitored, controlled, and reported, providing transparency to both the provider and consumer of the utilized services.

[0116] The service model is as follows.

[0117] Software as a Service (SaaS): The ability provided to consumers is to use the provider's applications running on cloud infrastructure. The applications can be accessed from various client devices via a client interface such as a web browser (e.g., web-based mail). Consumers do not manage or control the underlying cloud infrastructure, which includes the network, servers, operating systems, storage, or even the individual application capabilities. However, there may be exceptions for limited user-specific application configurations.

[0118] Platform as a Service (PaaS): The ability provided to consumers is to deploy the applications created or acquired by the consumers on cloud infrastructure using programming languages and tools supported by the provider. Consumers do not manage or control the underlying cloud infrastructure, which includes the network, servers, operating systems, or storage, but can control the deployed applications and, in some cases, the application hosting environment configuration.

[0119] Infrastructure as a Service (IaaS): The ability provided to consumers is to provision processing, storage, network, and other basic computing resources, and consumers can deploy and run any software that may include operating systems and applications. Consumers do not manage or control the underlying cloud infrastructure, but can control the operating systems, storage, deployed applications, and, in some cases, selected networking components (e.g., host firewalls) in a limited manner.

[0120] The deployment model is as follows.

[0121] Private cloud: The cloud infrastructure is operated only for an organization. It can be managed by the organization or a third party and can exist on-premises or off-premises.

[0122] Community cloud: This cloud infrastructure is shared by several organizations and supports a specific community with common concerns (e.g., mission, security requirements, policies, and compliance considerations). It can be managed by an organization or a third party and can exist on-premises or off-premises.

[0123] Public cloud: The cloud infrastructure is made available to the general public or a large industry group and is owned by an organization that sells cloud services.

[0124] Hybrid cloud: This cloud infrastructure is a composite of two or more clouds (private, community, or public), and the two or more clouds remain separate entities but are joined together by standard or proprietary technologies that enable data and application portability (e.g., cloud bursting for load balancing between clouds).

[0125] The cloud computing environment is service-oriented, emphasizing statelessness, loose coupling, modularity, and semantic interoperability. The core of cloud computing is an infrastructure that includes a network of interconnected nodes.

[0126] Referring now to FIG. 9, an exemplary cloud computing environment 950 is shown. As shown, cloud computing environment 950 includes one or more cloud computing nodes 910 with which a local computing device used by a cloud consumer, such as, for example, a personal digital assistant (PDA (registered trademark)) or cellular telephone 954A, desktop computer 954B, laptop computer 954C, and / or automotive computer system 954N, may communicate. Nodes 910 can communicate with one another. They may be physically or virtually grouped (not shown) in one or more networks such as private clouds, community clouds, public clouds, or hybrid clouds, or combinations thereof, as described above. Thereby, cloud computing environment 950 enables a cloud consumer to provide infrastructure as a service, platform as a service, and / or software as a service such that the cloud consumer need not maintain resources on a local computing device. It should be understood that the types of computing devices 954A-N illustrated in FIG. 9 are solely exemplary, and that cloud computing nodes 910 and cloud computing environment 950 can communicate with any type of computerized device through any type of network and / or network addressable connection (e.g., using a web browser).

[0127] Referring now to FIG. 10, a set of functional abstractions provided by cloud computing environment 950 (FIG. 9) is shown. It should be pre-understood that the components, layers, and functions shown in FIG. 10 are for purposes of illustration only and that embodiments of the invention are not limited thereto. As shown, the following layers and corresponding functions are provided.

[0128] The hardware and software layer 1060 includes hardware and software components. Examples of hardware components include mainframe 1061, RISC (Reduced Instruction Set Computer) architecture-based server 1062, server 1063, blade server 1064, storage device 1065, and network and network components 1066. In some embodiments, software components include network application server software 1067 and database software 1068.

[0129] The virtualization layer 1070 provides an abstraction layer. From the abstraction layer, examples of the following virtual entities may be provided: virtual server 1071; virtual storage 1072; virtual network 1073 including a virtual private network; virtual applications and operating systems 1074; and virtual client 1075.

[0130] In one example, the management layer 1080 may provide the functions described below. Resource provisioning 1081 provides dynamic procurement of computing resources and other resources utilized to execute tasks within a cloud computing environment. Measurement and pricing 1082 provides cost tracking and billing or invoicing for the consumption of these resources when the resources are used within a cloud computing environment. In one example, these resources may include application software licenses. Security performs identity verification for cloud consumers and tasks, and protection for data and other resources. The user portal 1083 provides access to the cloud computing environment for consumers and system administrators. Service level management 1084 provides cloud computing resource allocation and management such that the required service levels are met. Service level agreement (SLA) planning and fulfillment 1085 provides upfront reservation and procurement for cloud computing resources for which future requirements are anticipated according to the SLA.

[0131] The workload layer 1090 provides examples of functionality that a cloud computing environment can utilize. Examples of workloads and functions that may be provided from this layer include mapping and navigation 1091, software development and lifecycle management 1092, virtual classroom education delivery 1093, data analysis processing 1094, transaction processing 1095, and CTR 1096 for modeling EHRs in the prediction of diabetes and other medical health complications.

[0132] The present invention may be a system, method, and / or computer program product at any possible technical detail level of integration. The computer program product may include a computer-readable storage medium (or multiple computer-readable storage media) having computer-readable program instructions for causing a processor to execute aspects of the present invention.

[0133] A computer-readable storage medium can be a tangible device that can hold and store instructions for use by an instruction execution device. The computer-readable storage medium can be, for example, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination thereof, but is not limited thereto. A non-exhaustive list of more specific examples of computer-readable storage media includes portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disc read-only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, mechanically encoded devices such as punch cards or raised structures in grooves in which instructions are recorded, and any suitable combination thereof. As used herein, a computer-readable storage medium should not be construed to be a transient signal per se, such as a radio wave or other freely propagating electromagnetic wave, an electromagnetic wave propagating through a waveguide or other transmission medium (e.g., an optical pulse passing through an optical fiber cable), or an electrical signal transmitted via a wire.

[0134] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computing device / processing device or to an external computer or external storage device via a network (e.g., the Internet, a local area network, a wide area network, and / or a wireless network). This network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface within each computing device / processing device receives the computer-readable program instructions from the network and transfers them for storage on a computer-readable storage medium within each computing device / processing device.

[0135] Computer-readable program instructions for carrying out the operations of the present invention may be in any combination of assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state-setting data, or source code or object code written in any one or more programming languages. The one or more programming languages include object-oriented programming languages such as SMALLTALK® and C++, and conventional procedural programming languages such as the "C" programming language or similar programming languages. The computer-readable program instructions may be executed entirely on the user's computer, partly on the user's computer as a stand-alone software package, partly on the user's computer and partly on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer via any type of network including a local area network (LAN) or a wide area network (WAN), or to an external computer (e.g., via the Internet using an Internet service provider). In some embodiments, to carry out aspects of the present invention, an electronic circuit including, for example, a programmable logic circuit, a field-programmable gate array (FPGA), or a programmable logic array (PLA) may execute computer-readable program instructions for customizing the electronic circuit by utilizing the state information of the computer-readable program instructions.

[0136] Aspects of the present invention will be described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable program instructions.

[0137] These computer-readable program instructions may be provided to the processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions / acts specified in the block or blocks of the flowchart and / or block diagram. These computer-readable program instructions may be stored in a computer-readable storage medium that includes instructions for causing a computer, programmable data processing apparatus, and / or other devices to function in a particular manner, such that the product includes the computer-readable storage medium storing instructions for implementing the aspects of the functions / acts specified in the block or blocks of the flowchart and / or block diagram.

[0138] The computer-readable program instructions may be loaded onto a computer, other programmable apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus, or other device such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions / acts specified in one or more blocks of the flowchart and / or block diagram.

[0139] Flowcharts and block diagrams in the drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of instructions that include one or more executable instructions for implementing the specified logical function. In some alternative implementations, the functions noted in the blocks may be performed in an order different from that noted in the drawings. For example, two blocks shown in succession may in fact be executed substantially simultaneously, or the blocks may sometimes be executed in the reverse order depending on the functions involved. It should also be noted that each block of the block diagrams and / or flowchart diagrams, and combinations of blocks in the block diagrams and / or flowchart diagrams, can be implemented by a dedicated hardware-based system that performs the specified function or operation, or by a combination of dedicated hardware and computer instructions.

[0140] References in this specification to "one embodiment" or "an embodiment" of the present invention and other variations thereof mean that a particular aspect, structure, characteristic, etc. described in connection with the embodiment is included in at least one embodiment of the present invention. Thus, the appearances of the phrases "in one embodiment" or "in an embodiment" and any other variations thereof that occur in various places throughout this specification are not necessarily all referring to the same embodiment.

[0141] It should be understood that any use of the following: " / ", "and / or", and "at least one of", for example, in the cases of "A / B", "A and / or B", and "at least one of A and B", is intended to encompass the selection of only the first-listed option (A), or only the second-listed option (B), or the selection of both options (A and B). As a further example, in the cases of "A, B, and / or C", and "at least one of A, B, and C", such expressions are intended to encompass the selection of only the first-listed option (A), or only the second-listed option (B), or only the third-listed option (C), or the selection of only the first and second-listed options (A and B), or the selection of only the first and third-listed options (A and C), or the selection of only the second and third-listed options (B and C), or the selection of all three options (A and B and C). This may be extended by the same number of items as are listed, so long as it is readily apparent to one of ordinary skill in the art.

[0142] (It is only intended to illustrate and is not limiting) Although preferred embodiments of the system and method have been described, it should be noted that modifications and variations can be made by those of ordinary skill in the art given the above teachings. Accordingly, it should be understood that changes may be made within the scope of the invention and within the specific embodiments disclosed and outlined by the appended claims. The aspects of the invention have been described in detail in this way, and, in particular, as required by patent law, what is desired to be claimed and protected by patent is described in the appended claims.

Claims

**Claim 1** A computer-implemented method for predicting a medical event time, comprising: Receiving an electronic health record (EHR) including a plurality of pairs of observed value variables and corresponding timestamps, wherein each of the plurality of pairs includes a respective observed value variable and a respective corresponding timestamp; Converting the EHR into a K-dimensional vector representing the cumulative sojourn time in a finite number of patient medical states, wherein the patient medical state is determined by the value of the observed value variable; and Processing, by a hardware processor, the K-dimensional vector using a medical event time prediction model to output a prediction of the medical event time, wherein the medical event time prediction model is configured to receive and process a K-dimensional vector converted from a past EHR through training to output a predicted medical event time; A computer-implemented method comprising the above steps. **Claim 2** The computer-implemented method according to claim 1, wherein the cumulative sojourn time is calculated as the sum of the products of a plurality of K-dimensional vectors and the periods of sojourn in the patient medical state. **Claim 3** The computer-implemented method according to claim 1 or claim 2, wherein the patient medical state is a discontinuous state that is a value of a non-overlapping segment of the observed value variable. **Claim 4** The computer-implemented method according to claim 3, further comprising applying the indicator function to the values of the non-overlapping segments of the observed value variable such that, in response to a given one of the observed value variables entering the k-th segment, only the k-th element of the indicator function is set to 1 and the remaining elements are set to 0. **Claim 5** The computer-implemented method according to claim 1 or claim 2, wherein the patient medical state is represented by a continuous measurement based on a kernel function. **Claim 6** The computer-implemented method according to claim 5, wherein the kernel function is calculated from past observed values and represents the proximity between the past observed values. **Claim 7** The computer-implemented method according to claim 5, wherein the kernel function is calculated from random vectors and represents the proximity between the random vectors. **Claim 8** The computer-implemented method according to claim 5, wherein the kernel function determines the K-dimensional vector representing the weights corresponding to the vector ratios assigned to each of the patient medical states. **Claim 9** The computer-implemented method according to claim 5, wherein the kernel function has K cardinalities corresponding to K dimensions of the K-dimensional vector.

10. The computer-implemented method according to claim 5, wherein the kernel function is calculated based on a bandwidth parameter optimized by grid search using an activation set in training data for the medical event time prediction model, and also based on an observed value normalization coefficient.

11. The computer-implemented method according to claim 5, wherein the kernel function has a string kernel for binary features, and the string kernel is calculated based on the sum of cosine similarities between term frequencies and inverse document frequencies.

12. The computer-implemented method according to claim 1, wherein the patient medical state is represented by continuous measurements based on a neural network trained with past observed values.

13. The computer-implemented method according to claim 12, wherein the neural network is trained in an end-to-end manner by training the medical event time prediction model with the past observed values.

14. The computer-implemented method according to claim 1, further comprising the step of parallel encoding a plurality of K-dimensional vectors across the observed value variables.

15. The computer-implemented method according to any one of claims 1 to 14, further comprising the step of testing the patient's blood using a hardware-based medical device to confirm the presence of an undesirable medical event in response to the prediction of the medical event time.

16. The computer-implemented method according to claim 15, further comprising the step of injecting a therapeutic substance into the patient using a patient injection device in response to the test of the blood to confirm the presence of the undesirable medical event.

17. The computer-implemented method according to any one of claims 1 to 16, further comprising the step of forming an electronic health record by converting a patient's blood sample into one or more observed value variables and one or more corresponding timestamps.

18. The computer-implemented method according to any one of claims 1 to 17, wherein the patient medical state is selected from the group consisting of hypertension exceeding a given amount threshold after a given time threshold, hyperglycemia exceeding a given amount threshold after a given time threshold, and high body fat percentage exceeding a given amount threshold after a given time threshold.

19. A computer program for predicting a medical event time, wherein the computer program has program instructions, the program instructions are executable by a computer, and the computer is caused to Receive an electronic health record (EHR) including a plurality of pairs of observed value variables and corresponding timestamps, where each of the plurality of pairs includes a respective observed value variable and a respective corresponding timestamp; Convert the EHR into a K-dimensional vector representing the cumulative residence time in a finite number of patient medical states, the patient medical state being determined by the values of the observed value variables; and Process the K-dimensional vector using a medical event time prediction model to output a prediction of the medical event time, where the medical event time prediction model is configured to receive and process a K-dimensional vector converted from a past EHR through training and output a predicted medical event time; A computer program that causes the method to be executed.

20. The computer program according to claim 19, wherein the patient medical state is a discontinuous state that is a value of a non-overlapping segment of the observed value variables.

21. The computer program according to claim 19, wherein the patient medical state is represented by continuous measurements based on a kernel function.

22. The computer program according to claim 21, wherein the kernel function is calculated from past observed values and represents the proximity between the past observed values.

23. The computer program according to claim 21, wherein the kernel function is calculated from random vectors and represents the proximity between the random vectors.

24. The computer program according to claim 19, wherein the patient medical state is represented by continuous measurements based on a neural network trained with past observed values.

25. A computer processing system for predicting a medical event time, comprising A memory device for storing program code; and Receive an electronic health record (EHR) including a plurality of pairs of observed value variables and corresponding timestamps, where each of the plurality of pairs includes a respective observed value variable and a respective corresponding timestamp; Convert the EHR into a K-dimensional vector representing the cumulative residence time in a finite number of patient medical states, the patient medical state being determined by the values of the observed value variables; and A procedure for processing the K-dimensional vector using a medical event time prediction model and outputting a prediction of the medical event time, where the medical event time prediction model is configured to receive and process K-dimensional vectors converted from past EHRs through training and output a predicted medical event time; A hardware processor operably coupled to the memory device for executing the program code for performing; A computer processing system comprising.

Images