medpython 1.1.1

Medial EarlySign Python

Medial EarlySign Python Library

A note on our journey: Medial EarlySign was a company that developed a proprietary platform for machine learning on electronic medical records. Following the company's liquidation, the decision was made to release the core software as an open-source project to allow the community to benefit from and build upon this technology. Please feel free to reach me out in any case of an issue. I'm voluntarily holding this, so please be patients.

Our platform is designed to transform complex, semi-structured Electronic Medical Records (EMR) into machine-learning-ready data and reproducible model pipelines. The framework is optimized for the unique challenges of sparse, time-series EMR data, delivering low memory usage and high-speed processing at scale.

It was conceived as a TensorFlow for machine learning on medical data.

All software is now open-sourced under the MIT license. Some of the models developed by Medial EarlySign that are currently in production are available exclusively through our partners.

The framework was battle-tested in production across multiple healthcare sites and was a key component of an award-winning submission to the CMS AI Health Outcomes Challenge.

Why Use This Platform?

• High-Performance Processing: Engineered for large-scale, sparse EMR time-series data where general-purpose libraries like pandas fall short.
• Reusable Pipelines: Save valuable engineering time by providing shareable, tested pipelines and methods.
• Built-in Safeguards: Mitigate common pitfalls like data leakage and time-series-specific overfitting.
• Production-Ready: Designed for easy deployment using Docker or minimal distroless Linux images. FHIR Ready with lightweight python script convert to AlgoMarker format in deployment.
• Innovative Algorithms: Access to state of the art algorithms for processing medical data, explainability, fairness, and more
  • Read My Journey on Explainability

Core Components

The platform is built on three key pillars:

• MedRepository: A compact, efficient data repository and API for storing and accessing EMR signals. Querying categorical signals like perscriptions and diagnosis in an easy and efficient API.
• MedModel: An end-to-end machine learning pipeline that takes data from MedRepository or JSON EMR inputs to produce predictions and explainability outputs. It supports both training and inference.
• Medial Tools: A suite of utilities for training, evaluation, and workflow management, including bootstrap analysis, fairness checks, and explainability. MedPython is the Python alternative to replace all those tools.

From Raw Data to Insight in Four Simple Steps

Our platform streamlines the development and deployment of clinical predictive models, transforming raw patient data into actionable insights. For live predictions (inference), you can use raw JSON data directly, bypassing the need for an optimized data store.

This structured approach ensures that data is processed efficiently, models are built systematically, and the results are both accurate and interpretable.

The Workflow

1. Start with Raw Patient Data

Begin with your data in a simple JSON format.

{
  "patient_id": "1",
  "data": {
    "signals": [
      {
        "code": "Hemoglobin",
        "unit": "g/dL",
        "data": [
          { "timestamp": [20240806], "value": ["14.1"] },
          { "timestamp": [20250806], "value": ["14.5"] }
        ]
      },
      {
        "code": "Diagnosis",
        "data": [
          { "timestamp": [20240701], "value": ["ICD10_CODE:J20"] },
          ...
        ]
      },
      ...
    ]
  }
}

Load it into our Optimized Store or use it "as is" in deployment.

2. Define Your Label

For each patient, and for any chosen prediction date (after which no future information is provided to the model), specify what the outcome label should be for training or testing

3. Define Your ML Pipeline

Configure your entire machine learning workflow from preprocessing and feature engineering to the final model using a single JSON configuration file. This approach ensures your experiments are reproducible and easy to version.

4. Get Explainable Predictions

Train your model using the Python SDK and generate predictions with clear, interpretable explanations. Example output.

This is an illustration of the final output in a visual format (Our infrastructure returns the data to create this):

For more details, refer to the Tutorials.

Setup

You can quickly install the package using pip:

pip install medpython

Install and compile from github source code:

python -m pip install -v "medpython @ git+https://github.com/Medial-EarlySign/medpython.git/#subdirectory=Internal/MedPyExport/generate_binding"

System Requirements

Platform Support for MedPython

Platform	x86_64 (Intel/AMD)	aarch64 (ARM / Apple Silicon)
Linux (glibc)	✅ Pre-built (Py 3.10-3.14)	✅ Pre-built (Py 3.12)
Linux (Alpine/musl)	🛠️ Compile Required	🛠️ Compile Required
Windows	✅ Pre-built (Py 3.10-3.13)	🛠️ Compile Required
macOS	🛠️ Compile Required	✅ Pre-built (Py 3.10-3.13)

Note: For any Compile Required or either not listed as Pre-built. Compliation is required. Compilation in Alpine was also tested, but pre-builds are not provided.

• Supported Systems: This linux pre-built version is available for modern Linux distributions (specifically manylinux2014 equivalents, such as CentOS >= 7 or Ubuntu >= 13.04).

Compilation for Other Systems More information in Installation

Release Notes

Please refer to Release Notes

Usage

import med
from AlgoMarker import AlgoMarker
from ETL_Infra import prepare_final_signals, prepare_dicts, finish_prepare_load, create_train_signal

More information on usage:

• ETL_Infra - To load data into medpython data format
  • API Documentation
• AlgoMarker
  • From usage in deployment/lighter API interface. Usefull for accessing prebuild models. API Documentation
• med library
  • Full library from training new models or using with existing models. Complete Example: From Data to Model
  • API Documentation

Getting Started

• Build a new model: Follow the step-by-step Tutorials to build a model from scratch.
• Use an existing model: Browse the collection of Models.

Community and Contributions

This is an open-source project, and we welcome contributions from the community.

• Report issues or ask questions: Please use our Github Discussions.
• Contribute to the code: Check out our repositories:
  • MedPython: The core infrastructure libraries.
  • MR_Tools: Tools and pipelines built on top of medpython.
  • MR_Scripts: Dev Ops tools