fix/test: fix tests after adding collenchyma

Author: hobofan

.travis.yml

@@ -21,6 +21,7 @@ before_script:
 script:
 - |
   travis-cargo build &&
+  travis-cargo test  &&
   travis-cargo bench &&
   travis-cargo doc
 addons:

src/layer.rs

@@ -31,12 +31,21 @@ use std::sync::{RwLockReadGuard, RwLockWriteGuard};
 /// ```
 /// extern crate phloem;
 /// # extern crate leaf;
+/// # extern crate collenchyma as co;
 /// use phloem::Blob;
 /// use std::sync::{RwLock, RwLockReadGuard};
 /// # use leaf::layer::ReadBlob;
+/// # use co::backend::{Backend, BackendConfig};
+/// # use co::frameworks::Native;
+/// # use co::framework::IFramework;
+/// # use std::rc::Rc;
 ///
 /// # fn main() {
-/// let lock = RwLock::new(Box::new(Blob::<f32>::of_shape(vec![3])));
+/// # let framework = Native::new();
+/// # let hardwares = framework.hardwares();
+/// # let backend_config = BackendConfig::new(framework, hardwares);
+/// # let backend = Rc::new(Backend::new(backend_config).unwrap());
+/// let lock = RwLock::new(Box::new(Blob::<f32>::of_shape(Some(backend.device()), &[3, 2, 3])));
 /// let read_blob: ReadBlob = lock.read().unwrap();
 /// # }
 /// ```
@@ -60,12 +69,21 @@ pub type ReadBlob<'_> = RwLockReadGuard<'_, HeapBlob>;
 /// ```
 /// extern crate phloem;
 /// # extern crate leaf;
+/// # extern crate collenchyma as co;
 /// use phloem::Blob;
 /// use std::sync::{RwLock, RwLockWriteGuard};
 /// # use leaf::layer::WriteBlob;
+/// # use co::backend::{Backend, BackendConfig};
+/// # use co::frameworks::Native;
+/// # use co::framework::IFramework;
+/// # use std::rc::Rc;
 ///
 /// # fn main() {
-/// let lock = RwLock::new(Box::new(Blob::<f32>::of_shape(vec![3])));
+/// # let framework = Native::new();
+/// # let hardwares = framework.hardwares();
+/// # let backend_config = BackendConfig::new(framework, hardwares);
+/// # let backend = Rc::new(Backend::new(backend_config).unwrap());
+/// let lock = RwLock::new(Box::new(Blob::<f32>::of_shape(Some(backend.device()), &[4, 2, 1])));
 /// let read_blob: WriteBlob = lock.write().unwrap();
 /// # }
 /// ```
@@ -455,7 +473,7 @@ pub trait ILayer {
     /// [2]: ./type.ReadBlob.html
     /// [3]: ./type.WriteBlob.html
     /// [3]: #method.forward_cpu
-    #[allow(map_clone)]
+    #[cfg_attr(lint, allow(map_clone))]
     fn forward(&self, bottom: &[ArcLock<HeapBlob>], top: &mut Vec<ArcLock<HeapBlob>>) -> f32 {
         // Lock();
         // Reshape(bottom, top); // Reshape the layer to fit top & bottom blob
@@ -495,7 +513,7 @@ pub trait ILayer {
     /// [2]: ./type.ReadBlob.html
     /// [3]: ./type.WriteBlob.html
     /// [3]: #method.backward_cpu
-    #[allow(map_clone)]
+    #[cfg_attr(lint, allow(map_clone))]
     fn backward(&self, top: &[ArcLock<HeapBlob>], propagate_down: &[bool], bottom: &mut Vec<ArcLock<HeapBlob>>) {
         let tp: Vec<_> = top.iter().map(|b| b.read().unwrap()).collect();
         let bt_ref = bottom.iter().cloned().collect::<Vec<_>>();

src/network.rs

@@ -120,9 +120,25 @@ impl<B: IBackend + IBlas<f32>> Network<B> {
     /// ## Examples
     ///
     /// ```
+    /// # extern crate collenchyma;
+    /// # extern crate leaf;
+    ///
     /// # use leaf::network::*;
+    /// # use collenchyma::backend::{Backend, BackendConfig};
+    /// # use collenchyma::frameworks::Native;
+    /// # use collenchyma::framework::IFramework;
+    /// # use std::rc::Rc;
+    ///
+    /// # fn main() {
+    /// // create backend
+    /// let framework = Native::new();
+    /// let hardwares = framework.hardwares();
+    /// let backend_config = BackendConfig::new(framework, hardwares);
+    /// let backend = Rc::new(Backend::new(backend_config).unwrap());
+    /// // create network
     /// let cfg = NetworkConfig::default();
-    /// Network::from_config(&cfg);
+    /// Network::from_config(backend, &cfg);
+    /// # }
     /// ```
     pub fn from_config(backend: Rc<B>, param: &NetworkConfig) -> Network<B> {
         let mut network = Network::default();
@@ -250,7 +266,7 @@ impl<B: IBackend + IBlas<f32>> Network<B> {
     /// Used during initialization of the Network.
     /// [1]: ../layer/struct.Layer.html
     /// [2]: ../layer/struct.Layer.html#method.connect
-    #[allow(ptr_arg)]
+    #[cfg_attr(lint, allow(ptr_arg))]
     fn init_input_blob(&mut self,
                   blob_name: &str,
                   input_shape: &Vec<usize>,

src/solver.rs

@@ -31,11 +31,18 @@ impl<S, B: IBackend + IBlas<f32>> Solver<S, B> {
     /// ## Example
     ///
     /// ```
+    /// # extern crate leaf;
+    /// # extern crate collenchyma;
     /// # use leaf::solver::*;
+    /// # use collenchyma::backend::Backend;
+    /// # use collenchyma::frameworks::Native;
+    ///
+    /// # fn main() {
     /// let cfg = SolverConfig{
     ///             solver: SolverKind::SGD(SGDKind::Momentum),
     ///             ..SolverConfig::default()};
-    /// let solver = Solver::<Box<ISolver>>::from_config(&cfg);
+    /// let solver = Solver::<Box<ISolver<Backend<Native>>>, Backend<Native>>::from_config(&cfg);
+    /// # }
     /// ```
     pub fn from_config(config: &SolverConfig) -> Solver<Box<ISolver<Backend<Native>>>, Backend<Native>> {
         let framework = Native::new();

src/solvers/sgd/momentum.rs

@@ -13,8 +13,6 @@
 //! into the same direction you will reach the optimum faster.
 //! It also makes solving more stable.
 use co::backend::*;
-use co::framework::*;
-use co::frameworks::*;
 use co::libraries::blas::IBlas;
 use shared_memory::*;
 use network::Network;

tests/layer_specs.rs

@@ -1,27 +1,39 @@
 extern crate leaf;
 extern crate phloem;
+extern crate collenchyma as co;
 
 #[cfg(test)]
 mod layer_spec {
 
     use leaf::layer::*;
     use phloem::Blob;
+    use std::rc::Rc;
+    use co::backend::{Backend, BackendConfig};
+    use co::frameworks::Native;
+    use co::framework::IFramework;
 
     fn new_layer_config() -> LayerConfig {
         LayerConfig::new("foo".to_owned(), LayerType::Sigmoid)
     }
 
+    fn backend() -> Rc<Backend<Native>> {
+        let framework = Native::new();
+        let hardwares = framework.hardwares();
+        let backend_config = BackendConfig::new(framework, hardwares);
+        Rc::new(Backend::new(backend_config).unwrap())
+    }
+
     #[test]
     fn new_layer() {
         let cfg = new_layer_config();
-        Layer::from_config(&cfg);
+        Layer::from_config(backend(), &cfg);
     }
 
     #[test]
     fn dim_check_strict() {
         let cfg = WeightConfig { share_mode: DimCheckMode::Strict, ..WeightConfig::default() };
-        let blob_one = Blob::<f32>::of_shape(vec![2, 3, 3]);
-        let blob_two = Blob::<f32>::of_shape(vec![3, 2, 3]);
+        let blob_one = Blob::<f32>::of_shape(Some(backend().device()), &[2, 3, 3]);
+        let blob_two = Blob::<f32>::of_shape(Some(backend().device()), &[3, 2, 3]);
         let param_name = "foo".to_owned();
         let owner_name = "owner".to_owned();
         let layer_name = "layer".to_owned();
@@ -43,9 +55,9 @@ mod layer_spec {
     #[test]
     fn dim_check_permissive() {
         let cfg = WeightConfig { share_mode: DimCheckMode::Permissive, ..WeightConfig::default() };
-        let blob_one = Blob::<f32>::of_shape(vec![2, 3, 3]);
-        let blob_two = Blob::<f32>::of_shape(vec![3, 2, 3]);
-        let blob_three = Blob::<f32>::of_shape(vec![3, 10, 3]);
+        let blob_one = Blob::<f32>::of_shape(Some(backend().device()), &[2, 3, 3]);
+        let blob_two = Blob::<f32>::of_shape(Some(backend().device()), &[3, 2, 3]);
+        let blob_three = Blob::<f32>::of_shape(Some(backend().device()), &[3, 10, 3]);
         let param_name = "foo".to_owned();
         let owner_name = "owner".to_owned();
         let layer_name = "layer".to_owned();

tests/network_specs.rs

@@ -1,13 +1,25 @@
 extern crate leaf;
 extern crate phloem;
+extern crate collenchyma as co;
 
 #[cfg(test)]
 mod network_spec {
+    use std::rc::Rc;
+    use co::backend::{Backend, BackendConfig};
+    use co::framework::IFramework;
+    use co::frameworks::Native;
     use leaf::network::*;
 
+    fn backend() -> Rc<Backend<Native>> {
+        let framework = Native::new();
+        let hardwares = framework.hardwares();
+        let backend_config = BackendConfig::new(framework, hardwares);
+        Rc::new(Backend::new(backend_config).unwrap())
+    }
+
     #[test]
     fn new_layer() {
         let cfg = NetworkConfig::default();
-        Network::from_config(&cfg);
+        Network::from_config(backend(), &cfg);
     }
 }

tests/solver_specs.rs

@@ -1,8 +1,11 @@
 extern crate leaf;
+extern crate collenchyma as co;
 
 #[cfg(test)]
 mod network_spec {
     use leaf::solver::*;
+    use co::backend::Backend;
+    use co::frameworks::Native;
 
     #[test]
     // fixed: always return base_lr.
@@ -40,6 +43,6 @@ mod network_spec {
     #[test]
     fn instantiate_solver_sgd_momentum() {
         let cfg = SolverConfig{ solver: SolverKind::SGD(SGDKind::Momentum), ..SolverConfig::default()};
-        Solver::<Box<ISolver>>::from_config(&cfg);
+        Solver::<Box<ISolver<Backend<Native>>>, Backend<Native>>::from_config(&cfg);
     }
 }