Packages

package root

Definition Classes: root

package lamp

Lamp provides utilities to build state of the art machine learning applications

Overview

Notable types and packages:

lamp.STen is a memory managed wrapper around aten.ATen, an off the heap, native n-dimensionl array backed by libtorch.
lamp.autograd implements reverse mode automatic differentiation.
lamp.nn contains neural network building blocks, see e.g. lamp.nn.Linear.
lamp.data.IOLoops implements a training loop and other data related abstractions.
lamp.knn implements k-nearest neighbor search on the CPU and GPU
lamp.umap.Umap implements the UMAP dimension reduction algorithm
lamp.onnx implements serialization of computation graphs into ONNX format
lamp.io contains CSV and NPY readers

How to get data into lamp

Use one of the file readers in lamp.io or one of the factories in lamp.STen$.

How to define a custom neural network layer

See the documentation on lamp.nn.GenericModule

How to compose neural network layers

See the documentation on lamp.nn

How to train models

See the training loops in lamp.data.IOLoops

Definition Classes: root

package autograd

Implements reverse mode automatic differentiaton

The main types in this package are lamp.autograd.Variable and lamp.autograd.Op. The computational graph built by this package consists of vertices representing values (as lamp.autograd.Variable) and vertices representing operations (as lamp.autograd.Op).

Variables contain the value of a Rⁿ => R^m function. Variables may also contain the partial derivative of their argument with respect to a single scalar. A Variable whose value is a scalar (m=1) can trigger the computation of partial derivatives of all the intermediate upstream Variables. Computing partial derivatives with respect to non-scalar variables is not supported.

A constant Variable may be created with the const or param factory method in this package. const may be used for constants which do not need their partial derivatives to be computed. param on the other hand create Variables which will fill in their partial derivatives. Further variables may be created by the methods in this class, eventually expressing more complex Rⁿ => R^m functions.

Example

lamp.Scope.root{ implicit scope =>
  // x is constant (depends on no other variables) and won't compute a partial derivative
  val x = lamp.autograd.const(STen.eye(3, STenOptions.d))
  // y is constant but will compute a partial derivative
  val y = lamp.autograd.param(STen.ones(List(3,3), STenOptions.d))

  // z is a Variable with x and y dependencies
  val z = x+y

  // w is a Variable with z as a direct and x, y as transient dependencies
  val w = z.sum
  // w is a scalar (number of elements is 1), thus we can call backprop() on it.
  // calling backprop will fill out the partial derivatives of the upstream variables
  w.backprop()

  // partialDerivative is empty since we created `x` with `const`
  assert(x.partialDerivative.isEmpty)

  // `y`'s partial derivatie is defined and is computed
  // it holds `y`'s partial derivative with respect to `w`, the scalar which we called backprop() on
  assert(y.partialDerivative.isDefined)

}

This package may be used to compute the derivative of any function, provided the function can be composed out of the provided methods. A particular use case is gradient based optimization.

Definition Classes: lamp
See also: https://arxiv.org/pdf/1811.05031.pdf for a review of the algorithm
lamp.autograd.Op for how to implement a new operation

package data

Definition Classes: lamp

package distributed

Definition Classes: lamp

package extratrees

Definition Classes: lamp

package knn

Definition Classes: lamp

package nn

Provides building blocks for neural networks

Notable types:

nn.GenericModule is an abstraction on parametric functions
nn.Optimizer is an abstraction of gradient based optimizers
nn.LossFunction is an abstraction of loss functions, see the companion object for the implemented losses
nn.SupervisedModel combines a module with a loss

Optimizers:

Modules facilitating composing other modules:

nn.Sequential composes a homogenous list of modules (analogous to List)
nn.sequence composes a heterogeneous list of modules (analogous to tuples)
nn.EitherModule composes two modules in a scala.Either

Examples of neural network building blocks, layers etc:

nn.Linear implements W X + b with parameters W and b and input X
nn.BatchNorm, nn.LayerNorm implement batch and layer normalization
nn.MLP is a factory of a multilayer perceptron architecture

Definition Classes: lamp

package onnx

Definition Classes: lamp

package saddle

Definition Classes: lamp

package umap

Definition Classes: lamp

package util

Definition Classes: lamp

CPU

FloatingPointPrecision

MPS

Scope

Companion object Scope

final class Scope extends AnyRef

Faciliates memory management of off-heap data structures.

Tracks allocations of aten.Tensor and aten.TensorOption instances.

aten.Tensor and aten.TensorOption instances are not freed up by the garbage collector. Lamp implements zoned memory management around these object. The managed counterpart of aten.Tensor is lamp.STen, while for aten.TensorOption it is lamp.STenOptions.

One can only create a lamp.STen instance with a lamp.Scope in implicit scope.

Create new scopes with lamp.Scope.root, lamp.Scope.apply or lamp.Scope.root.

Examples

// Scope.root returns Unit
Scope.root { implicit scope =>
    val sum = Scope { implicit scope =>
    // Intermediate values allocated in this block (`ident` and `ones`) are freed when
    // this block returns
    // The return value (`ident + ones`) of this block is moved to the outer scope
    val ident = STen.eye(3, STenOptions.d)
    val ones = STen.ones(List(3, 3), STenOptions.d)
    ident + ones
    }
    assert(sum.toMat == mat.ones(3, 3) + mat.ident(3))
    // `sum` is freed once this block exits
}

Linear Supertypes

AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

Scope
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Type Members

type ResourceType = Either[Tensor, TensorOptions]

Value Members

final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##: Int
Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
def apply(resource: TensorOptions): TensorOptions
Adds a resource to the managed resources, then returns it unchanged.
Adds a resource to the managed resources, then returns it unchanged.
The resources will be released when this Scope goes out of scope or otherwise releases.
def apply(resource: Tensor): Tensor
Adds a resource to the managed resources, then returns it unchanged.
Adds a resource to the managed resources, then returns it unchanged.
The resources will be released when this Scope goes out of scope or otherwise releases.
final def asInstanceOf[T0]: T0
Definition Classes
Any
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @IntrinsicCandidate() @native()
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@IntrinsicCandidate() @native()
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@IntrinsicCandidate() @native()
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@IntrinsicCandidate() @native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@IntrinsicCandidate() @native()
def register(resource: TensorOptions): Unit
Adds a resource to the managed resources.
Adds a resource to the managed resources.
The resources will be released when this Scope goes out of scope or otherwise releases.
def register(resource: Tensor): Unit
Adds a resource to the managed resources.
Adds a resource to the managed resources.
The resources will be released when this Scope goes out of scope or otherwise releases.
def release(): Unit
Immediately release the resources managed by this Scope
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def toString(): String
Definition Classes
AnyRef → Any
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable]) @Deprecated
Deprecated
(Since version 9)

Packages

Overview

How to get data into lamp

How to define a custom neural network layer

How to compose neural network layers

How to train models

Example

Scope

Companion object Scope

final class Scope extends AnyRef

Examples

Type Members

Value Members

Deprecated Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Overview

How to get data into lamp

How to define a custom neural network layer

How to compose neural network layers

How to train models

Example

Scope

Companion object Scope

final class Scope extends AnyRef

Examples

Type Members

Value Members

Deprecated Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Scope