sarek 0.1.0

A work-in-progress, experimental neural network library utilizing TensorFlow Keras
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use {
    std::{
        env,
        error::Error,
        fmt
    },
    lazy_static::lazy_static,
    log::info,
    pyo3::{
        prelude::*
    },
    crate::{
        backend::{
            keras::{
                async_runner::{
                    AsyncRunner
                },
                py_utils::{
                    py_err
                }
            }
        }
    }
};

lazy_static! {
    static ref RUNNER: AsyncRunner = AsyncRunner::new();
}

#[derive(Clone)]
pub struct Context {
    _dummy: ()
}

pub struct ContextCreationError( Box< Error + Send > );

impl fmt::Display for ContextCreationError {
    fn fmt( &self, fmt: &mut fmt::Formatter ) -> fmt::Result {
        fmt::Display::fmt( &self.0, fmt )
    }
}

impl fmt::Debug for ContextCreationError {
    fn fmt( &self, fmt: &mut fmt::Formatter ) -> fmt::Result {
        fmt::Debug::fmt( &self.0, fmt )
    }
}

impl Error for ContextCreationError {}

impl Context {
    fn new_internal( py: Python ) -> PyResult< Self > {
        env::set_var( "TF_CPP_MIN_LOG_LEVEL", "3" );

        let sys = py.import( "sys" )?;
        let version: String = sys.get( "version" )?.extract()?;
        info!( "Using Python {}", version.replace( "\n", "" ) );

        let tf = py.import( "tensorflow" )?;
        let tf_version: String = tf.get( "VERSION" )?.extract()?;
        info!( "Using TensorFlow {}", tf_version );

        let np = py.import( "numpy" )?;
        let np_version: String = np.get( "version" )?.getattr( "version" )?.extract()?;
        info!( "Using numpy {}", np_version );

        let ctx = Context { _dummy: () };
        Ok( ctx )
    }

    pub fn new() -> Result< Self, ContextCreationError > {
        Context::gil( |py| {
            Self::new_internal( py ).map_err( |err| py_err( py, err ) ).map_err( ContextCreationError )
        })
    }

    pub(crate) fn gil< R, F >( callback: F ) -> R where F: FnOnce( Python ) -> R + Send, R: Send + 'static {
        // For some reason Tensorflow breaks if we access Python from
        // different threads (even if we use a mutex!) so we'll just
        // spawn a dedicated Python thread and run everything on it.
        RUNNER.execute_sync( || {
            let gil = Python::acquire_gil();
            let py = gil.python();
            callback( py )
        })
    }
}