[Python 3.X] Conversion de code : des librairies Teano et Lasagne à Tensorflow

Bonjour à tous!
Je me suis approprié un projet sur GitHub que je trouvais intéressant mais malheureusement ce projet utilise des librairies pour le machine learning incompatible avec python 3.7 : Theano et Lasagne.
De plus celles ci commencent à se faire vielle devant le magnifique Tensorflow de Google!:mouarf: Je voudrais donc remettre à jour la partie de code qui utilise ces librairies avec Tensorflow.
Cette partie ne fait que créer une classe RNN et une classe LSTM mais il y a beaucoup de calculs et de fonctions utilisés (surtout dans le __init__ de la classe RNN) qui sont un peu obscurs pour moi.
J'ai bien essayé avec ma propre conversion de code faite maison mais sans succès:calim2:.
Sachant en plus que je suis un encore un débutant à Tensorflow je me tourne vers vos yeux d'expert pour m'aider à faire la conversion de ce code ;).

Voici le code en question :

Code:

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
 
import numpy as np
import theano
import theano.tensor as T
import lasagne
import sys
 
 
class RNN(object):
    def __init__(self, seq_len, n_feature):
        self.Input = lasagne.layers.InputLayer(shape=(None, seq_len, n_feature))
        self.buildNetwork()
        self.output = lasagne.layers.get_output(self.network)
        self.params = lasagne.layers.get_all_params(self.network, trainable=True)
        self.output_fn = theano.function([self.Input.input_var], self.output)
 
        fx = T.fvector().astype("float64")
        choices = T.ivector()
        px = self.output[T.arange(self.output.shape[0]), choices]
        log_px = T.log(px)
        cost = -fx.dot(log_px)
        updates = lasagne.updates.adagrad(cost, self.params, 0.0008)
        Input = lasagne.layers.InputLayer(shape=(None, seq_len, n_feature))
        self.train_fn = theano.function([self.Input.input_var, choices, fx], [cost, px, log_px], updates=updates)
 
 
 
    def buildNetwork(self):
        l_forward = lasagne.layers.RecurrentLayer(
                                                    self.Input, 20,
                                                    grad_clipping = 100,
                                                    W_in_to_hid=lasagne.init.HeUniform(),
                                                    W_hid_to_hid=lasagne.init.HeUniform(),
                                                    nonlinearity=lasagne.nonlinearities.tanh
                                                    #only_return_final=True)
                                                 )
 
        self.network = lasagne.layers.DenseLayer(
            l_forward, num_units=3, nonlinearity=lasagne.nonlinearities.softmax)
 
    def predict(self, x):
        x = np.array([x]).astype(theano.config.floatX)
        prediction = self.output_fn(x)
        return prediction[0]
 
    def train(self, Input, choices, rewards):
        if rewards.std() != 0:
            rewards = (rewards - rewards.mean()) / rewards.std()
        cost, px, log_px = self.train_fn(Input, choices, rewards)
        if np.isnan(cost) or any(np.isnan(log_px)):
            print (rewards, "\n", cost, px, log_px)
 
    def save(self, path='model.npz'):
        np.savez(path, *lasagne.layers.get_all_param_values(self.network))
 
    def load(self, path='model.npz'):
        with np.load(path) as f:
            param_values = [f['arr_%d' % i] for i in range(len(f.files))]
            lasagne.layers.set_all_param_values(network, param_values)
 
 
class LSTM(RNN):
    def buildNetwork(self):
        l_forward = lasagne.layers.LSTMLayer(self.Input, 20, grad_clipping = 10)
 
        self.network = lasagne.layers.DenseLayer(
            l_forward, num_units=3, nonlinearity=lasagne.nonlinearities.softmax)