Multi-head convolutional networks for average glucose prediction

Abstract

Disclosed herein are systems and methods for determining a user's glucose level. The method includes receiving a plurality of data inputs associated with the user's biometric data, the plurality of data inputs including at least one data input representing the user's past estimated glucose levels, and further including processing the plurality of data inputs with a multi-head temporal convolutional neural network to generate a blood glucose level for the user. The method also includes providing a notification to the user based at least in part on the blood glucose level.

Description

[Technical Field]

[0001] The present disclosure relates to determining a user's average glucose value. In particular, aspects of the present disclosure may include a multi-head temporal convolutional neural network ("MH-TCNN") that can analyze historical average blood glucose concentrations and other relevant biometric data to predict a user's estimated average glucose value. [Background technology]

[0002] People living with diabetes may be required to wear continuous glucose monitor ("CGM") devices, which require the user to insert a needle into the bloodstream to monitor the average glucose concentration in the blood. CGM devices can provide diabetic users with notifications when their average blood glucose concentration becomes hyperglycemic (too high) or hypoglycemic (too low), as well as trends regarding the average blood glucose concentration. However, if the device malfunctions or otherwise stops functioning, or if the user removes the device, the user is left without a consistent way to monitor their blood glucose concentration. Therefore, a model for estimating a user's blood glucose concentration is desired. Summary of the Invention

[0003] Aspects and advantages of embodiments of the present disclosure will be set forth in part in the description that follows, or may be learned from the description, or may be learned by practice of the embodiments.

[0004] One aspect of the present disclosure provides a method for determining a user's glucose level. The method includes receiving a plurality of data inputs associated with biometric data of the user, the plurality of data inputs including at least one data input representing the user's past estimated glucose levels, and further including processing the plurality of data inputs with a multi-head temporal convolutional neural network to generate a blood glucose level for the user. The method also includes providing a notification to the user based at least in part on the blood glucose level.

[0005] Another aspect of the present disclosure provides a wearable computing device. The computing device includes one or more processors and a non-transitory computer-readable medium containing instructions that, when executed by the one or more processors, cause the one or more processors to perform a process. The process includes receiving a plurality of data inputs associated with biometric data of a user, the plurality of data inputs including at least one data input representing past estimated glucose values ​​of the user, and the process further includes processing the plurality of data inputs with a multi-head temporal convolutional neural network to generate a blood glucose value for the user. The process also includes providing a notification to the user based at least in part on the blood glucose value.

[0006] A further aspect of the present disclosure provides a non-transitory computer-readable medium including instructions that, when executed by one or more processors, cause the one or more processors to perform a process. The process includes receiving a plurality of data inputs associated with biometric data of a user, the plurality of data inputs including at least one data input representing past estimated glucose values ​​of the user, and the process further includes processing the plurality of data inputs with a multi-head temporal convolutional neural network to generate a blood glucose value for the user. The process also includes providing a notification to the user based at least in part on the blood glucose value.

[0007] These and other features, aspects, and advantages of various embodiments of the present disclosure will become better understood with reference to the following detailed description and the appended claims. The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate exemplary embodiments of the present disclosure and, together with the description, serve to explain the associated principles.

[0008] Detailed descriptions of embodiments directed to those skilled in the art are set forth herein with reference to the accompanying drawings. [Brief explanation of the drawings]

[0009] [Figure 1] 1 illustrates a multi-head convolutional neural network for predicting estimated mean glucose values, according to one aspect of the present disclosure. [Figure 2] 1 illustrates a multi-head convolutional neural network for predicting estimated mean glucose values, according to one aspect of the present disclosure. [Figure 3] 1 illustrates buffer normalization for convolutional layers in a multi-head convolutional neural network, according to one aspect of the present disclosure. [Figure 4] 1 illustrates lifting non-temporal data input for a convolutional neural network, according to one aspect of the present disclosure. [Figure 5] 1 illustrates patterns noticed in a convolutional layer for various data inputs, according to one aspect of the present disclosure. [Figure 6] 1 illustrates a method for predicting an estimated glucose value according to one aspect of the present disclosure. [Figure 7] 1 illustrates a wearable computing device according to one aspect of the present disclosure. [Figure 8] 1 illustrates a computing device in communication with a server according to one aspect of the present disclosure. DETAILED DESCRIPTION OF THE INVENTION

[0010] Reference will now be made in detail to the embodiments of the present disclosure, one or more examples of which are illustrated in the drawings. Each example is provided by way of explanation of the disclosure, and not as a limitation thereof. Indeed, it will be apparent to those skilled in the art that various modifications and variations can be made in the present disclosure without departing from the scope or spirit of the disclosure. For example, features illustrated or described as part of one embodiment can be used with other embodiments to yield still further embodiments. It is therefore intended that the present invention cover modifications and variations of the present disclosure that come within the scope of the appended claims and their equivalents.

[0011] Aspects of the present disclosure include a multi-head temporal convolutional neural network ("MH-TCNN") that can analyze past estimated glucose values, such as, for example, past average blood glucose concentrations and other related biometric data, to generate or determine a user's blood glucose level, such as, for example, predicting the user's estimated average glucose value. For example, the MH-TCNN's future estimated glucose average ("eGA") data can be trained using eGA data associated with a particular user with diabetes or an average user, and supplemental physiological or biometric data, such as heart rate, to increase the estimated prediction confidence.

[0012] This is achieved using MH-TCNN by assigning each data input to a separate "head," or convolutional layer, which is used to learn the underlying patterns of how various data inputs affect the output glucose concentration. The convolutional layers of MH-TCNN can operate independently of each other. The output of each convolutional layer is then provided to a final concatenation layer, which learns the underlying patterns of the outputs from each convolutional layer to predict the estimated glucose level of the user's blood without needing a current glucose reading.

[0013] The MH-TCNN can be trained for each specific user and can iteratively learn from the user during use. For example, the MH-TCNN can be operated on a computing device, such as a smartwatch, that includes one or more biometric sensors that can collect biometric data about the user. In another example, the MH-TCNN can run on a computing device, such as a smartphone, that can receive biometric data from various devices that include biometric sensors, such as smartwatches, CGM devices, etc. In other embodiments, the MH-TCNN can run on a server in communicative contact with the computing device.

[0014] The advantage of using MH-TCNN with supplemental data over a regular convolutional neural network is that the loss function associated with MH-TCNN yields more accurate predictions, such as a much smaller mean squared error ("MSE"). For example, using a convolutional neural network with a single convolutional layer, or using other modeling techniques, such as a baseline model or a polynomial fitting model, is comparable. For example, for a given set of training data, the baseline model was found to have an MSE of 260.3, while the polynomial fitting model had an MSE of 1181.8. For the same set of training data, a one-dimensional (e.g., one-headed) convolutional neural network was found to have an MSE of 191.9.

[0015] In contrast, MH-TCNN has an MSE of 20 on the same dataset. This lower MSE value results in more accurate blood glucose level predictions. Using a multi-head model, in which each individual variable receives its own "head," or convolutional layer, results in a much more accurately trained model for predicting a user's blood glucose level. This is because each variable is learned separately from the others in a separate convolutional layer, and the resulting trained convolutional layers are then combined in a concatenated convolutional layer that experiences the learning from each of the convolutional layers. The resulting concatenated convolutional layer can then output a prediction of the user's blood glucose level.

[0016] FIG. 1 illustrates a MH-TCNN (hereinafter referred to as "network") 100 for predicting an estimated mean glucose value, according to one embodiment of the present disclosure.

[0017] Network 100 may include one or more convolutional layers. For example, in one embodiment, network 100 may include a first convolutional layer 101, a second convolutional layer 102, and a third convolutional layer 103. In alternative embodiments, network 100 may include more or fewer convolutional layers.

[0018] In a further embodiment, each convolutional layer of the network 100 may be associated with a single data input (e.g., a particular parameter, measurement, or other value). Each convolutional layer receives input data and, through the process of convolution, distills the input data into a feature map. In a further embodiment, each convolutional layer of the network 100 may be associated with a specific single type of data. For example, as shown in FIG. 1, the first convolutional layer 101 may be associated with a user's eGA value, the second convolutional layer 102 may be associated with the number of steps the user has taken, and the third convolutional layer 103 may be associated with the user's heart rate. Each convolutional layer may then process the individual data inputs to create an output feature map (or activation map) for each convolutional layer. A feature map or activation map is the output of a layer after a particular weight filter has been applied to that layer. The filter may be drawn across the layer, and each position across the filter results in the activation of a "neuron" or node within the layer. The resulting outputs are collected in a feature map. This process can be repeated across layers to produce feature maps. In a further embodiment, the output of each convolutional layer can be output as a feature map having a shape such as (number of inputs) x (feature map height) x (feature map width) x (feature map channel), or other suitable output shape. The convolutional layer is split because each input may have a different time correlation principle, but each input has some potential information that affects the eGA value.

[0019] The output of one or more convolutional layers may be received by one or more pooling layers, such as first pooling layer 111, second pooling layer 112, and third pooling layer 113. The pooling layers may process portions of the output feature maps from one or more convolutional layers, for example, by selecting a filter, sliding the filter over the output feature maps, and performing a pooling operation, resulting in an output from the pooling layer based on the currently selected value (e.g., currently under the filter) from the output feature map(s). Examples of pooling operations include max pooling and average pooling.

[0020] The outputs from the pooling layers may then be provided to a concatenation layer 120. The concatenation layer 120 receives the outputs from the pooling layers and concatenates the outputs along a particular dimension. For example, the concatenation layer 120 may receive multiple outputs from multiple pooling layers and combine those inputs along a specified dimension that each of the multiple outputs has in common with the other outputs.

[0021] The concatenation layer 120 can be used as input for the final convolutional layer 130. Like the convolutional layers described above, the final convolutional layer 130 receives input data and, through a process of convolution, extracts the input data into a feature map. The output of the final convolutional layer 130 is an estimated glucose average ("eGA") 140.

[0022] Network 100 can be trained using general training data (e.g., predetermined training data encompassing a variety of users and data values) and / or can be trained for a particular user over time. For example, network 100 can be trained using a general data set and then reinforced over time from specific patterns associated with the user.

[0023] In a further embodiment, different convolutional layers may have different input layer sizes. For example, FIG. 2 illustrates a multi-head convolutional neural network ("network") 200 for predicting an estimated mean glucose value, according to one aspect of the present disclosure. Similar to network 100 described above with reference to FIG. 1, network 200 may include two or more convolutional layers, such as convolutional layers 201-204 and one or more pooling layers 210. However, as illustrated, different convolutional layers may have different input layer, or head, sizes. For example, the input head size of convolutional layer 201 may be shorter than the input head size of convolutional layer 202. This is because the input of convolutional layer 201 may only be the blood glucose concentration (e.g., average value) for the past hour, while the input of convolutional layer 202 may be the average heart rate for the past hour and the current heart rate, the heart rate for the past six hours, or any other variation within a duration.

[0024] In another example, non-temporal input data may be assigned a larger input size to align the non-temporal data with temporal data. For example, heart rate data may be collected continuously over time and have different values ​​at different times. However, sleep data is a non-temporal binary value—a user is either asleep or awake. To align this non-temporal sleep data with temporal data such as heart rate, times when the user is awake may be assigned a value of 0, and times when the user is asleep may be assigned a value of 1. This allows the non-temporal sleep data to be represented temporally as a sequence of 0s and 1s indicating when the user goes to sleep and when the user wakes up. This would require a much longer input duration in convolutional layer 201 than, for example, the average blood glucose concentration over the past hour. Therefore, a convolutional layer such as convolutional layer 204 may have a much larger input size (e.g., a larger number of input data points for convolutional layer 204) than the input of convolutional layer 201.

[0025] 2 illustrates an example of performing various stages of convolution and pooling (see iterative convolution and pooling step 220). In a further embodiment, network 200 may include additional convolution and / or pooling layers that may perform convolution and / or pooling on a subset of the outputs of pooling layer 210. This iterative convolution and pooling step 220 may be performed any number of times. The outputs of the pooling layers may then be concatenated into a concatenation layer 230, which is then used as an input to a final convolution layer 240, as described with reference to network 100 of FIG. 1. The output of this final convolution layer 250 is an estimated blood glucose level 250.

[0026] FIG. 3 illustrates buffer standardization of convolutional layers in a multi-head convolutional neural network according to one embodiment of the present disclosure. Buffer standardization improves the convergence rate of the MH-TCNN during training, thereby improving the final evaluation accuracy of the MH-TCNN for estimating a user's blood glucose concentration. As shown in FIG. 3, without buffer standardization (310), the MH-TCNN takes longer to converge compared to standardization per channel of each head of the MH-TCNN (320), i.e., each input convolutional layer. Per-channel buffer standardization is performed by applying function 330 to the output feature map of convolutional layer 340 to standardize the range of values ​​for the input to each convolutional layer.

[0027] FIG. 4 illustrates lifting non-temporal data inputs for a convolutional neural network according to one aspect of the present disclosure. As described above with respect to FIG. 2, non-temporal data such as sleep and wake times, meal times, and other instances of events not measured over time can be “lifted,” i.e., assigned a 0 or 1 value based on when the event occurs, to align the non-temporal data with temporal data such as heart rate, average blood glucose levels, and number of steps taken. For example, in FIG. 4, sleep is tracked as a binary 0 or 1 in curve 405, with 0 indicating times when the user is awake and 1 indicating times when the user is asleep. This “lifting” thus transforms non-temporal data (e.g., occurrences of discrete events such as meals eaten, going to bed, and waking up) into a temporal curve that transitions between 0 and 1 values. Lifting or aligning non-temporal data with temporal data allows convolutional layers to receive inputs with similar dimensions to other convolutional layers, which allows for easier alignment when the outputs of pooling layers are concatenated.

[0028] FIG. 5 illustrates patterns observed in a convolutional layer for various data inputs, according to one embodiment of the present disclosure. As illustrated, different patterns and which types of filters are most suitable for analyzing the output feature maps of the convolutional layer for a particular data type may become apparent based on the type of data input to the convolutional layer and the type of filter used by the pooling layer associated with the convolutional layer. For example, gradient ascent and descent filters may be useful for general trend data (e.g., blood glucose levels, heart rate, etc.), such as in pattern 510. Low-pass filters, particularly Gaussian low-pass filters, may be useful for data inputs with high or low valleys, such as when an insulin injection is administered or other medication is introduced (as shown in pattern 520). Furthermore, high-pass filters may lead to better inputs for data inputs with fast fluctuations, such as stress indicators, sugars consumed from meals, etc. (as shown in example 530).

[0029] FIG. 6 illustrates a method 600 for determining a user's glucose value (e.g., predicting an estimated glucose value) according to one aspect of the present disclosure. In a further embodiment, method 600 may be stored as instructions in a non-transitory computer-readable medium, such as a memory, and performed by one or more processors, such as one or more processors of a computing device. FIG. 6 illustrates steps performed in a particular order for purposes of illustration and explanation. One skilled in the art, with the disclosure provided herein, will understand that the various steps of method 600, or any of the other methods disclosed herein, may be adapted, modified, rearranged, performed simultaneously, or modified in various ways without departing from the scope of the present disclosure.

[0030] At block 605, the method 600 includes receiving a data input associated with the user's biometric data and / or other data associated with the user. In a further embodiment, the received data input may include the user's past measured eGA values ​​for a period of time, such as the last 20 minutes, the last hour, the last 12 hours, etc.

[0031] In a further embodiment, the received data inputs may also include basal insulin data, bolus insulin data, nutritional intake data (e.g., calories burned, macronutrients burned, etc.), sleep data (e.g., the user's hours of sleep per day, the time the user went to bed, the time the user woke up, etc.), stressor data, hypoglycemic event data, illness data (e.g., the type of illness experienced, the duration of the illness, medications consumed, lifestyle changes such as extra sleep or hydration made during the duration of the illness, etc.), exercise data (e.g., the type and duration of exercise, changed heart rate data, calories burned, etc.), heart rate data, air temperature data, skin temperature data, step count data (e.g., the number of steps the user took within a given time frame), and galvanic skin response data. These data inputs may be obtained in various ways. For example, the user may be required to input nutritional intake data into a software application on the computing device, such as entering nutritional intake data related to meals the user consumed. As another example, data may be collected by one or more sensors, such as sensors on a smart wearable for detecting heart rate, skin temperature, step count, etc.

[0032] Various time frames for temporal data (e.g., heart rate, skin temperature, steps, stress data, etc.) can be user-defined and / or determined by other means, such as having a default time frame for specific temporal data input, a predetermined time range for all temporal data, etc.

[0033] Non-temporal data can be determined via user input (e.g., a user entering nutritional intake or sleep data) or by one or more sensors, such as a CGM detecting hypoglycemic events, a smart wearable or smartphone detecting user movement, or a weather software application providing weather data (e.g., temperature) as a data input.

[0034] At block 610, the method 600 includes inputting each received data input into a separate convolutional layer of a multi-head temporal convolutional neural network. As described above with reference to Figures 1 and 2, the networks 100 and 200 may include a separate convolutional layer for each data input to learn how each data input may affect the resulting eGA value.

[0035] In a further embodiment, inputting each received data input into a separate convolutional layer may include providing different input layer sizes for different data input types, as described above with respect to Figure 2. For example, the input head size of the first convolutional layer may be shorter than the input head size of the second convolutional layer, because the input of the first convolutional layer may only be the blood glucose concentration (e.g., average value) for the past hour, while the input of the second convolutional layer may be the average heart rate for the past hour and the current heart rate, the heart rate for the past six hours, or any other variation within a duration.

[0036] In a further embodiment, buffer standardization can be performed after each data input is assigned to a convolutional layer. Buffer standardization improves the convergence rate of the MH-TCNN during training, thereby improving the final evaluation accuracy of the MH-TCNN for estimating a user's blood glucose concentration. As shown in FIG. 3, without buffer standardization, the MH-TCNN takes longer to converge compared to standardizing each head of the MH-TCNN, i.e., each input convolutional layer, per channel. Channel standardization is performed by applying a function to the output feature map of the convolutional layer.

[0037] At block 615, method 600 includes analyzing each convolutional layer associated with each data input. For example, as described above with respect to FIGS. 1 and 2, each convolutional layer may undergo convolution to output a feature map. The feature map may have n dimensions and represent particular features of the input data. During convolution, one or more functions, such as activation functions, may be applied to the particular data input associated with the convolutional layer to generate the feature map.

[0038] In a further embodiment, after analyzing each convolutional layer and receiving an output feature map from each convolutional layer, the generated feature map can be provided to a pooling layer. As described above with respect to FIG. 1, the pooling layer can process portions of the output feature map from one or more convolutional layers by, for example, selecting a filter, sliding the filter over the output feature map, and performing a pooling operation, resulting in an output from the pooling layer based on the currently selected value (e.g., currently under the filter) from the output feature map(s). Examples of pooling operations include max pooling and average pooling.

[0039] In a further embodiment, the outputs from the pooling layers may then be provided to a concatenation layer, which receives the outputs from the pooling layers and concatenates the outputs along a particular dimension. For example, the concatenation layer may receive multiple outputs from multiple pooling layers and combine the inputs along a specified dimension that each of the multiple outputs has in common with the other inputs.

[0040] At block 620, the method 600 includes combining the output of each respective convolutional layer (and / or pooling layer) into a concatenation layer. The concatenation layer can be used as an input for the final convolutional layer. Like the convolutional layers described above, the final convolutional layer receives input data and, through a process of convolution, distills the input data into feature maps.

[0041] Based on the output of the final convolutional layer (e.g., glucose value), a prediction of eGA is determined (at block 625). This eGA may indicate a likely blood glucose average value for the user's blood. This is particularly useful if the user is either not currently using a CGM or is experiencing a CGM malfunction.

[0042] In a further embodiment, the predicted eGA may include a range of possible eGA values. For example, the predicted eGA may include an upper limit of the possible eGA value and a lower limit of the possible eGA value. This range may indicate that an accurate estimate is not available, but the likely value of the user's blood eGA falls within these known limits. This may allow the user to take action based on this known range.

[0043] At block 630, method 600 includes providing a notification to the user based at least in part on the predicted eGA. For example, the notification may include a first notification indicating that the user is hyperglycemic when the user's blood glucose level is higher than a first threshold. In another example, the notification may include a second notification indicating that the user is hypoglycemic when the user's blood glucose level is lower than a second blood glucose level that is lower than the first threshold. In a further example, the notification may include a third notification indicating that the user is at risk of hypoglycemia when the user's blood glucose level is not higher than the second threshold by a threshold amount.

[0044] The notification may also include actionable items for the user. For example, the notification may include instructions to stop exercising if the user is exercising, to consume food or beverages to avoid the risk of hypoglycemia, to wake the user, to indicate to the user that a CGM associated with the user is not functioning, to indicate to the user to seek medical attention, etc. In other examples, the notification may simply include outputting the determined blood glucose level to the user for the user's observation.

[0045] 7 illustrates a wearable computing device 700 according to some implementations of the present disclosure. As shown, the wearable computing device 700 can be worn, for example, on a user's arm 702 (e.g., wrist). For example, the wearable computing device 700 can include a band 704 and a housing 710. In some implementations, the housing 710 can include a conductive material (e.g., metal). In alternative embodiments, the housing 110 can include a non-conductive material (e.g., a plastic material, a ceramic material).

[0046] The housing 710 can be coupled to the band 704. In this manner, the band 704 can be fastened to the user's arm 702 to secure the housing 710 to the user's arm 702.

[0047] In some implementations, the wearable computing device 700 may include a display screen 712. The display screen 712 may display content (e.g., time, date, biometrics, etc.) for a user to view. In some implementations, the display screen 712 may include an interactive display screen (e.g., a touchscreen or a touchless screen). In such implementations, the user may interact with the wearable computing device 700 via the display screen 712 to control the operation of the wearable computing device 700.

[0048] In some implementations, the wearable computing device 700 may include one or more input devices 714 that a user can manipulate (e.g., press) to interact with the wearable computing device 700. For example, the one or more input devices 714 may include mechanical buttons that can be manipulated (e.g., pressed) to interact with the wearable computing device 700. In some implementations, the one or more input devices 714 may be manipulated to control the operation of a backlight (not shown) associated with the display screen 712. It should be understood that the one or more input devices 714 may be configured to enable a user to interact with the wearable computing device 600 in any suitable manner. For example, in some implementations, the one or more input devices 714 may be manipulated by a user to navigate content (e.g., one or more menu screens) displayed on the display screen 712.

[0049] Although wearable computing device 700 is shown as an exemplary computing device, it is contemplated that the details of the present disclosure may be implemented in other types of computing devices, such as smart cellular telephones, personal computers, tablet computers, personal digital assistants, laptop computers, etc.

[0050] In a further embodiment, wearable computing device 700 may include one or more sensors for collecting biometric data related to the user. For example, wearable computing device 700 may include a heart rate sensor, an air temperature sensor, a skin temperature sensor, and other sensors for collecting data for use in network 100 or network 200.

[0051] 8 illustrates a block diagram of an exemplary computing system 800 for performing eGA predictions, according to an exemplary embodiment of the present disclosure. The system 800 includes a user computing device 802, a server computing system 830, and a training computing system 850 communicatively coupled via a network 880.

[0052] The user computing device 802 may be any type of computing device, such as, for example, a personal computing device (e.g., a laptop or desktop), a mobile computing device (e.g., a smartphone or tablet), a game console or controller, a wearable computing device, an embedded computing device, or any other type of computing device.

[0053] The user computing device 802 includes one or more processors 812 and memory 814. The one or more processors 812 may be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, an FPGA, a controller, a microcontroller, etc.) and may be a single processor or multiple operatively connected processors. The memory 814 may include one or more non-transitory computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, etc., and combinations thereof. The memory 814 may store data 816 and instructions 818 that are executed by the processor 812 to cause the user computing device 802 to perform operations.

[0054] In some implementations, the user computing device 802 may store or include one or more OVERALL models 820. For example, the OVERALL models 820 may be or otherwise include various machine-learned models, such as neural networks (e.g., deep neural networks), or other types of machine-learned models, including nonlinear and / or linear models. The neural networks may include feedforward neural networks, recurrent neural networks (e.g., long-short-term memory recurrent neural networks), convolutional neural networks, or other forms of neural networks. Some exemplary machine-learned models may utilize attention mechanisms, such as self-attention. For example, some exemplary machine-learned models may include multi-head self-attention models (e.g., Transformer models). An exemplary L model 820 is described with reference to FIGS. 1 and 2.

[0055] In some implementations, one or more models 820 may be received from a server computing system 830 over a network 880, stored in a user computing device memory 814, and then used or otherwise implemented by one or more processors 812. In some implementations, a user computing device 802 may implement multiple parallel instances of a single model 820 (e.g., to make parallel eGA predictions across multiple instances of eGA-related data).

[0056] More specifically, the model 820 may include one or more convolutional layers. For example, the model 820 may include a first convolutional layer, a second convolutional layer, and a third convolutional layer. It should be understood that there may be more or fewer convolutional layers in the network.

[0057] In a further embodiment, each convolutional layer of model 820 may be associated with a single data input (e.g., a particular parameter, measurement, or other value). Each convolutional layer receives input data and extracts the input data into a feature map through a process of convolution. In a further embodiment, each convolutional layer of model 820 may be associated with a specific single type of data. For example, as shown in FIG. 1 , the first convolutional layer may be associated with a user's eGA value, the second convolutional layer may be associated with the number of steps the user has taken, and the third convolutional layer may be associated with the user's heart rate. Each convolutional layer may then process the individual data inputs to create an output for each convolutional layer. In a further embodiment, the output of each convolutional layer may be output as a feature map having a shape such as (number of inputs) × (feature map height) × (feature map width) × (feature map channels), or any other suitable output shape. The convolutional layer is split because each input may have different time correlation principles, but each input carries some underlying information that influences the eGA value.

[0058] The output of one or more convolutional layers may be received by one or more pooling layers, such as a first pooling layer, a second pooling layer, and a third pooling layer. The pooling layers may process portions of the output feature maps from one or more convolutional layers, for example, by selecting a filter, sliding the filter over the output feature map, and performing a pooling operation, resulting in an output from the pooling layer based on the currently selected value (e.g., currently under the filter) from the output feature map(s). Examples of pooling operations include max pooling and average pooling.

[0059] The outputs from the pooling layers can then be provided to a concatenation layer, which receives the outputs from the pooling layers and concatenates the outputs along a particular dimension. For example, a concatenation layer can receive multiple outputs from multiple pooling layers and combine the inputs along a specified dimension that each of the multiple outputs has in common with the other inputs.

[0060] The concatenation layer can be used as the input for the final convolutional layer. Like the convolutional layers described above, the final convolutional layer receives input data and extracts the input data into feature maps through a process of convolution. The output of the final convolutional layer is the estimated glucose average ("eGA").

[0061] Additionally or alternatively, one or more models 840 may be included in or otherwise stored on and implemented by a server computing system 830 that communicates with the user computing device 802 according to a client-server relationship. For example, the models 840 may be implemented by the server computing system 840 as part of a web service (e.g., an eGA prediction service). Thus, one or more models 820 may be stored and implemented at the user computing device 802 and / or one or more models 840 may be stored and implemented at the server computing system 830.

[0062] The user computing device 802 may also include one or more user input components 822 that receive user input. For example, the user input component 822 may be a touch-sensitive component (e.g., a touch-sensitive display screen or touchpad) that is sensitive to the touch of a user input object (e.g., a finger or stylus). The touch-sensitive component may serve to implement a virtual keyboard. Other exemplary user input components include a microphone, a traditional keyboard, or other means by which a user can provide user input.

[0063] The server computing system 830 includes one or more processors 832 and memory 834. The one or more processors 832 can be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, an FPGA, a controller, a microcontroller, etc.) and can be a single processor or multiple operatively connected processors. The memory 834 can include one or more non-transitory computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, etc., and combinations thereof. The memory 834 can store data 836 and instructions 838 that are executed by the processor 832 to cause the server computing system 830 to operate.

[0064] In some implementations, server computing system 830 includes or is otherwise implemented by one or more server computing devices. When server computing system 830 includes multiple server computing devices, such server computing devices may operate according to a sequential computing architecture, a parallel computing architecture, or some combination thereof.

[0065] As described above, the server computing system 830 may store or otherwise include one or more models 840. For example, the models 840 may be or otherwise include various machine-learned models. Exemplary machine-learned models include neural networks or other multi-layer nonlinear models. Exemplary neural networks include feedforward neural networks, deep neural networks, recurrent neural networks, and convolutional neural networks. Some exemplary machine-learned models may utilize attention mechanisms such as self-attention. For example, some exemplary machine-learned models may include multi-head self-attention models (e.g., Transformer models). An exemplary L model 840 is described with reference to FIGS. 1 and 2.

[0066] User computing device 802 and / or server computing system 830 can train models 820 and / or 840 by interacting with training computing system 850, which is communicatively coupled via network 880. Training computing system 850 may be separate from server computing system 830 or may be part of server computing system 830.

[0067] The training computing system 850 includes one or more processors 852 and memory 854. The one or more processors 852 may be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, an FPGA, a controller, a microcontroller, etc.) and may be a single processor or multiple operably connected processors. The memory 854 may include one or more non-transitory computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, etc., and combinations thereof. The memory 854 may store data 856 and instructions 858 that are executed by the processor 852 to cause the training computing system 850 to perform operations. In some implementations, the training computing system 850 includes or is otherwise implemented by one or more server computing devices.

[0068] The training computing system 850 may include a model trainer 860 that trains the machine-learned models 820 and / or 840 stored on the user computing device 802 and / or the server computing system 830 using various training or learning techniques, such as, for example, backpropagation. For example, a loss function may be backpropagated through the model(s) to update one or more parameters of the model(s) (e.g., based on the gradient of the loss function). Various loss functions may be used, such as mean squared error, likelihood loss, cross-entropy loss, hinge loss, and / or various other loss functions. Gradient descent may be used to iteratively update parameters over several training iterations.

[0069] In some implementations, performing backpropagation may include performing truncated backpropagation over time. The model trainer 860 may perform several generalization techniques (e.g., weight decay, dropout, etc.) to improve the generalization ability of the trained model.

[0070] In particular, model trainer 860 can train OVERALL model 820 and / or 840 based on a set of training data 862. Training data 862 can include, for example, general training data collected from various users (e.g., each user's typical eGA, typical steps taken per hour, typical heart rate, etc.). Training data 862 can also include user-specific training data (e.g., data from a user's CGM indicating a particular user's averaged eGA, etc.).

[0071] In some implementations, if the user provides consent, the training examples may be provided by the user computing device 802. Thus, in such implementations, the model 820 provided to the user computing device 802 may be trained by the training computing system 850 against user-specific data received from the user computing device 802. In some implementations, this process may be referred to as personalizing the model.

[0072] Model trainer 860 includes computer logic utilized to provide desired functionality. Model trainer 860 can be implemented in hardware, firmware, and / or software controlling a general-purpose processor. For example, in some embodiments, model trainer 860 includes program files stored on a storage device, loaded into memory, and executed by one or more processors. In other embodiments, model trainer 860 includes one or more sets of computer-executable instructions stored on a tangible computer-readable storage medium, such as RAM, a hard disk, or an optical or magnetic medium.

[0073] Network 880 may be any type of communications network, such as a local area network (e.g., an intranet), a wide area network (e.g., the Internet), or some combination thereof, and may include any number of wired or wireless links. In general, communications over network 880 may be carried over any type of wired or wireless link using a wide variety of communications protocols (e.g., TCP / IP, HTTP, SMTP, FTP), encodings or formats (e.g., HTML, XML), and / or protection schemes (e.g., VPN, Secure HTTP, SSL).

[0074] The machine-learned models described herein may be used for a variety of tasks, applications, and / or use cases.

[0075] In some implementations, input to the machine-learned model(s) of the present disclosure may be text or natural language data. The machine-learned model(s) may process the text or natural language data to generate an output. As an example, the machine-learned model(s) may process the natural language data to generate a language-encoded output. As another example, the machine-learned model(s) may process the text or natural language data to generate a latent text embedding output. As another example, the machine-learned model(s) may process the text or natural language data to generate a translation output. As another example, the machine-learned model(s) may process the text or natural language data to generate a classification output. As another example, the machine-learned model(s) may process the text or natural language data to generate a text segmentation output. As another example, the machine-learned model(s) may process the text or natural language data to generate a semantic intent output. As another example, the machine-learned model(s) may process text or natural language data to generate an upgraded text or natural language output (e.g., text or natural language data of higher quality than the input text or natural language). As another example, the machine-learned model(s) may process text or natural language data to generate a predicted output.

[0076] In some implementations, input to the machine-learned model(s) of the present disclosure may be statistical data. The statistical data may be, represent, or otherwise include data computed and / or calculated from some other data source. The machine-learned model(s) may process the statistical data to generate an output. As an example, the machine-learned model(s) may process the statistical data to generate a recognition output. As another example, the machine-learned model(s) may process the statistical data to generate a prediction output. As another example, the machine-learned model(s) may process the statistical data to generate a classification output. As another example, the machine-learned model(s) may process the statistical data to generate a segmentation output. As another example, the machine-learned model(s) may process the statistical data to generate a visualization output. As another example, the machine-learned model(s) may process the statistical data to generate a diagnostic output.

[0077] In some implementations, the input to the machine-learned model(s) of the present disclosure may be sensor data. The machine-learned model(s) may process the sensor data to generate an output. As an example, the machine-learned model(s) may process the sensor data to generate a recognition output. As another example, the machine-learned model(s) may process the sensor data to generate a prediction output. As another example, the machine-learned model(s) may process the sensor data to generate a classification output. As another example, the machine-learned model(s) may process the sensor data to generate a segmentation output. As another example, the machine-learned model(s) may process the sensor data to generate a visualization output. As another example, the machine-learned model(s) may process the sensor data to generate a diagnostic output. As another example, the machine-learned model(s) may process the sensor data to generate a detection output.

[0078] In some cases, the machine-learned model(s) can be configured to perform a task that includes encoding input data for reliable and / or efficient transmission or storage (and / or corresponding decoding). For example, the task can be an audio compression task. The input can include audio data, and the output can include compressed audio data. In another example, the input can include visual data (e.g., one or more images or videos), and the output can include compressed visual data, and the task is a visual data compression task. In another example, the task can include generating an embedding for the input data (e.g., input audio or visual data).

[0079] 8 illustrates one exemplary computing system that can be used to implement the present disclosure. Other computing systems can be used as well. For example, in some implementations, a user computing device 802 can include a model trainer 860 and a training dataset 862. In such implementations, the model 820 can be both trained and used locally on the user computing device 802. In some such implementations, the user computing device 802 can implement the model trainer 860 to personalize the model 820 based on user-specific data.

[0080] In addition to the above, users may be provided with controls that allow them to choose both whether and when the systems, programs, or features described herein may enable the collection of user information (e.g., information about the user's social network, social behavior, or activities, occupation, user preferences, or the user's current location), as well as whether the user is sent content or communications from the server. Furthermore, certain data may be handled in one or more ways so that personally identifiable information is removed before it is stored or used. For example, the user's identity may be handled in such a way that personally identifiable information about the user cannot be determined, or if location information is obtained (e.g., to the city, zip code, or state level), the user's geographic location may be generalized so that the user's specific location cannot be determined. Thus, users may control what information is collected about them, how that information is used, and what information is provided to them. To that end, any information collected about users as described herein will be kept private and confidential and will not be used or disclosed inappropriately.

[0081] While the subject matter of the present disclosure has been described in detail with respect to various specific exemplary embodiments thereof, each example is provided for purposes of explanation and not limitation of the present disclosure. Those skilled in the art, once they arrive at the foregoing understanding, will be able to readily create modifications, variations, and equivalents to such embodiments. Accordingly, the disclosure of the subject matter does not exclude the inclusion of such modifications, variations, and / or additions to the subject matter as would be readily apparent to one skilled in the art. For example, features illustrated or described as part of one embodiment may be used with other embodiments to yield still other embodiments. Accordingly, the present disclosure is intended to cover such modifications, variations, and equivalents.

Claims

1. 1. A method for determining a glucose level of a user, the method comprising: receiving a plurality of data inputs associated with biometric data of the user, the plurality of data inputs including at least one data input representing a past estimated glucose value of the user, the method further comprising: processing the plurality of data inputs using a multi-head temporal convolutional neural network to generate a blood glucose level for the user; providing a notification to the user based at least in part on the blood glucose level; A method comprising:

2. processing the plurality of data inputs with a multi-head temporal convolutional neural network to generate a blood glucose level for the user; inputting each data input of the plurality of data inputs into a corresponding convolutional layer of the multi-head temporal convolutional neural network; analyzing each individual convolutional layer of each of said data inputs separately from other individual convolutional layers; Combining outputs from the analyzed individual convolutional layers into a concatenated convolutional layer; and generating the blood glucose level for the user based on an output of the concatenated convolutional layer; and The method of claim 1 , comprising:

3. 2. The method of claim 1, wherein the plurality of data inputs includes at least one data input representing a data input selected from the group of data inputs consisting of basal insulin data, bolus insulin data, nutrient intake data, sleep data, stressor data, hypoglycemic event data, illness data, exercise data, heart rate data, air temperature data, skin temperature data, step count, and galvanic skin response data.

4. The method of claim 1 , wherein analyzing each individual convolutional layer comprises performing layer-by-layer standardization for each convolutional layer.

5. The method of claim 1 , further comprising performing a lift on a non-temporal data input of the plurality of data inputs to align the non-temporal data input with a temporal data input of the plurality of data inputs.

6. 2. The method of claim 1, wherein at least one individual convolutional layer of the multi-head temporal convolutional neural network has a different input layer size than other individual convolutional layers of the multi-head temporal convolutional neural network.

7. The method of claim 1 , wherein the blood glucose value comprises a range of blood glucose values.

8. the notification includes a first notification indicating that the user is hyperglycemic when the blood glucose level of the user is higher than a first threshold; the notification includes a second notification indicating that the user is hypoglycemic when the blood glucose level of the user is lower than a second blood glucose level that is lower than the first threshold; the notification includes a third notification indicating that the user is at risk of hypoglycemia when the blood glucose level of the user is not higher than the second threshold by a threshold amount. The method of claim 1.

9. The method of claim 8 , wherein the notification includes a fourth notification instructing the user to stop exercising or consume food.

10. 1. A computing device, comprising: one or more processors; and a non-transitory computer-readable medium comprising instructions that, when executed by the one or more processors, cause the one or more processors to perform a process, the process comprising: receiving a plurality of data inputs associated with biometric data of a user, the plurality of data inputs including at least one data input representing a past estimated glucose value of the user, the process further comprising: processing the plurality of data inputs using a multi-head temporal convolutional neural network to generate a blood glucose level for the user; providing a notification to the user based at least in part on the blood glucose level; a computing device,

11. processing the plurality of data inputs with a multi-head temporal convolutional neural network to generate a blood glucose level for the user; inputting each data input of the plurality of data inputs into a corresponding convolutional layer of the multi-head temporal convolutional neural network; analyzing each individual convolutional layer of each of said data inputs separately from other individual convolutional layers; Combining outputs from the analyzed individual convolutional layers into a concatenated convolutional layer; and generating the blood glucose level for the user based on an output of the concatenated convolutional layer; and The computing device of claim 10, comprising:

12. 11. The computing device of claim 10, wherein the process further comprises performing a lift on a non-temporal data input of the plurality of data inputs to align the non-temporal data input with a temporal data input of the plurality of data inputs.

13. The computing device of claim 10 , wherein the blood glucose value comprises a range of blood glucose values.

14. the notification includes a first notification indicating that the user is hyperglycemic when the blood glucose level of the user is higher than a first threshold; the notification includes a second notification indicating that the user is hypoglycemic when the blood glucose level of the user is lower than a second blood glucose level that is lower than the first threshold; the notification includes a third notification indicating that the user is at risk of hypoglycemia when the blood glucose level of the user is not higher than the second threshold by a threshold amount. The computing device of claim 10.

15. 1. A non-transitory computer-readable medium comprising instructions that, when executed by one or more processors, cause the one or more processors to perform a process, the process comprising: receiving a plurality of data inputs associated with biometric data of a user, the plurality of data inputs including at least one data input representing a past estimated glucose value of the user, the process further comprising: processing the plurality of data inputs using a multi-head temporal convolutional neural network to generate a blood glucose level for the user; providing a notification to the user based at least in part on the blood glucose level; 1. A non-transitory computer-readable medium comprising:

16. processing the plurality of data inputs with a multi-head temporal convolutional neural network to generate a blood glucose level for the user; inputting each data input of the plurality of data inputs into a corresponding convolutional layer of the multi-head temporal convolutional neural network; analyzing each individual convolutional layer of each of said data inputs separately from other individual convolutional layers; Combining outputs from the analyzed individual convolutional layers into a concatenated convolutional layer; and generating the blood glucose level for the user based on an output of the concatenated convolutional layer; and 16. The non-transitory computer-readable medium of claim 15, comprising:

17. 16. The non-transitory computer-readable medium of claim 15, wherein the process further comprises performing a lift on a non-temporal data input of the plurality of data inputs to align the non-temporal data input with a temporal data input of the plurality of data inputs.

18. 16. The non-transitory computer-readable medium of claim 15, wherein the blood glucose value comprises a range of blood glucose values.

19. the notification includes a first notification indicating that the user is hyperglycemic when the blood glucose level of the user is higher than a first threshold; the notification includes a second notification indicating that the user is hypoglycemic when the blood glucose level of the user is lower than a second blood glucose level that is lower than the first threshold; the notification includes a third notification indicating that the user is at risk of hypoglycemia when the blood glucose level of the user is not higher than the second threshold by a threshold amount.

16. The non-transitory computer-readable medium of claim 15.

20. 20. The non-transitory computer-readable medium of claim 19, wherein the notification includes a fourth notification instructing the user to stop exercising or consume food.

Images