block_graph/builtin/
mod.rs

1impl Decompose for Alignment{
2	fn compose(decomposition:Self::Decomposition)->Self{
3		match decomposition{0=>Self::Center,1=>Self::Left,2=>Self::Right,_=>panic!("unknown alignment number")}
4	}
5	fn decompose(self)->Self::Decomposition{
6		match self{Self::Center=>0,Self::Left=>1,Self::Right=>2}
7	}
8	fn decompose_cloned(&self)->Self::Decomposition{
9		match self{Self::Center=>0,Self::Left=>1,Self::Right=>2}
10	}
11	type Decomposition=usize;
12}
13impl Decompose for OnMismatch{// TODO with explicit u64 decomposition this could fit a f32 in the pad
14	fn compose(decomposition:Self::Decomposition)->Self{
15		match decomposition%10{0=>Self::Error,1=>Self::Pad(Alignment::compose(decomposition/10)),2=>Self::Truncate(Alignment::compose(decomposition/10)),_=>panic!("unknown mismatch number")}
16	}
17	fn decompose(self)->Self::Decomposition{
18		match self{Self::Error=>0,Self::Pad(a)=>a.decompose()*10+1,Self::Truncate(a)=>a.decompose()*10+2}
19	}
20	fn decompose_cloned(&self)->Self::Decomposition{self.clone().decompose()}
21	type Decomposition=usize;
22}
23impl Decompose for ReductionMode{
24	fn compose(decomposition:u64)->Self{
25		match decomposition>>32{0=>Self::Component,1=>Self::Dim(decomposition as i32),2=>Self::Tensor,_=>panic!("unknown reduction mode number")}
26	}
27	fn decompose(self)->Self::Decomposition{
28		match self{Self::Component=>0,Self::Dim(x)=>(1_u64<<32)|(x as u32 as u64),Self::Tensor=>2<<32}
29	}
30	fn decompose_cloned(&self)->Self::Decomposition{self.clone().decompose()}
31	type Decomposition=u64;
32}
33impl Default for Alignment{
34	fn default()->Self{Self::Left}
35}
36impl Default for OnMismatch{
37	fn default()->Self{Self::Error}
38}
39impl Default for ReductionMode{
40	fn default()->Self{Self::Component}
41}
42impl<M:AI<M::Output,M::Output>+Op> Sequential<Vec<M>>{
43	/// appends the module to the sequence, then returns the sequence
44	pub fn with_next<A:Into<M>>(mut self,m:A)->Self{
45		self.inner_mut().push(m.into());
46		self
47	}
48}
49impl<A:AI<R,S>+Op<Output=S>,B:AI<S,T>+Op<Output=T>,C:AI<T,U>+Op<Output=U>,D:AI<U,V>+Op<Output=V>,E:AI<V,W>+Op<Output=W>,F:AI<W,X>+Op<Output=X>,G:AI<X,Y>+Op<Output=Y>,H:AI<Y,Z>,R,S,T,U,V,W,X,Y,Z> AI<R,Z> for Sequential<(A,B,C,D,E,F,G,H)>{
50	fn forward(&self,input:R)->Z{
51		let (a,b,c,d,e,f,g,h)=self.inner();
52		h.forward(g.forward(f.forward(e.forward(d.forward(c.forward(b.forward(a.forward(input))))))))
53	}
54	fn forward_mut(&mut self,input:R)->Z{
55		let (a,b,c,d,e,f,g,h)=self.inner_mut();
56		h.forward(g.forward_mut(f.forward_mut(e.forward_mut(d.forward_mut(c.forward_mut(b.forward_mut(a.forward_mut(input))))))))
57	}
58}
59impl<A:AI<S,T>+Op<Output=T>,B:AI<T,U>+Op<Output=U>,C:AI<U,V>+Op<Output=V>,D:AI<V,W>+Op<Output=W>,E:AI<W,X>+Op<Output=X>,F:AI<X,Y>+Op<Output=Y>,G:AI<Y,Z>,S,T,U,V,W,X,Y,Z> AI<S,Z> for Sequential<(A,B,C,D,E,F,G)>{
60	fn forward(&self,input:S)->Z{
61		let (a,b,c,d,e,f,g)=self.inner();
62		g.forward(f.forward(e.forward(d.forward(c.forward(b.forward(a.forward(input)))))))
63	}
64	fn forward_mut(&mut self,input:S)->Z{
65		let (a,b,c,d,e,f,g)=self.inner_mut();
66		g.forward_mut(f.forward_mut(e.forward_mut(d.forward_mut(c.forward_mut(b.forward_mut(a.forward_mut(input)))))))
67	}
68}
69impl<A:AI<T,U>+Op<Output=U>,B:AI<U,V>+Op<Output=V>,C:AI<V,W>+Op<Output=W>,D:AI<W,X>+Op<Output=X>,E:AI<X,Y>+Op<Output=Y>,F:AI<Y,Z>,T,U,V,W,X,Y,Z> AI<T,Z> for Sequential<(A,B,C,D,E,F)>{
70	fn forward(&self,input:T)->Z{
71		let (a,b,c,d,e,f)=self.inner();
72		f.forward(e.forward(d.forward(c.forward(b.forward(a.forward(input))))))
73	}
74	fn forward_mut(&mut self,input:T)->Z{
75		let (a,b,c,d,e,f)=self.inner_mut();
76		f.forward_mut(e.forward_mut(d.forward_mut(c.forward_mut(b.forward_mut(a.forward_mut(input))))))
77	}
78}
79impl<A:AI<U,V>+Op<Output=V>,B:AI<V,W>+Op<Output=W>,C:AI<W,X>+Op<Output=X>,D:AI<X,Y>+Op<Output=Y>,E:AI<Y,Z>,U,V,W,X,Y,Z> AI<U,Z> for Sequential<(A,B,C,D,E)>{
80	fn forward(&self,input:U)->Z{
81		let (a,b,c,d,e)=self.inner();
82		e.forward(d.forward(c.forward(b.forward(a.forward(input)))))
83	}
84	fn forward_mut(&mut self,input:U)->Z{
85		let (a,b,c,d,e)=self.inner_mut();
86		e.forward_mut(d.forward_mut(c.forward_mut(b.forward_mut(a.forward_mut(input)))))
87	}
88}
89impl<A:AI<V,W>+Op<Output=W>,B:AI<W,X>+Op<Output=X>,C:AI<X,Y>+Op<Output=Y>,D:AI<Y,Z>,V,W,X,Y,Z> AI<V,Z> for Sequential<(A,B,C,D)>{
90	fn forward(&self,input:V)->Z{
91		let (a,b,c,d)=self.inner();
92		d.forward(c.forward(b.forward(a.forward(input))))
93	}
94	fn forward_mut(&mut self,input:V)->Z{
95		let (a,b,c,d)=self.inner_mut();
96		d.forward_mut(c.forward_mut(b.forward_mut(a.forward_mut(input))))
97	}
98}
99impl<A:AI<W,X>+Op<Output=X>,B:AI<X,Y>+Op<Output=Y>,C:AI<Y,Z>,W,X,Y,Z> AI<W,Z> for Sequential<(A,B,C)>{
100	fn forward(&self,input:W)->Z{
101		let (a,b,c)=self.inner();
102		c.forward(b.forward(a.forward(input)))
103	}
104	fn forward_mut(&mut self,input:W)->Z{
105		let (a,b,c)=self.inner_mut();
106		c.forward_mut(b.forward_mut(a.forward_mut(input)))
107	}
108}
109impl<A:AI<W,Z>+AI<X,Y>,W,X,Y,Z> AI<W,Z> for SetType<A,X,Y>{
110	fn forward(&self,input:W)->Z{self.inner().forward(input)}
111	fn forward_mut(&mut self,input:W)->Z{self.inner_mut().forward_mut(input)}
112}
113impl<A:AI<X,X>+Op<Output=X>,X> Op for Sequential<&[A]>{
114	type Output=X;
115}
116impl<A:AI<X,X>+Op<Output=X>,X> Op for Sequential<&mut [A]>{
117	type Output=X;
118}
119impl<A:AI<X,X>+Op<Output=X>,X> Op for Sequential<Vec<A>>{
120	type Output=X;
121}
122impl<A:AI<X,X>,X:Clone> Iterator for Autoregression<A,X>{
123	fn next(&mut self)->Option<Self::Item>{
124		let output=self.state.clone();
125		self.state=Some(self.ai.forward_mut(self.state.take().unwrap()));
126		output
127	}
128	fn size_hint(&self)->(usize,Option<usize>){(usize::MAX,None)}
129	type Item=X;
130}
131impl<A:AI<X,X>,X> AI<X,X> for Sequential<&[A]>{
132	fn forward(&self,input:X)->X{self.inner().iter().fold(input,|x,a|a.forward(x))}
133}
134impl<A:AI<X,X>,X> AI<X,X> for Sequential<&mut [A]>{
135	fn forward(&self,input:X)->X{self.inner().iter().fold(input,|x,a|a.forward(x))}
136	fn forward_mut(&mut self,input:X)->X{self.inner_mut().iter_mut().fold(input,|x,a|a.forward_mut(x))}
137}
138impl<A:AI<X,X>,X> AI<X,X> for Sequential<Vec<A>>{
139	fn forward(&self,input:X)->X{self.inner().iter().fold(input,|x,a|a.forward(x))}
140	fn forward_mut(&mut self,input:X)->X{self.inner_mut().iter_mut().fold(input,|x,a|a.forward_mut(x))}
141}
142impl<A:AI<X,Y>+Op<Output=Y>,B:AI<Y,Z>,X,Y,Z> AI<X,Z> for Sequential<(A,B)>{
143	fn forward(&self,input:X)->Z{
144		let (a,b)=self.inner();
145		b.forward(a.forward(input))
146	}
147	fn forward_mut(&mut self,input:X)->Z{
148		let (a,b)=self.inner_mut();
149		b.forward_mut(a.forward_mut(input))
150	}
151}
152impl<A:AI<X,Y>+Op<Output=Y>,I:IntoIterator<Item=X>,J:FromIterator<Y>,X,Y> AI<I,J> for Map<A>{
153	fn forward(&self,input:I)->J{
154		let a=self.inner();
155		input.into_iter().map(|x|a.forward(x)).collect()
156	}
157	fn forward_mut(&mut self,input:I)->J{
158		let a=self.inner_mut();
159		input.into_iter().map(|x|a.forward_mut(x)).collect()
160	}
161}
162impl<A> Residual<A>{
163	/// creates a new residual wrapped layer
164	pub fn new(inner:A)->Self{
165		Self{apply:true,inner}
166	}
167	/// sets whether residual should be applied (true by default)
168	pub fn with_apply(mut self,apply:bool)->Self{
169		self.apply=apply;
170		self
171	}
172}
173impl<A:AI<X,Y>+Op<Output=Y>,X:Clone+OpsAdd<Y,Output=Z>,Y:Into<Z>,Z> AI<X,Z> for Residual<A>{
174	fn forward(&self,x:X)->Z{
175		let apply=self.apply;
176		let f=&self.inner;
177
178		if apply{x.clone()+f.forward(x)}else{f.forward(x).into()}
179	}
180	fn forward_mut(&mut self,x:X)->Z{
181		let apply=self.apply;
182		let f=&mut self.inner;
183
184		if apply{x.clone()+f.forward_mut(x)}else{f.forward_mut(x).into()}
185	}
186}
187impl<A:AI<X,Y>,X,Y:Clone,const N:usize> AI<X,[Y;N]> for Duplicate<A>{
188	fn forward(&self,input:X)->[Y;N]{
189		let y=self.inner().forward(input);
190		[0;N].map(|_|y.clone())
191	}
192	fn forward_mut(&mut self,input:X)->[Y;N]{
193		let y=self.inner_mut().forward_mut(input);
194		[0;N].map(|_|y.clone())
195	}
196}
197impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y)> for Duplicate<A>{
198	fn forward(&self,input:X)->(Y,Y){
199		let y=self.inner().forward(input);
200		(y.clone(),y)
201	}
202	fn forward_mut(&mut self,input:X)->(Y,Y){
203		let y=self.inner_mut().forward_mut(input);
204		(y.clone(),y)
205	}
206}
207impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y)> for Duplicate<A>{
208	fn forward(&self,input:X)->(Y,Y,Y){
209		let y=self.inner().forward(input);
210		(y.clone(),y.clone(),y)
211	}
212	fn forward_mut(&mut self,input:X)->(Y,Y,Y){
213		let y=self.inner_mut().forward_mut(input);
214		(y.clone(),y.clone(),y)
215	}
216}
217impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y,Y)> for Duplicate<A>{
218	fn forward(&self,input:X)->(Y,Y,Y,Y){
219		let y=self.inner().forward(input);
220		(y.clone(),y.clone(),y.clone(),y)
221	}
222	fn forward_mut(&mut self,input:X)->(Y,Y,Y,Y){
223		let y=self.inner_mut().forward_mut(input);
224		(y.clone(),y.clone(),y.clone(),y)
225	}
226}
227impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y,Y,Y)> for Duplicate<A>{
228	fn forward(&self,input:X)->(Y,Y,Y,Y,Y){
229		let y=self.inner().forward(input);
230		(y.clone(),y.clone(),y.clone(),y.clone(),y)
231	}
232	fn forward_mut(&mut self,input:X)->(Y,Y,Y,Y,Y){
233		let y=self.inner_mut().forward_mut(input);
234		(y.clone(),y.clone(),y.clone(),y.clone(),y)
235	}
236}
237impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y,Y,Y,Y)> for Duplicate<A>{
238	fn forward(&self,input:X)->(Y,Y,Y,Y,Y,Y){
239		let y=self.inner().forward(input);
240		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
241	}
242	fn forward_mut(&mut self,input:X)->(Y,Y,Y,Y,Y,Y){
243		let y=self.inner_mut().forward_mut(input);
244		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
245	}
246}
247impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y,Y,Y,Y,Y)> for Duplicate<A>{
248	fn forward(&self,input:X)->(Y,Y,Y,Y,Y,Y,Y){
249		let y=self.inner().forward(input);
250		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
251	}
252	fn forward_mut(&mut self,input:X)->(Y,Y,Y,Y,Y,Y,Y){
253		let y=self.inner_mut().forward_mut(input);
254		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
255	}
256}
257impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y,Y,Y,Y,Y,Y)> for Duplicate<A>{
258	fn forward(&self,input:X)->(Y,Y,Y,Y,Y,Y,Y,Y){
259		let y=self.inner().forward(input);
260		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
261	}
262	fn forward_mut(&mut self,input:X)->(Y,Y,Y,Y,Y,Y,Y,Y){
263		let y=self.inner_mut().forward_mut(input);
264		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
265	}
266}
267impl<A:AI<X,Y>,X,Y> Op for SetType<A,X,Y>{
268	type Output=Y;
269}
270impl<A:AI<X,Y>,X,Y> SetType<A,X,Y>{
271	accessible_inner!(inner:A);
272	pub fn new(inner:A)->Self{
273		Self{inner,phantom:PhantomData}
274	}
275}
276impl<A:Decompose,X:Decompose> Decompose for Autoregression<A,X>{
277	fn compose(decomposition:Self::Decomposition)->Self{
278		Self{ai:A::compose(decomposition.0),state:Some(X::compose(decomposition.1))}
279	}
280	fn decompose(self)->Self::Decomposition{(self.ai.decompose(),self.state.unwrap().decompose())}
281	fn decompose_cloned(&self)->Self::Decomposition{(self.ai.decompose_cloned(),self.state.as_ref().unwrap().decompose_cloned())}
282	type Decomposition=(A::Decomposition,X::Decomposition);
283}
284impl<A:Decompose,X,Y> Decompose for SetType<A,X,Y>{
285	fn compose(decomposition:Self::Decomposition)->Self{
286		Self{inner:A::compose(decomposition),phantom:PhantomData}
287	}
288	fn decompose(self)->Self::Decomposition{self.inner.decompose()}
289	fn decompose_cloned(&self)->Self::Decomposition{self.inner.decompose_cloned()}
290	type Decomposition=A::Decomposition;
291}
292impl<A:Decompose> Decompose for Duplicate<A>{
293	fn compose((inner,times):Self::Decomposition)->Self{
294		Self{inner:A::compose(inner),times}
295	}
296	fn decompose(self)->Self::Decomposition{(self.inner.decompose(),self.times)}
297	fn decompose_cloned(&self)->Self::Decomposition{(self.inner.decompose_cloned(),self.times)}
298	type Decomposition=(A::Decomposition,usize);
299}
300impl<A:Decompose> Decompose for Sequential<A>{
301	fn compose(decomposition:Self::Decomposition)->Self{
302		Self{inner:A::compose(decomposition)}
303	}
304	fn decompose(self)->Self::Decomposition{self.inner.decompose()}
305	fn decompose_cloned(&self)->Self::Decomposition{self.inner.decompose_cloned()}
306	type Decomposition=A::Decomposition;
307}
308impl<A:Decompose> Decompose for Map<A>{
309	fn compose(decomposition:Self::Decomposition)->Self{
310		Self{inner:A::compose(decomposition)}
311	}
312	fn decompose(self)->Self::Decomposition{self.inner.decompose()}
313	fn decompose_cloned(&self)->Self::Decomposition{self.inner.decompose_cloned()}
314	type Decomposition=A::Decomposition;
315}
316impl<A:Decompose> Decompose for Residual<A>{
317	fn compose((decomposition,apply):Self::Decomposition)->Self{
318		Self{apply,inner:A::compose(decomposition)}
319	}
320	fn decompose(self)->Self::Decomposition{(self.inner.decompose(),self.apply)}
321	fn decompose_cloned(&self)->Self::Decomposition{(self.inner.decompose_cloned(),self.apply)}
322	type Decomposition=(A::Decomposition,bool);
323}
324impl<A:Op<Output=Y>,Y> Op for Residual<A>{
325	type Output=Y;
326}
327impl<A:Decompose> Decompose for Zip<A>{
328	fn compose(decomposition:Self::Decomposition)->Self{
329		Self{inner:A::compose(decomposition)}
330	}
331	fn decompose(self)->Self::Decomposition{self.inner.decompose()}
332	fn decompose_cloned(&self)->Self::Decomposition{self.inner.decompose_cloned()}
333	type Decomposition=A::Decomposition;
334}
335impl<A:IntoSequence<M>,M:AI<M::Output,M::Output>+Op> IntoSequence<M> for Duplicate<A> where Duplicate<M>:Into<M>{
336	fn into_sequence(self)->Sequential<Vec<M>>{
337		let mut s=self.inner.into_sequence();
338		if let Some(l)=s.inner_mut().pop(){
339			s.inner_mut().push(Duplicate{inner:l,times:self.times}.into())
340		}
341		s
342	}
343}
344impl<A:IntoSequence<M>,M:AI<M::Output,M::Output>+Op> IntoSequence<M> for Map<A> where Map<M>:Into<M>{
345	fn into_sequence(self)->Sequential<Vec<M>>{
346		Sequential::new(self.inner.into_sequence().into_inner().into_iter().map(|inner|Map{inner}.into()).collect())
347	}
348}
349impl<A:IntoSequence<M>,M:AI<M::Output,M::Output>+Op> IntoSequence<M> for Sequential<Vec<A>>{//TODO into sequence for tuple
350	fn into_sequence(self)->Sequential<Vec<M>>{
351		Sequential{inner:self.into_inner().into_iter().flat_map(|a|a.into_sequence().into_inner()).collect()}
352	}
353}
354impl<A:Op<Output=S>,B:AI<S,T>+Op<Output=T>,C:AI<T,U>+Op<Output=U>,D:AI<U,V>+Op<Output=V>,E:AI<V,W>+Op<Output=W>,F:AI<W,X>+Op<Output=X>,G:AI<Y,Z>+Op<Output=Y>,H:AI<Y,Z>+Op<Output=Z>,S,T,U,V,W,X,Y,Z> Op for Sequential<(A,B,C,D,E,F,G,H)>{
355	type Output=Z;
356}
357impl<A:Op<Output=T>,B:AI<T,U>+Op<Output=U>,C:AI<U,V>+Op<Output=V>,D:AI<V,W>+Op<Output=W>,E:AI<W,X>+Op<Output=X>,F:AI<Y,Z>+Op<Output=Y>,G:AI<Y,Z>+Op<Output=Z>,T,U,V,W,X,Y,Z> Op for Sequential<(A,B,C,D,E,F,G)>{
358	type Output=Z;
359}
360impl<A:Op<Output=U>,B:AI<U,V>+Op<Output=V>,C:AI<V,W>+Op<Output=W>,D:AI<W,X>+Op<Output=X>,E:AI<Y,Z>+Op<Output=Y>,F:AI<Y,Z>+Op<Output=Z>,U,V,W,X,Y,Z> Op for Sequential<(A,B,C,D,E,F)>{
361	type Output=Z;
362}
363impl<A:Op<Output=V>,B:AI<V,W>+Op<Output=W>,C:AI<W,X>+Op<Output=X>,D:AI<Y,Z>+Op<Output=Y>,E:AI<Y,Z>+Op<Output=Z>,V,W,X,Y,Z> Op for Sequential<(A,B,C,D,E)>{
364	type Output=Z;
365}
366impl<A:Op<Output=W>,B:AI<W,X>+Op<Output=X>,C:AI<Y,Z>+Op<Output=Y>,D:AI<Y,Z>+Op<Output=Z>,W,X,Y,Z> Op for Sequential<(A,B,C,D)>{
367	type Output=Z;
368}
369impl<A:Op<Output=X>,B:AI<Y,Z>+Op<Output=Y>,C:AI<Y,Z>+Op<Output=Z>,X,Y,Z> Op for Sequential<(A,B,C)>{
370	type Output=Z;
371}
372impl<A:Op<Output=Y>,B:AI<Y,Z>+Op<Output=Z>,Y,Z> Op for Sequential<(A,B)>{
373	type Output=Z;
374}
375impl<A:Op<Output=Y>,Y> Op for Duplicate<A>{
376	type Output=(Y,Y);
377}
378impl<A:Op<Output=Y>,Y> Op for Map<A>{
379	type Output=Vec<Y>;
380}
381impl<A:UnwrapInner> UnwrapInner for Duplicate<A>{
382	fn unwrap_inner(self)->Self::Inner{self.inner.unwrap_inner()}
383	type Inner=A::Inner;
384}
385impl<A:UnwrapInner> UnwrapInner for Map<A>{
386	fn unwrap_inner(self)->Self::Inner{self.inner.unwrap_inner()}
387	type Inner=A::Inner;
388}
389impl<A,X> Autoregression<A,X>{
390	accessible_inner!(ai:A);
391	pub fn new<W>(mut ai:A,input:W)->Self where A:AI<W,X>+AI<X,X>,X:Clone{
392		let state=Some(ai.forward_mut(input));
393		Self{ai,state}
394	}
395}
396impl<A> Duplicate<A>{
397	accessible_inner!(inner:A);
398	/// creates a new duplicate module from the inner value
399	pub fn from_inner(inner:A)->Self{
400		Duplicate{inner,times:2}
401	}
402	/// creates a new duplicate module from the inner value
403	pub fn new(inner:A)->Self{
404		Duplicate{inner,times:2}
405	}
406	/// returns the suggested number of times to duplicate
407	pub fn times(&self)->usize{self.times}
408	/// replaces the inner value
409	pub fn with_inner<B>(&self,inner:B)->Duplicate<B>{Duplicate::from_inner(inner).with_times(self.times)}
410	/// sets the suggested number of times to duplicate for a variable sized output like a vec. fixed array outputs of other lengths will still be allowed
411	pub fn with_times(mut self,times:usize)->Self{
412		self.times=times;
413		self
414	}
415}
416impl<A> Sequential<A>{
417	accessible_inner!(inner:A);
418	pub fn new(inner:A)->Self{
419		Self{inner}
420	}
421}
422impl<A> Map<A>{
423	accessible_inner!(inner:A);
424	pub fn new(inner:A)->Self{
425		Self{inner}
426	}
427}
428impl<A> Zip<A>{
429	accessible_inner!(inner:A);
430	pub fn new(inner:A)->Self{
431		Self{inner}
432	}
433}
434impl<F:Fn(X)->Y,M:AI<M::Output,M::Output>+Op,X,Y> IntoSequence<M> for Apply<F,X,Y> where Self:Into<M>{
435	fn into_sequence(self)->Sequential<Vec<M>>{vec![self.into()].sequential()}
436}
437impl<F:Fn(X)->Y,X,Y> AI<X,Y> for Apply<F,X,Y>{
438	fn forward(&self,input:X)->Y{(&self.inner)(input)}
439}
440impl<F:Fn(X)->Y,X,Y> Op for Apply<F,X,Y>{
441	type Output=Y;
442}
443/// creates accessor functions for the inner value
444macro_rules! accessible_inner{
445	($field:ident:$type:ident)=>(
446		/// references the inner value
447		pub fn inner(&self)->&$type{&self.$field}
448		/// references the inner value
449		pub fn inner_mut(&mut self)->&mut $type{&mut self.$field}
450		/// returns the inner value
451		pub fn into_inner(self)->$type{self.$field}
452	);
453}
454macro_rules! zip_tuple{
455	($(($($type:ident),+):($($input:ident),+)->($($output:ident),+)),*)=>($(
456		impl<$($type:AI<$input,$output>,$input,$output),+> AI<($($input),+),($($output),+)> for Zip<($($type),+)>{
457			#[allow(non_snake_case)]
458			fn forward(&self,($($input),+):($($input),+))->($($output),+){
459				let ($($type),+)=self.inner();
460				($($type.forward($input)),+)
461			}
462			#[allow(non_snake_case)]
463			fn forward_mut(&mut self,($($input),+):($($input),+))->($($output),+){
464				let ($($type),+)=self.inner_mut();
465				($($type.forward_mut($input)),+)
466			}
467		}
468		impl<$($type:Op<Output=$output>,$output),+> Op for Zip<($($type),+)>{
469			type Output=($($output),+);
470		}
471	)*);
472}
473#[cfg(test)]
474mod tests{
475	#[test]
476	fn acc_q_vec(){
477		let op=().fix_type::<Vec<f32>>().acc_q(0.5);
478		let x:Vec<f32>=vec![1.0,1.0,1.0,1.0,1.0];
479		let y:Vec<f32>=op.forward(x);
480		assert_eq!(y,[1.9375_f32,1.875,1.75,1.5,1.0]);
481	}
482	#[test]
483	fn mse_vec(){
484		let op=().fix_type::<Vec<f32>>().squared_error().mean();
485		let x:(Vec<f32>,Vec<f32>)=(vec![0.0,0.5,1.5],vec![-2.0,1.5,5.5]);
486		let y:f32=op.forward(x);
487		assert_eq!(y,7.0);
488	}
489	use super::*;
490}
491#[derive(Clone,Copy,Debug,Deserialize,Eq,Hash,PartialEq,Serialize)]
492/// alignment
493pub enum Alignment{Center,Left,Right}
494#[derive(Clone,Copy,Debug,Deserialize,Eq,Hash,PartialEq,Serialize)]
495/// shape mismatch handling
496pub enum OnMismatch{Error,Pad(Alignment),Truncate(Alignment)}
497#[derive(Clone,Copy,Debug,Deserialize,Eq,Hash,PartialEq,Serialize)]
498/// reduction mode
499pub enum ReductionMode{Component,Dim(i32),Tensor}
500/// creates an operation that applies the closure
501pub fn apply<F:Fn(X)->Y,X,Y>(f:F)->Apply<F,X,Y>{
502	Apply{inner:f,phantom:PhantomData}
503}
504/// layers representing important mathematical operations
505pub mod math;
506/// layers relating to reinforcement learning
507pub mod reinforcement;
508/// layers relating to cross entropy or softmax
509pub mod soft;
510/// layers like cat or swap dims that change the organization or structure of tensors
511pub mod structural;
512
513impl<A:AI<X,Y>+IntoSequence<M>,M:AI<M::Output,M::Output>+Op,X,Y> IntoSequence<M> for SetType<A,X,Y>{
514	fn into_sequence(self)->Sequential<Vec<M>>{self.into_inner().into_sequence()}
515}
516impl<A:AI<X,Y>+UnwrapInner,X,Y> UnwrapInner for SetType<A,X,Y>{
517	fn unwrap_inner(self)->Self::Inner{self.into_inner().unwrap_inner()}
518	type Inner=A::Inner;
519}
520
521#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
522/// applies a closure to the input// TODO more closure layers maybe
523pub struct Apply<F:Fn(X)->Y,X,Y>{inner:F,phantom:PhantomData<fn(X)->Y>}
524#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
525/// autoregressive inference
526pub struct Autoregression<A,X>{ai:A,state:Option<X>}
527#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
528/// module for cloning things
529pub struct Duplicate<A>{inner:A,times:usize}
530#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
531/// wraps to apply to every element of a vector
532pub struct Map<A>{inner:A}
533#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
534/// layer to add an optional residual connection
535pub struct Residual<A>{apply:bool,inner:A}
536#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
537/// layer for removing dimensions with size 1
538pub struct SqueezeLayer{dim:i32}
539#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
540/// wrapper for applying ai modules sequentially
541pub struct Sequential<A>{inner:A}
542#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
543/// fixes the output type of a layer for a particular input type.
544pub struct SetType<A,X,Y>{inner:A,phantom:PhantomData<fn(X)->Y>}
545#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
546/// wraps to apply each function
547pub struct Zip<A>{inner:A}
548use {accessible_inner,zip_tuple};
549use crate::{
550	AI,Decompose,IntoSequence,Op,UnwrapInner
551};
552use serde::{Deserialize,Serialize};
553use std::{
554	iter::FromIterator,marker::PhantomData,ops::Add as OpsAdd
555};
556zip_tuple!((A,B):(W,X)->(Y,Z),(A,B,C):(U,V,W)->(X,Y,Z),(A,B,C,D):(S,T,U,V)->(W,X,Y,Z),(A,B,C,D,E):(Q,R,S,T,U)->(V,W,X,Y,Z),(A,B,C,D,E,F):(O,P,Q,R,S,T)->(U,V,W,X,Y,Z),(A,B,C,D,E,F,G):(M,N,O,P,Q,R,S)->(T,U,V,W,X,Y,Z),(A,B,C,D,E,F,G,H):(K,L,M,N,O,P,Q,R)->(S,T,U,V,W,X,Y,Z));
block_graph/builtin/mod.rs

block_graph/builtin/
mod.rs
