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! 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.
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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)