Struct Graph 

pub struct Graph<C> { /* private fields */ }

graph like ai operation structure

Implementations

impl<C: AI<V, V> + Op<Output = V>, V: Clone + Default + Merge> Graph<C>

pub fn new() -> Self

creates a new empty graph

pub fn add_connection<'a>(&mut self, config: &ConnectionEditor<'a, C, V>)

adds a connection between two vertices

pub fn add_layer<X: Into<C>, L: Into<Label>>(&mut self, label: L, layer: X)

adds a layer without connecting it

pub fn connect<I: Into<Label>, O: Into<Label>>( &mut self, input: I, output: O, ) -> ConnectionEditor<'_, C, V>

adds a connection between vertices

pub fn connections<'a>( &'a self, ) -> impl Iterator<Item = ConnectionInfo<'a, C, V>>

returns an iterator over the connections in an arbitrary order

pub fn get_connection<'a>( &'a self, label: &Label, ) -> Option<ConnectionInfo<'a, C, V>>

gets connection information by label

pub fn get_layer(&self, label: &Label) -> Option<&C>

gets the layer information by label

pub fn merge<A: Into<C>>(&mut self, graph: Graph<A>)

another graphs into this one

pub fn order(&self) -> &[Label]

gets the connection order

pub fn split<F: FnMut(bool, &Label, &Label, &C, &Label, &Label) -> bool>( &mut self, predicate: F, ) -> Self

where C: Clone,

splits the graph according to the predicate(clear, connectionlabel, inputlabel, layer, layerlabel, outputlabel). true will be sent to the returned graph. the resulting graphs will only have the layers they use

pub fn sort(&mut self)

topologically sorts the graph. Inputs to the same node will retain their relative order.

Trait Implementations

impl<C: AI<V, V> + Op<Output = V>, V: Clone + Default + Merge, S: BuildHasher> AI<HashMap<Label, V, S>, HashMap<Label, V, S>> for Graph<C>

fn forward(&self, map: HashMap<Label, V, S>) -> HashMap<Label, V, S>

applies to the input

fn forward_mut(&mut self, map: HashMap<Label, V, S>) -> HashMap<Label, V, S>

applies to the input, possibly updating internal caches

impl<C: AI<V, V> + Op<Output = V>, V: Clone + Default + Merge> AI<Vec<V>, Vec<V>> for Graph<C>

fn forward(&self, values: Vec<V>) -> Vec<V>

applies to the input

fn forward_mut(&mut self, values: Vec<V>) -> Vec<V>

applies to the input, possibly updating internal caches

impl<C: Clone> Clone for Graph<C>

fn clone(&self) -> Graph<C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug> Debug for Graph<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C: Decompose> Decompose for Graph<C>

type Decomposition = (Vec<(String, (u64, String, String, String))>, Vec<(String, <C as Decompose>::Decomposition)>)

the decomposed type

fn compose((connections, layers): Self::Decomposition) -> Self

recreates from the decomposition

fn decompose(self) -> Self::Decomposition

owned decomposition

fn decompose_cloned(&self) -> Self::Decomposition

decomposition that copies data

impl<C: AI<V, V> + Op<Output = V>, V: Clone + Default + Merge> Default for Graph<C>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, C> Deserialize<'de> for Graph<C>

where C: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Into<C>, C: AI<V, V> + Op<Output = V>, V: Clone + Default + Merge> Extend<Graph<A>> for Graph<C>

fn extend<I: IntoIterator<Item = Graph<A>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<A: Into<C>, C: AI<V, V> + Op<Output = V>, V: Clone + Default + Merge> FromIterator<Graph<A>> for Graph<C>

fn from_iter<I: IntoIterator<Item = Graph<A>>>(iter: I) -> Self

Creates a value from an iterator.

impl<C: Op> Op for Graph<C>

type Output = Vec<<C as Op>::Output>

suggested output type to help with composition coherence. Ideally, Self should implement AI<X,Self::Output> for some X

fn abnormal_softmax(self, temperature: f32) -> AbnormalSoftmax<Self>

where Self: Sized, AbnormalSoftmax<Self>: Op,

wraps with a softmax operation

fn acc_q(self, gamma: f32) -> AccQ<Self>

where AccQ<Self>: Op, Self: Sized,

wraps with a accq operation

fn chain<B>(self, b: B) -> Sequential<(Self, B)>

where Self: Sized, Sequential<(Self, B)>: Op,

sequences with another ai operation

fn duplicate(self) -> Duplicate<Self>

where Duplicate<Self>: Op, Self: Sized,

wraps with a duplicate operation

fn fix_type<Z>(self) -> SetType<Self, Z, Z>

where Self: AI<Z, Z> + Sized,

set type but with the same input and output

fn flatten<R: Clone>(self, args: R) -> Flatten<Self, R>

where Flatten<Self, R>: Op, Self: Sized,

wraps with a flatten layer

fn forward_fixed<Z>(&self, input: Z) -> Z

where Self: AI<Z, Z> + Sized,

applies to the input

fn forward_fixed_mut<Z>(&mut self, input: Z) -> Z

where Self: AI<Z, Z> + Sized,

applies to the input

fn forward_typed<W, Z>(&self, input: W) -> Z

where Self: AI<W, Z> + Sized,

applies to the input

fn forward_typed_mut<W, Z>(&mut self, input: W) -> Z

where Self: AI<W, Z> + Sized,

applies to the input, possibly updating internal caches

fn infer_autoregressive<X, Y>(self, input: X) -> Autoregression<Self, Y>

where Self: AI<X, Y> + AI<Y, Y> + Sized, Y: Clone,

creates an autoregressive inference

fn log_softmax(self, temperature: f32) -> LogSoftmax<Self>

where Self: Sized, LogSoftmax<Self>: Op,

wraps with a softmax operation

fn map<B>(self, b: B) -> Map<Sequential<(Self, B)>>

where Map<Sequential<(Self, B)>>: Op, Self: Sized, Sequential<(Self, B)>: Op,

applies the operation to every output

fn mean(self) -> Mean<Self>

where Mean<Self>: Op, Self: Sized,

wraps with a mean operation

fn optional(self) -> Option<Self>

where Self: Sized,

creates an optional operation

fn reshape<R: Clone>(self, args: R) -> Reshape<Self, R>

where Reshape<Self, R>: Op, Self: Sized,

wraps with a reshape layer

fn residual(self) -> Residual<Self>

where Residual<Self>: Op, Self: Sized,

wraps in a residual layer

fn set_type<W, Z>(self) -> SetType<Self, W, Z>

where Self: AI<W, Z> + Sized,

sets the input output types

fn softmax(self, temperature: f32) -> Softmax<Self>

where Self: Sized, Softmax<Self>: Op,

wraps with a softmax operation

fn squared_error(self) -> SquaredError<Self>

where SquaredError<Self>: Op, Self: Sized,

wraps with a mse operation

fn squeeze(self, dim: i32) -> Squeeze<Self>

where Squeeze<Self>: Op, Self: Sized,

wraps with a squeeze operation

fn to_each(self) -> Map<Self>

where Map<Self>: Op, Self: Sized,

wraps with a map operation

fn unsqueeze(self, dim: i32) -> Unsqueeze<Self>

where Unsqueeze<Self>: Op, Self: Sized,

wraps with a unsqueeze operation

fn sum(self) -> Sum<Self>

where Sum<Self>: Op, Self: Sized,

wraps with a sum operation

fn wrap_inner(self) -> Inner<Self>

where Self: Sized,

wraps the inner value so it can be unwrapped with unwrap inner

fn zip<B>(self, b: B) -> Zip<(Self, B)>

where Self: Sized, Zip<(Self, B)>: Op,

zips with another ai operation

impl<C: PartialEq> PartialEq for Graph<C>

fn eq(&self, other: &Graph<C>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<C> Serialize for Graph<C>

where C: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<W: Wrappable> Wrappable for Graph<W>

type B = <W as Wrappable>::B

type With<C: Backend> = Graph<<W as Wrappable>::With<C>>

impl<C: Eq> Eq for Graph<C>

impl<C> StructuralPartialEq for Graph<C>