burn/burn-core/Cargo.toml

[package]
authors = ["nathanielsimard <nathaniel.simard.42@gmail.com>"]
categories = ["science", "no-std", "embedded", "wasm"]
description = "Flexible and Comprehensive Deep Learning Framework in Rust"
edition = "2021"
keywords = ["deep-learning", "machine-learning", "tensor", "pytorch", "ndarray"]
license = "MIT OR Apache-2.0"
name = "burn-core"
readme = "README.md"
repository = "https://github.com/burn-rs/burn/tree/main/burn-core"
version = "0.10.0"

[features]
default = ["std", "dataset-minimal"]
std = [
  "burn-common/std",
  "burn-tensor/std",
  "flate2",
  "log",
  "rand/std",
  "rmp-serde",
  "serde/std",
  "serde_json/std",
  "bincode/std",
  "half/std",
  "derive-new/std",
]
dataset = ["burn-dataset/default"]
dataset-minimal = ["burn-dataset"]
dataset-sqlite = ["burn-dataset/sqlite"]
dataset-sqlite-bundled = ["burn-dataset/sqlite-bundled"]

# Backend
autodiff = ["burn-autodiff"]

ndarray = ["__ndarray", "burn-ndarray/default"]
ndarray-no-std = ["__ndarray", "burn-ndarray"]
ndarray-blas-accelerate = ["__ndarray", "ndarray", "burn-ndarray/blas-accelerate"]
ndarray-blas-netlib = ["__ndarray", "ndarray", "burn-ndarray/blas-netlib"]
ndarray-blas-openblas = ["__ndarray", "ndarray", "burn-ndarray/blas-openblas"]
ndarray-blas-openblas-system = ["__ndarray", "ndarray", "burn-ndarray/blas-openblas-system"]
__ndarray = [] # Internal flag to know when one ndarray feature is enabled.

wgpu = ["burn-wgpu/default"]

tch = ["burn-tch"]

# Serialization formats
experimental-named-tensor = ["burn-tensor/experimental-named-tensor"]

test-tch = ["tch"]    # To use tch during testing, default uses ndarray.
test-wgpu = ["wgpu"]   # To use wgpu during testing, default uses ndarray.

[dependencies]

# ** Please make sure all dependencies support no_std when std is disabled **

burn-common = { path = "../burn-common", version = "0.10.0", default-features = false }
burn-dataset = { path = "../burn-dataset", version = "0.10.0", optional = true, default-features = false }
burn-derive = { path = "../burn-derive", version = "0.10.0" }
burn-tensor = { path = "../burn-tensor", version = "0.10.0", default-features = false }

# Backends
burn-ndarray = { path = "../burn-ndarray", version = "0.10.0", optional = true, default-features = false }
burn-autodiff = { path = "../burn-autodiff", version = "0.10.0", optional = true }
burn-wgpu = { path = "../burn-wgpu", version = "0.10.0", optional = true }
burn-tch = { path = "../burn-tch", version = "0.10.0", optional = true }

derive-new = { workspace = true, default-features = false }
libm = { workspace = true }
log = { workspace = true, optional = true }
rand = { workspace = true, features = ["std_rng"] } # Default enables std  
# Using in place of use std::sync::Mutex when std is disabled
spin = { workspace = true, features = ["mutex", "spin_mutex"] }

# The same implementation of HashMap in std but with no_std support (only alloc crate is needed)
hashbrown = { workspace = true, features = ["serde"] } # no_std compatible

# Serialize Deserialize
flate2 = { workspace = true, optional = true }
serde = { workspace = true, features = ["derive"] }

bincode = { workspace = true }
half = { workspace = true }
rmp-serde = { workspace = true, optional = true }
serde_json = { workspace = true, features = ["alloc"] } #Default enables std 

[dev-dependencies]
tempfile = { workspace = true }
burn-dataset = { path = "../burn-dataset", version = "0.10.0", features = [
  "fake",
] }

burn-ndarray = { path = "../burn-ndarray", version = "0.10.0", default-features = false }
burn-autodiff = { path = "../burn-autodiff", version = "0.10.0" }