API Reference

Tensor::new

Create a new tensor from data.

fn Tensor::new(data: [T], requires_grad: bool = false) -> Tensor

let t = Tensor::new([1.0, 2.0, 3.0])
let grad_t = Tensor::new([1.0, 2.0], requires_grad: true)

Tensor::zeros / Tensor::ones

Create tensors filled with zeros or ones.

fn Tensor::zeros(shape: [int32], dtype: Type = float64) -> Tensor
fn Tensor::ones(shape: [int32], dtype: Type = float64) -> Tensor

let zeros = Tensor::zeros([3, 4])           // 3x4 tensor of 0.0
let ones = Tensor::ones([2, 3, 4])         // 2x3x4 tensor of 1.0
let int_zeros = Tensor::zeros([5], int32)  // Integer tensor

Tensor::randn / Tensor::rand

Create tensors with random values from normal or uniform distribution.

fn Tensor::randn(shape: [int32], mean: float64 = 0.0, std: float64 = 1.0) -> Tensor
fn Tensor::rand(shape: [int32], low: float64 = 0.0, high: float64 = 1.0) -> Tensor

let normal = Tensor::randn([100, 100])              // Normal(0, 1)
let custom_normal = Tensor::randn([10], 5.0, 2.0)   // Normal(5, 2)
let uniform = Tensor::rand([50, 50])                 // Uniform(0, 1)
let custom_uniform = Tensor::rand([10], -1.0, 1.0)  // Uniform(-1, 1)

NeuralNetwork

Create a simple feedforward neural network.

fn NeuralNetwork(layer_sizes: [int32]) -> Model

// Create 3-layer network: 784 -> 128 -> 10
let model = NeuralNetwork([784, 128, 10])

model.add_layer(Dense(784, 128, activation: "relu"))
model.add_layer(Dense(128, 10, activation: "softmax"))

model.compile(
    optimizer: Adam(learning_rate: 0.001),
    loss: "categorical_crossentropy"
)

Sequential

Sequential model for stacking layers linearly.

fn Sequential(layers: [Layer]) -> Model

let model = Sequential([
    Dense(units: 128, activation: "relu", input_shape: [784]),
    Dropout(rate: 0.2),
    Dense(units: 64, activation: "relu"),
    Dense(units: 10, activation: "softmax")
])

model.compile(
    optimizer: Adam(lr: 0.001),
    loss: "sparse_categorical_crossentropy",
    metrics: ["accuracy"]
)

Gradient Computation

Compute gradients automatically using the computational graph.

// Enable gradient tracking
let x = Tensor::new([2.0, 3.0], requires_grad: true)
let y = Tensor::new([4.0, 5.0], requires_grad: true)

// Forward pass - builds computational graph
let z = x * y + x.pow(2)
let loss = z.sum()

// Backward pass - compute gradients
loss.backward()

// Access gradients
print(x.grad)  // dL/dx
print(y.grad)  // dL/dy

Custom Gradients

Define custom backward passes for new operations.

// Custom autograd function
struct MyFunction {
    fn forward(ctx: Context, x: Tensor) -> Tensor {
        ctx.save_for_backward([x])
        return x * x
    }

    fn backward(ctx: Context, grad_output: Tensor) -> Tensor {
        let saved = ctx.saved_tensors()
        let x = saved[0]
        return grad_output * 2 * x
    }
}

// Use custom function
let x = Tensor::new([1.0, 2.0, 3.0], requires_grad: true)
let y = MyFunction::apply(x)
y.sum().backward()

Optimizer Usage

// Initialize optimizer
let optimizer = Adam(
    params: model.parameters(),
    learning_rate: 0.001,
    betas: (0.9, 0.999),
    eps: 1e-8
)

// Training loop
for epoch in range(100) {
    // Forward pass
    let predictions = model(x_train)
    let loss = cross_entropy_loss(predictions, y_train)

    // Backward pass
    loss.backward()

    // Update parameters
    optimizer.step()

    // Clear gradients
    optimizer.zero_grad()
}

Layer Examples

// Dense (fully connected) layer
let dense = Dense(
    units: 128,
    activation: "relu",
    input_shape: [784]
)

// Convolutional layer
let conv = Conv2D(
    filters: 32,
    kernel_size: 3,
    activation: "relu",
    padding: "same"
)

// LSTM layer
let lstm = LSTM(
    input_size: 128,
    hidden_size: 256,
    num_layers: 2,
    bidirectional: true
)

// Multi-head attention
let attention = Attention(
    dim: 512,
    num_heads: 8,
    dropout: 0.1
)

Device Management

// Check GPU availability
if gpu::is_available() {
    print("GPU is available")
    print("GPU count:", gpu::device_count())
}

// Create tensor on GPU
let x = Tensor::randn([1000, 1000], device: "gpu")
let y = Tensor::randn([1000, 1000], device: "gpu")

// Operations automatically run on GPU
let z = x @ y  // Matrix multiplication on GPU

// Move tensor between devices
let cpu_tensor = x.to("cpu")
let gpu_tensor = cpu_tensor.to("gpu")

Performance Tips

KnowledgeGraph

Create and manipulate knowledge graphs.

// Create knowledge graph
let kg = KnowledgeGraph()

// Add entities
kg.add_entity("Paris", type: "City")
kg.add_entity("France", type: "Country")
kg.add_entity("Europe", type: "Continent")

// Add relations
kg.add_relation("Paris", "capital_of", "France")
kg.add_relation("France", "located_in", "Europe")

// Query
let capital = kg.query("?x capital_of France")
print(capital)  // ["Paris"]

// Get all relations for entity
let paris_relations = kg.get_relations("Paris")

// Embed knowledge graph
let embeddings = kg.embed(
    method: "TransE",
    dim: 128,
    epochs: 100
)

ChainOfThought

Multi-step reasoning with language models.

// Create chain-of-thought reasoner
let cot = ChainOfThought(
    model: language_model,
    max_steps: 10,
    temperature: 0.7
)

// Solve problem with reasoning steps
let problem = "What is 15% of 240?"
let solution = cot.solve(problem)

// Access reasoning steps
for step in solution.steps {
    print("Step:", step.description)
    print("Result:", step.result)
}

print("Final answer:", solution.answer)

LogicReasoner

First-order logic reasoning.

// Create logic reasoner
let reasoner = LogicReasoner()

// Add facts
reasoner.add_fact("mortal(socrates)")
reasoner.add_fact("human(socrates)")

// Add rules
reasoner.add_rule("forall X: human(X) -> mortal(X)")

// Query
let is_mortal = reasoner.query("mortal(socrates)")
print(is_mortal)  // true

// Infer new facts
let inferred = reasoner.infer_all()
for fact in inferred {
    print("Inferred:", fact)
}