Tensorless

Tensorless trains small custom models with sensible defaults. It uses a native NumPy engine on CPU and optional JAX or MLX backends for accelerator execution. It supports text generation, text classification, tabular classification, and regression.

Install

pip install -e .

Optional accelerator backends:

pip install -e '.[cuda]'# JAX CUDA
pip install -e '.[tpu]'# JAX TPU
pip install -e '.[mps]'# Apple Silicon MLX

CUDA, TPU, and MPS backends accelerate both transformer text tasks and tabular MLP tasks. Whatever device is auto-detected (or passed via device=...) is what training and inference actually run on; only unsupported platforms (no CUDA/TPU/MPS available) fall back to the native CPU engine.

Train on your data

importtensorlessastlmodel=tl.train("./corpus.txt", task="text-generation")
print(model.generate("The", max_new_tokens=40))

Text files are trained as next-token language models. BPE is the default tokenizer; use tokenizer="char" for a character-level model. Tensorless derives model size, batch size, epochs, validation, device, and BPE vocabulary size from the data, while every setting can be overridden.

Long text is tokenized lazily and fed through the native engine in fixed-size batches. The automatic batch size uses a token budget; reduce batch_size if your available memory is limited.

English starter pretraining

importtensorlessastlmodel=tl.pretrain(out="english.tl", epochs=20, max_seq_len=128)
print(model.generate("A complete sentence", max_new_tokens=30))

This offline starter corpus contains English prose and grammar examples. It is for demos and smoke tests, not a replacement for a large language dataset. For real pretraining, pass your own .txt corpus to tl.train() and increase the training settings as your hardware allows.

Other tasks

tl.train("reviews/", task="text-classification")
tl.train("housing.csv", task="regression")

Tabular preprocessing automatically handles numeric values, ISO dates, and high-cardinality categories. Missing and rare values are handled using the fitted training data, and the same preprocessing is stored in the .tl file.

Models are saved as .tl files and can be loaded later:

model=tl.load("model.tl")
print(model.info())

The native extension API is in tensorless.engine: Module, Parameter, Adam, and SGD provide model parameters, gradients, and optimization without a PyTorch dependency. Accelerator cache helpers are available as tensorless.devices.clear_memory() and tensorless.devices.memory_stats().

See the documentation for data formats, configuration, checkpointing, and the command-line interface.

Tensorless

Tensorless trains small custom models with sensible defaults. It uses a native NumPy engine on CPU and optional JAX or MLX backends for accelerator execution. It supports text generation, text classification, tabular classification, and regression.

Install

pip install -e .

Optional accelerator backends:

pip install -e '.[cuda]'# JAX CUDA
pip install -e '.[tpu]'# JAX TPU
pip install -e '.[mps]'# Apple Silicon MLX

CUDA, TPU, and MPS backends accelerate both transformer text tasks and tabular MLP tasks. Whatever device is auto-detected (or passed via device=...) is what training and inference actually run on; only unsupported platforms (no CUDA/TPU/MPS available) fall back to the native CPU engine.

Train on your data

importtensorlessastlmodel=tl.train("./corpus.txt", task="text-generation")
print(model.generate("The", max_new_tokens=40))

Text files are trained as next-token language models. BPE is the default tokenizer; use tokenizer="char" for a character-level model. Tensorless derives model size, batch size, epochs, validation, device, and BPE vocabulary size from the data, while every setting can be overridden.

Long text is tokenized lazily and fed through the native engine in fixed-size batches. The automatic batch size uses a token budget; reduce batch_size if your available memory is limited.

English starter pretraining

importtensorlessastlmodel=tl.pretrain(out="english.tl", epochs=20, max_seq_len=128)
print(model.generate("A complete sentence", max_new_tokens=30))

This offline starter corpus contains English prose and grammar examples. It is for demos and smoke tests, not a replacement for a large language dataset. For real pretraining, pass your own .txt corpus to tl.train() and increase the training settings as your hardware allows.

Other tasks

tl.train("reviews/", task="text-classification")
tl.train("housing.csv", task="regression")

Tabular preprocessing automatically handles numeric values, ISO dates, and high-cardinality categories. Missing and rare values are handled using the fitted training data, and the same preprocessing is stored in the .tl file.

Models are saved as .tl files and can be loaded later:

model=tl.load("model.tl")
print(model.info())

The native extension API is in tensorless.engine: Module, Parameter, Adam, and SGD provide model parameters, gradients, and optimization without a PyTorch dependency. Accelerator cache helpers are available as tensorless.devices.clear_memory() and tensorless.devices.memory_stats().

See the documentation for data formats, configuration, checkpointing, and the command-line interface.

Tensorless

Tensorless trains small custom models with sensible defaults. It uses a native NumPy engine on CPU and optional JAX or MLX backends for accelerator execution. It supports text generation, text classification, tabular classification, and regression.

Install

pip install -e .

Optional accelerator backends:

pip install -e '.[cuda]'# JAX CUDA
pip install -e '.[tpu]'# JAX TPU
pip install -e '.[mps]'# Apple Silicon MLX

CUDA, TPU, and MPS backends accelerate both transformer text tasks and tabular MLP tasks. Whatever device is auto-detected (or passed via device=...) is what training and inference actually run on; only unsupported platforms (no CUDA/TPU/MPS available) fall back to the native CPU engine.

Train on your data

importtensorlessastlmodel=tl.train("./corpus.txt", task="text-generation")
print(model.generate("The", max_new_tokens=40))

Text files are trained as next-token language models. BPE is the default tokenizer; use tokenizer="char" for a character-level model. Tensorless derives model size, batch size, epochs, validation, device, and BPE vocabulary size from the data, while every setting can be overridden.

Long text is tokenized lazily and fed through the native engine in fixed-size batches. The automatic batch size uses a token budget; reduce batch_size if your available memory is limited.

English starter pretraining

importtensorlessastlmodel=tl.pretrain(out="english.tl", epochs=20, max_seq_len=128)
print(model.generate("A complete sentence", max_new_tokens=30))

This offline starter corpus contains English prose and grammar examples. It is for demos and smoke tests, not a replacement for a large language dataset. For real pretraining, pass your own .txt corpus to tl.train() and increase the training settings as your hardware allows.

Other tasks

tl.train("reviews/", task="text-classification")
tl.train("housing.csv", task="regression")

Tabular preprocessing automatically handles numeric values, ISO dates, and high-cardinality categories. Missing and rare values are handled using the fitted training data, and the same preprocessing is stored in the .tl file.

Models are saved as .tl files and can be loaded later:

model=tl.load("model.tl")
print(model.info())

The native extension API is in tensorless.engine: Module, Parameter, Adam, and SGD provide model parameters, gradients, and optimization without a PyTorch dependency. Accelerator cache helpers are available as tensorless.devices.clear_memory() and tensorless.devices.memory_stats().

See the documentation for data formats, configuration, checkpointing, and the command-line interface.

Tensorless

Tensorless trains small custom models with sensible defaults. It uses a native NumPy engine on CPU and optional JAX or MLX backends for accelerator execution. It supports text generation, text classification, tabular classification, and regression.

Install

pip install -e .

Optional accelerator backends:

pip install -e '.[cuda]'# JAX CUDA
pip install -e '.[tpu]'# JAX TPU
pip install -e '.[mps]'# Apple Silicon MLX

CUDA, TPU, and MPS backends accelerate both transformer text tasks and tabular MLP tasks. Whatever device is auto-detected (or passed via device=...) is what training and inference actually run on; only unsupported platforms (no CUDA/TPU/MPS available) fall back to the native CPU engine.

Train on your data

importtensorlessastlmodel=tl.train("./corpus.txt", task="text-generation")
print(model.generate("The", max_new_tokens=40))

Text files are trained as next-token language models. BPE is the default tokenizer; use tokenizer="char" for a character-level model. Tensorless derives model size, batch size, epochs, validation, device, and BPE vocabulary size from the data, while every setting can be overridden.

Long text is tokenized lazily and fed through the native engine in fixed-size batches. The automatic batch size uses a token budget; reduce batch_size if your available memory is limited.

English starter pretraining

importtensorlessastlmodel=tl.pretrain(out="english.tl", epochs=20, max_seq_len=128)
print(model.generate("A complete sentence", max_new_tokens=30))

This offline starter corpus contains English prose and grammar examples. It is for demos and smoke tests, not a replacement for a large language dataset. For real pretraining, pass your own .txt corpus to tl.train() and increase the training settings as your hardware allows.

Other tasks

tl.train("reviews/", task="text-classification")
tl.train("housing.csv", task="regression")

Tabular preprocessing automatically handles numeric values, ISO dates, and high-cardinality categories. Missing and rare values are handled using the fitted training data, and the same preprocessing is stored in the .tl file.

Models are saved as .tl files and can be loaded later:

model=tl.load("model.tl")
print(model.info())

The native extension API is in tensorless.engine: Module, Parameter, Adam, and SGD provide model parameters, gradients, and optimization without a PyTorch dependency. Accelerator cache helpers are available as tensorless.devices.clear_memory() and tensorless.devices.memory_stats().

See the documentation for data formats, configuration, checkpointing, and the command-line interface.

Tensorless

Tensorless trains small custom models with sensible defaults. It uses a native NumPy engine on CPU and optional JAX or MLX backends for accelerator execution. It supports text generation, text classification, tabular classification, and regression.

Install

pip install -e .

Optional accelerator backends:

pip install -e '.[cuda]'# JAX CUDA
pip install -e '.[tpu]'# JAX TPU
pip install -e '.[mps]'# Apple Silicon MLX

CUDA, TPU, and MPS backends accelerate both transformer text tasks and tabular MLP tasks. Whatever device is auto-detected (or passed via device=...) is what training and inference actually run on; only unsupported platforms (no CUDA/TPU/MPS available) fall back to the native CPU engine.

Train on your data

importtensorlessastlmodel=tl.train("./corpus.txt", task="text-generation")
print(model.generate("The", max_new_tokens=40))

Text files are trained as next-token language models. BPE is the default tokenizer; use tokenizer="char" for a character-level model. Tensorless derives model size, batch size, epochs, validation, device, and BPE vocabulary size from the data, while every setting can be overridden.

Long text is tokenized lazily and fed through the native engine in fixed-size batches. The automatic batch size uses a token budget; reduce batch_size if your available memory is limited.

English starter pretraining

importtensorlessastlmodel=tl.pretrain(out="english.tl", epochs=20, max_seq_len=128)
print(model.generate("A complete sentence", max_new_tokens=30))

This offline starter corpus contains English prose and grammar examples. It is for demos and smoke tests, not a replacement for a large language dataset. For real pretraining, pass your own .txt corpus to tl.train() and increase the training settings as your hardware allows.

Other tasks

tl.train("reviews/", task="text-classification")
tl.train("housing.csv", task="regression")

Tabular preprocessing automatically handles numeric values, ISO dates, and high-cardinality categories. Missing and rare values are handled using the fitted training data, and the same preprocessing is stored in the .tl file.

Models are saved as .tl files and can be loaded later:

model=tl.load("model.tl")
print(model.info())

The native extension API is in tensorless.engine: Module, Parameter, Adam, and SGD provide model parameters, gradients, and optimization without a PyTorch dependency. Accelerator cache helpers are available as tensorless.devices.clear_memory() and tensorless.devices.memory_stats().

See the documentation for data formats, configuration, checkpointing, and the command-line interface.

Tensorless

Tensorless trains small custom models with sensible defaults. It uses a native NumPy engine on CPU and optional JAX or MLX backends for accelerator execution. It supports text generation, text classification, tabular classification, and regression.

Install

pip install -e .

Optional accelerator backends:

pip install -e '.[cuda]'# JAX CUDA
pip install -e '.[tpu]'# JAX TPU
pip install -e '.[mps]'# Apple Silicon MLX

CUDA, TPU, and MPS backends accelerate both transformer text tasks and tabular MLP tasks. Whatever device is auto-detected (or passed via device=...) is what training and inference actually run on; only unsupported platforms (no CUDA/TPU/MPS available) fall back to the native CPU engine.

Train on your data

importtensorlessastlmodel=tl.train("./corpus.txt", task="text-generation")
print(model.generate("The", max_new_tokens=40))

Text files are trained as next-token language models. BPE is the default tokenizer; use tokenizer="char" for a character-level model. Tensorless derives model size, batch size, epochs, validation, device, and BPE vocabulary size from the data, while every setting can be overridden.

Long text is tokenized lazily and fed through the native engine in fixed-size batches. The automatic batch size uses a token budget; reduce batch_size if your available memory is limited.

English starter pretraining

importtensorlessastlmodel=tl.pretrain(out="english.tl", epochs=20, max_seq_len=128)
print(model.generate("A complete sentence", max_new_tokens=30))

This offline starter corpus contains English prose and grammar examples. It is for demos and smoke tests, not a replacement for a large language dataset. For real pretraining, pass your own .txt corpus to tl.train() and increase the training settings as your hardware allows.

Other tasks

tl.train("reviews/", task="text-classification")
tl.train("housing.csv", task="regression")

Tabular preprocessing automatically handles numeric values, ISO dates, and high-cardinality categories. Missing and rare values are handled using the fitted training data, and the same preprocessing is stored in the .tl file.

Models are saved as .tl files and can be loaded later:

model=tl.load("model.tl")
print(model.info())

The native extension API is in tensorless.engine: Module, Parameter, Adam, and SGD provide model parameters, gradients, and optimization without a PyTorch dependency. Accelerator cache helpers are available as tensorless.devices.clear_memory() and tensorless.devices.memory_stats().

See the documentation for data formats, configuration, checkpointing, and the command-line interface.

Tensorless

Tensorless trains small custom models with sensible defaults. It uses a native NumPy engine on CPU and optional JAX or MLX backends for accelerator execution. It supports text generation, text classification, tabular classification, and regression.

Install

pip install -e .

Optional accelerator backends:

pip install -e '.[cuda]'# JAX CUDA
pip install -e '.[tpu]'# JAX TPU
pip install -e '.[mps]'# Apple Silicon MLX

CUDA, TPU, and MPS backends accelerate both transformer text tasks and tabular MLP tasks. Whatever device is auto-detected (or passed via device=...) is what training and inference actually run on; only unsupported platforms (no CUDA/TPU/MPS available) fall back to the native CPU engine.

Train on your data

importtensorlessastlmodel=tl.train("./corpus.txt", task="text-generation")
print(model.generate("The", max_new_tokens=40))

Text files are trained as next-token language models. BPE is the default tokenizer; use tokenizer="char" for a character-level model. Tensorless derives model size, batch size, epochs, validation, device, and BPE vocabulary size from the data, while every setting can be overridden.

Long text is tokenized lazily and fed through the native engine in fixed-size batches. The automatic batch size uses a token budget; reduce batch_size if your available memory is limited.

English starter pretraining

importtensorlessastlmodel=tl.pretrain(out="english.tl", epochs=20, max_seq_len=128)
print(model.generate("A complete sentence", max_new_tokens=30))

This offline starter corpus contains English prose and grammar examples. It is for demos and smoke tests, not a replacement for a large language dataset. For real pretraining, pass your own .txt corpus to tl.train() and increase the training settings as your hardware allows.

Other tasks

tl.train("reviews/", task="text-classification")
tl.train("housing.csv", task="regression")

Tabular preprocessing automatically handles numeric values, ISO dates, and high-cardinality categories. Missing and rare values are handled using the fitted training data, and the same preprocessing is stored in the .tl file.

Models are saved as .tl files and can be loaded later:

model=tl.load("model.tl")
print(model.info())

The native extension API is in tensorless.engine: Module, Parameter, Adam, and SGD provide model parameters, gradients, and optimization without a PyTorch dependency. Accelerator cache helpers are available as tensorless.devices.clear_memory() and tensorless.devices.memory_stats().

See the documentation for data formats, configuration, checkpointing, and the command-line interface.

Tensorless

Tensorless trains small custom models with sensible defaults. It uses a native NumPy engine on CPU and optional JAX or MLX backends for accelerator execution. It supports text generation, text classification, tabular classification, and regression.

Install

pip install -e .

Optional accelerator backends:

pip install -e '.[cuda]'# JAX CUDA
pip install -e '.[tpu]'# JAX TPU
pip install -e '.[mps]'# Apple Silicon MLX

CUDA, TPU, and MPS backends accelerate both transformer text tasks and tabular MLP tasks. Whatever device is auto-detected (or passed via device=...) is what training and inference actually run on; only unsupported platforms (no CUDA/TPU/MPS available) fall back to the native CPU engine.

Train on your data

importtensorlessastlmodel=tl.train("./corpus.txt", task="text-generation")
print(model.generate("The", max_new_tokens=40))

Text files are trained as next-token language models. BPE is the default tokenizer; use tokenizer="char" for a character-level model. Tensorless derives model size, batch size, epochs, validation, device, and BPE vocabulary size from the data, while every setting can be overridden.

Long text is tokenized lazily and fed through the native engine in fixed-size batches. The automatic batch size uses a token budget; reduce batch_size if your available memory is limited.

English starter pretraining

importtensorlessastlmodel=tl.pretrain(out="english.tl", epochs=20, max_seq_len=128)
print(model.generate("A complete sentence", max_new_tokens=30))

This offline starter corpus contains English prose and grammar examples. It is for demos and smoke tests, not a replacement for a large language dataset. For real pretraining, pass your own .txt corpus to tl.train() and increase the training settings as your hardware allows.

Other tasks

tl.train("reviews/", task="text-classification")
tl.train("housing.csv", task="regression")

Tabular preprocessing automatically handles numeric values, ISO dates, and high-cardinality categories. Missing and rare values are handled using the fitted training data, and the same preprocessing is stored in the .tl file.

Models are saved as .tl files and can be loaded later:

model=tl.load("model.tl")
print(model.info())

The native extension API is in tensorless.engine: Module, Parameter, Adam, and SGD provide model parameters, gradients, and optimization without a PyTorch dependency. Accelerator cache helpers are available as tensorless.devices.clear_memory() and tensorless.devices.memory_stats().

See the documentation for data formats, configuration, checkpointing, and the command-line interface.

Name		Name	Last commit message	Last commit date
.github		.github
docs		docs
examples		examples
tensorless		tensorless
tests		tests
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
LICENSE		LICENSE
MANIFEST.in		MANIFEST.in
README.md		README.md
SECURITY.md		SECURITY.md
poetry.lock		poetry.lock
pyproject.toml		pyproject.toml

Name		Name	Last commit message	Last commit date
.github		.github
docs		docs
examples		examples
tensorless		tensorless
tests		tests
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
LICENSE		LICENSE
MANIFEST.in		MANIFEST.in
README.md		README.md
SECURITY.md		SECURITY.md
poetry.lock		poetry.lock
pyproject.toml		pyproject.toml

Name		Name	Last commit message	Last commit date
.github		.github
docs		docs
examples		examples
tensorless		tensorless
tests		tests
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
LICENSE		LICENSE
MANIFEST.in		MANIFEST.in
README.md		README.md
SECURITY.md		SECURITY.md
poetry.lock		poetry.lock
pyproject.toml		pyproject.toml

Name		Name	Last commit message	Last commit date
.github		.github
docs		docs
examples		examples
tensorless		tensorless
tests		tests
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
LICENSE		LICENSE
MANIFEST.in		MANIFEST.in
README.md		README.md
SECURITY.md		SECURITY.md
poetry.lock		poetry.lock
pyproject.toml		pyproject.toml

Name		Name	Last commit message	Last commit date
.github		.github
docs		docs
examples		examples
tensorless		tensorless
tests		tests
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
LICENSE		LICENSE
MANIFEST.in		MANIFEST.in
README.md		README.md
SECURITY.md		SECURITY.md
poetry.lock		poetry.lock
pyproject.toml		pyproject.toml

Uh oh!

Latest commit

History

Folders and files

Repository files navigation

Tensorless

Install

Train on your data

English starter pretraining

Other tasks

About

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

Watchers

Forks

Releases

Sponsor this project

Packages

Used by

Contributors

Languages

Uh oh!

Latest commit

History

Folders and files

Repository files navigation

Tensorless

Install

Train on your data

English starter pretraining

Other tasks

About

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

Watchers

Forks

Releases

Sponsor this project

Packages

Used by

Contributors

Languages

Uh oh!

Latest commit

History

Folders and files

Repository files navigation

Tensorless

Install

Train on your data

English starter pretraining

Other tasks

About

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

Watchers

Forks

Releases

Sponsor this project

Packages

Used by

Contributors

Languages

Uh oh!

Latest commit

History

Folders and files

Repository files navigation