networks.py

import os
from keras import Sequential
from keras.models import load_model
from keras.layers import Dense
from keras.optimizers import Adam
from keras.activations import relu, linear
from keras.regularizers import l2
from keras.callbacks import EarlyStopping
class QNet:
    
    learn_rate = 0.0005

    def __init__(self, conf):
        if conf.force_cpu:
            os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
            os.environ["CUDA_VISIBLE_DEVICES"] = ""
        self.net = None    
        self.net = Sequential()
        self.compile_net(conf)
        self.net.summary()
        self.learn_rate = conf.learn_rate

    def compile_net(self, conf):
        self.net.add(Dense(conf.net_layout[0], input_dim=conf.env.observation_space.shape[0], activation=relu))
        for layer in range(1, len(conf.net_layout)):
            self.net.add(Dense(conf.net_layout[layer], activation=relu))
        self.net.add(Dense(conf.env.action_space.n, activation=linear))
        self.net.compile(loss='mse', optimizer=Adam(lr=self.learn_rate))

    def predict(self, state): 
        return self.net.predict(state)

    def predict_on_batch(
        self, states): return self.net.predict_on_batch(states)

    def fit(self, X, Y, epochs=1, verbose=0):
        callback = EarlyStopping(monitor='loss', patience=3)
        history = self.net.fit(X, Y, epochs=epochs, verbose=verbose, callbacks=[callback])
        return history.history['loss'][-1]

    def save(self, path):
        self.net.save(path)
    
    def load(self, path):
        self.net = load_model(path)
        self.net.summary()

class QL2Net(QNet):
    def __init__(self, action_space, state_space):
        super().__init__(action_space, state_space)
    
    def compile_net(self, action_space, state_space):
        self.net.add(Dense(192, input_dim=state_space, activation=relu, kernel_regularizer=l2(0.01)))
        self.net.add(Dense(64, activation=relu))
        self.net.add(Dense(action_space, activation=linear))
        self.net.compile(loss='mse', optimizer=Adam(lr=self.learn_rate))