Proposal - Supporting user-provided ML models in workflows

[tanishqgandhi1908]

Goal

Make Texera a platform where a user can bring their own trained model and run it inside a workflow — upload the model, pick it in an operator, and get predictions on the data stream.

Context

• We already have a Hugging Face operator for hosted/third-party models — that's a separate, ongoing effort.
• This proposal is about models the user uploads themselves (their own trained weights), stored and versioned in Texera like datasets.

Scope

• Step 1: PyTorch — first framework we support end-to-end.
• Next: TensorFlow, then scikit-learn — same flow, more loaders.

flowchart TD
  Texera(["Texera"])

  subgraph Packaging
    HF[Hugging Face]
    MLflow[MLflow]
    ONNX[ONNX]
  end

  subgraph Libraries
    TF[TensorFlow]
    PT[PyTorch]
    SK[scikit-learn]
  end

  subgraph Models["Model categories"]
    LLM[LLM]
    REG[Regression]
    CLS[Classification]
    TREE[Tree]
  end

  Texera --> HF
  Texera --> MLflow
  Texera --> ONNX

  HF --> TF
  HF --> PT
  MLflow --> TF
  MLflow --> PT
  MLflow --> SK
  ONNX --> PT
  ONNX --> SK

  TF --> LLM
  TF --> REG
  TF --> CLS
  PT --> LLM
  PT --> REG
  PT --> CLS
  SK --> REG
  SK --> CLS
  SK --> TREE

Loading

Storage

Models are stored exactly like datasets — versioned in LakeFS with the bytes in MinIO — so we reuse the existing upload, versioning, and access-control stack. A model is simply an asset tagged with a type (DATASET or MODEL); To namespace by type, logical file paths now carry a resource-type prefix — /datasets/<owner>/<name>/<version>/<file> and, for models,
/models/<owner>/<name>/<version>/<file> — resolved through the same path → LakeFS → MinIO chain. A dedicated Models section in the UI mirrors Datasets for browsing and uploading.

Design (from #4198)

Two user experiences

Both reuse the existing dataset storage (LakeFS/MinIO); a model is just an uploaded asset the operator/UDF fetches at run time.

1. No-code operator — drag a "Model Inference" operator, select the uploaded model, choose the input columns and the output column. No code. Best for non-technical users.

2. Python UDF — select the model in the UDF's property panel; the framework fetches + loads it and exposes it to your code, so you only write the inference logic. For users who need custom pre/post-processing.

Feedback wanted

We'd love feedback on the overall idea and the proposed architecture:

• Library order: does PyTorch → TensorFlow → scikit-learn match what users need most?
• Two UX: any concerns with offering both the no-code operator and the UDF (vs. just one)?

All thoughts, concerns, and alternative approaches welcome.