Medical event prediction through health record monitoring

Abstract

A computer-implemented method for predicting the timing of medical events includes receiving electronic health records (EHRs) comprising multiple pairs of observed variables and corresponding timestamps. Each of the multiple pairs includes a corresponding observed variable and a corresponding timestamp. The method further includes converting the EHRs into a K-dimensional vector, the K-dimensional vector representing the cumulative dwell time over a finite number of patient medical states, determined by the values ​​of the observed variables. The method further includes processing the K-dimensional vector by a hardware processor using a medical event timing prediction model to output a prediction of the medical event timing. The medical event timing prediction model has been trained and configured to receive and process the K-dimensional vector converted from past EHRs to output the predicted medical event timing.

Description

Background Technology

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

[0002] Predicting diabetic complications or certain medical events from electronic health records (HERs) that represent a patient's health history is an important task in medical and healthcare applications. To improve health history modeling, time series data within EHRs should be addressed. Summary of the Invention

[0003] According to one aspect of the invention, a computer-implemented method for predicting the timing of medical events is provided. The method includes receiving an Electronic Health Record (HER), which includes multiple pairs of observation variables and corresponding timestamps. Each of the multiple pairs includes a corresponding observation variable and a corresponding timestamp. The method further includes converting the HER into a K-dimensional vector, the K-dimensional vector representing the cumulative dwell time over a finite number of patient medical states, which are determined by the values ​​of the observation variables. The method further includes processing the K-dimensional vector by a hardware processor using a medical event timing prediction model to output a prediction of the medical event timing. The medical event timing prediction model has been trained and configured to receive and process the K-dimensional vector converted from past HERs to output the predicted medical event timing.

[0004] According to another aspect of the invention, a computer program product for predicting the timing of medical events is provided. The computer program product includes a non-transitory computer-readable storage medium having program instructions embodied therein. The program instructions are executable by a computer to cause the computer to perform a method. The method includes receiving electronic health records (EHRs) comprising multiple pairs of observed variables and corresponding timestamps. Each of the multiple pairs includes a corresponding observed variable and a corresponding timestamp. The method includes converting the EHRs into a K-dimensional vector, the K-dimensional vector representing the cumulative dwell time over a finite number of patient medical states, the patient medical states being determined by the values ​​of the observed variables. The method further includes processing the K-dimensional vector using a medical event timing prediction model to output a prediction of the timing of the medical event. The medical event timing prediction model has been trained and configured to receive and process the K-dimensional vector converted from past EHRs to output the predicted timing of the medical event.

[0005] According to another aspect of the invention, a computer processing system for predicting the timing of medical events is provided. The computer processing system further includes a memory device for storing program code. The computer processing system also includes a hardware processor operatively coupled to the memory device for running the program code to receive electronic health records (EHRs) comprising multiple pairs of observed variables and corresponding timestamps. Each of the multiple pairs includes a corresponding observed variable and a corresponding timestamp. The hardware processor further runs program code to convert the EHRs into a K-dimensional vector representing the cumulative dwell time over a finite number of patient medical states, determined by the values ​​of the observed variables. The hardware processor further runs program code to process the K-dimensional vector using a medical event timing prediction model to output a prediction of the timing of the medical event. The medical event timing prediction model has been trained and configured to receive and process the K-dimensional vector converted from past EHRs to output the predicted timing of the medical event.

[0006] These and other features and advantages will become apparent from the following detailed description of illustrative embodiments of the invention, which is read in conjunction with the accompanying drawings. Attached Figure Description

[0007] The following description will provide details of preferred embodiments with reference to the following figures, in which:

[0008] Figure 1 This is a block diagram illustrating an exemplary computing device according to an embodiment of the present invention;

[0009] Figure 2 This is a block diagram illustrating an exemplary representation of the original observation as a k-dimensional vector according to an embodiment of the present invention;

[0010] Figure 3-5 An exemplary method for predicting and processing medical event timing according to an embodiment of the present invention is shown;

[0011] Figure 6 This is a graph illustrating exemplary curves and corresponding data for representing cumulative dwell time according to an embodiment of the present invention;

[0012] Figure 7 This is a diagram illustrating exemplary pseudocode for an algorithm for calculating a representation of cumulative dwell time according to an embodiment of the present invention;

[0013] Figure 8 This is a block diagram illustrating an exemplary system according to an embodiment of the present invention;

[0014] Figure 9 This is a block diagram illustrating an illustrative cloud computing environment with one or more cloud computing nodes according to an embodiment of the present invention, wherein a local computing device used by a cloud consumer communicates with the cloud computing node; and

[0015] Figure 10 This is a block diagram illustrating a set of functional abstraction layers provided by a cloud computing environment according to an embodiment of the present invention. Detailed Implementation

[0016] Embodiments of the present invention relate to a cumulative dwell time (CTR) representation for modeling electronic health records in the prediction of diabetes and other healthcare complications. Specifically, embodiments of the present invention can be used to predict when a patient will develop certain diseases after an exponential date from past observations in the electronic health record (HER).

[0017] To better model health history, raw observations should be processed in the EHR, and the raw observations in each patient's EHR should be transformed into easily tractable representations as input to the predictive model. This is because raw observations are not structured or formatted in a way that facilitates machine learning-based methods.

[0018] Ordinary time series representation is the common and simplest way to use it for this purpose, and it focuses on modeling detailed dependencies between consecutive observations.

[0019] On the other hand, the progression of some diseases and complications, particularly lifestyle-related and age-related diseases, is known to be associated with cumulative time of stay in a specific patient state, such as hypertension, hyperglycemia, and hyperlipidemia. Since cumulative time of stay is a precise case of long-term dependence, conventional time series representations are considerably inefficient for modeling it. Therefore, it is desirable to directly model / represent cumulative time of stay in a specific patient state to accurately predict diabetes and / or other complications.

[0020] Furthermore, the observation interval can vary over time. Therefore, it is desirable to handle variable observation intervals.

[0021] Therefore, one or more embodiments cumulatively record the dwell time for each combination of values ​​of the observed variables representing the patient's health status as states. Three types of definitions are derived for the states; the first discretely determines the state assignments for observation as non-overlapping segments, and the second and third define them as continuous measurements and are based on kernel functions and neural networks, respectively.

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

[0023] The computing device 100 can be embodied as any type of computing or computer device capable of performing the functions described herein, including but 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 devices, web devices, distributed computing systems, processor-based systems, and / or consumer electronics devices. Additionally or alternatively, the computing device 100 can be implemented as one or more computing sleds, memory sleds, or other racks, rails, computer racks, or other physically separate components of a computing device. Figure 1 As shown, computing device 100 illustratively includes processor 110, input / output subsystem 120, memory 130, data storage device 140, and communication subsystem 150, and / or other components and devices common in servers or similar computing devices. Of course, in other embodiments, computing device 100 may include other or additional components, such as those typically found in server computers (e.g., various input / output devices). Additionally, in some embodiments, one or more illustrative components may be incorporated into another component or otherwise formed part of another component. For example, in some embodiments, memory 130 or a portion thereof may be incorporated into processor 110.

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

[0025] Memory 130 can be implemented as any type of volatile or non-volatile memory or data storage device capable of performing the functions described herein. In operation, memory 130 can store various data and software used during the operation of computing device 100, such as operating systems, applications, programs, libraries, and drivers. Memory 130 is communicatively coupled to processor 110 via I / O subsystem 120, which can be embodied as circuitry and / or components to facilitate input / output operations with processor 110, memory 130, and other components of computing device 100. For example, I / O subsystem 120 can be implemented as or otherwise include a memory controller hub, input / output control hub, platform controller hub, integrated control circuitry, firmware devices, communication links (e.g., point-to-point links, bus links, wires, cables, optical fibers, printed circuit board traces, etc.) and / or other components and subsystems to facilitate input / output operations. In some embodiments, the I / O subsystem 120 may form part of a system-on-a-chip (SOC) and be integrated onto a single integrated circuit chip along with the processor 110, memory 130, and other components of the computing device 100.

[0026] Data storage device 140 can be embodied as one or more devices of any type configured for short-term or long-term data storage, such as memory devices and circuitry, memory cards, hard disk drives, solid-state drives, or other data storage devices. Data storage device 140 can store program code for providing a cumulative dwell time representation (CTR) used to model electronic health records (EHRs) in the prediction of diabetes and / or other complications. The communication subsystem 150 of computing device 100 can be implemented as any network interface controller or other communication circuitry, device, or combination thereof capable of enabling communication between computing device 100 and other remote devices via a network. Communication subsystem 150 can be configured to use any one or more communication technologies (e.g., wired or wireless communication) and associated protocols (e.g., Ethernet, etc.). WiMAX and other similar technologies can be used to achieve this kind of communication.

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

[0028] Of course, the computing device 100 may also include other elements (not shown) that are readily apparent to those skilled in the art, and some elements may be omitted. For example, as will be readily understood by those skilled in the art, various other input and / or output devices may be included in the computing device 100 depending on the specific implementation of the computing device 100. For example, various types of wireless and / or wired input and / or output devices may be used. Furthermore, additional processors, controllers, memories, etc., may be utilized in various configurations. Additionally, in another embodiment, a cloud configuration may be used (e.g., see...). Figure 9-10 Given the teachings of the invention provided herein, these and other variations of the processing system 100 will readily occur to those skilled in the art.

[0029] As used herein, the terms "hardware processor subsystem" or "hardware processor" can refer to a processor, memory (including RAM, cache(s), etc.), software (including memory management software), or a combination thereof that cooperate to perform one or more specific tasks. In useful embodiments, a hardware processor subsystem may include one or more data processing elements (e.g., logic circuitry, processing circuitry, instruction execution devices, etc.). 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.). A hardware processor subsystem may include one or more on-board memories (e.g., cache, dedicated memory array, read-only memory, etc.). In some embodiments, a hardware processor subsystem may include one or more memories that may be on-board or off-board, or may be dedicated to 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 and 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, specialized circuitry that performs 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] According to embodiments of the present invention, these and other variations of the hardware processor subsystem are also contemplated.

[0033] Figure 2 This is a block diagram illustrating an exemplary representation 200 of the original observation as a k-dimensional vector according to an embodiment of the present invention.

[0034] The representation 200 includes patients 1 to 4, the initial observation time 210, the censorship time 220, the observation window 230, and the prediction window 240. The prediction window can indicate disease progression 250. The predicted index date 260 corresponds to the end of the observation window 230. That is, each patient's past observations come from a window spanning from the initial observation time to the index date. A model is constructed that predicts the timing of disease progression events based on the observations corresponding to each patient.

[0035] Figure 3-5 An exemplary method 300 for predicting and processing medical event timing is shown according to an embodiment of the present invention.

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

[0037] At box 310, the EHR is received, which includes multiple pairs of observed variables and their corresponding timestamps. Each of the multiple pairs includes the corresponding observed variable and its corresponding timestamp.

[0038] In box 320, the EHR is transformed into a K-dimensional vector representing the cumulative dwell time across a finite number of patient medical states. The patient medical state is determined by the values ​​of the observed variables. In one embodiment, the patient medical state can be a discrete state, which is a non-overlapping piecewise value of the observed variables.

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

[0040] In box 320A, an indicator function is applied to the non-overlapping segment values ​​of the observed variable such that, in response to a given value in the observed variable falling into 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.

[0041] In box 320B, the patient's medical status is represented by continuous measurements based on kernel functions.

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

[0043] In box 320B1, the kernel function is calculated based on past observations and represents the proximity between past observations.

[0044] In box 320B2, a kernel function is computed based on random vectors, representing the proximity between the random vectors. In one embodiment, the kernel function can be configured to determine a k-dimensional vector, where the k-dimensional vector represents a weight corresponding to the proportion of the vector to be assigned to each of the patient's medical states.

[0045] In box 320B3, the kernel function is computed with k bases corresponding to the k dimensions of the k-dimensional vector.

[0046] In box 320B4, a kernel function is computed based on the bandwidth parameter and also on the observation normalization factor. This bandwidth parameter is then optimized via grid search using the validation set from the training data used for the medical event time prediction model.

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

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

[0049] Box 320C may include box 320C1.

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

[0051] In box 320D, the cumulative dwell time is calculated as the sum of the products of multiple k-dimensional vectors and the duration of the patient’s stay in the medical state.

[0052] In box 330, a medical event time prediction model is used to process a K-dimensional vector to output a prediction of the medical event time. The medical event time prediction model has been trained and configured to receive and process a K-dimensional vector transformed from past EHRs to output the predicted medical event time.

[0053] In box 340, in response to a prediction of the timing of a medical event, a hardware-based medical device is used to test the patient to confirm the presence of an unwanted medical event. For example, diabetic complications such as hyperglycemia and gout can be detected. In this embodiment, a blood analysis device and a vision testing device are used to test the patient's blood and / or vision, respectively. The hardware-based medical device can be a centrifuge, a needle, an automated vision test, etc.

[0054] At box 350, in response to a blood test confirming an unwanted medical event, a therapeutic substance is administered to the patient using a patient infusion device. The therapeutic substance may be a drug or other substance (e.g., glucose) used to treat a specific condition / complication.

[0055] A description of illustrative embodiments will now be given.

[0056] In this embodiment, the original observation results and timestamps are converted into k-dimensional vectors. It represents the cumulative dwell time in a finite number of states. The state is determined by the values ​​of the observed variables.

[0057] By using continuous time t s 、d≡{d (1) d (1) , ..., d (M) The difference between} is defined by the state function s as z(X,t)≡∑d {m} s(x {m} ).

[0058] Apart from illustrative embodiments, descriptions of state function variables will now be given according to various embodiments of the invention.

[0059] A description of the state function variables realized by discrete states will now be given.

[0060] In this case, the state function S can be represented as follows:

[0061] s(x {m} )≡I(x {m} A) where A is a collection of K non-overlapping collectively exhaustive values. The k-th state a k The segmentation represents a combination of the ranges of values ​​of the D-th attribute in x. I is an indicator function, where if x falls into the k-th segment, only the k-th element of I becomes 1, while the other elements are 0.

[0062] In this context, the discrete state can be viewed as bins of non-overlapping piecewise values ​​of the observed variables. Each bin is filled with the patient's corresponding stay time.

[0063] A description of state function variables implemented from continuous states using kernel functions will now be given.

[0064] In this case, the state function s K It can be represented as follows:

[0065] s K (x {m} )≡φ(x {m}， X′)

[0066] Since the number of discrete states grows exponentially with the number of features D, the number of kernels and the number of bases K are... Used together, in This is the Kth basis. The kernel function Φ outputs a K-dimensional vector representing the weights, which determine the proportion by which the current dwell time is allocated to each state represented by the basis. The kernel function also results in smooth interpolation between states. The basis can be randomly sampled from the training data.

[0067] A description of state function variables implemented using neural networks through continuous states will now be given.

[0068] In this case, the state function s N It can be represented as follows:

[0069] S N (x {m} )≡g(x {m} θ g )

[0070] The kernel function can be replaced by a neural network trained in an end-to-end manner, where θ φ These are the parameters of the neural network, where the neural network g also outputs a K-dimensional vector to represent the weight vector of the state.

[0071] It should be understood that the k-dimensional vector z does not have a time axis, but instead preserves time information as the cumulative dwell time in each state. This provides a lightweight method for representing time series and can be parallelized on observations. Furthermore, since d is directly encoded, it can naturally handle the variable observation intervals.

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

[0073] It can be seen that the continuous states involving kernel functions and neural networks avoid an exponential increase in the number of states and result in smooth interpolation between states.

[0074] Figure 6 This is an exemplary graph 600 and corresponding data 620 showing the cumulative dwell time representation according to an embodiment of the present invention.

[0075] In the graph, the x-axis represents time, and the y-axis represents the value of the original observed variable in the EHR of the m-th patient. It can be seen that the value of the original observed variable spans from anywhere, from low to high, as shown by curve 600.

[0076] As shown in box 620, calculate the corresponding data, i.e., the cumulative dwell time 621 for each state. That is, record the cumulative dwell time at each combination of the values ​​of the observed variable.

[0077] Figure 7 This is a diagram illustrating exemplary pseudocode 700 for an algorithm for calculating a representation of cumulative dwell time according to an embodiment of the present invention.

[0078] The algorithm's inputs include the original observations {X, t} and the state function s.

[0079] The output from the algorithm includes the cumulative dwell time (CTR) as a k-dimensional vector.

[0080] A description of the continuous states using each kernel function will now be given according to embodiments of the invention.

[0081] As mentioned above, the state function s K It can be represented as follows:

[0082] s K (x {m} )≡φ(x {m} ,X′)

[0083] In the implementation, φ is the following RBF kernel:

[0084]

[0085] Where γ is the bandwidth parameter optimized using the validation set from the training data via grid search, Z m It is the normalization factor for the m-th observation.

[0086] Other kernels representing proximity between past observations can be used, such as string kernels with binary features (e.g., tf-idf vector τ(x) + cosine similarity):

[0087]

[0088] A description of the continuous states using each kernel function will now be given according to embodiments of the invention.

[0089] As mentioned above, the state function s N It can be represented as follows:

[0090] S N (x {m} )≡g(x {m} θ g )

[0091] To learn g from the data, a multi-layer neural network can be used on g as follows:

[0092] g(x {m} θ φ )≡σ(w l h l-1 (x {m} )+b l )

[0093] Where σ is the activation function, which in the implementation is the ReLU of the intermediate layer and the Softmax of the final output layer, h l-1 It is the output of the (l-1)th layer (the previous layer), and These are the parameters of the neural network.

[0094] A description of predicting the timing of medical events from the EHR will now be given according to embodiments of the present invention.

[0095] Based on past raw observations in HER, a model is built for predicted event times y > 0 after the indexed date. These past raw observations are M pairs of observed variables and their corresponding timestamps {X, t}. The observed variables are... Where the m-th observed variable x {m} Represented as a D-dimensional vector And X thus forms an MxD matrix. The timestamp is... The m-th timestamp is t. {m} >0. Note that this assumes the observation interval can vary over time, and the length of sequence M can vary from patient to patient, such as... Figure 2 As shown.

[0096] When employing machine learning methods, the original observations {X, t} 810 must be formalized into a tractable representation 820 as input to a subsequent predictive model 830 (e.g., a linear model, random forest, and NNs including recurrent neural networks) to obtain, for example... Figure 8 The event time shown is 840. Figure 8 This is a block diagram illustrating an exemplary system 800 according to an embodiment of the present invention. The representation is defined as z as a function of {X, t}, z{X, t}, whose output depends on the formalization and forms a vector, matrix, or tensor.

[0097] Once {X, t} is formalized as z, z is used as the input f(x(X, t)) to the prediction model, and the prediction model is learned using a general scheme that minimizes the expected loss as follows:

[0098]

[0099] Where f * It is the optimal regression function. It is a loss function, such as the squared error. Poisson loss Sum of log-normal loss And E represents the expectation of p(y, X, t). By using the learned f * The new data y can be predicted as follows:

[0100]

[0101] According to embodiments of the invention, a description of formalizing raw observations into easily processed representations will now be given.

[0102] This section describes how the raw observations {X, t} are formalized into a tractable representation z to predict event times y. The cumulative time of stay for a specific patient state is modeled directly using the construction of z. First, a standard time series representation is considered. Then, the cumulative time of stay representation (CTR) is derived.

[0103] A description of ordinary time series representation will now be given according to embodiments of the present invention.

[0104] In ordinary time series representation, the original observations {X; t} are transformed into a matrix representation z. ts ∈R MxD Its two-dimensional index represents the timestamp and variable name, respectively. This corresponds to us directly using matrix X as z. ts Ignore t and z ts (X, t) ≡ X, or concatenate X and t as z ts (X, t) ≡ (X, t).

[0105] Note that this representation is inefficient for handling cumulative dwell time, which is a precise case of long-term dependence, as discussed in the introduction. Even when using complex RNN variants, the learning cost required to encode every observation in the entire time series from the training data into a cumulative dwell time is high. Moreover, to handle this cumulative feature, the RNN needs to remember all observations and timestamps in the time series. Since the states in the RNN are not static, a large amount of memory is required.

[0106] A description of CTR-D will now be given according to an embodiment of the invention: a representation of cumulative dwell time with discrete states.

[0107] A new cumulative dwell time (CTR) representation is proposed to directly model the cumulative dwell time of a specific patient state as a novel form of z. The original observation (X; t) is transformed into a K-dimensional vector z representing the cumulative dwell time across a finite number of K states, where the Kth element is z. k>0. Each state represents a combination of values ​​for the observed variable and can be viewed as a lattice-divided compartment that defines the range of values ​​for each observed variable within each state. Each compartment is cumulatively filled with the dwell time of the original observations that fall within the corresponding value range.

[0108] By using the state function s(x) {m} )∈{0,1} K Its output represents the input observation x {m} The one-hot vector (CTR) of the current state is defined as follows:

[0109] z(X,t)≡∑ m d {m} s(x {m} (3)

[0110] Where d {m} ≡t {m} -t {m-1} ,

[0111] Where d {m} It is the duration of the m-th observation, which is calculated by the continuous timestamp t. {m} and t {m-1} The difference between them is used to estimate. Because the function s(x) {m} The output of is a one-hot vector, so only one element in this vector can become 1, while the other elements are 0, and the index of the element with a value of 1 represents the patient's current state. Therefore, for the m-th observation, d {m} s(x {m} The element with the current state becomes d. {m} The other elements are 0. This is achieved by using d on m. {m} s(x {m} The summation of z, where each element of z represents the sum of the durations of stays in a certain state during the observation period. The algorithm is described in Algorithm 1. Note that this representation can explicitly handle variable observation intervals without any additional coding, as shown in Equation (3). Furthermore, Equation (3) does not have any recursive computation, which allows for a significant reduction in memory costs compared to RNNs, and allows for parallel computation on observations, which is typically not possible with RNNs.

[0112] State function s(x) {m} Defined by the indicator function I, it always outputs a K-dimensional one-hot vector:

[0113] s(x {m} )≡I{x {m} A) (4)

[0114] in It is a segment of K non-overlapping common exhaustive values. The k-th state a k The segmentation represents x {m} The combination of the D value ranges of the D attributes is used as Where ζ d，k and ξ d，k Representing the Dth attribute respectively The lower and upper limits. Example segment a k exist Figure 5 The corresponding data 520 is shown in the table. This is achieved by using ζ. d，k and ξ d，k The k-elements of function I are

[0115]

[0116] in It is an indicator function that returns 1 only when the condition is met, and 0 otherwise. If x {m} If it falls into the k-th segment, then due to the non-overlapping segments, only I(x) {m} The kth element of A becomes 1, while the others are 0.

[0117] The CTR in equation (3) that has the state function in equation (4) is called the cumulative dwell time representation with discrete state (CTR-D). Discretely defined state S(X) {m} The expression is easy to understand. When the number of variables in x is small, the function S(x) in equation (3) is easy to understand. {m} ) can be used to calculate z.

[0118] However, since the number of common exhaustive combinations representing states grows exponentially with the number of observed variables D, it cannot handle more than a few variables. In the case of EHR modeling, the states are not simple enough to be modeled using such a low-dimensional space. Furthermore, discontinuous boundaries prevent generalization between adjacent states, even though adjacent states should represent states similar to each other because they share boundaries as defined in equation (4). {m} ) was expanded into a more practical function.

[0119] A description of CTR-K will now be given according to an embodiment of the invention: a cumulative dwell time representation (CTR) of continuous states based on a kernel function.

[0120] To mitigate the exponential growth in the number of states, the definition of a state changes from discrete, focusing on the variable values ​​of an observation, to continuous, focusing on how closely the observation approximates some basis vectors. Continuous states are no longer represented as one-hot vectors corresponding to unique states. Instead, they are represented as weight vectors that determine the proportion by which the current dwell time is allocated to each state represented by the basis vectors. In this case, the number of states is limited to the number of basis vectors. This also allows for interpolation between states and a smooth representation of intermediate states between states.

[0121] To compute the continuous state, a kernel function representing the affinity of the basis for the observations is used, where a continuous value vector is constructed by assigning distinct values ​​among multiple elements according to the affinity. The state function is based on the kernel function φ. Defined as

[0122] s K (x {m} )=φ(x {m} ,X') (6)

[0123] in There are K bases. It is the Kth basis. For example, s K (x {m} = {0, 0.3, 0.7, 0, ..., 0} means that in the summation of equation (3), the dwell time of the m-th observation with weights of 0.3 and 0.7 is assigned to the second and third states, respectively.

[0124] When the variable is real-valued, this also includes the exemplary case where the choice of φ is defined as the RBF kernel.

[0125] Where γ is the bandwidth parameter to be optimized using the training data via grid search, and Z m ≡Σ k exp(0.5γ||x {m} -x′ {k} || 2 ) is the normalization factor for the m-th observation, which comes from using S K As a weight to allocate the dwell time requirement in equation (3). For binary features, other kernels, such as string kernels, such as tf-idf vector + cosine similarity, can also be used.

[0126] The CTR in equation (3) is called using the state function in formula (6), and is represented by the cumulative dwell time (CTR-K) of the 266 states defined by the kernel.

[0127] A description of CTR-N with continuous states based on embodiments of the present invention will now be given: a cumulative dwell time representation (CTR) based on a neural network.

[0128] Furthermore, it can be seen that in equation (6), for the continuous state S K (x {m} The requirement is to represent similar observations with similar weight vectors. Such vectors can also be modeled using neural networks.

[0129] Therefore, by replacing the kernel function with a trainable neural network g, S K (x {m} ) is extended to S N (x {m} This produces a state indicator weight vector similar to φ, as... sN (x {m} )≡g(x {m} θ g (8)

[0130] Where θ g These are the parameters of the neural network. The last layer used for g is the softmax function, which serves as the weight vector for normalization. The specific neural network structure of g is shown in the experimental results section.

[0131] The CTR in equation (3) with the state function in equation (8) is called the cumulative dwell time representation of the state with a neural network definition (CTR-N). This representation can be learned from the data and thus provides more flexibility in adapting the state definition to the target data.

[0132] It should be understood that although this disclosure includes a detailed description of cloud computing, the implementation of the teachings set forth herein is not limited to a cloud computing environment. Rather, embodiments of the invention can be implemented in conjunction with any other type of computing environment now known or developed hereafter.

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

[0134] The characteristics are as follows:

[0135] On-demand self-service: Cloud consumers can unilaterally and automatically provide computing power, such as server time and network storage, as needed, without requiring manual interaction with the service provider.

[0136] Wide Area Network (WAN) Access: Gaining capabilities on a network and accessing them through standard mechanisms that facilitate the use of heterogeneous thin or thick client platforms (e.g., mobile phones, laptops, and PDAs).

[0137] Resource pooling: A provider's computing resources are pooled to serve multiple consumers using a multi-tenant model, where different physical and virtual resources are dynamically allocated and reallocated based on demand. Location independence has significance because consumers typically do not control or know the exact location of the resources provided, but can specify the location at a higher level of abstraction (e.g., country, state, or data center).

[0138] Rapid Flexibility: In some cases, the ability to scale outwards and inwards quickly and flexibly can be provided. For consumers, the available capacity often appears unlimited and can be purchased in any quantity at any time.

[0139] Measurement services: Cloud systems automatically control and optimize resource usage by leveraging metering capabilities at a level of abstraction appropriate to the service type (e.g., storage, processing, bandwidth, and activated user accounts). Resource utilization can be monitored, controlled, and reported, providing transparency for both service providers and consumers.

[0140] The service model is as follows:

[0141] Software as a Service (SaaS): The capability offered to consumers is the ability to use applications from a provider that run on cloud infrastructure. These applications can be accessed from various client devices through thin client interfaces such as web browsers (e.g., web-based email). Consumers do not manage or control the underlying cloud infrastructure, including the network, servers, operating system, storage, or even individual application capabilities, with possible exceptions such as limited user-specific application configuration settings.

[0142] Platform as a Service (PaaS): This provides consumers with the ability to deploy applications created or acquired by the consumer onto cloud infrastructure using programming languages ​​and tools supported by the provider. Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but they have control over the deployed applications and the configuration of any application hosting environment.

[0143] Infrastructure as a Service (IaaS): This provides consumers with the capability to offer processing, storage, networking, and other basic computing resources that enable consumers to deploy and run arbitrary software, which may include operating systems and applications. Consumers do not manage or control the underlying cloud infrastructure, but they have control over the operating system, storage, deployed applications, and possibly limited control over selected networking components (e.g., host firewalls).

[0144] The deployment model is as follows:

[0145] Private cloud: Cloud infrastructure operated solely by an organization. It can be managed by the organization or a third party and can exist inside or outside a building.

[0146] Community cloud: Cloud infrastructure shared by several organizations and supporting a specific community with shared concerns (e.g., tasks, security requirements, policies, and compliance considerations). It can be managed by an organization or a third party and can exist on-site or off-site.

[0147] Public cloud: Cloud infrastructure available to the general public or large industrial groups and owned by organizations that sell cloud services.

[0148] Hybrid cloud: A cloud infrastructure is a combination of two or more clouds (private, community, or public) that remain a single entity but are bound together by standardized or proprietary technologies that enable data and applications to be ported together (e.g., cloud bursting for load balancing between clouds).

[0149] Cloud computing environments are service-oriented, focusing on statelessness, loose coupling, modularity, and semantic interoperability. At the heart of cloud computing is the infrastructure of a network of interconnected nodes.

[0150] Now for reference Figure 9 The diagram illustrates an illustrative cloud computing environment 950. As shown, the cloud computing environment 950 includes one or more cloud computing nodes 910 with which local computing devices used by cloud consumers can communicate, such as personal digital assistants (PDAs) or cellular phones 954A, desktop computers 954B, laptop computers 954C, and / or automotive computer systems 954N. The nodes 910 can communicate with each other. They can 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. This allows the cloud computing environment 950 to provide infrastructure, platform, and / or software as a service, without requiring cloud consumers to maintain resources on their local computing devices. It should be understood that... Figure 9The types of computing devices 954A-N shown are for illustrative purposes only, and the computing node 910 and cloud computing environment 950 can communicate with any type of computerized device on any type of network and / or network-addressable connection (e.g., using a web browser).

[0151] Now for reference Figure 10 This demonstrates the 950 (cloud computing environment) Figure 9 This provides a set of functional abstraction layers. It should be understood beforehand that... Figure 10 The components, layers, and functions shown are for illustrative purposes only, and embodiments of the invention are not limited thereto. As depicted, the following layers and corresponding functions are provided:

[0152] The hardware and software layer 1060 includes hardware and software components. Examples of hardware components include: a host 1061; a server 1062 based on a RISC (Reduced Instruction Set Computer) architecture; a server 1063; a blade server 1064; a storage device 1065; and a network component 1066. In some embodiments, the software components include network application server software 1067 and database software 1068.

[0153] The virtualization layer 1070 provides an abstraction layer from which the following examples of virtual entities can be provided: virtual server 1071; virtual storage 1072; virtual network 1073, including virtual private network; virtual application and operating system 1074; and virtual client 1075.

[0154] In one example, management layer 1080 can provide the following functionalities: Resource Provisioning 1081 provides dynamic procurement of computing resources and other resources used to perform tasks within the cloud computing environment. Metering and Pricing 1082 provides cost tracking when utilizing resources in the cloud computing environment, as well as billing or invoicing for the consumption of these resources. In one example, these resources may include application software licenses. Security provides authentication for cloud consumers and tasks, as well as protection for data and other resources. User Portal 1083 provides access to the cloud computing environment for consumers and system administrators. Service Level Management 1084 provides cloud resource allocation and management to ensure that required service levels are met. Service Level Agreement (SLA) Planning and Fulfillment 1085 provides pre-scheduling and procurement of cloud resources, where future needs are anticipated according to the SLA.

[0155] Workload layer 1090 provides examples of functionalities that can be leveraged in a cloud computing environment. Examples of workloads and functionalities that can be provided from this layer include: mapping and navigation 1091; software development and lifecycle management 1092; virtual classroom education delivery 1093; data analytics processing 1094; transaction processing 1095; and CTR 1096 for EHR modeling to predict diabetes and other healthcare complications.

[0156] Embodiments of the present invention can be systems, methods, and / or computer program products at any possible level of technical detail integration. A computer program product may include a computer-readable storage medium (or medium) having computer-readable program instructions thereon for causing a processor to perform aspects of the present invention.

[0157] Computer-readable storage media can be tangible devices capable of retaining and storing instructions for use by an instruction execution device. Computer-readable storage media can be, for example, but not limited to, electronic storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any suitable combination of the foregoing. 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 optical disc read-only memory (CD-ROM), digital multifunction disc (DVD), memory sticks, floppy disks, mechanical encoding devices such as punch cards or recessed structures with instructions recorded thereon, and any suitable combination of the foregoing. As used herein, computer-readable storage media should not be construed as transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses through fiber optic cables), or electrical signals transmitted through wires.

[0158] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to a suitable computing / processing device, or via a network, such as the Internet, a local area network (LAN), a wide area network (WAN), and / or a wireless network, to an external computer or external storage device. The network may include copper cables, optical fibers, wireless transmission, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards them to a computer-readable storage medium within the respective computing / processing device.

[0159] Computer-readable program instructions for performing the operations of this invention may be 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 combination of one or more programming languages ​​(including object-oriented programming languages ​​such as SMALLTALK, C++, etc.) and traditional 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, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or entirely on a server. In the latter case, 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 may be connected to an external computer (e.g., via the Internet using an Internet service provider). In some embodiments, to perform aspects of this invention, electronic circuits, including, for example, programmable logic circuits, field-programmable gate arrays (FPGAs), or programmable logic arrays (PLAs), may execute the computer-readable program instructions to personalize the electronic circuits by utilizing state information from the computer-readable program instructions.

[0160] Various aspects of the present invention are 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.

[0161] These computer-readable program instructions may be provided to a processor of a general-purpose computer, a 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 / actions specified in one or more blocks of a flowchart and / or block diagram. These computer-readable program instructions may also be stored in a computer-readable storage medium that can direct a computer, programmable data processing apparatus, and / or other devices to operate in a particular manner, such that the computer-readable storage medium in which the instructions are stored includes an article of writing comprising instructions for implementing aspects of the functions / actions specified in one or more blocks of a flowchart and / or block diagram.

[0162] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer-implemented process, such that the instructions, which are executed on the computer, other programmable apparatus or other device, implement the functions / actions specified in one or more boxes of a flowchart and / or block diagram.

[0163] The flowcharts and block diagrams in the accompanying 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 comprising one or more executable instructions for implementing a specified logical function. In some alternative embodiments, the functions indicated in the blocks may occur in a non-consecutive order as shown in the figures. For example, two blocks shown consecutively may actually be executed substantially simultaneously, or these blocks may sometimes be executed in reverse order, depending on the functions involved. It will also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, may be implemented by a dedicated hardware-based system that performs the specified function or action or executes a combination of dedicated hardware and computer instructions.

[0164] References to "one embodiment" or "embodiment" and other variations of the invention in this specification mean that a particular feature, structure, characteristic, etc., described in connection with that embodiment is included in at least one embodiment of the invention. Therefore, the phrases "in one embodiment" or "in an embodiment" appearing in various places throughout the specification, as well as any other variations, do not necessarily refer to the same embodiment.

[0165] It should be understood that, for example, in the cases of “A / B,” “A and / or B,” and “at least one of A and B,” the use of any of the following “ / ,” “and / or,” and “at least one” is intended to cover the selection of only the first listed option (A), or only the selection of 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 wording is intended to include selecting only the first listed option (A), or only the second listed option (B), or only the third listed option (C), or only the first and second listed options (A and B), or only the first and third listed options (A and C), or only the second and third listed options (B and C), or all three options (A, B, and C). This can be extended to many of the listed items, as will be apparent to those skilled in the art and related fields.

[0166] Preferred embodiments of the systems and methods have been described (these are intended to be illustrative and not limiting), and it is noted that modifications and variations can be made by those skilled in the art based on the foregoing teachings. Therefore, it should be understood that changes can be made to the specific embodiments disclosed, and these changes are within the scope of the invention as summarized by the appended claims. Thus, aspects of the invention have been described in the details and features required by patent law, and the claimed and desired protections are set forth in the appended claims.

Claims

1. A computer-implemented method for predicting the timing of medical events, the method comprising: Receive electronic health records (EHRs) that include multiple pairs of observed variables and corresponding timestamps, wherein each of the multiple pairs includes a corresponding observed variable and a corresponding timestamp; By determining the difference between the patient's medical status at different observation times, the EHR is transformed into a K-dimensional vector, which represents the cumulative dwell time in a finite number of patient medical statuses, and the patient's medical status is determined by the combination of the values ​​of the observed variables. The processor device uses a medical event time prediction model, including a recurrent neural network, to process the K-dimensional vector, wherein the medical event time prediction model has been trained and configured to receive and process the K-dimensional vector transformed from past EHRs as a function to obtain the patient's medical status. Based on the function of the patient's medical status, the medical event timing prediction model is used to predict the timing of unwanted medical events. The progression of a patient’s health history is modeled using cumulative time of stay, including the time of the undesirable medical event. In response to a prediction of the timing of the medical event, the patient's blood is tested using a hardware-based medical device to confirm the presence of the unintended medical event; and In response to the blood test confirming the presence of diabetes as an undesirable medical event, a therapeutic substance is injected into the patient using a patient injection device, the therapeutic substance regulating the patient's blood glucose level.

2. The computer-implemented method according to claim 1, wherein, The cumulative stay time is calculated as the sum of the products of multiple K-dimensional vectors and the duration of stay in the patient's medical state.

3. The computer-implemented method according to claim 1, wherein, The patient's medical status is a discrete state, which is a non-overlapping segment of the observed variable.

4. The computer-implemented method according to claim 3 further includes: The indicator function is applied to the non-overlapping segment values ​​of the observed variables such that, in response to a given observed variable falling into 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.

5. The computer-implemented method according to claim 1, wherein, The patient's medical status is represented by continuous measurements based on kernel functions.

6. The computer-implemented method according to claim 5, wherein, The kernel function is calculated based on past observations and represents the proximity between those past observations.

7. The computer-implemented method according to claim 5, wherein, The kernel function is calculated based on random vectors and represents the proximity between the random vectors.

8. The computer-implemented method according to claim 5, wherein, The kernel function determines the k-dimensional vector representing the weights, which correspond to the proportion of the vector to be assigned to each of the patient medical states.

9. The computer-implemented method according to claim 5, wherein, The kernel function has k bases corresponding to the k dimensions of the k-dimensional vector.

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

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

12. The computer-implemented method according to claim 1, wherein, The patient's medical status is represented by continuous measurements based on the recurrent neural network trained with past observations.

13. The computer-implemented method according to claim 12, wherein, The recurrent neural network is trained end-to-end by using the past observations to train the medical event time prediction model.

14. The computer-implemented method according to claim 1, wherein, Also includes: Multiple k-dimensional vectors are encoded in parallel on the observed variables.

15. The computer-implemented method according to claim 1, further comprising: Electronic health records are created by converting a patient's blood sample into one or more observation variables and one or more corresponding timestamps.

16. The computer-implemented method according to claim 1, wherein, The medical condition is selected from the group consisting of: hypertension exceeding a given quantity threshold for a given time threshold, hyperglycemia exceeding a given quantity threshold for a given time threshold, and hyperlipidemia exceeding a given quantity threshold for a given time threshold.

17. A computer program product for predicting the timing of medical events, the computer program product comprising a non-transitory computer-readable storage medium having program instructions embodied therein, the program instructions being executable by a computer to cause the computer to perform a method comprising the steps of: The system receives electronic health records (EHRs) that include multiple pairs of observed variables and corresponding timestamps. Each of the multiple pairs includes a corresponding observation variable and a corresponding timestamp; By determining the difference between the patient's medical status at different observation times, the EHR is transformed into a K-dimensional vector, which represents the cumulative dwell time in a finite number of patient medical statuses, and the patient's medical status is determined by the combination of the values ​​of the observed variables. The K-dimensional vector is processed using a medical event time prediction model that includes a recurrent neural network, wherein the medical event time prediction model has been trained and configured to receive and process a K-dimensional vector transformed from past EHRs as a function to obtain the patient's medical status. Based on the function of the patient's medical status, the medical event timing prediction model is used to predict the timing of unwanted medical events. The progression of a patient’s health history is modeled using cumulative time of stay, including the time of the undesirable medical event. In response to a prediction of the timing of the medical event, the patient's blood is tested using a hardware-based medical device to confirm the presence of the unintended medical event; and In response to the blood test confirming the presence of diabetes as an undesirable medical event, a therapeutic substance is injected into the patient using a patient injection device, the therapeutic substance regulating the patient's blood glucose level.

18. The computer program product according to claim 17, wherein, The patient's medical status is a discrete state, which is a non-overlapping segment of the observed variable.

19. The computer program product according to claim 17, wherein, The patient's medical status is represented by continuous measurements based on kernel functions.

20. The computer program product according to claim 19, wherein, The kernel function is calculated based on past observations and represents the proximity between those past observations.

21. The computer program product according to claim 19, wherein, The kernel function is calculated based on random vectors and represents the proximity between the random vectors.

22. The computer program product according to claim 17, wherein, The patient's medical status is represented by continuous measurements based on a neural network trained with past observations.

23. A computer processing system for predicting the timing of medical events, comprising: Memory devices used to store program code; as well as A processor device, operatively coupled to the memory device, for running the program code to: Receive electronic health records (EHRs) that include multiple pairs of observed variables and corresponding timestamps, wherein each of the multiple pairs includes a corresponding observed variable and a corresponding timestamp; By determining the difference between the patient's medical status at different observation times, the EHR is transformed into a K-dimensional vector, which represents the cumulative dwell time in a finite number of patient medical statuses, and the patient's medical status is determined by the combination of the values ​​of the observed variables. The processor device uses a medical event time prediction model, including a recurrent neural network, to process the K-dimensional vector, wherein the medical event time prediction model has been trained and configured to receive and process the K-dimensional vector transformed from past EHRs as a function to obtain the patient's medical status. Based on the function of the patient's medical status, the medical event timing prediction model is used to predict the timing of unwanted medical events. The progression of a patient’s health history is modeled using cumulative time of stay, including the time of the undesirable medical event. In response to a prediction of the timing of the medical event, the patient's blood is tested using a hardware-based medical device to confirm the presence of the unintended medical event; and In response to the blood test confirming the presence of diabetes as an undesirable medical event, a therapeutic substance is injected into the patient using a patient injection device, the therapeutic substance regulating the patient's blood glucose level.

Images