Upload 3 files

config.json

@@ -10,9 +10,9 @@
   "d_fcn": 2048,
   "d_model": 512,
   "distil": true,
+  "len_label": 60,
   "len_pred": 12,
   "len_seq": 180,
-  "len_label": 60,
   "model_type": "gluformer",
   "n_heads": 12,
   "num_dec_layers": 1,
@@ -20,5 +20,5 @@
   "num_features": 5,
   "r_drop": 0.1,
   "torch_dtype": "float32",
-  "transformers_version": "4.53.3"
+  "transformers_version": "4.54.0"
 }

model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dc157c82a48b496db650fda5a6827786dcf7b38cf64b3c48ba38857923c2e649
+oid sha256:185f3885fbd96c6de6b51a0d3762ca3f6885932768fc862ef03789e0aa9c35d4
 size 65480616

modeling_gluformer.py

@@ -298,32 +298,35 @@ class Preprocessor:
     def unnormalize_glucose(self, glucose):
         return (glucose + self.SCALE_1) / (self.SCALE_1 * self.SCALE_2) * (self.UPPER - self.LOWER) + self.LOWER
 
-    def normalize_datetime(self, date):
-        DAYS_YEAR = 182.5
-        DAYS_MONTH = 15.5
-        DAYS_WEEK = 3.5
-        HOURS_DAY = 12.0
-        MINUTES_HOUR = 30.0
-        OFFSET = 1
-        return np.array([date.timetuple().tm_yday / DAYS_YEAR - OFFSET,
-                         date.day / DAYS_MONTH - OFFSET,
-                         date.weekday() / DAYS_WEEK - OFFSET,
-                         date.hour / HOURS_DAY - OFFSET,
-                         date.minute / MINUTES_HOUR - OFFSET], dtype = float)
+    def normalize_datetime(self, ts: np.ndarray) -> np.ndarray:
+        ts = np.asarray(ts, dtype="datetime64[ns]")
+        d, y, m, h = ts.astype("datetime64[D]"), ts.astype("datetime64[Y]"), ts.astype("datetime64[M]"), ts.astype("datetime64[h]")
+        return np.stack((
+            ((d - y).astype("timedelta64[D]").astype(np.int64) + 1) / 182.5 - 1.0,                 # day of year
+            ((d - m).astype("timedelta64[D]").astype(np.int64) + 1) / 15.5  - 1.0,                 # day of month
+            ((d.astype(np.int64) + 3) % 7) / 3.5 - 1.0,                                            # weekday (Mon=0)
+            ((h - d).astype("timedelta64[h]").astype(np.int64)) / 12.0 - 1.0,                      # hour
+            ((ts.astype("datetime64[m]") - h).astype("timedelta64[m]").astype(np.int64)) / 30.0 - 1.0,  # minute
+        ), axis=-1).astype(float)
 
     def __call__(self, subject_id, timestamps, glucose_values):
-        subject_id = torch.tensor([subject_id]).float()
-        glucose_values = torch.tensor(glucose_values).reshape(1, self.len_seq, 1).float()
+        batch_size, seq_len = glucose_values.shape
+        subject_id = torch.full((batch_size,), subject_id, dtype=torch.float)
+        glucose_values = torch.tensor(glucose_values).reshape(-1, self.len_seq, 1).float()
         glucose_values = self.normalize_glucose(glucose_values)
+        ts = np.asarray(timestamps, dtype=np.int64).reshape(batch_size, -1)
 
         # Model takes any number of inputs to encoder.
         # Decoder takes exactly 60 (5 hours of history) previous values with 12 (1 hour) of zeros.
         # Timestamps for y are the corresponding timestamp for the 60 values passed into the decoder with 12 future values separated by 5 minutes.
-        y_timestamps = timestamps[-self.len_label:] + [timestamps[-1] + timedelta(minutes=5 * i) for i in range(self.len_pred)]
-        decoder_input = torch.cat([glucose_values[:,-self.len_label:,:], torch.zeros(1, self.len_pred, 1).float()], dim=1)
+        nanos_per_interval = np.int64(5 * 60 * 1e9)
+        ts_deltas = np.arange(1, self.len_pred + 1, dtype=np.int64) * nanos_per_interval
+        ts_deltas = ts_deltas.reshape(1, -1).repeat(batch_size, axis=0)
+        y_timestamps = np.concatenate([ts[:, -self.len_label:], ts[:, -1:] + ts_deltas], axis=1)
+        decoder_input = torch.cat([glucose_values[:,-self.len_label:,:], torch.zeros(batch_size, self.len_pred, 1).float()], dim=1)
 
-        x_ts = torch.tensor(np.vstack([self.normalize_datetime(date) for date in timestamps])).float().unsqueeze(0)
-        y_ts = torch.tensor(np.vstack([self.normalize_datetime(date) for date in y_timestamps])).float().unsqueeze(0)
+        x_ts = torch.tensor(self.normalize_datetime(ts)).float()
+        y_ts = torch.tensor(self.normalize_datetime(y_timestamps)).float()
         return subject_id, glucose_values, decoder_input, x_ts, y_ts
 
 class GluformerForTimeSeries(PreTrainedModel):
@@ -348,6 +351,10 @@ class GluformerForTimeSeries(PreTrainedModel):
         self.preprocessor = Preprocessor(config.len_seq, config.len_pred, config.len_label)
 
     def forward(self, subject_id, timestamps, glucose_values):
+        if len(glucose_values.shape) == 1:
+            subject_id = subject_id.unsqueeze(0)
+            timestamps = timestamps.unsqueeze(0)
+            glucose_values = glucose_values.unsqueeze(0)
         x_id, x_enc, x_dec, x_mark_enc, y_mark_dec = self.preprocessor(subject_id, timestamps, glucose_values)
         output, log_var = self.model(x_id, x_enc, x_mark_enc, x_dec, y_mark_dec)
         return self.preprocessor.unnormalize_glucose(output), log_var