arsalanaf · June 15, 2023 04:10 · lorrp1 · Jul 8, 2018 · traderpro446 · Jul 15, 2018
diff --git a/myTestLSTM.py b/myTestLSTM.py
 from btgym import BTgymEnv
 import IPython.display as Display
 import PIL.Image as Image
 from gym import spaces


 import gym
 import numpy as np
 import random

 '''
 from keras.models import Sequential
 from keras.layers import Dense, Dropout
 from keras.optimizers import Adam
 '''

 from keras.models import Sequential, load_model
 from keras.layers.core import Dense, Dropout, Activation
 from keras.layers.recurrent import LSTM
 from keras.optimizers import RMSprop, Adam

 from collections import deque

 class DQN:
    def __init__(self, env):
        self.env     = env
        self.memory  = deque(maxlen=20000)
        
        self.gamma = 0.85
        self.epsilon = 1.0
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.learning_rate = 0.005
        self.tau = .125

        self.model        = self.create_model()
        self.target_model = self.create_model()

    def create_model(self):
        model   = Sequential()
       # state_shape  = list(self.env.observation_space.shape.items())[0][1]
        #Reshaping for LSTM 
        #state_shape=np.array(state_shape)
        #state_shape= np.reshape(state_shape, (30,4,1))
        '''
        model.add(Dense(24, input_dim=state_shape[1], activation="relu"))
        model.add(Dense(48, activation="relu"))
        model.add(Dense(24, activation="relu"))
        model.add(Dense(self.env.action_space.n))
        model.compile(loss="mean_squared_error",
            optimizer=Adam(lr=self.learning_rate))
        '''
        model.add(LSTM(64,
               input_shape=(4,1),
               #return_sequences=True,
               stateful=False
               ))
        model.add(Dropout(0.5))
        
        #model.add(LSTM(64,
                       #input_shape=(1,4),
                       #return_sequences=False,
        #               stateful=False
        #               ))
        model.add(Dropout(0.5))
        
        model.add(Dense(self.env.action_space.n, init='lecun_uniform'))
        model.add(Activation('linear')) #linear output so we can have range of real-valued outputs

        rms = RMSprop()
        adam = Adam()
        model.compile(loss='mse', optimizer=adam)
        return model

    def act(self, state):
        self.epsilon *= self.epsilon_decay
        self.epsilon = max(self.epsilon_min, self.epsilon)
        if np.random.random() < self.epsilon:
            return self.env.action_space.sample()
        return np.argmax(self.model.predict(state)[0])

   
    def target_train(self):
        weights = self.model.get_weights()
        target_weights = self.target_model.get_weights()
        for i in range(len(target_weights)):
            target_weights[i] = weights[i] * self.tau + target_weights[i] * (1 - self.tau)
        self.target_model.set_weights(target_weights)

    def save_model(self, fn):
        self.model.save(fn)
              
    def show_rendered_image(self, rgb_array):
        """
        Convert numpy array to RGB image using PILLOW and
        show it inline using IPykernel.
        """
        Display.display(Image.fromarray(rgb_array))

    def render_all_modes(self, env):
        """
        Retrieve and show environment renderings
        for all supported modes.
        """
        for mode in self.env.metadata['render.modes']:
            print('[{}] mode:'.format(mode))
            self.show_rendered_image(self.env.render(mode))

 def main():
    env     = BTgymEnv(filename='./data/DAT_ASCII_EURUSD_M1_2016.csv',
                       state_shape={'raw_state': spaces.Box(low=-100, high=100,shape=(30,4))},
                       skip_frame=5,
                       start_cash=100000,
                       broker_commission=0.02,
                       fixed_stake=100,
                       drawdown_call=90,
                       render_ylabel='Price Lines',
                       render_size_episode=(12,8),
                       render_size_human=(8, 3.5),
                       render_size_state=(10, 3.5),
                       render_dpi=75,
                       verbose=0,) 
    gamma   = 0.9
    epsilon = .95

    trials  = 100
    trial_len = 1000

    # updateTargetNetwork = 1000
    dqn_agent = DQN(env=env)
    steps = []
    for trial in range(trials): 
        #dqn_agent.model= load_model("./model.model")
        cur_state = np.array(list(env.reset().items())[0][1])
        cur_state= np.reshape(cur_state, (30,4,1))
        for step in range(trial_len):
            action = dqn_agent.act(cur_state)
            new_state, reward, done, _ = env.step(action)
            reward = reward*10 if not done else -10
            new_state =list(new_state.items())[0][1]
            new_state= np.reshape(new_state, (30,4,1))
            dqn_agent.target_train() # iterates target model

            cur_state = new_state
            if done:
                break
        
        print("Completed trial #{} ".format(trial))
        dqn_agent.render_all_modes(env)
        dqn_agent.save_model("model.model".format(trial))
        

 if __name__ == "__main__":
    main()
	from btgym import BTgymEnv
	import IPython.display as Display
	import PIL.Image as Image
	from gym import spaces


	import gym
	import numpy as np
	import random

	'''
	from keras.models import Sequential
	from keras.layers import Dense, Dropout
	from keras.optimizers import Adam
	'''

	from keras.models import Sequential, load_model
	from keras.layers.core import Dense, Dropout, Activation
	from keras.layers.recurrent import LSTM
	from keras.optimizers import RMSprop, Adam

	from collections import deque

	class DQN:
	def __init__(self, env):
	self.env = env
	self.memory = deque(maxlen=20000)

	self.gamma = 0.85
	self.epsilon = 1.0
	self.epsilon_min = 0.01
	self.epsilon_decay = 0.995
	self.learning_rate = 0.005
	self.tau = .125

	self.model = self.create_model()
	self.target_model = self.create_model()

	def create_model(self):
	model = Sequential()
	# state_shape = list(self.env.observation_space.shape.items())[0][1]
	#Reshaping for LSTM
	#state_shape=np.array(state_shape)
	#state_shape= np.reshape(state_shape, (30,4,1))
	'''
	model.add(Dense(24, input_dim=state_shape[1], activation="relu"))
	model.add(Dense(48, activation="relu"))
	model.add(Dense(24, activation="relu"))
	model.add(Dense(self.env.action_space.n))
	model.compile(loss="mean_squared_error",
	optimizer=Adam(lr=self.learning_rate))
	'''
	model.add(LSTM(64,
	input_shape=(4,1),
	#return_sequences=True,
	stateful=False
	))
	model.add(Dropout(0.5))

	#model.add(LSTM(64,
	#input_shape=(1,4),
	#return_sequences=False,
	# stateful=False
	# ))
	model.add(Dropout(0.5))

	model.add(Dense(self.env.action_space.n, init='lecun_uniform'))
	model.add(Activation('linear')) #linear output so we can have range of real-valued outputs

	rms = RMSprop()
	adam = Adam()
	model.compile(loss='mse', optimizer=adam)
	return model

	def act(self, state):
	self.epsilon *= self.epsilon_decay
	self.epsilon = max(self.epsilon_min, self.epsilon)
	if np.random.random() < self.epsilon:
	return self.env.action_space.sample()
	return np.argmax(self.model.predict(state)[0])


	def target_train(self):
	weights = self.model.get_weights()
	target_weights = self.target_model.get_weights()
	for i in range(len(target_weights)):
	target_weights[i] = weights[i] * self.tau + target_weights[i] * (1 - self.tau)
	self.target_model.set_weights(target_weights)

	def save_model(self, fn):
	self.model.save(fn)

	def show_rendered_image(self, rgb_array):
	"""
	Convert numpy array to RGB image using PILLOW and
	show it inline using IPykernel.
	"""
	Display.display(Image.fromarray(rgb_array))

	def render_all_modes(self, env):
	"""
	Retrieve and show environment renderings
	for all supported modes.
	"""
	for mode in self.env.metadata['render.modes']:
	print('[{}] mode:'.format(mode))
	self.show_rendered_image(self.env.render(mode))

	def main():
	env = BTgymEnv(filename='./data/DAT_ASCII_EURUSD_M1_2016.csv',
	state_shape={'raw_state': spaces.Box(low=-100, high=100,shape=(30,4))},
	skip_frame=5,
	start_cash=100000,
	broker_commission=0.02,
	fixed_stake=100,
	drawdown_call=90,
	render_ylabel='Price Lines',
	render_size_episode=(12,8),
	render_size_human=(8, 3.5),
	render_size_state=(10, 3.5),
	render_dpi=75,
	verbose=0,)
	gamma = 0.9
	epsilon = .95

	trials = 100
	trial_len = 1000

	# updateTargetNetwork = 1000
	dqn_agent = DQN(env=env)
	steps = []
	for trial in range(trials):
	#dqn_agent.model= load_model("./model.model")
	cur_state = np.array(list(env.reset().items())[0][1])
	cur_state= np.reshape(cur_state, (30,4,1))
	for step in range(trial_len):
	action = dqn_agent.act(cur_state)
	new_state, reward, done, _ = env.step(action)
	reward = reward*10 if not done else -10
	new_state =list(new_state.items())[0][1]
	new_state= np.reshape(new_state, (30,4,1))
	dqn_agent.target_train() # iterates target model

	cur_state = new_state
	if done:
	break

	print("Completed trial #{} ".format(trial))
	dqn_agent.render_all_modes(env)
	dqn_agent.save_model("model.model".format(trial))


	if __name__ == "__main__":
	main()