SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2409.16554 · 2024

EMIT- Event-Based Masked Auto Encoding for Irregular Time Series

arXiv · PDF · Open in the Atlas

Code that ran

14 of 15 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 12 failures of our instrument; 1 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2409.16554.json · badge: /api/ran/2409.16554.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
hrishi-ds/EMIT canonical (classifier label)
classifier basis: census
14 ran · 1 no recorded run
FunctionStatusWhere it lives
batch_indices_to_mask_numba Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
hrishi-ds/EMIT/src/event_masks/generate_event_masks_mimic_iii.py
code served (permissive licence) · get_code("50d80e69db8ed9fa")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import numba

# Examine the function to understand parameter requirements:
# - times_array: 2D array of shape (batch_size, seq_len) with time values
# - values_array: 2D array of shape (batch_size, seq_len) with numeric values
# - variables_array: 2D array of shape (batch_size, seq_len) with variable IDs
# - threshold: scalar numeric value for rate of change threshold

# Create small test data
batch_size = 2
seq_len = 4

# times_array: timestamps for each observation
times_array = np.array([
    [0.0, 1.0, 2.0, 3.0],
    [0.0, 1.5, 3.0, 4.5]
], dtype=np.float64)

# values_array: measured values
values_array = np.array([
    [10.0, 12.0, 15.0, 18.0],
    [5.0, 7.0, 10.0, 14.0]
], dtype=np.float64)

# variables_array: variable identifiers (which variable each measurement is from)
# Using small integers to represent different variables
variables_array = np.array([
    [1, 1, 1, 2],
    [1, 1, 2, 2]
], dtype=np.int64)

# threshold: cutoff for significant rate of change
threshold = 1.5

ARGS = {
    'times_array': times_array,
    'values_array': values_array,
    'variables_array': variables_array,
    'threshold': threshold
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numba, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
batch_indices_to_mask_numba_with_insignificant_masks Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
hrishi-ds/EMIT/src/event_masks/generate_event_masks_mimic_iii.py
code served (permissive licence) · get_code("15cd4150d9fa7f1c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import numba

np.random.seed(0)

# Create small test arrays
batch_size = 2
seq_length = 4
num_variables = 3

# times_array: shape (batch_size, seq_length) - timestamps for each sequence
times_array = np.array([
    [0.0, 1.0, 2.0, 3.0],
    [0.0, 0.5, 1.5, 2.5]
], dtype=np.float64)

# values_array: shape (batch_size, seq_length) - values at each timestamp
values_array = np.array([
    [10.0, 12.0, 15.0, 18.0],
    [5.0, 5.5, 6.0, 7.0]
], dtype=np.float64)

# variables_array: shape (batch_size, seq_length) - variable IDs (0 means no variable)
variables_array = np.array([
    [1, 1, 2, 2],
    [1, 2, 2, 3]
], dtype=np.int64)

# threshold: scalar threshold for rate of change
threshold = 0.5

# insignificant_prob: probability of including insignificant changes
insignificant_prob = 0.1

ARGS = {
    "times_array": times_array,
    "values_array": values_array,
    "variables_array": variables_array,
    "threshold": threshold,
    "insignificant_prob": insignificant_prob
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numba, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
calculate_rate_of_change_numba Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
hrishi-ds/EMIT/src/event_masks/generate_event_masks_mimic_iii.py
code served (permissive licence) · get_code("920cd3a05aae993a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (5,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import numba

@numba.njit
def calculate_rate_of_change_numba(values, times):
    time_diffs = np.diff(times)
    value_diffs = np.diff(values)
    rates = np.zeros(len(values))
    for j in range(len(time_diffs)):
        if time_diffs[j] != 0:
            rates[j] = value_diffs[j] / time_diffs[j]
        else:
            rates[j] = 0
    rates[-1] = 0
    return rates

# Construct valid arguments
values = np.array([1.0, 2.0, 4.0, 7.0, 11.0], dtype=np.float64)
times = np.array([0.0, 1.0, 2.0, 3.0, 4.0], dtype=np.float64)

ARGS = {
    "values": values,
    "times": times
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numba, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (5,) — shape (5,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
extend_model Ran
ran; our contract draft was wrong, not the code
hrishi-ds/EMIT/src/finetuning/finetune_mimic.py
code served (permissive licence) · get_code("1489d78f67b0582d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Functional. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Dropout, BatchNormalization, Lambda, Concatenate
from tensorflow.keras.models import Model

# Create a minimal base model that accepts 3 inputs and outputs a tensor
def create_base_model():
    input_layers = [
        Input(shape=(10,)),
        Input(shape=(10,)),
        Input(shape=(10,))
    ]
    # Simple processing: concatenate inputs and pass through dense layer
    concatenated = Concatenate()(input_layers)
    output = Dense(8, activation='relu')(concatenated)
    base_model = Model(inputs=input_layers, outputs=output)
    return base_model

base_model = create_base_model()

ARGS = {
    'base_model': base_model,
    'V': 5000,
    'max_seq_length': 10
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Functional — a Functional output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Functional output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
f Ran
ran, honoured the contract we drafted
hrishi-ds/EMIT/src/data_preprocessing/preprocess_mimic_iii.py
code served (permissive licence) · get_code("06ddfb40099e743b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

class X:
    def __init__(self):
        self.CHARTTIME = 100
        self.icustay_times = [
            (1, 50, 150),
            (2, 200, 300),
            (3, 400, 500)
        ]

x = X()

ARGS = {"x": x}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
f Ran
ran; our contract draft was wrong, not the code
hrishi-ds/EMIT/src/data_preprocessing/preprocess_mimic_iii.py
code served (permissive licence) · get_code("2ff0290f2f537f28")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyzing the function:
# f(x) checks len(x), accesses x[0], and calls ','.join(x)
# This suggests x should be a sequence (list or tuple) of strings
# 
# If len(x) == 0: returns x[0] (would raise IndexError, but we need valid args)
# else: returns ','.join(x) which requires x to be iterable of strings
#
# To make valid arguments, we should pass a non-empty list of strings
# so the function doesn't try to access x[0] on an empty sequence

x = ["hello", "world", "test"]

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_batches Ran
ran; our contract draft was wrong, not the code
hrishi-ds/EMIT/src/pretraining/pretrain_mimic.py
code served (permissive licence) · get_code("1d91c0a1e3f11311")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import tempfile
import os

# Create temporary directory for test files
temp_dir = tempfile.mkdtemp()

# Create mock data file with required keys
data_file = os.path.join(temp_dir, 'data.npz')
fore_train_ip = np.random.rand(10, 4, 3)  # 10 samples, 4x3 shape
fore_train_op = np.random.rand(10, 2)
fore_valid_ip = [
    np.random.rand(5, 4, 3),  # fore_valid_ip[0]
    np.random.rand(5, 4, 3),  # fore_valid_ip[1]
    np.random.rand(5, 4, 3)   # fore_valid_ip[2]
]
fore_valid_op = np.random.rand(5, 2)
np.savez(data_file, 
         fore_train_ip=fore_train_ip, 
         fore_train_op=fore_train_op,
         fore_valid_ip=fore_valid_ip, 
         fore_valid_op=fore_valid_op)

# Create mock mask file with required keys
mask_file = os.path.join(temp_dir, 'mask.npz')
fore_train_masks = np.random.rand(10, 4, 3)
fore_val_masks = np.random.rand(5, 4, 3)
np.savez(mask_file, 
         fore_train_masks=fore_train_masks, 
         fore_val_masks=fore_val_masks)

ARGS = {
    'data_path': data_file,
    'mask_path': mask_file,
    'batch_size': 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
inv_list Ran
ran; our contract draft was wrong, not the code
hrishi-ds/EMIT/src/data_preprocessing/preprocess_mimic_iii.py
code served (permissive licence) · get_code("2f43552b3b5e5b82")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyze the function:
# - Takes parameter 'x' which must be indexable (len(x) works)
# - Iterates through x with x[i] 
# - Uses elements of x as dictionary keys
# - Takes optional 'start' parameter (default 0, an int)

# The function creates an inverted index mapping elements to their positions
# 'x' should be a list or sequence of hashable items

ARGS = {
    "x": ["apple", "banana", "cherry", "date"],
    "start": 0
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
inv_list Ran
ran; our contract draft was wrong, not the code
hrishi-ds/EMIT/src/data_preprocessing/preprocess_physionet_2012.py
code served (permissive licence) · get_code("0fe5d13698c6faf8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyzing the function:
# - l: a list that is iterated over with len(l) and indexed with l[i]
# - start: an integer with default value 0
# - The function builds a dictionary mapping elements of l to their indices (offset by start)

# Create a simple list with distinct hashable elements
l = ['a', 'b', 'c', 'd']
start = 0

ARGS = {
    'l': l,
    'start': start
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_and_generate_train_val_test_sets Ran
ran; our contract draft was wrong, not the code
hrishi-ds/EMIT/src/finetuning/finetune_mimic.py
code served (permissive licence) · get_code("ff295c09ba198ddc")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import pickle
import numpy as np
import pandas as pd
import tempfile
import os

# Create a minimal mock dataset that matches the function's expectations
def create_mock_data():
    # Create indices for train/valid/test splits
    train_ind = np.array([0, 1])
    valid_ind = np.array([2])
    test_ind = np.array([3])
    
    # Create sample data dataframe with required columns
    data_records = []
    for ts_ind in range(4):
        for var in ['Age', 'Gender', 'HR', 'BP']:
            for hour in range(5):
                data_records.append({
                    'ts_ind': ts_ind,
                    'variable': var,
                    'hour': hour,
                    'value': np.random.rand() * 100
                })
    
    data = pd.DataFrame(data_records)
    
    # Create outcome dataframe
    oc_records = []
    for ts_ind in range(4):
        oc_records.append({
            'ts_ind': ts_ind,
            'in_hospital_mortality': float(ts_ind % 2)
        })
    
    oc = pd.DataFrame(oc_records)
    
    # Create pickle file with the required structure
    temp_dir = tempfile.gettempdir()
    pickle_path = os.path.join(temp_dir, 'mock_medical_data.pkl')
    
    with open(pickle_path, 'wb') as f:
        pickle.dump((data, oc, train_ind, valid_ind, test_ind), f)
    
    return pickle_path

# Generate the mock data file
data_path = create_mock_data()

# Define ARGS
ARGS = {
    'data_path': data_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_and_generate_train_val_test_sets Ran
ran; our contract draft was wrong, not the code
hrishi-ds/EMIT/src/finetuning/finetune_physionet.py
code served (permissive licence) · get_code("986be89dea6054c4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import pickle
import numpy as np
import pandas as pd
from io import BytesIO

# Create a minimal pickle file that satisfies the function's requirements
def create_mock_data():
    # Create mock time series data
    n_samples = 10
    n_observations = 50
    
    # Create the main data dataframe
    ts_inds = []
    variables = []
    hours = []
    values = []
    
    static_varis = ['Age', 'Gender', 'Height', 'ICUType_1', 'ICUType_2', 'ICUType_3', 'ICUType_4']
    all_varis = static_varis + ['var1', 'var2', 'var3', 'var4', 'var5']
    
    # Add static data
    for ts_ind in range(n_samples):
        for static_var in static_varis:
            ts_inds.append(ts_ind)
            variables.append(static_var)
            hours.append(0)
            values.append(np.random.rand())
    
    # Add dynamic data
    for ts_ind in range(n_samples):
        for obs in range(n_observations):
            var = np.random.choice(['var1', 'var2', 'var3', 'var4', 'var5'])
            ts_inds.append(ts_ind)
            variables.append(var)
            hours.append(float(obs))
            values.append(np.random.rand())
    
    data = pd.DataFrame({
        'ts_ind': ts_inds,
        'variable': variables,
        'hour': hours,
        'value': values
    })
    
    # Create outcome dataframe
    oc = pd.DataFrame({
        'ts_ind': range(n_samples),
        'in_hospital_mortality': np.random.randint(0, 2, n_samples)
    })
    
    # Create train/val/test splits
    train_ind = np.array([0, 1, 2, 3])
    valid_ind = np.array([4, 5])
    test_ind = np.array([6, 7, 8, 9])
    
    return (data, oc, train_ind, valid_ind, test_ind)

# Create the pickle data
data, oc, train_ind, valid_ind, test_ind = create_mock_data()
pickle_buffer = BytesIO()
pickle.dump((data, oc, train_ind, valid_ind, test_ind), pickle_buffer)
pickle_buffer.seek(0)

# Save to a temporary file-like path
import tempfile
with tempfile.NamedTemporaryFile(delete=False, suffix='.pkl') as f:
    f.write(pickle_buffer.getvalue())
    data_path = f.name

ARGS = {
    'data_path': data_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_data Ran
ran; our contract draft was wrong, not the code
hrishi-ds/EMIT/src/pretraining/pretrain_mimic.py
code served (permissive licence) · get_code("cbc9a2663cb2b73a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import tempfile
import os

# Create a temporary directory and a mock .npz file
temp_dir = tempfile.mkdtemp()
data_path = os.path.join(temp_dir, "test_data.npz")

# Create sample data with distinct sizes to avoid ambiguity
fore_train_ip = np.random.randn(2, 4).astype(np.float32)  # batch=2, dim=4
fore_train_op = np.random.randn(2, 3).astype(np.float32)  # batch=2, dim=3
fore_valid_ip = np.random.randn(2, 4).astype(np.float32)  # batch=2, dim=4
fore_valid_op = np.random.randn(2, 3).astype(np.float32)  # batch=2, dim=3

# Save the data to the npz file
np.savez(
    data_path,
    fore_train_ip=fore_train_ip,
    fore_train_op=fore_train_op,
    fore_valid_ip=fore_valid_ip,
    fore_valid_op=fore_valid_op
)

ARGS = {
    "data_path": data_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_mask Ran
ran, honoured the contract we drafted
hrishi-ds/EMIT/src/pretraining/pretrain_mimic.py
code served (permissive licence) · get_code("19a72224a3e8b996")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 4, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import tempfile
import os

# Create a temporary directory for the mask file
temp_dir = tempfile.mkdtemp()
mask_path = os.path.join(temp_dir, "mask.npz")

# Create sample mask data
fore_train_masks = np.random.rand(2, 4, 4).astype(np.float32)
fore_val_masks = np.random.rand(2, 4, 4).astype(np.float32)

# Save as npz file
np.savez(mask_path, fore_train_masks=fore_train_masks, fore_val_masks=fore_val_masks)

ARGS = {
    "mask_path": mask_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 4, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
pad Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
hrishi-ds/EMIT/src/pretraining_data_preparation/get_pretraining_data_mimic_iii.py
code served (permissive licence) · get_code("a753dc77394af824")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

fore_max_len = 880

def pad(x):
    return x + [0] * (fore_max_len - len(x))

# The function takes a list x and pads it with zeros to reach fore_max_len
# We need to provide a list that is shorter than fore_max_len

x_input = [1, 2, 3, 4, 5]

ARGS = {
    "x": x_input
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family int — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
build_strats Not yet run
unverified (harvested, no recorded run)
hrishi-ds/EMIT/src/model.py
code served (permissive licence) · get_code("f51fe6452652adec")
How it ran

no invocation recorded.

Also present in other papers' code

Of 15 samples lifted from this paper's linked repositories, 15 carry a function identity and 0 do not. Of the 15 distinct functions with an identity, 2 are also present in other papers whose code we hold (2 with at least one paper dated earlier, 0 the same month, 0 later) and 13 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
f 1 other paper
1 dated earlier
2107.14293 (2021-07)
Self-Supervised Transformer for Sparse and Irregularly Sampled Multivariate Clinical Time-Series
f 1 other paper
1 dated earlier
2107.14293 (2021-07)
Self-Supervised Transformer for Sparse and Irregularly Sampled Multivariate Clinical Time-Series

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Irregular time series, where data points are recorded at uneven intervals, are prevalent in healthcare settings, such as emergency wards where vital signs and laboratory results are captured at varying times. This variability, which reflects critical fluctuations in patient health, is essential for informed clinical decision-making. Existing self-supervised learning research on irregular time series often relies on generic pretext tasks like forecasting, which may not fully utilise the signal provided by irregular time series. There is a significant need for specialised pretext tasks designed for the characteristics of irregular time series to enhance model performance and robustness, especially in scenarios with limited data availability. This paper proposes a novel pretraining framework, EMIT, an event-based masking for irregular time series. EMIT focuses on masking-based reconstruction in the latent space, selecting masking points based on the rate of change in the data. This method preserves the natural variability and timing of measurements while enhancing the model's ability to process irregular intervals without losing essential information. Extensive experiments on the MIMIC-III and PhysioNet Challenge datasets demonstrate the superior performance of our event-based masking strategy. The code has been released at https://github.com/hrishi-ds/EMIT.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2409.16554")
get_code_for_paper("2409.16554")
have("2409.16554")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2409.16554.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2409.16554.svg)](https://syntology.ai/paper/2409.16554)

Connect an agent — have() is free.