def __init__(self, policy_params):
self.ob_dim = policy_params['ob_dim']
self.ac_dim = policy_params['ac_dim']
self.weights = np.empty(0)
# a filter for updating statistics of the observations and normalizing inputs to the policies
self.observation_filter = get_filter(policy_params['ob_filter'], shape = (self.ob_dim,))
self.update_filter = True
def __init__(self, policy_params):
self.ob_dim = policy_params['ob_dim']
self.ac_dim = policy_params['ac_dim']
# a filter for updating statistics of the observations and normalizing inputs to the policies
self.observation_filter = get_filter(policy_params['ob_filter'],
shape=(self.ob_dim, ))
self.state_normalize = {"mean", None, "std", None}
self.update_filter = True
def process_tracker(self,tracker):
Filter = get_filter(tracker.filter)
Loader = get_loader(tracker.loader)
loader = Loader(tracker,Filter(self.interest_list,tracker.publisher))
media_list = loader.fetch()
for media in media_list:
if not media in self.submitted_list and \
not media in self.wait_list:
media.fetch()
self.wait_list.append(media)
def __init__(self, policy_params):
self.ob_dim = policy_params['ob_dim']
self.ac_dim = policy_params['ac_dim']
self.weights = np.empty(0)
# a filter for updating statistics of the observations and normalizing
# inputs to the policies
self.observation_filter = filter.get_filter(
policy_params['ob_filter'], shape=(self.ob_dim,))
self.update_filter = True
def __init__(self, policy_params):
self.ob_dim = policy_params['ob_dim']
self.ac_dim = policy_params['ac_dim']
self.weights = np.zeros((self.ac_dim, self.ob_dim), dtype=np.float64)
#self.weights = np.zeros(self.ac_dim)
# a filter for updating statistics of the observations and normalizing inputs to the policies
self.observation_filter = get_filter(policy_params['ob_filter'],
shape=(self.ob_dim,),
mean=policy_params['initial_mean'],
std=policy_params['initial_std'])
#self.observation_filter = None
self.update_filter = True
def __init__(self, agent_args, id_num=0):
Base_ARS_Agent.__init__(self)
self.ob_dim = agent_args['ob_dim']
self.ac_dim = agent_args['ac_dim']
self.weights = np.zeros((self.ac_dim, self.ob_dim), dtype=np.float64)
# a filter for updating statistics of the observations and normalizing inputs to the policies
self.observation_filter = get_filter(agent_args['ob_filter'],
shape=(self.ob_dim, ))
####################################
# auction stuff
self.id = id_num
self.active = True
def _set_filters(self, value):
"""Filters may be specified in a variety of different ways,
including by giving their name; we need to make sure we resolve
everything to an actual filter instance.
"""
if value is None:
self._filters = ()
return
if isinstance(value, basestring):
filters = map(unicode.strip, unicode(value).split(','))
elif isinstance(value, (list, tuple)):
filters = value
else:
filters = [value]
self._filters = [get_filter(f) for f in filters]
def __init__(self, policy_params):
self.ob_dim = policy_params['ob_dim']
self.ac_dim = policy_params['ac_dim']
self.policy = MlpPolicy('pi',
policy_params['ob_space'],
policy_params['ac_space'],
hid_size=64,
num_hid_layers=2)
all_var_list = self.policy.get_trainable_variables()
var_list = [
v for v in all_var_list if v.name.split("/")[1].startswith("pol")
]
self.get_flat = U.GetFlat(var_list)
self.set_from_flat = U.SetFromFlat(var_list)
sess = tf.get_default_session()
U.initialize()
#print('sess',sess)
#sess.run(tf.global_variables_initializer())
self.weights = self.get_flat()
# a filter for updating statistics of the observations and normalizing inputs to the policies
self.observation_filter = get_filter(policy_params['ob_filter'],
shape=(self.ob_dim, ))
self.update_filter = True
if __name__=='__main__':
_stock = Stock(1301, 't', 100)
entry = MyEntry()
entry.stock = _stock
p( entry.check_long_entry(0) )
p( entry.check_long_entry(1) )
print
p(entry.check_short_entry(0))
p(entry.check_short_entry(1))
print
my_exit = MyExit()
my_exit.stock = _stock
trade1 = entry.check_long(0)
my_exit.check_exit(trade1,1)
p( trade1.entry_price )
p( trade1.exit_price )
print
stop = MyStop()
trade3 = entry.check_long(0)
print stop.get_stop(trade3, 0)
trade4 = entry.check_short(1)
print stop.get_stop(trade4, 1)
print
filter = MyFilter()
print filter.get_filter(0)
print filter.get_filter(1)
print filter.get_filter(2)
print filter.get_filter(3)
from flask import Flask, request, render_template
from PIL import Image
from io import BytesIO
import base64
import urllib
from filter import add_dog_filter, get_filter
import numpy as np
app = Flask(__name__)
dog_filter = get_filter()
@app.route('/')
def index():
return render_template('index.html')
@app.route('/submit',methods=["POST"])
def submit_file():
#img = request.files['imagefile']
img = Image.open(BytesIO(request.files['imagefile'].read()))
imx = np.array(img)
result = add_dog_filter(imx, dog_filter)
res_img = Image.fromarray(result)
inp_byte_io = BytesIO()
img.save(inp_byte_io, 'PNG')
inp_byte_io.seek(0)
