def main_button_click(self):
self.play_beep()
self.tick_timer()
Recorder.start_recording()
self.full_file_path = "test.wav"
self.l_selected_file_name_var.set("[Selected file name]: " + "test.wav")
self.b_spectrogram['state'] = 'active'
def main():
parser = OptionParser()
parser.add_option('-v', '--verbose',
dest='verbose', action='store_true', default=False,
help='verbose output')
(options, args) = parser.parse_args()
verbose = options.verbose
if verbose:
print 'verbose output mode.'
if len(args) == 0:
print 'no input files.'
exit
filename = args[0]
if verbose:
print 'filename: ' + filename
p = Player(filename)
r = Recorder()
r.start()
pl = plotter(p, r)
th = Thread(target=pl)
th.daemon = True
th.start()
p.run()
def test_SocketPair1(self):
rec = Recorder()
rec.createSocketPair(1,2)
socDetails = rec._getSocketDetails(1)
self.assertEqual(socDetails["socketPair"], 2)
self.assertEqual(socDetails["isForwardChannel"], False)
socDetails = rec._getSocketDetails(2)
self.assertEqual(socDetails["socketPair"], 1)
self.assertEqual(socDetails["isForwardChannel"], True)
def test_record_when_title_and_command_given(self):
recorder = Recorder(self.pty_recorder)
asciicast = recorder.record('ls -l', 'the title')
assert_equal('the title', asciicast.title)
assert_equal('ls -l', asciicast.command)
assert_equal(('ls -l',), self.pty_recorder.record_call_args())
assert_equal(123.45, asciicast.duration)
assert_equal(self.pty_recorder.stdout, asciicast.stdout)
def start_recording():
try:
config = read_config()
r = Recorder(config.get('directories', 'sessions'))
r._run()
except KeyboardInterrupt:
logger.info("KeyboardInterrupt")
except:
logger.error(sys.exc_info()[1])
logger.info("Finished recording.")
def test_record_when_no_title_nor_command_given(self):
env = { 'SHELL': '/bin/blush' }
recorder = Recorder(self.pty_recorder, env)
asciicast = recorder.record(None, None)
assert_equal(None, asciicast.title)
assert_equal(None, asciicast.command)
assert_equal(('/bin/blush',), self.pty_recorder.record_call_args())
assert_equal(123.45, asciicast.duration)
assert_equal(self.pty_recorder.stdout, asciicast.stdout)
def main():
# start recording -> 5 sec default
recorder = Recorder()
frames = recorder.start(5)
recorder.write_wav(frames, "input.wav")
# load the hum and process
hum = track_pitch("input.wav")
timeseries(hum)
process(hum)
"""
def submit(self, table_name, form_obj, id):
db = self.db
r = Recorder(db, table_name)
updated = True
if id:
result_msg = r.update(id, form_obj)
form_obj['id'] = id
else:
result_msg = r.input(form_obj)
updated = False
form_obj['id'] = r.get_last_id()
self.submitted.emit(updated, table_name, form_obj)
return result_msg
class MyApp( wxApp ):
def OnInit( self ):
self.recorder=Recorder()
self.res = wxXmlResource( GUI_FILENAME )
self.frame = self.res.LoadFrame( None, GUI_MAINFRAME_NAME )
self.frame.Show()
EVT_BUTTON(self.frame, XRCID("button_quit"), self.onClick)
EVT_BUTTON(self.frame, XRCID("button_start"), self.onClick)
EVT_BUTTON(self.frame, XRCID("button_stop"), self.onClick)
in_src = XRCCTRL(self.frame, "choice_inputsource")
for n in self.recorder.getDeviceNames():
in_src.Append(n)
in_src.SetSelection(0)
self.frame.Bind(EVT_IDLE, self.onIdle)
return 1
def onIdle(self, evt):
if self.recorder.status == RECORDING:
self.recorder.process()
XRCCTRL(self.frame, "main_frame_statusbar").SetStatusText("bytes written: " +str(self.recorder.bytesWritten()),0)
evt.Skip()
def onClick(self, evt):
btn = evt.GetEventObject()
name = evt.GetEventObject().GetName()
if name == "button_start":
self.startRecording()
btn.Disable()
XRCCTRL(self.frame, "button_stop").Enable()
elif name == "button_stop":
self.stopRecording()
btn.Disable()
XRCCTRL(self.frame, "button_start").Enable()
else:
self.quitApplication()
def quitApplication(self):
self.frame.Close(true)
def startRecording(self):
self.recorder.setDevice(XRCCTRL(self.frame, "choice_inputsource").GetStringSelection())
file = wxFileSelector("Select file to save mp3 audio to")
self.recorder.start(open(file,"wb"))
def stopRecording(self):
self.recorder.stop()
class ButtonRecorder(object):
def __init__(self, filename):
self.filename = filename
gpio.setup(23, gpio.IN, pull_up_down=gpio.PUD_UP)
self.rec = Recorder(channels=2)
def start(self):
gpio.add_event_detect(23, gpio.FALLING, callback=self.falling, bouncetime=10)
def rising(self, channel):
gpio.remove_event_detect(23)
print 'Button up'
gpio.add_event_detect(23, gpio.FALLING, callback=self.falling, bouncetime=10)
#TODO: dim red LED
self.recfile.stop_recording()
self.recfile.close()
def falling(self, channel):
ts = time.time()
gpio.remove_event_detect(23)
print 'Button down'
gpio.add_event_detect(23, gpio.RISING, callback=self.rising, bouncetime=10)
#TODO: lit green LED
play = PlayFile(vloeken.keys()[random.randint(0,len(vloeken))])
play.start()
#TODO: dim green, lite red LED
vloeken[self.filename + str(ts) + '.wav'] = {'inputfor':[]}
with open('vloeken.log', 'wb') as handle:
pickle.dump(vloeken, handle)
self.recfile = self.rec.open(self.filename + str(ts) + '.wav', 'wb')
self.recfile.start_recording()
def __init__(self, config_path):
# read config file
config = ConfigParser.RawConfigParser()
config.read(config_path)
# general
self.tmp_file = config.get('general', 'tmp_file')
# gsr api
self.gsr_api_lang = config.get('gsr_api', 'language')
# moses
self.e = config.get('moses', 'e')
self.f = config.get('moses', 'f')
self.moses_config_orig = config.get('moses', 'config_orig')
self.moses_config_fix = config.get('moses', 'config_fix')
self.moses_dir = config.get('moses', 'moses_dir')
self.model_dir = config.get('moses', 'model_dir')
self.model_dir_jenkins = config.get('moses', 'model_dir_jenkins')
self.threads = config.getint('moses', 'threads')
# pyttsx
self.tts_voice_id = config.get('pyttsx', 'voice')
self.tts_voice_rate = config.getint('pyttsx', 'rate')
# create recorder
self.recorder = Recorder(language=self.gsr_api_lang)
def __init__(self,url):
self.url = url # 要分析的url
self.block_li = [] # 网页所包含的文本块列表
self.title = ''
#重置记录
self.recorder = Recorder()
self.recorder.reset()
def __init__(self, solve_continuous=False, **kwargs):
super(Control, self).__init__(**kwargs)
self.DOF = 2 # task space dimensionality
self.u = None
self.solve_continuous = solve_continuous
if self.write_to_file is True:
from recorder import Recorder
# set up recorders
self.u_recorder = Recorder('control signal', self.task, 'lqr')
self.xy_recorder = Recorder('end-effector position', self.task, 'lqr')
self.dist_recorder = Recorder('distance from target', self.task, 'lqr')
self.recorders = [self.u_recorder,
self.xy_recorder,
self.dist_recorder]
def sendValue():
rec = Recorder()
data = rec.read()
vol = rec.rms(data) * 50
bam = np.fft.fft(data)
bam = rec.prepare_fft(data, CHUNK)
result_dict = {"volume": vol, "frequency": bam}
for client in clients:
# client.write_message(vol.__str__())
# client.write_message(bam.__str__())
# client.write_message(value.__str__())
client.write_message(tornado.escape.json_encode(result_dict))
def __init__(self, pos = (0, 0)):
filename = datetime.datetime.fromtimestamp(time.time())\
.strftime('%Y-%m-%d %H.%M.%S')
from recorder import Recorder
self.path = Recorder.traceFileToPath(filename)
widget_pos = snapshot.snapWidgetFromPoint(pos, self.path)
# SmartClick does not support Orient
self.pos = (pos[0] - widget_pos[0], pos[1] - widget_pos[1])
def __init__(self, null_control=True, **kwargs):
"""
null_control boolean: apply second controller in null space or not
"""
super(Control, self).__init__(**kwargs)
self.DOF = 2 # task space dimensionality
self.null_control = null_control
if self.write_to_file is True:
from recorder import Recorder
# set up recorders
self.u_recorder = Recorder('control signal', self.task, 'osc')
self.xy_recorder = Recorder('end-effector position', self.task, 'osc')
self.dist_recorder = Recorder('distance from target', self.task, 'osc')
self.recorders = [self.u_recorder,
self.xy_recorder,
self.dist_recorder]
def __init__(self): """Initializes cameras""" spyral.scene.Scene.__init__(self) self.rootCamera = spyral.director.get_camera() self.screenCamera= self.rootCamera.make_child(); self.theaterCamera= self.rootCamera.make_child(virtual_size= geom['theater'].size, real_size= geom['theater'].size, offset= geom['theater'].topleft, layers=['upstage','stage','faces','downstage']); self.recorder= Recorder() self.preventEscapeLock = False
def start_recording(self):
""" Start recording data. """
if self._recorder == None:
logger.info("Starting recorder...")
self._restarts = 0
self._recorder = Recorder(self._path)
self._recorder.start()
self.menu.current_item = self._root_item
self._toggle_item.header = "Stop\nRecording"
self._root_item.header = "DreamCatcher\nRecording..."
self.menu.lcd.backlight(self.menu.lcd.RED)
def startRecorder(self):
strftime = time.strftime('%Y%m%d%H%M%S')
self.workdir = '/tmp/xcorder/{s}/'.format(s=strftime)
if not os.path.isdir(self.workdir):
os.makedirs(self.workdir)
self.recorder = Recorder(
self.video.screen, self.audio.device, self.workdir)
self.recorder.start()
class CustomSimulation(Simulation): #Custom
def __init__(self, code=None):
self.code = code
self.record_every_stock = False
def setting(self, params, fname=None):
"""複数の株だけど、いくつかの株に絞ってシミュレーションする場合は
_fnameにファイル名を指定
"""
if 'from' in params:
self.set_date_from(params['from'])
if 'to' in params:
self.set_date_to(params['to'])
print 'from:', self.date_from
print 'to:', self.date_to
if self.code is not None:
self.simulate_a_stock(self.code) # privateメソッドのため、親クラスのメソッドを直接呼び出す
else:
self.simulate_all_stocks(fname)
def set_trading_system(self, params):
self.trading_system = TradingSystem(params)
def set_date_from(self, date):
self.date_from = date
def set_date_to(self, date):
self.date_to = date
def set_data_loader(self, data_loader):
Simulation.data_loader = data_loader
def set_record_dir(self, record_dir, setting_file_name, system_name, version):
self.recorder = \
Recorder(os.path.join(record_dir,system_name,version))
self.recorder.create_record_folder()
self.recorder.record_setting(setting_file_name)
def set_record_every_stock(self, true_or_false):
self.record_every_stock = true_or_false
def startStopRecording_(self, notification):
if self.recording:
self.recorder.join()
# Create timelapse after recording?
if encode:
self.encoder = Encoder(
self.image_dir, self.encoder_output_basedir)
self.encoder.start()
else:
self.recorder = Recorder(self.image_dir, screenshot_interval)
self.recorder.start()
self.recording = not self.recording
self.setStatus()
def __init__(self, **kwargs):
super(Control, self).__init__(**kwargs)
self.old_target = [None, None]
# load up our network
import glob
# this code goes into the weights folder, finds the most
# recent trial, and loads up the weights
files = sorted(glob.glob('controllers/weights/rnn*'))
print 'loading weights from %s'%files[-1]
W = np.load(files[-1])['arr_0']
num_states = 4
self.rnn = RNNet(shape=[num_states * 2, 32, 32, num_states, num_states],
layers=[Linear(), Tanh(), Tanh(), Linear(), Linear()],
rec_layers=[1,2],
conns={0:[1, 2], 1:[2], 2:[3], 3:[4]},
load_weights=W,
use_GPU=False)
offset, W_end, b_end = self.rnn.offsets[(3,4)]
self.rnn.mask = np.zeros(self.rnn.W.shape, dtype=bool)
self.rnn.mask[offset:b_end] = True
self.rnn.W[offset:W_end] = np.eye(4).flatten()
self.joint_targets = None
self.act = None
# set up recorders
if self.write_to_file is True:
from recorder import Recorder
self.u_recorder = Recorder('control signal', self.task, 'hf')
self.xy_recorder = Recorder('end-effector position', self.task, 'hf')
self.dist_recorder = Recorder('distance from target', self.task, 'hf')
self.recorders = [self.u_recorder,
self.xy_recorder,
self.dist_recorder]
def insertPolygon(self, geometry):
# Convert geometry
wktGeom = geometry.exportToWkt()
# To force 2D geometry
if len(wktGeom.split('Z')) > 1:
wktGeom = wktGeom.split('Z')[0] + wktGeom.split('Z')[1]
wktGeom = wktGeom.replace(" 0,", ",")
wktGeom = wktGeom.replace(" 0)", ")")
geom = "GeomFromText('"
geom += wktGeom
geom += "', 2154)"
geomObj = {}
geomObj['the_geom'] = geom
db = DbManager(CarhabLayerRegistry.instance().getCurrentCarhabLayer().dbPath)
r = Recorder(db, 'polygon')
r.input(geomObj)
db.commit()
db.close()
def __init__(self):
logging.basicConfig(
level=logging.INFO,
filename=Dashcam.LOG_FILE,
format="%(asctime)-15s %(name)-12s %(levelname)s %(message)s",
datefmt="%y-%m-%d %H:%M:%S",
)
self.logger = logging.getLogger(self.__class__.__name__)
current_time = time.localtime()
if current_time < Dashcam.JAN_1ST_2016:
# we probably doesnt have RTC, do not raise error for now
self.logger.error("No RTC? Current time is " + str(datetime.datetime.now()))
# raise ValueError("There doesn't seem to be a RTC")
self.recorder = Recorder()
def play(self):
from recorder import Recorder
if len(self.filenames) == 1:
img = Recorder.imageFileToPath(self.filenames[0])
if not os.path.exists(img):
snapshot.snapWindow(self.title, img)
return "message: " + "check point image file " + img + \
" doesn't exist and has been created"
tempfile = 'snapshots/checkpoint.png'
snapshot.snapWindow(self.title, tempfile)
if not snapshot.compareSnapshots(img, tempfile):
return "error: " + "checkpoint fails: " + tempfile + \
" is inconsistent with " + img
# delete temp file
os.remove(os.path.realpath(tempfile))
else: # this is a temporary behavior modification
match = False
tempfile = 'snapshots/checkpoint.png'
snapshot.snapWindow(self.title, tempfile)
for i in self.filenames:
img = Recorder.imageFileToPath(i)
if not os.path.exists(img):
return "message: check point image file " + img + \
" doesn't exist"
if snapshot.compareSnapshots(img, tempfile):
match = True
break
if not match:
return "error: checkpoint fails: " + tempfile + \
" matches none of the image files"
def __init__(self, **kwargs):
super(Control, self).__init__(**kwargs)
self.DOF = 2 # task space dimensionality
self.u = None
# specify which gradient approximation method to use
self.gradient_approximation = self.spsa
if self.write_to_file is True:
from recorder import Recorder
# set up recorders
self.xy_recorder = Recorder('end-effector position', self.task, 'gradient_spsa')
self.recorders = [self.xy_recorder]
def OnInit( self ):
self.recorder=Recorder()
self.res = wxXmlResource( GUI_FILENAME )
self.frame = self.res.LoadFrame( None, GUI_MAINFRAME_NAME )
self.frame.Show()
EVT_BUTTON(self.frame, XRCID("button_quit"), self.onClick)
EVT_BUTTON(self.frame, XRCID("button_start"), self.onClick)
EVT_BUTTON(self.frame, XRCID("button_stop"), self.onClick)
in_src = XRCCTRL(self.frame, "choice_inputsource")
for n in self.recorder.getDeviceNames():
in_src.Append(n)
in_src.SetSelection(0)
self.frame.Bind(EVT_IDLE, self.onIdle)
return 1
def __init__(self):
gladefile = "main.glade"
self.windowname = "main"
self.wTree = gtk.glade.XML(gladefile, self.windowname)
self.wTree.signal_autoconnect(self)
# load popup
self.popupEpochTree = gtk.glade.XML(gladefile, "menuPopupEpochs")
self.popupEpoch = self.popupEpochTree.get_widget("menuPopupEpochs")
self.popupEpochTree.signal_autoconnect(self)
self.recorder = Recorder()
self.setupEpochs()
# now connect the new-experiment and new-epoch widgets
self.recorder.connect('experiment-create', self.experimentCreate)
self.propertyPanes = {}
def start(self):
# Init the amp
print 'Initializing the amp...'
recorder = Recorder('lslamp', params.FREQ_S, params.LEN_REC_BUF_SEC, params.NUM_CHANNELS)
thread_rec = threading.Thread(target=recorder.record)
thread_rec.start()
# Start plotting
plt.show()
#thread_plot = threading.Thread(target=self.plot_live)
#thread_plot.start()
# Get and display data from the amp
counter = 0
while not is_terminate_requested:
data_last_chunk = recorder.get_new_data(params.LEN_DATA_CHUNK_READ, params.AMP_WAIT_SEC)
recorder.acknowledge_new_data()
print 'recorder.new_data_counter:', recorder.new_data_counter
#print 'data_last_chunk.shape: ', data_last_chunk.shape
# Position the older data to the beginning of the buffer
self.X_buf[0:(self.len_buf - params.LEN_DATA_CHUNK_READ)]\
= self.X_buf[params.LEN_DATA_CHUNK_READ:]
# Insert the new data into the buffer
self.X_buf[(self.len_buf - params.LEN_DATA_CHUNK_READ):]\
= data_last_chunk
#i_row_from = int((counter*params.LEN_DATA_CHUNK_READ) % self.len_buf)
#i_row_to = int(((counter+1)*params.LEN_DATA_CHUNK_READ) % self.len_buf)
#if i_row_to == 0:
# i_row_to = self.len_buf
#print 'i_row_from, i_row_to:', i_row_from, i_row_to
#self.X_buf[i_row_from: i_row_to] = data_last_chunk
#print 'X_buf[i_row_from: i_row_to]:\n', self.X_buf[i_row_from: i_row_to]
if counter % 2 == 0:
self.plot_live()
counter += 1
# End of while
# Stop the amp
recorder.stop_recording()
def sync(self):
""" Send all data in source db but not in the
destination db to the destination db.
"""
from recorder import Recorder
for file in self.files:
srcpath = os.path.join(self.srcdir, file)
dstpath = os.path.join(self.dstdir, file)
srcRec = Recorder(srcpath)
srcdb = srcRec.opendb()
dstRec = Recorder(dstpath)
dstdb = dstRec.opendb()
keys = [k for k in srcdb if k not in dstdb]
count = 0
for key in keys:
dstdb[key] = srcdb[key]
print("transferring %s" % key)
count += 1
dstRec.persist()
print("done, %s records transferred to %s" % (count, dstpath))
def __init__(self):
"""Init class with attributes."""
self.website = Website()
self.collector = Collector()
self.cleaner = Cleaner()
self.recorder = Recorder()
class PpoAgent(object):
envs = None
def __init__(
self,
*,
scope,
ob_space,
ac_space,
stochpol_fn,
nsteps,
nepochs=4,
nminibatches=1,
gamma=0.99,
gamma_ext=0.99,
lam=0.95,
ent_coef=0,
cliprange=0.2,
max_grad_norm=1.0,
vf_coef=1.0,
lr=30e-5,
adam_hps=None,
testing=False,
comm=None,
comm_train=None,
use_news=False,
update_ob_stats_every_step=True,
int_coeff=None,
ext_coeff=None,
obs_save_flag=False,
):
self.lr = lr
self.ext_coeff = ext_coeff
self.int_coeff = int_coeff
self.use_news = use_news
self.update_ob_stats_every_step = update_ob_stats_every_step
self.abs_scope = (tf.get_variable_scope().name + '/' +
scope).lstrip('/')
self.testing = testing
self.comm_log = MPI.COMM_SELF
if comm is not None and comm.Get_size() > 1:
self.comm_log = comm
assert not testing or comm.Get_rank(
) != 0, "Worker number zero can't be testing"
if comm_train is not None:
self.comm_train, self.comm_train_size = comm_train, comm_train.Get_size(
)
else:
self.comm_train, self.comm_train_size = self.comm_log, self.comm_log.Get_size(
)
self.is_log_leader = self.comm_log.Get_rank() == 0
self.is_train_leader = self.comm_train.Get_rank() == 0
self.obs_save_flag = obs_save_flag
if self.is_log_leader:
self.obs_rec = [{'acs': [], 'obs': []} for i in range(100)]
with tf.variable_scope(scope):
self.best_ret = -np.inf
self.local_best_ret = -np.inf
self.rooms = []
self.local_rooms = []
self.scores = []
self.ob_space = ob_space
self.ac_space = ac_space
self.stochpol = stochpol_fn()
self.nepochs = nepochs
self.cliprange = cliprange
self.nsteps = nsteps
self.nminibatches = nminibatches
self.gamma = gamma
self.gamma_ext = gamma_ext
self.lam = lam
self.adam_hps = adam_hps or dict()
self.ph_adv = tf.placeholder(tf.float32, [None, None])
self.ph_ret_int = tf.placeholder(tf.float32, [None, None])
self.ph_ret_ext = tf.placeholder(tf.float32, [None, None])
self.ph_oldnlp = tf.placeholder(tf.float32, [None, None])
self.ph_oldvpred = tf.placeholder(tf.float32, [None, None])
self.ph_lr = tf.placeholder(tf.float32, [])
self.ph_lr_pred = tf.placeholder(tf.float32, [])
self.ph_cliprange = tf.placeholder(tf.float32, [])
#Define loss.
neglogpac = self.stochpol.pd_opt.neglogp(self.stochpol.ph_ac)
entropy = tf.reduce_mean(self.stochpol.pd_opt.entropy())
vf_loss_int = (0.5 * vf_coef) * tf.reduce_mean(
tf.square(self.stochpol.vpred_int_opt - self.ph_ret_int))
vf_loss_ext = (0.5 * vf_coef) * tf.reduce_mean(
tf.square(self.stochpol.vpred_ext_opt - self.ph_ret_ext))
vf_loss = vf_loss_int + vf_loss_ext
ratio = tf.exp(self.ph_oldnlp - neglogpac) # p_new / p_old
negadv = -self.ph_adv
pg_losses1 = negadv * ratio
pg_losses2 = negadv * tf.clip_by_value(
ratio, 1.0 - self.ph_cliprange, 1.0 + self.ph_cliprange)
pg_loss = tf.reduce_mean(tf.maximum(pg_losses1, pg_losses2))
ent_loss = (-ent_coef) * entropy
approxkl = .5 * tf.reduce_mean(
tf.square(neglogpac - self.ph_oldnlp))
maxkl = .5 * tf.reduce_max(tf.square(neglogpac - self.ph_oldnlp))
clipfrac = tf.reduce_mean(
tf.to_float(tf.greater(tf.abs(ratio - 1.0),
self.ph_cliprange)))
loss = pg_loss + ent_loss + vf_loss + self.stochpol.aux_loss
#Create optimizer.
params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.abs_scope)
logger.info("PPO: using MpiAdamOptimizer connected to %i peers" %
self.comm_train_size)
trainer = MpiAdamOptimizer(self.comm_train,
learning_rate=self.ph_lr,
**self.adam_hps)
grads_and_vars = trainer.compute_gradients(loss, params)
grads, vars = zip(*grads_and_vars)
if max_grad_norm:
_, _grad_norm = tf.clip_by_global_norm(grads, max_grad_norm)
global_grad_norm = tf.global_norm(grads)
grads_and_vars = list(zip(grads, vars))
self._train = trainer.apply_gradients(grads_and_vars)
#Quantities for reporting.
self._losses = [
loss, pg_loss, vf_loss, entropy, clipfrac, approxkl, maxkl,
self.stochpol.aux_loss, self.stochpol.feat_var,
self.stochpol.max_feat, global_grad_norm
]
self.loss_names = [
'tot', 'pg', 'vf', 'ent', 'clipfrac', 'approxkl', 'maxkl',
"auxloss", "featvar", "maxfeat", "gradnorm"
]
self.I = None
self.disable_policy_update = None
allvars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope=self.abs_scope)
if self.is_log_leader:
tf_util.display_var_info(allvars)
tf.get_default_session().run(tf.variables_initializer(allvars))
sync_from_root(tf.get_default_session(),
allvars) #Syncs initialization across mpi workers.
self.t0 = time.time()
self.global_tcount = 0
def start_interaction(self, venvs, disable_policy_update=False):
self.I = InteractionState(ob_space=self.ob_space,
ac_space=self.ac_space,
nsteps=self.nsteps,
gamma=self.gamma,
venvs=venvs,
stochpol=self.stochpol,
comm=self.comm_train)
self.disable_policy_update = disable_policy_update
self.recorder = Recorder(nenvs=self.I.nenvs,
score_multiple=venvs[0].score_multiple)
def collect_random_statistics(self, num_timesteps):
#Initializes observation normalization with data from random agent.
all_ob = []
for lump in range(self.I.nlump):
all_ob.append(self.I.venvs[lump].reset())
for step in range(num_timesteps):
for lump in range(self.I.nlump):
acs = np.random.randint(low=0,
high=self.ac_space.n,
size=(self.I.lump_stride, ))
self.I.venvs[lump].step_async(acs)
ob, _, _, _ = self.I.venvs[lump].step_wait()
all_ob.append(ob)
if len(all_ob) % (128 * self.I.nlump) == 0:
ob_ = np.asarray(all_ob).astype(np.float32).reshape(
(-1, *self.ob_space.shape))
self.stochpol.ob_rms.update(ob_[:, :, :, -1:])
all_ob.clear()
def stop_interaction(self):
self.I.close()
self.I = None
@logger.profile("update")
def update(self):
#Some logic gathering best ret, rooms etc using MPI.
temp = sum(MPI.COMM_WORLD.allgather(self.local_rooms), [])
temp = sorted(list(set(temp)))
self.rooms = temp
temp = sum(MPI.COMM_WORLD.allgather(self.scores), [])
temp = sorted(list(set(temp)))
self.scores = temp
temp = sum(MPI.COMM_WORLD.allgather([self.local_best_ret]), [])
self.best_ret = max(temp)
eprews = MPI.COMM_WORLD.allgather(
np.mean(list(self.I.statlists["eprew"])))
local_best_rets = MPI.COMM_WORLD.allgather(self.local_best_ret)
n_rooms = sum(MPI.COMM_WORLD.allgather([len(self.local_rooms)]), [])
if MPI.COMM_WORLD.Get_rank() == 0:
logger.info(f"Rooms visited {self.rooms}")
logger.info(f"Best return {self.best_ret}")
logger.info(f"Best local return {sorted(local_best_rets)}")
logger.info(f"eprews {sorted(eprews)}")
logger.info(f"n_rooms {sorted(n_rooms)}")
logger.info(f"Extrinsic coefficient {self.ext_coeff}")
logger.info(f"Gamma {self.gamma}")
logger.info(f"Gamma ext {self.gamma_ext}")
logger.info(f"All scores {sorted(self.scores)}")
#Normalize intrinsic rewards.
rffs_int = np.array(
[self.I.rff_int.update(rew) for rew in self.I.buf_rews_int.T])
self.I.rff_rms_int.update(rffs_int.ravel())
rews_int = self.I.buf_rews_int / np.sqrt(self.I.rff_rms_int.var)
self.mean_int_rew = np.mean(rews_int)
self.max_int_rew = np.max(rews_int)
#Don't normalize extrinsic rewards.
rews_ext = self.I.buf_rews_ext
rewmean, rewstd, rewmax = self.I.buf_rews_int.mean(
), self.I.buf_rews_int.std(), np.max(self.I.buf_rews_int)
#Calculate intrinsic returns and advantages.
lastgaelam = 0
for t in range(self.nsteps - 1, -1, -1): # nsteps-2 ... 0
if self.use_news:
nextnew = self.I.buf_news[:, t +
1] if t + 1 < self.nsteps else self.I.buf_new_last
else:
nextnew = 0.0 #No dones for intrinsic reward.
nextvals = self.I.buf_vpreds_int[:, t +
1] if t + 1 < self.nsteps else self.I.buf_vpred_int_last
nextnotnew = 1 - nextnew
delta = rews_int[:,
t] + self.gamma * nextvals * nextnotnew - self.I.buf_vpreds_int[:,
t]
self.I.buf_advs_int[:,
t] = lastgaelam = delta + self.gamma * self.lam * nextnotnew * lastgaelam
rets_int = self.I.buf_advs_int + self.I.buf_vpreds_int
#Calculate extrinsic returns and advantages.
lastgaelam = 0
for t in range(self.nsteps - 1, -1, -1): # nsteps-2 ... 0
nextnew = self.I.buf_news[:, t +
1] if t + 1 < self.nsteps else self.I.buf_new_last
#Use dones for extrinsic reward.
nextvals = self.I.buf_vpreds_ext[:, t +
1] if t + 1 < self.nsteps else self.I.buf_vpred_ext_last
nextnotnew = 1 - nextnew
delta = rews_ext[:,
t] + self.gamma_ext * nextvals * nextnotnew - self.I.buf_vpreds_ext[:,
t]
self.I.buf_advs_ext[:,
t] = lastgaelam = delta + self.gamma_ext * self.lam * nextnotnew * lastgaelam
rets_ext = self.I.buf_advs_ext + self.I.buf_vpreds_ext
#Combine the extrinsic and intrinsic advantages.
self.I.buf_advs = self.int_coeff * self.I.buf_advs_int + self.ext_coeff * self.I.buf_advs_ext
#Collects info for reporting.
info = dict(
advmean=self.I.buf_advs.mean(),
advstd=self.I.buf_advs.std(),
retintmean=rets_int.mean(), # previously retmean
retintstd=rets_int.std(), # previously retstd
retextmean=rets_ext.mean(), # previously not there
retextstd=rets_ext.std(), # previously not there
rewintmean_unnorm=rewmean, # previously rewmean
rewintmax_unnorm=rewmax, # previously not there
rewintmean_norm=self.mean_int_rew, # previously rewintmean
rewintmax_norm=self.max_int_rew, # previously rewintmax
rewintstd_unnorm=rewstd, # previously rewstd
vpredintmean=self.I.buf_vpreds_int.mean(), # previously vpredmean
vpredintstd=self.I.buf_vpreds_int.std(), # previously vrpedstd
vpredextmean=self.I.buf_vpreds_ext.mean(), # previously not there
vpredextstd=self.I.buf_vpreds_ext.std(), # previously not there
ev_int=np.clip(
explained_variance(self.I.buf_vpreds_int.ravel(),
rets_int.ravel()), -1, None),
ev_ext=np.clip(
explained_variance(self.I.buf_vpreds_ext.ravel(),
rets_ext.ravel()), -1, None),
rooms=SemicolonList(self.rooms),
n_rooms=len(self.rooms),
best_ret=self.best_ret,
reset_counter=self.I.reset_counter)
info[f'mem_available'] = psutil.virtual_memory().available
to_record = {
'acs': self.I.buf_acs,
'rews_int': self.I.buf_rews_int,
'rews_int_norm': rews_int,
'rews_ext': self.I.buf_rews_ext,
'vpred_int': self.I.buf_vpreds_int,
'vpred_ext': self.I.buf_vpreds_ext,
'adv_int': self.I.buf_advs_int,
'adv_ext': self.I.buf_advs_ext,
'ent': self.I.buf_ent,
'ret_int': rets_int,
'ret_ext': rets_ext,
}
if self.I.venvs[0].record_obs:
to_record['obs'] = self.I.buf_obs[None]
self.recorder.record(bufs=to_record, infos=self.I.buf_epinfos)
#Create feeddict for optimization.
envsperbatch = self.I.nenvs // self.nminibatches
ph_buf = [
(self.stochpol.ph_ac, self.I.buf_acs),
(self.ph_ret_int, rets_int),
(self.ph_ret_ext, rets_ext),
(self.ph_oldnlp, self.I.buf_nlps),
(self.ph_adv, self.I.buf_advs),
]
if self.I.mem_state is not NO_STATES:
ph_buf.extend([
(self.stochpol.ph_istate, self.I.seg_init_mem_state),
(self.stochpol.ph_new, self.I.buf_news),
])
verbose = True
if verbose and self.is_log_leader:
samples = np.prod(self.I.buf_advs.shape)
logger.info(
"buffer shape %s, samples_per_mpi=%i, mini_per_mpi=%i, samples=%i, mini=%i "
% (str(self.I.buf_advs.shape), samples, samples //
self.nminibatches, samples * self.comm_train_size,
samples * self.comm_train_size // self.nminibatches))
logger.info(" " * 6 + fmt_row(13, self.loss_names))
epoch = 0
start = 0
#Optimizes on current data for several epochs.
while epoch < self.nepochs:
end = start + envsperbatch
mbenvinds = slice(start, end, None)
fd = {ph: buf[mbenvinds] for (ph, buf) in ph_buf}
fd.update({self.ph_lr: self.lr, self.ph_cliprange: self.cliprange})
fd[self.stochpol.ph_ob[None]] = np.concatenate([
self.I.buf_obs[None][mbenvinds],
self.I.buf_ob_last[None][mbenvinds, None]
], 1)
assert list(fd[self.stochpol.ph_ob[None]].shape) == [self.I.nenvs//self.nminibatches, self.nsteps + 1] + list(self.ob_space.shape), \
[fd[self.stochpol.ph_ob[None]].shape, [self.I.nenvs//self.nminibatches, self.nsteps + 1] + list(self.ob_space.shape)]
fd.update({
self.stochpol.ph_mean: self.stochpol.ob_rms.mean,
self.stochpol.ph_std: self.stochpol.ob_rms.var**0.5
})
ret = tf.get_default_session().run(self._losses + [self._train],
feed_dict=fd)[:-1]
if not self.testing:
lossdict = dict(zip([n for n in self.loss_names], ret), axis=0)
else:
lossdict = {}
#Synchronize the lossdict across mpi processes, otherwise weights may be rolled back on one process but not another.
_maxkl = lossdict.pop('maxkl')
lossdict = dict_gather(self.comm_train, lossdict, op='mean')
maxmaxkl = dict_gather(self.comm_train, {"maxkl": _maxkl},
op='max')
lossdict["maxkl"] = maxmaxkl["maxkl"]
if verbose and self.is_log_leader:
logger.info(
"%i:%03i %s" %
(epoch, start,
fmt_row(13, [lossdict[n] for n in self.loss_names])))
start += envsperbatch
if start == self.I.nenvs:
epoch += 1
start = 0
if self.is_train_leader:
self.I.stats["n_updates"] += 1
info.update([('opt_' + n, lossdict[n]) for n in self.loss_names])
tnow = time.time()
info['tps'] = self.nsteps * self.I.nenvs / (tnow -
self.I.t_last_update)
info['time_elapsed'] = time.time() - self.t0
self.I.t_last_update = tnow
self.stochpol.update_normalization( # Necessary for continuous control tasks with odd obs ranges, only implemented in mlp policy,
ob=self.I.buf_obs # NOTE: not shared via MPI
)
return info
def env_step(self, l, acs):
self.I.venvs[l].step_async(acs)
self.I.env_results[l] = None
def env_get(self, l):
"""
Get most recent (obs, rews, dones, infos) from vectorized environment
Using step_wait if necessary
"""
if self.I.step_count == 0: # On the zeroth step with a new venv, we need to call reset on the environment
ob = self.I.venvs[l].reset()
out = self.I.env_results[l] = (ob, None,
np.ones(self.I.lump_stride,
bool), {})
else:
if self.I.env_results[l] is None:
out = self.I.env_results[l] = self.I.venvs[l].step_wait()
else:
out = self.I.env_results[l]
return out
@logger.profile("step")
def step(self):
#Does a rollout.
t = self.I.step_count % self.nsteps
epinfos = []
for l in range(self.I.nlump):
obs, prevrews, news, infos = self.env_get(l)
if self.is_log_leader:
if self.obs_save_flag:
while self.I.stats['epcount'] + 1 > len(self.obs_rec):
self.obs_rec.append({'obs': [], 'acs': []})
self.obs_rec[self.I.stats['epcount']]['obs'].append(obs)
for env_pos_in_lump, info in enumerate(infos):
if 'episode' in info:
#Information like rooms visited is added to info on end of episode.
epinfos.append(info['episode'])
info_with_places = info['episode']
try:
info_with_places['places'] = info['episode'][
'visited_rooms']
except:
import ipdb
ipdb.set_trace()
self.I.buf_epinfos[
env_pos_in_lump +
l * self.I.lump_stride][t] = info_with_places
sli = slice(l * self.I.lump_stride, (l + 1) * self.I.lump_stride)
memsli = slice(None) if self.I.mem_state is NO_STATES else sli
dict_obs = self.stochpol.ensure_observation_is_dict(obs)
with logger.profile_kv("policy_inference"):
#Calls the policy and value function on current observation.
acs, vpreds_int, vpreds_ext, nlps, self.I.mem_state[
memsli], ent = self.stochpol.call(
dict_obs,
news,
self.I.mem_state[memsli],
update_obs_stats=self.update_ob_stats_every_step)
if self.is_log_leader:
if self.obs_save_flag:
while self.I.stats['epcount'] + 1 > len(self.obs_rec):
self.obs_rec.append({'obs': [], 'acs': []})
self.obs_rec[self.I.stats['epcount']]['acs'].append(acs)
self.env_step(l, acs)
#Update buffer with transition.
for k in self.stochpol.ph_ob_keys:
self.I.buf_obs[k][sli, t] = dict_obs[k]
self.I.buf_news[sli, t] = news
self.I.buf_vpreds_int[sli, t] = vpreds_int
self.I.buf_vpreds_ext[sli, t] = vpreds_ext
self.I.buf_nlps[sli, t] = nlps
self.I.buf_acs[sli, t] = acs
self.I.buf_ent[sli, t] = ent
if t > 0:
self.I.buf_rews_ext[sli, t - 1] = prevrews
self.I.step_count += 1
if t == self.nsteps - 1 and not self.disable_policy_update:
#We need to take one extra step so every transition has a reward.
for l in range(self.I.nlump):
sli = slice(l * self.I.lump_stride,
(l + 1) * self.I.lump_stride)
memsli = slice(None) if self.I.mem_state is NO_STATES else sli
nextobs, rews, nextnews, _ = self.env_get(l)
dict_nextobs = self.stochpol.ensure_observation_is_dict(
nextobs)
for k in self.stochpol.ph_ob_keys:
self.I.buf_ob_last[k][sli] = dict_nextobs[k]
self.I.buf_new_last[sli] = nextnews
with logger.profile_kv("policy_inference"):
_, self.I.buf_vpred_int_last[
sli], self.I.buf_vpred_ext_last[
sli], _, _, _ = self.stochpol.call(
dict_nextobs,
nextnews,
self.I.mem_state[memsli],
update_obs_stats=False)
self.I.buf_rews_ext[sli, t] = rews
#Calcuate the intrinsic rewards for the rollout.
fd = {}
fd[self.stochpol.ph_ob[None]] = np.concatenate(
[self.I.buf_obs[None], self.I.buf_ob_last[None][:, None]], 1)
fd.update({
self.stochpol.ph_mean: self.stochpol.ob_rms.mean,
self.stochpol.ph_std: self.stochpol.ob_rms.var**0.5
})
fd[self.stochpol.ph_ac] = self.I.buf_acs
self.I.buf_rews_int[:] = tf.get_default_session().run(
self.stochpol.int_rew, fd)
if not self.update_ob_stats_every_step:
#Update observation normalization parameters after the rollout is completed.
obs_ = self.I.buf_obs[None].astype(np.float32)
self.stochpol.ob_rms.update(
obs_.reshape((-1, *obs_.shape[2:]))[:, :, :, -1:])
if not self.testing:
update_info = self.update()
else:
update_info = {}
self.I.seg_init_mem_state = copy(self.I.mem_state)
global_i_stats = dict_gather(self.comm_log, self.I.stats, op='sum')
global_deque_mean = dict_gather(
self.comm_log,
{n: np.mean(dvs)
for n, dvs in self.I.statlists.items()},
op='mean')
update_info.update(global_i_stats)
update_info.update(global_deque_mean)
self.global_tcount = global_i_stats['tcount']
for infos_ in self.I.buf_epinfos:
infos_.clear()
else:
update_info = {}
#Some reporting logic.
for epinfo in epinfos:
if self.testing:
self.I.statlists['eprew_test'].append(epinfo['r'])
self.I.statlists['eplen_test'].append(epinfo['l'])
else:
if "visited_rooms" in epinfo:
self.local_rooms += list(epinfo["visited_rooms"])
self.local_rooms = sorted(list(set(self.local_rooms)))
score_multiple = self.I.venvs[0].score_multiple
if score_multiple is None:
score_multiple = 1000
rounded_score = int(
epinfo["r"] / score_multiple) * score_multiple
self.scores.append(rounded_score)
self.scores = sorted(list(set(self.scores)))
self.I.statlists['eprooms'].append(
len(epinfo["visited_rooms"]))
self.I.statlists['eprew'].append(epinfo['r'])
if self.local_best_ret is None:
self.local_best_ret = epinfo["r"]
elif epinfo["r"] > self.local_best_ret:
self.local_best_ret = epinfo["r"]
self.I.statlists['eplen'].append(epinfo['l'])
self.I.stats['epcount'] += 1
self.I.stats['tcount'] += epinfo['l']
self.I.stats['rewtotal'] += epinfo['r']
# self.I.stats["best_ext_ret"] = self.best_ret
return {'update': update_info}
def __init__(self):
logging.basicConfig(format='%(asctime)s %(levelname)s: %(message)s',
level=logging.DEBUG)
logging.info('Start Robotic Arm Control')
self.robotic_arm = RoboticArm()
self.robotic_arm.recorder = Recorder(usb_arm=self.robotic_arm.usb_arm)
self.file_path = None
Gtk.Window.__init__(self, title='Robotic Arm Control')
self.connect('delete_event', self.delete_event)
self.connect('destroy', self.destroy)
self.set_border_width(10)
self.base_label = Gtk.Label('Base: ')
self.base_label.set_alignment(0, 0)
self.base_label.show()
self.base_clockwise = Gtk.Button('Clockwise')
self.base_clockwise.connect('clicked',
self._action_base_clockwise, None)
self.base_clockwise.show()
self.base_anticlockwise = Gtk.Button('AntiClockwise')
self.base_anticlockwise.connect('clicked',
self._action_base_anticlockwise, None)
self.base_anticlockwise.show()
self.base_stop = Gtk.Button('Stop')
self.base_stop.connect('clicked', self._action_base_stop, None)
self.base_stop.show()
self.arm_label = Gtk.Label('Shoulder: ')
self.arm_label.set_alignment(0, 0)
self.arm_label.show()
self.arm_up = Gtk.Button('Up')
self.arm_up.connect('clicked', self._action_arm_up, None)
self.arm_up.show()
self.arm_down = Gtk.Button('Down')
self.arm_down.connect('clicked', self._action_arm_down, None)
self.arm_down.show()
self.arm_stop = Gtk.Button('Stop')
self.arm_stop.connect('clicked', self._action_arm_stop, None)
self.arm_stop.show()
self.elbow_label = Gtk.Label('Elbow: ')
self.elbow_label.set_alignment(0, 0)
self.elbow_label.show()
self.elbow_up = Gtk.Button('Up')
self.elbow_up.connect('clicked', self._action_elbow_up, None)
self.elbow_up.show()
self.elbow_down = Gtk.Button('Down')
self.elbow_down.connect('clicked', self._action_elbow_down, None)
self.elbow_down.show()
self.elbow_stop = Gtk.Button('Stop')
self.elbow_stop.connect('clicked', self._action_elbow_stop, None)
self.elbow_stop.show()
self.wrist_label = Gtk.Label('Wrist: ')
self.wrist_label.set_alignment(0, 0)
self.wrist_label.show()
self.wrist_up = Gtk.Button('Up')
self.wrist_up.connect('clicked', self._action_wrist_up, None)
self.wrist_up.show()
self.wrist_down = Gtk.Button('Down')
self.wrist_down.connect('clicked', self._action_wrist_down, None)
self.wrist_down.show()
self.wrist_stop = Gtk.Button('Stop')
self.wrist_stop.connect('clicked', self._action_wrist_stop, None)
self.wrist_stop.show()
self.gripper_label = Gtk.Label('Gripper: ')
self.gripper_label.set_alignment(0, 0)
self.gripper_label.show()
self.gripper_open = Gtk.Button('Open')
self.gripper_open.connect('clicked', self._action_gripper_open, None)
self.gripper_open.show()
self.gripper_close = Gtk.Button('Close')
self.gripper_close.connect('clicked', self._action_gripper_close, None)
self.gripper_close.show()
self.gripper_stop = Gtk.Button('Stop')
self.gripper_stop.connect('clicked', self._action_gripper_stop, None)
self.gripper_stop.show()
self.led_label = Gtk.Label('Light: ')
self.led_label.set_alignment(0, 0)
self.led_label.show()
self.led = Gtk.Button('Off')
self.led.connect('clicked', self._action_led, None)
self.led.show()
self.stop_all = Gtk.Button('Stop All')
self.stop_all.connect('clicked', self._action_stop_all, None)
self.stop_all.show()
self.image = Gtk.Image()
self.image.set_from_file('arm.jpg')
self.image.show()
self.space_label = Gtk.Label(' ')
self.space_label.set_alignment(0, 0)
self.space_label.show()
self.rec_label = Gtk.Label('Recorded Program:')
self.rec_label.set_alignment(0, 0)
self.rec_label.show()
self.record_switch = Gtk.Button('Record')
self.record_switch.connect('clicked', self._action_record_switch, None)
self.record_switch.show()
self.record_play = Gtk.Button('Play')
self.record_play.connect('clicked', self._action_record_play, None)
self.record_play.show()
self.record_play_reverse = Gtk.Button('Play Reversed')
self.record_play_reverse.connect('clicked',
self._action_record_play_reverse,
None)
self.record_play_reverse.show()
self.record_clear = Gtk.Button('Clear Program')
self.record_clear.connect('clicked', self._action_record_clear, None)
self.record_clear.show()
self.file_label = Gtk.Label(' - unsaved - ')
self.file_label.set_alignment(0, 0)
self.file_label.show()
self.nsteps_label = Gtk.Label('# Steps: ')
self.nsteps_label.set_alignment(0, 0)
self.nsteps_label.show()
self.runtime_label = Gtk.Label('Runtime: ')
self.runtime_label.set_alignment(0, 0)
self.runtime_label.show()
self.nsteps_value_label = Gtk.Label('0')
self.nsteps_value_label.set_alignment(0, 0)
self.nsteps_value_label.show()
self.runtime_value_label = Gtk.Label('00:00')
self.runtime_value_label.set_alignment(0, 0)
self.runtime_value_label.show()
self.save = Gtk.Button('Save')
self.save.connect('clicked', self._action_save, None)
self.save.show()
self.open = Gtk.Button('Open')
self.open.connect('clicked', self._action_open, None)
self.open.show()
adj = Gtk.Adjustment(2.0, 0.0, 100.0, 0.1)
self.run_4_entry = Gtk.SpinButton()
self.run_4_entry.configure(adj, 0.1, 2)
self.run_4_entry.show()
self.run_4_toggle = Gtk.CheckButton('Run for sec:')
self.run_4_toggle.set_active(False)
self.run_4_toggle.connect('toggled', self._action_run_4_toggle, None)
self.run_4_toggle.show()
self.controls = Gtk.Grid()
self.controls.attach(self.base_label, 0, 0, 1, 1)
self.controls.attach(self.base_clockwise, 1, 0, 1, 1)
self.controls.attach(self.base_stop, 2, 0, 1, 1)
self.controls.attach(self.base_anticlockwise, 3, 0, 1, 1)
self.controls.attach(self.arm_label, 0, 1, 1, 1)
self.controls.attach(self.arm_up, 1, 1, 1, 1)
self.controls.attach(self.arm_stop, 2, 1, 1, 1)
self.controls.attach(self.arm_down, 3, 1, 1, 1)
self.controls.attach(self.elbow_label, 0, 2, 1, 1)
self.controls.attach(self.elbow_up, 1, 2, 1, 1)
self.controls.attach(self.elbow_stop, 2, 2, 1, 1)
self.controls.attach(self.elbow_down, 3, 2, 1, 1)
self.controls.attach(self.wrist_label, 0, 3, 1, 1)
self.controls.attach(self.wrist_up, 1, 3, 1, 1)
self.controls.attach(self.wrist_stop, 2, 3, 1, 1)
self.controls.attach(self.wrist_down, 3, 3, 1, 1)
self.controls.attach(self.gripper_label, 0, 4, 1, 1)
self.controls.attach(self.gripper_open, 1, 4, 1, 1)
self.controls.attach(self.gripper_stop, 2, 4, 1, 1)
self.controls.attach(self.gripper_close, 3, 4, 1, 1)
self.controls.attach(self.led_label, 0, 5, 1, 1)
self.controls.attach(self.led, 1, 5, 3, 1)
self.controls.attach(self.stop_all, 1, 6, 3, 1)
self.controls.attach(self.image, 4, 0, 1, 7)
self.controls.attach(self.run_4_toggle, 0, 7, 2, 1)
self.controls.attach(self.run_4_entry, 2, 7, 2, 1)
self.controls.attach(self.space_label, 0, 8, 5, 1)
self.controls.attach(self.rec_label, 0, 9, 5, 1)
self.controls.attach(self.file_label, 0, 10, 5, 1)
self.controls.attach(self.record_switch, 4, 10, 1, 1)
self.controls.attach(self.record_play, 4, 11, 1, 1)
self.controls.attach(self.record_play_reverse, 4, 12, 1, 1)
self.controls.attach(self.record_clear, 4, 13, 1, 1)
self.controls.attach(self.nsteps_label, 0, 12, 2, 1)
self.controls.attach(self.runtime_label, 0, 13, 2, 1)
self.controls.attach(self.nsteps_value_label, 2, 12, 2, 1)
self.controls.attach(self.runtime_value_label, 2, 13, 2, 1)
self.controls.attach(self.save, 0, 14, 4, 1)
self.controls.attach(self.open, 4, 14, 1, 1)
self.controls.show()
self.add(self.controls)
self.show()
logging.info('Started Robotic Arm Control')
def pitch2(bank, dependency):
odir = setup_dir(dependency)
section_title = "--------{title}---------"
question = "Q.{n}: {q}"
total_time = 0
pitch_start = time()
q_times = {}
next = 1
q_done = set()
while next != 0:
q_index = next
q_done.add(q_index)
q = bank[q_index]
print(question.format(n=q_index, q=q))
q_start = time()
q_fname = string_to_filename(q)
rec_path = f"{odir}/{q_fname}.wav"
rec = Recorder(rec_path)
rec.start()
while next in q_done:
print(set(bank) - set(q_done))
inp = input("Next question:")
try:
inp = int(inp)
except:
pass
if inp in q_done:
print(f"repeated q {q_done}")
elif inp not in bank:
print("invalid q no.")
else:
next = inp
rec.stop()
rec.join()
q_end = time()
q_time = int(q_end - q_start)
# print (f"Duration:{q_time}s TotalTime:{total_time}s")
total_time += q_time
q_times[q_index] = q_time
wall_time = int(time() - pitch_start)
print("++++++++++++PITCH Finished++++++{wall_time} secs+++++++")
for section in dependency:
total_time = sum(q_times[q] for q in dependency[section])
num_questions = len(dependency[section])
print(
f"---------{section}---duration {total_time} seconds --- #{num_questions} questions ----"
)
for q_index in sorted(q_times, reverse=True):
print(f"{q_times[q_index]} secs: {bank[q_index]}")
shutil.copytree(odir, "latest")
def __init__(self): self.sampler = GridSampler() self.recorder = Recorder() self.lidar = Lidar() self.tracer = Tracer(self.lidar, self.recorder)
def getFlightPrice(driver, url, id, worker_num):
"""
This function send url to remote server and get the result.
Save the result into file.
Input parameter:
dirver: The web driver.
url: type[string] . The url address.
id: type[int] The flight id.
worker_num: type[int] the worker number.
"""
# flight_module_class_name='flight-module.segment.offer-listing'
flight_id = str(id)
re = Recorder(flight_id, recorder.RecorderMode.binary)
if runDriver(driver, url, id) == True:
#Write the fight id.
flight_id = "<flight_id>" + flight_id
re.writeN(flight_id)
#Write the url
re.write("<url>")
re.writeN(url)
#Write the search date
t = datetime.datetime.now().strftime("%Y-%m-%d %H %M %S")
search_date = "<search_date>" + t
re.writeN(search_date)
#Write the worker number
re.write("<worker_num>")
re.writeN(str(worker_num))
time.sleep(1)
body_element = driver.find_element_by_tag_name('body')
re.writeN(body_element.text)
time.sleep(1)
re.finish()
else:
print("worker[%d] failed to handle flight_id[%d]" % (worker_num, id))
def __init__(self, config, pnhandler, inlet_amp, stimulator = None):
self.config = config
self.kalman_time = 0
# init pnhandler, inlet_amp, stimulator and decoder/filter
self.pnhandler = pnhandler
self.inlet_amp = inlet_amp
self.stimulator = stimulator
self.recorder = Recorder(self.config, prediction = True)
self.decoder = None
self.filter = None
# params of amp data stream
self.numCh = self.config['amp_config'].getint('n_channels_amp')
# if feedback, last channel is stimulation data
if self.config['amp_config'].getboolean('feedback'):
self.numCh -= 1
self.offCh = self.numCh
self.srate = self.config['amp_config'].getint('fs_amp')
# time of realtime experiment (inf if it set to -1)
experiment_time = self.config['realtime'].getint('experiment_time_realtime')
self.experiment_time = float('inf') if experiment_time < 0 else experiment_time * self.srate
avatar_freq = self.config['avatar'].getint('avatar_freq')
self.avatar_period = 1 / avatar_freq
self.avatar_buffer_size = self.config['avatar'].getint('avatar_buffer_size')
# buffer for plotting
self.coordbuff = []
# PN channels for finger joints
self.pn_fingers_range = np.asarray(list(map(int, self.config['avatar']['pn_fingers_coords'].split())))
# avatar channels for finger joints
self.avatar_fingers_range = np.asarray(list(map(int, self.config['avatar']['avatar_fingers_coords'].split())))
# buffer
self.avatar_buffer = np.zeros(self.avatar_buffer_size)
# initializing Avatar connection
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.server_address = ('127.0.0.1', 12001)
self.client_address = ('127.0.0.1', 9001)
self.sock.bind(self.server_address)
self._printm('UDP from {} {} established'.format(*self.server_address))
# get parameters of stimulation and setup redractory period
self.stimulator.configurate(self.config['stimulation'].getint('electrode_start'),
self.config['stimulation'].getint('electrode_stop'))
self.stimulation_time = self.config['stimulation'].getint('stimulation_time')
self.refractory_time = self.config['stimulation'].getint('refractory_time')
self.refractory_start = 0
self.avatar_bias_thumb = self.config['avatar'].getint('avatar_bias_thumb')
self.avatar_scalar_thumb = self.config['avatar'].getfloat('avatar_scalar_thumb')
self.avatar_bias_index = self.config['avatar'].getint('avatar_bias_index')
self.avatar_scalar_index = self.config['avatar'].getfloat('avatar_scalar_index')
self.avatar_parameters = refresh_avatar_parameters()
# control from keyboard
self.queue_keyboard = Queue()
self.avatar_data_type = False
self.realtime_close = False
on_press = lambda key: keyboard_on_press(self.queue_keyboard, key)
self.listener = Listener(on_press=on_press, on_release=keyboard_on_release)
self.listener.start()
class Control(control.Control):
"""
A controller that implements operational space control.
Controls the (x,y) position of a robotic arm end-effector.
"""
def __init__(self, solve_continuous=False, **kwargs):
super(Control, self).__init__(**kwargs)
self.DOF = 2 # task space dimensionality
self.u = None
self.solve_continuous = solve_continuous
if self.write_to_file is True:
from recorder import Recorder
# set up recorders
self.u_recorder = Recorder('control signal', self.task, 'lqr')
self.xy_recorder = Recorder('end-effector position', self.task, 'lqr')
self.dist_recorder = Recorder('distance from target', self.task, 'lqr')
self.recorders = [self.u_recorder,
self.xy_recorder,
self.dist_recorder]
def calc_derivs(self, x, u):
eps = 0.00001 # finite difference epsilon
#----------- compute xdot_x and xdot_u using finite differences --------
# NOTE: here each different run is in its own column
x1 = np.tile(x, (self.arm.DOF*2,1)).T + np.eye(self.arm.DOF*2) * eps
x2 = np.tile(x, (self.arm.DOF*2,1)).T - np.eye(self.arm.DOF*2) * eps
uu = np.tile(u, (self.arm.DOF*2,1))
f1 = self.plant_dynamics(x1, uu)
f2 = self.plant_dynamics(x2, uu)
xdot_x = (f1 - f2) / 2 / eps
xx = np.tile(x, (self.arm.DOF,1)).T
u1 = np.tile(u, (self.arm.DOF,1)) + np.eye(self.arm.DOF) * eps
u2 = np.tile(u, (self.arm.DOF,1)) - np.eye(self.arm.DOF) * eps
f1 = self.plant_dynamics(xx, u1)
f2 = self.plant_dynamics(xx, u2)
xdot_u = (f1 - f2) / 2 / eps
return xdot_x, xdot_u
def control(self, arm, x_des=None):
"""Generates a control signal to move the
arm to the specified target.
arm Arm: the arm model being controlled
des list: the desired system position
x_des np.array: desired task-space force,
system goes to self.target if None
"""
if self.u is None:
self.u = np.zeros(arm.DOF)
self.Q = np.zeros((arm.DOF*2, arm.DOF*2))
self.Q[:arm.DOF, :arm.DOF] = np.eye(arm.DOF) * 1000.0
self.R = np.eye(arm.DOF) * 0.001
# calculate desired end-effector acceleration
if x_des is None:
self.x = arm.x
x_des = self.x - self.target
self.arm, state = self.copy_arm(arm)
A, B = self.calc_derivs(state, self.u)
if self.solve_continuous is True:
X = sp_linalg.solve_continuous_are(A, B, self.Q, self.R)
K = np.dot(np.linalg.pinv(self.R), np.dot(B.T, X))
else:
X = sp_linalg.solve_discrete_are(A, B, self.Q, self.R)
K = np.dot(np.linalg.pinv(self.R + np.dot(B.T, np.dot(X, B))), np.dot(B.T, np.dot(X, A)))
# transform the command from end-effector space to joint space
J = self.arm.gen_jacEE()
u = np.hstack([np.dot(J.T, x_des), arm.dq])
self.u = -np.dot(K, u)
if self.write_to_file is True:
# feed recorders their signals
self.u_recorder.record(0.0, self.u)
self.xy_recorder.record(0.0, self.x)
self.dist_recorder.record(0.0, self.target - self.x)
# add in any additional signals
for addition in self.additions:
self.u += addition.generate(self.u, arm)
return self.u
def copy_arm(self, real_arm):
""" Make a copy of the arm for local simulation. """
arm = real_arm.__class__()
arm.dt = real_arm.dt
# reset arm position to x_0
arm.reset(q = real_arm.q, dq = real_arm.dq)
return arm, np.hstack([real_arm.q, real_arm.dq])
def plant_dynamics(self, x, u):
""" Simulate the arm dynamics locally. """
if x.ndim == 1:
x = x[:,None]
u = u[None,:]
xnext = np.zeros((x.shape))
for ii in range(x.shape[1]):
# set the arm position to x
self.arm.reset(q=x[:self.arm.DOF, ii],
dq=x[self.arm.DOF:self.arm.DOF*2, ii])
# apply the control signal
# TODO: should we be using a constant timestep here instead of arm.dt?
# to even things out when running at different dts?
self.arm.apply_torque(u[ii], self.arm.dt)
# get the system state from the arm
xnext[:,ii] = np.hstack([np.copy(self.arm.q),
np.copy(self.arm.dq)])
if self.solve_continuous is True:
xdot = ((np.asarray(xnext) - np.asarray(x)) / self.arm.dt).squeeze()
return xdot
return xnext
def gen_target(self, arm):
gain = np.sum(arm.L) * .75
bias = -np.sum(arm.L) * 0
self.target = np.random.random(size=(2,)) * gain + bias
return self.target.tolist()
class Control(control.Control):
"""
A controller that implements operational space control.
Controls the (x,y) position of a robotic arm end-effector.
"""
def __init__(self, null_control=True, **kwargs):
"""
null_control boolean: apply second controller in null space or not
"""
super(Control, self).__init__(**kwargs)
self.DOF = 2 # task space dimensionality
self.null_control = null_control
if self.write_to_file is True:
from recorder import Recorder
# set up recorders
self.u_recorder = Recorder('control signal', self.task, 'osc')
self.xy_recorder = Recorder('end-effector position', self.task,
'osc')
self.dist_recorder = Recorder('distance from target', self.task,
'osc')
self.recorders = [
self.u_recorder, self.xy_recorder, self.dist_recorder
]
def control(self, arm, x_des=None):
"""Generates a control signal to move the
arm to the specified target.
arm Arm: the arm model being controlled
des list: the desired system position
x_des np.array: desired task-space force,
system goes to self.target if None
"""
# calculate desired end-effector acceleration
if x_des is None:
self.x = arm.x
x_des = self.kp * (self.target - self.x)
# generate the mass matrix in end-effector space
Mq = arm.gen_Mq()
Mx = arm.gen_Mx()
# calculate force
Fx = np.dot(Mx, x_des)
# calculate the Jacobian
JEE = arm.gen_jacEE()
# tau = J^T * Fx + tau_grav, but gravity = 0
# add in velocity compensation in GC space for stability
self.u = np.dot(JEE.T, Fx).reshape(-1, ) - np.dot(Mq, self.kv * arm.dq)
# if null_control is selected and the task space has
# fewer DOFs than the arm, add a control signal in the
# null space to try to move the arm to its resting state
if self.null_control and self.DOF < len(arm.L):
# calculate our secondary control signal
# calculated desired joint angle acceleration
prop_val = (
(arm.rest_angles - arm.q) + np.pi) % (np.pi * 2) - np.pi
q_des = (self.kp * prop_val + \
self.kv * -arm.dq).reshape(-1,)
Mq = arm.gen_Mq()
u_null = np.dot(Mq, q_des)
# calculate the null space filter
Jdyn_inv = np.dot(Mx, np.dot(JEE, np.linalg.inv(Mq)))
null_filter = np.eye(len(arm.L)) - np.dot(JEE.T, Jdyn_inv)
null_signal = np.dot(null_filter, u_null).reshape(-1, )
self.u += null_signal
if self.write_to_file is True:
# feed recorders their signals
self.u_recorder.record(0.0, self.u)
self.xy_recorder.record(0.0, self.x)
self.dist_recorder.record(0.0, self.target - self.x)
# add in any additional signals
for addition in self.additions:
self.u += addition.generate(self.u, arm)
return self.u
def gen_target(self, arm):
"""Generate a random target"""
gain = np.sum(arm.L) * .75
bias = -np.sum(arm.L) * 0
self.target = np.random.random(size=(2, )) * gain + bias
return self.target.tolist()
from player import Player
from sys import argv
import mido
### Call python test_recorder.py
##
## Options:
## -i Select input device
## -o Select output device
### Options
verbose = "-v" in argv
### Create instance of Piano, Recorder and Player
p = Piano()
rec = Recorder()
player = Player()
player.start() # Start thread
### Connecting player with piano
player.setPiano(p)
### Select input and output devices
[ins, outs] = p.listDevices()
if "-i" in argv:
print "[+] List of input devices"
for i in range(len(ins)):
print "%d: %s" % (i + 1, ins[i])
inDev = ins[int(raw_input("Select input device: ")) - 1]
else:
inDev = mido.get_input_names()[0]
print("Usage:")
print("python test_track.py -f filename")
exit()
except IndexError:
print("Missing arguments")
exit()
### Quantization
if "-q" in argv:
quant = int(argv[argv.index("-q") + 1])
else:
quant = 16
### Create instance of Piano, Recorder, Player and Track
p = Piano()
rec = Recorder()
track = Track()
player = Player()
player.start() # Start thread
### Connecting player with piano
player.setPiano(p)
### Select input and output devices
[ins, outs] = p.listDevices()
if "-i" in argv:
print("[+] List of input devices")
for i in range(len(ins)):
print("%d: %s" % (i + 1, ins[i]))
inDev = ins[int(input("Select input device: ")) - 1]
else:
import pprint
envs = ENVIORNMENTS()
parents = POPULATION(c.popSize)
parents.Initialize()
parents.Evaluate(envs, pb=True, pp=False)
parents.Print()
startTimes = []
copyTimes = []
evalTimes = []
generations = []
fillTimes = []
entire_fill = []
recorder = Recorder()
children = None
for g in range(1, c.numGens):
start = time.time()
# generations.append(g)
starttime = time.time() - start
if g > 0:
del children
children = POPULATION(c.popSize)
entire_fill_temp = children.Fill_From(parents)
fillTime = time.time() - starttime
# pp.pformat(children.pop[0])
children.Evaluate(envs, pb=True, pp=False)
evaluateTime = time.time() - fillTime
parents = copy.deepcopy(children)
from server import Api
from recorder import Recorder
import settings
if __name__ == '__main__':
recorder = Recorder()
api = Api(recorder=recorder)
api.demonize(port=settings.PORT)
while True:
recorder.update_frame_rate()
recorder.handle_frame()
class ExperimentRealtime():
def __init__(self, config, pnhandler, inlet_amp, stimulator = None):
self.config = config
self.kalman_time = 0
# init pnhandler, inlet_amp, stimulator and decoder/filter
self.pnhandler = pnhandler
self.inlet_amp = inlet_amp
self.stimulator = stimulator
self.recorder = Recorder(self.config, prediction = True)
self.decoder = None
self.filter = None
# params of amp data stream
self.numCh = self.config['amp_config'].getint('n_channels_amp')
# if feedback, last channel is stimulation data
if self.config['amp_config'].getboolean('feedback'):
self.numCh -= 1
self.offCh = self.numCh
self.srate = self.config['amp_config'].getint('fs_amp')
# time of realtime experiment (inf if it set to -1)
experiment_time = self.config['realtime'].getint('experiment_time_realtime')
self.experiment_time = float('inf') if experiment_time < 0 else experiment_time * self.srate
avatar_freq = self.config['avatar'].getint('avatar_freq')
self.avatar_period = 1 / avatar_freq
self.avatar_buffer_size = self.config['avatar'].getint('avatar_buffer_size')
# buffer for plotting
self.coordbuff = []
# PN channels for finger joints
self.pn_fingers_range = np.asarray(list(map(int, self.config['avatar']['pn_fingers_coords'].split())))
# avatar channels for finger joints
self.avatar_fingers_range = np.asarray(list(map(int, self.config['avatar']['avatar_fingers_coords'].split())))
# buffer
self.avatar_buffer = np.zeros(self.avatar_buffer_size)
# initializing Avatar connection
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.server_address = ('127.0.0.1', 12001)
self.client_address = ('127.0.0.1', 9001)
self.sock.bind(self.server_address)
self._printm('UDP from {} {} established'.format(*self.server_address))
# get parameters of stimulation and setup redractory period
self.stimulator.configurate(self.config['stimulation'].getint('electrode_start'),
self.config['stimulation'].getint('electrode_stop'))
self.stimulation_time = self.config['stimulation'].getint('stimulation_time')
self.refractory_time = self.config['stimulation'].getint('refractory_time')
self.refractory_start = 0
self.avatar_bias_thumb = self.config['avatar'].getint('avatar_bias_thumb')
self.avatar_scalar_thumb = self.config['avatar'].getfloat('avatar_scalar_thumb')
self.avatar_bias_index = self.config['avatar'].getint('avatar_bias_index')
self.avatar_scalar_index = self.config['avatar'].getfloat('avatar_scalar_index')
self.avatar_parameters = refresh_avatar_parameters()
# control from keyboard
self.queue_keyboard = Queue()
self.avatar_data_type = False
self.realtime_close = False
on_press = lambda key: keyboard_on_press(self.queue_keyboard, key)
self.listener = Listener(on_press=on_press, on_release=keyboard_on_release)
self.listener.start()
# fit data from file
def fit(self):
self._printm('fitting data from:\n{}'.format(self.config['paths']['train_data_to_fit_path']))
# fit the model from file and initialize filter
self.decoder = EMGDecoder()
self.decoder.fit(X = None, Y = None,
file=self.config['paths']['train_data_to_fit_path'],
numCh = self.numCh, offCh = self.offCh,
pn_channels = self.pn_fingers_range,
lag = 2, forward = 0, downsample = 0)
self.filter = envelopeFilter()
# decode realtime data
def decode(self):
self._printm('decoding...')
# initialize pn_buffer and KalmanCoords
pn_buffer = np.zeros(len(self.pn_fingers_range))
KalmanCoords = np.zeros((1, len(self.pn_fingers_range)))
# get chunks, decode and sent to avatar
start_time = time.time()
counter = 0
counter_messages = 0
while (time.time() - start_time < self.experiment_time):
# handle keyboard events
self._handle_keyboard()
# if you press esc - save data and close
if self.realtime_close:
self.recorder.save_data()
return
cycle_start_time = time.time()
# get chunks of data from inlets
chunk_pn, timestamp_pn = self.pnhandler.get_next_chunk_pn()
ampchunk, amptimestemp = self.inlet_amp.pull_chunk(max_samples=20)
chunk_amp, timestamp_amp = np.asarray(ampchunk), np.asarray(amptimestemp)
# process chunks, if no chunks - previous data will be used
if chunk_pn is not None:
pn_buffer = self._process_chunk_pn(chunk_pn, pn_buffer)
else:
self._printm('empty pn chunk encountered')
if chunk_amp.shape[0] > 3:
counter += chunk_amp.shape[0]
WienerCoords, KalmanCoords = self._process_chunk_amp(chunk_amp)
else:
self._printm('empty amp chunk encountered')
# get predictions and factual result and send them to avatar
prediction = KalmanCoords[-1,:len(self.pn_fingers_range)]
fact = np.copy(pn_buffer)
self.coordbuff.append((prediction, fact))
if self.avatar_data_type :
thumb_coord, index_coord = prediction[0], prediction[1]
else:
thumb_coord, index_coord = fact[0], fact[1]
thumb_angle = - self.avatar_scalar_thumb*thumb_coord - self.avatar_bias_thumb - 55
index_angle = - self.avatar_scalar_index*index_coord + self.avatar_bias_index
#print(thumb_angle, index_angle)
if self.stimulator is not None and (thumb_angle < 0) and (index_angle > self.avatar_parameters['MaxIndexAngleMale']):
self._stimulate()
self._send_data_to_avatar(prediction, fact)
self.recorder.record_data(chunk_amp, timestamp_amp, chunk_pn, timestamp_pn, prediction)
# massege to see progress
if counter // 10000 > counter_messages:
counter_messages += 1
self._printm('sent {} samples to avatar'.format(counter))
# control time of each cycle of the loop
difference_time = self.avatar_period - (time.time() - cycle_start_time)
if difference_time > 0:
time.sleep(difference_time)
else:
self._printm('not enough time for chunks {} and {} processing, latency is {} s'.format(chunk_pn.shape,
chunk_amp.shape,
difference_time))
self._printm('Kalman decoding time: {}'.format(self.kalman_time))
# save realtime data
self.recorder.save_data()
def get_coordbuff(self):
return self.coordbuff
def close(self):
self.listener.stop()
def _process_chunk_pn(self, chunk_pn, pn_buffer):
chunk = chunk_pn[:, self.pn_fingers_range]
medians = np.nanmedian(chunk, axis=0)
pn_buffer[~np.isnan(medians)] = medians[~np.isnan(medians)]
return pn_buffer
def _process_chunk_amp(self, chunk_amp):
chunk = chunk_amp[:, :self.numCh]
chunk = self.filter.filterEMG(chunk)
t4 = time.time()
WienerCoords, KalmanCoords = self.decoder.transform(chunk)
self.kalman_time = time.time() - t4
return WienerCoords, KalmanCoords
def _send_data_to_avatar(self, prediction, fact):
self.avatar_parameters = refresh_avatar_parameters()
fact[0] = fact[0] *self.avatar_scalar_thumb + self.avatar_bias_thumb
fact[1] = fact[1] *self.avatar_scalar_index - self.avatar_bias_index
prediction[0] = prediction[0] *self.avatar_scalar_thumb + self.avatar_bias_thumb
prediction[1] = prediction[1] *self.avatar_scalar_index - self.avatar_bias_index
if self.avatar_data_type:
self.avatar_buffer[self.avatar_fingers_range] = prediction
else:
self.avatar_buffer[self.avatar_fingers_range] = fact
self.avatar_buffer[self.avatar_fingers_range + self.avatar_buffer_size//2] = prediction
#print(self.avatar_buffer)
data = struct.pack('%df' % len(self.avatar_buffer), *list(map(float, self.avatar_buffer)))
self.sock.sendto(data, self.client_address)
def _stimulate(self):
if (time.time() - self.refractory_start)*1000 >= self.refractory_time:
self.stimulator.stimulate(self.stimulation_time, 1)
self.refractory_start = time.time()
# helper to parse all commands from keyboard
def _handle_keyboard(self):
while not self.queue_keyboard.empty():
k, _ = self.queue_keyboard.get()
if k == 'realtime_close':
self.realtime_close = not self.realtime_close
elif k == 'avatar_data_type':
self.avatar_data_type = not self.avatar_data_type
def _printm(self, message):
print('{} {}: '.format(time.strftime('%H:%M:%S'), type(self).__name__) + message)
class Scene:
def __init__(self):
self.sampler = GridSampler()
self.recorder = Recorder()
self.lidar = Lidar()
self.tracer = Tracer(self.lidar, self.recorder)
def render(self):
samples = [sample for sample in self.sampler.getSample()]
# self.saveSample(samples)
weights = self.getWeights(samples)
num = len(samples)
k = 0
for sample, weight in zip(samples, weights):
if k % 10000 == 0:
print('%d / %d' % (k, num))
k += 1
ray = self.lidar.generateRay(sample)
# initialize the energy of the ray
ray.energy = self.lidar.pulseEnergy * weight
self.tracer.trace(ray, 0, 0)
# records = np.array(self.tracer.records)
# np.savetxt('records.txt', records)
self.recorder.save()
def getWeights(self, samples):
sampleRadii = np.array([np.linalg.norm(sample) for sample in samples])
weights = np.exp(-sampleRadii * sampleRadii * 0.5 / self.lidar.sigmaBeam2)
weights = weights / np.sum(weights)
return weights
def saveSample(self, sample):
npsample = np.array(sample)
np.savetxt('imPulseFile.txt', npsample)
def renderUsingSimulatedPhoton(self):
""" According to DART manual.
:return:
"""
minPerSubcenter = 5
samples = self.sampler.getSample()
weights = self.getWeights(samples)
minWeight = min(weights)
# get photon number per subcenter
subcenterPhotonNumbers = []
for weight in weights:
subcenterPhotonNumber = int(weight / minWeight * minPerSubcenter) # TODO little number may not be divisor
subcenterPhotonNumbers.append(subcenterPhotonNumber)
# be sure that subcenter with smallest weight has minimun photon
# and keep gaussian shape pulse
actualPhotonNumber = sum(subcenterPhotonNumbers)
#
energy = self.lidar.pulseEnergy / actualPhotonNumber
for sample, subcenterPhotonNumber in zip(samples, subcenterPhotonNumbers):
for i in range(subcenterPhotonNumber):
ray = self.lidar.generateRay(sample)
ray.energy = energy
self.tracer.trace(ray, 0, 0)
def renderUsingMultiLaunch(self):
n = 5
samples = [sample for sample in self.sampler.getSample()]
# self.saveSample(samples)
weights = self.getWeights(samples)
num = len(samples)
k = 0
for sample, weight in zip(samples, weights):
if k % 10000 == 0:
print('%d / %d' % (k, num))
k += 1
for i in range(n):
ray = self.lidar.generateRay(sample)
# initialize the energy of the ray
ray.energy = self.lidar.pulseEnergy * weight / n
self.tracer.trace(ray, 0, 0)
# records = np.array(self.tracer.records)
# np.savetxt('records.txt', records)
self.recorder.save()
class App:
def __init__(self):
self.window = Tk()
self.window.title("Wellcome To Long's App")
self.window.geometry('350x200')
self.recorder = Recorder()
file = open("text.txt", mode="r", encoding="utf8")
self.article = file.read()
self.count = 1
file.close()
def initUI(self):
self.scrolledText = scrolledtext.ScrolledText(self.window,
width=50,
height=30)
self.scrolledText.grid(column=0, row=0)
panelRight = PanedWindow(self.window)
panelRight.grid(column=1, row=0)
labelFolder = Label(panelRight, text="Folder Name: ")
labelFolder.grid(column=0, row=0)
self.folderNameInput = Entry(panelRight)
self.folderNameInput.grid(column=0, row=1)
labelFileName = Label(panelRight, text="File Name: ")
labelFileName.grid(column=0, row=2)
self.fileNameInput = Entry(panelRight)
self.fileNameInput.grid(column=0, row=3)
labelSentence = Label(panelRight, text="Sentence: ")
labelSentence.grid(column=0, row=4)
self.sentenceInput = Entry(panelRight)
self.sentenceInput.grid(column=0, row=5)
self.startButton = Button(
panelRight,
text="Start",
)
self.startButton.grid(column=0, row=6)
self.stopButton = Button(panelRight, text="Stop")
self.stopButton.grid(column=0, row=7)
self.resetCountButton = Button(panelRight, text="Reset")
self.resetCountButton.grid(column=0, row=8)
def initLogic(self):
def startClickHandler():
self.recorder.startRecord()
def stopClickHandler():
frames = self.recorder.stopRecord()
textFile = open("data/" + self.folderNameInput.get() +
"/index.txt",
mode="a",
encoding="utf8")
textFile.write(self.fileNameInput.get() + ".wav" + '\n')
textFile.write(self.sentenceInput.get() + '\n')
self.recorder.writeFile(
frames, "data/" + self.folderNameInput.get() + "/" +
self.fileNameInput.get() + ".wav")
self.count = self.count + 1
self.fileNameInput.delete(0, END)
self.fileNameInput.insert(
0,
self.folderNameInput.get() + "-" + str(self.count))
def resetHandler():
self.count = 1
self.startButton.configure(command=startClickHandler)
self.stopButton.configure(command=stopClickHandler)
self.resetCountButton.configure(command=resetHandler)
self.scrolledText.insert(INSERT, self.article)
def mainLoop(self):
self.window.mainloop()
def __init__(self):
self.recorder = Recorder()
class Rollout(object):
def __init__(self, ob_space, ac_space, nenvs, nsteps_per_seg, nsegs_per_env, nlumps, envs, policy,
int_rew_coeff, ext_rew_coeff, record_rollouts, dynamics):
self.nenvs = nenvs
self.nsteps_per_seg = nsteps_per_seg
self.nsegs_per_env = nsegs_per_env
self.nsteps = self.nsteps_per_seg * self.nsegs_per_env
self.ob_space = ob_space
self.ac_space = ac_space
self.nlumps = nlumps
self.lump_stride = nenvs // self.nlumps
self.envs = envs
self.policy = policy
self.dynamics = dynamics
self.reward_fun = lambda ext_rew, int_rew: ext_rew_coeff * np.clip(ext_rew, -1., 1.) + int_rew_coeff * int_rew
self.buf_vpreds = np.empty((nenvs, self.nsteps), np.float32)
self.buf_nlps = np.empty((nenvs, self.nsteps), np.float32)
self.buf_rews = np.empty((nenvs, self.nsteps), np.float32)
self.buf_ext_rews = np.empty((nenvs, self.nsteps), np.float32)
self.buf_acs = np.empty((nenvs, self.nsteps, *self.ac_space.shape), self.ac_space.dtype)
self.buf_obs = np.empty((nenvs, self.nsteps, *self.ob_space.shape), self.ob_space.dtype)
self.buf_obs_last = np.empty((nenvs, self.nsegs_per_env, *self.ob_space.shape), np.float32)
self.buf_news = np.zeros((nenvs, self.nsteps), np.float32)
self.buf_new_last = self.buf_news[:, 0, ...].copy()
self.buf_vpred_last = self.buf_vpreds[:, 0, ...].copy()
self.env_results = [None] * self.nlumps
# self.prev_feat = [None for _ in range(self.nlumps)]
# self.prev_acs = [None for _ in range(self.nlumps)]
self.int_rew = np.zeros((nenvs,), np.float32)
self.recorder = Recorder(nenvs=self.nenvs, nlumps=self.nlumps) if record_rollouts else None
self.statlists = defaultdict(lambda: deque([], maxlen=100))
self.stats = defaultdict(float)
self.best_ext_ret = None
self.all_visited_rooms = []
self.all_scores = []
self.all_ep_r = []
self.step_count = 0
def collect_rollout(self):
self.ep_infos_new = []
for t in range(self.nsteps):
self.rollout_step()
self.calculate_reward()
self.update_info()
def calculate_reward(self):
int_rew = self.dynamics.calculate_loss(ob=self.buf_obs,
last_ob=self.buf_obs_last,
acs=self.buf_acs)
self.buf_rews[:] = self.reward_fun(int_rew=int_rew, ext_rew=self.buf_ext_rews)
def rollout_step(self):
t = self.step_count % self.nsteps
s = t % self.nsteps_per_seg
for l in range(self.nlumps):
obs, prevrews, news, infos = self.env_get(l)
# if t > 0:
# prev_feat = self.prev_feat[l]
# prev_acs = self.prev_acs[l]
for info in infos:
epinfo = info.get('episode', {})
mzepinfo = info.get('mz_episode', {})
retroepinfo = info.get('retro_episode', {})
epinfo.update(mzepinfo)
epinfo.update(retroepinfo)
if epinfo:
if "n_states_visited" in info:
epinfo["n_states_visited"] = info["n_states_visited"]
epinfo["states_visited"] = info["states_visited"]
self.ep_infos_new.append((self.step_count, epinfo))
sli = slice(l * self.lump_stride, (l + 1) * self.lump_stride)
acs, vpreds, nlps = self.policy.get_ac_value_nlp(obs)
self.env_step(l, acs)
# self.prev_feat[l] = dyn_feat
# self.prev_acs[l] = acs
self.buf_obs[sli, t] = obs
self.buf_news[sli, t] = news
self.buf_vpreds[sli, t] = vpreds
self.buf_nlps[sli, t] = nlps
self.buf_acs[sli, t] = acs
if t > 0:
self.buf_ext_rews[sli, t - 1] = prevrews
# if t > 0:
# dyn_logp = self.policy.call_reward(prev_feat, pol_feat, prev_acs)
#
# int_rew = dyn_logp.reshape(-1, )
#
# self.int_rew[sli] = int_rew
# self.buf_rews[sli, t - 1] = self.reward_fun(ext_rew=prevrews, int_rew=int_rew)
if self.recorder is not None:
self.recorder.record(timestep=self.step_count, lump=l, acs=acs, infos=infos, int_rew=self.int_rew[sli],
ext_rew=prevrews, news=news)
self.step_count += 1
if s == self.nsteps_per_seg - 1:
for l in range(self.nlumps):
sli = slice(l * self.lump_stride, (l + 1) * self.lump_stride)
nextobs, ext_rews, nextnews, _ = self.env_get(l)
self.buf_obs_last[sli, t // self.nsteps_per_seg] = nextobs
if t == self.nsteps - 1:
self.buf_new_last[sli] = nextnews
self.buf_ext_rews[sli, t] = ext_rews
_, self.buf_vpred_last[sli], _ = self.policy.get_ac_value_nlp(nextobs)
# dyn_logp = self.policy.call_reward(self.prev_feat[l], last_pol_feat, prev_acs)
# dyn_logp = dyn_logp.reshape(-1, )
# int_rew = dyn_logp
#
# self.int_rew[sli] = int_rew
# self.buf_rews[sli, t] = self.reward_fun(ext_rew=ext_rews, int_rew=int_rew)
def update_info(self):
all_ep_infos = MPI.COMM_WORLD.allgather(self.ep_infos_new)
all_ep_infos = sorted(sum(all_ep_infos, []), key=lambda x: x[0])
if all_ep_infos:
all_ep_infos = [i_[1] for i_ in all_ep_infos] # remove the step_count
keys_ = all_ep_infos[0].keys()
all_ep_infos = {k: [i[k] for i in all_ep_infos] for k in keys_}
self.statlists['eprew'].extend(all_ep_infos['r'])
self.all_ep_r.append(np.mean(all_ep_infos['r']))
if (len(self.all_ep_r) % 100 == 0 and self.all_ep_r != 0):
np.save('all_ep_r_{}_pacman_basline'.format(len(self.all_ep_r) // 100), self.all_ep_r)
self.stats['eprew_recent'] = np.mean(all_ep_infos['r'])
self.statlists['eplen'].extend(all_ep_infos['l'])
self.stats['epcount'] += len(all_ep_infos['l'])
self.stats['tcount'] += sum(all_ep_infos['l'])
if 'visited_rooms' in keys_:
# Montezuma specific logging.
self.stats['visited_rooms'] = sorted(list(set.union(*all_ep_infos['visited_rooms'])))
self.stats['pos_count'] = np.mean(all_ep_infos['pos_count'])
self.all_visited_rooms.extend(self.stats['visited_rooms'])
self.all_scores.extend(all_ep_infos["r"])
self.all_scores = sorted(list(set(self.all_scores)))
self.all_visited_rooms = sorted(list(set(self.all_visited_rooms)))
if MPI.COMM_WORLD.Get_rank() == 0:
print("All visited rooms")
print(self.all_visited_rooms)
print("All scores")
print(self.all_scores)
if 'levels' in keys_:
# Retro logging
temp = sorted(list(set.union(*all_ep_infos['levels'])))
self.all_visited_rooms.extend(temp)
self.all_visited_rooms = sorted(list(set(self.all_visited_rooms)))
if MPI.COMM_WORLD.Get_rank() == 0:
print("All visited levels")
print(self.all_visited_rooms)
current_max = np.max(all_ep_infos['r'])
else:
current_max = None
self.ep_infos_new = []
if current_max is not None:
if (self.best_ext_ret is None) or (current_max > self.best_ext_ret):
self.best_ext_ret = current_max
self.current_max = current_max
def env_step(self, l, acs):
self.envs[l].step_async(acs)
self.env_results[l] = None
def env_get(self, l):
if self.step_count == 0:
ob = self.envs[l].reset()
out = self.env_results[l] = (ob, None, np.ones(self.lump_stride, bool), {})
else:
if self.env_results[l] is None:
out = self.env_results[l] = self.envs[l].step_wait()
else:
out = self.env_results[l]
return out
from pymouse import PyMouseEvent
from recorder import Recorder
import time, sys
import cmd, shlex
class ClickEventListener(PyMouseEvent):
def click(self, x, y, button, press):
if press:
recorder.OnLeftDown((x, y))
mouseListener = ClickEventListener()
mouseListener.start()
recorder = Recorder()
class CLI(cmd.Cmd):
running = False
def do_clear(self, line):
"""clear
Clear the operation list."""
recorder.clear()
def do_list(self, line):
"""list
Print operation list."""
recorder.printOpList()
def __init__(self):
self.recorder = Recorder()
self.text = ""
def startButtonClicked(self):
self.stopButton.setEnabled(True)
self.startButton.setEnabled(False)
self.recorder = Recorder()
self.recorder.start()
app = Flask(__name__)
try:
with open("/etc/machine-id", "r") as fh:
app.config['SECRET_KEY'] = fh.read()
except:
app.config['SECRET_KEY'] = 'secret!'
sockets = Sockets(app)
# Build pipeline
grabber = PanoramaGrabber() # config read from ~/.robovision/grabber.conf
image_recognizer = ImageRecognizer(grabber)
gameplay = Gameplay(image_recognizer)
rf = RemoteRF(gameplay, "/dev/ttyACM0")
visualizer = Visualizer(image_recognizer, framedrop=1)
recorder = Recorder(grabber)
def generator():
visualizer.enable()
queue = visualizer.get_queue()
while True:
try:
buf, resized, frame, r = queue.get_nowait()
except Empty:
sleep(0.001) # Fix this stupid thingie
continue
else:
yield b'--frame\r\nContent-Type: image/jpeg\r\n\r\n'
yield buf
yield b'\r\n\r\n'
class Pircam:
image_width = 1280
image_height = 720
def __init__(self, bot, pir_pin, camera_port, audio_index):
self.bot = bot
self.pin = int(pir_pin)
self.camera_port = int(camera_port)
self.audio_index = int(audio_index)
# init pir sensor
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.pin, GPIO.IN)
self.recorder = Recorder(self.bot, self.audio_index)
def takePictures(self):
logger.info('PIR movement detected: taking pictures')
frames = 0
loop = 0
self.recorder.start()
camera = cv2.VideoCapture(self.camera_port)
camera.set(cv2.CAP_PROP_FRAME_WIDTH, self.image_width)
camera.set(cv2.CAP_PROP_FRAME_HEIGHT, self.image_height)
camera.set(cv2.CAP_PROP_SATURATION, 50.0)
while 1 == GPIO.input(self.pin):
return_value, image = camera.read()
if frames == 0:
encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 70]
is_success, imbuffer = cv2.imencode('.jpg', image,
encode_param)
stream = BytesIO(imbuffer)
self.bot.sendPicture(stream)
stream.close()
if (loop < 2):
loop += 1
frames = 10
else:
frames = 80
else:
frames -= 1
camera.release()
self.recorder.stop()
def start(self):
thread = Thread(target=self.observe)
thread.start()
def observe(self):
logger.info('start PIR observing')
self.observing = True
while self.observing:
if 0 == GPIO.input(self.pin):
time.sleep(1)
else:
self.takePictures()
logger.info('stop PIR observing')
def stop(self):
self.observing = False
class Rollout(object):
def __init__(self, ob_space, ac_space, nenvs, nsteps_per_seg,
nsegs_per_env, nlumps, envs, policy, int_rew_coeff,
ext_rew_coeff, record_rollouts, dynamics, patience):
self.nenvs = nenvs
self.nsteps_per_seg = nsteps_per_seg
self.nsegs_per_env = nsegs_per_env
self.nsteps = self.nsteps_per_seg * self.nsegs_per_env
self.ob_space = ob_space
self.ac_space = ac_space
self.nlumps = nlumps
self.lump_stride = nenvs // self.nlumps
self.envs = envs
self.policy = policy
self.dynamics = dynamics
self.patience = patience
self.reward_fun = lambda ext_rew, int_rew: ext_rew_coeff * np.clip(
ext_rew, -1., 1.) + int_rew_coeff * int_rew
self.buf_vpreds = np.empty((nenvs, self.nsteps), np.float32)
self.buf_nlps = np.empty((nenvs, self.nsteps), np.float32)
self.buf_rews = np.empty((nenvs, self.nsteps), np.float32)
self.buf_ext_rews = np.empty((nenvs, self.nsteps), np.float32)
self.buf_acs = np.empty((nenvs, self.nsteps, *self.ac_space.shape),
self.ac_space.dtype)
self.buf_obs = np.empty((nenvs, self.nsteps, *self.ob_space.shape),
self.ob_space.dtype)
self.buf_obs_last = np.empty(
(nenvs, self.nsegs_per_env, *self.ob_space.shape), np.float32)
self.buf_news = np.zeros((nenvs, self.nsteps), np.float32)
self.buf_new_last = self.buf_news[:, 0, ...].copy()
self.buf_vpred_last = self.buf_vpreds[:, 0, ...].copy()
self.env_results = [None] * self.nlumps
# self.prev_feat = [None for _ in range(self.nlumps)]
# self.prev_acs = [None for _ in range(self.nlumps)]
self.int_rew = np.zeros((nenvs, ), np.float32)
self.recorder = Recorder(
nenvs=self.nenvs, nlumps=self.nlumps) if record_rollouts else None
self.statlists = defaultdict(lambda: deque([], maxlen=100))
self.stats = defaultdict(float)
self.best_ext_ret = None
self.all_visited_rooms = []
self.all_scores = []
self.step_count = 0
#########################################################
self.ps_buf = self.int_rew = np.zeros((nenvs, ), np.float32)
self.ps_buf_nold = self.int_rew = np.zeros((nenvs, ), np.float32)
self.ac_buf = self.int_rew = np.zeros((nenvs, ), np.float32)
self.buf_acs_nold = np.empty(
(nenvs, self.nsteps, *self.ac_space.shape), self.ac_space.dtype)
self.ac_buf_nold = np.empty((nenvs, self.nsteps, *self.ac_space.shape),
self.ac_space.dtype)
self.nthe = 2
self.ac_list = []
self.ps_list = []
self.rew_list = []
self.obs_list = []
self.feat_list = []
self.patience_pred = 0
self.pat = 0
self.mean = np.zeros((nenvs, ), np.float32)
self.var = np.ones_like((nenvs, ), np.float32)
#########################################################
def collect_rollout(self):
self.ep_infos_new = []
for t in range(self.nsteps):
self.rollout_step()
self.calculate_reward()
self.update_info()
def calculate_reward(self):
#여기도 수정
##############################################################################
int_rew, ps, ac, feat = self.dynamics.calculate_loss(
ob=self.buf_obs,
last_ob=self.buf_obs_last,
acs=self.buf_acs,
feat_input=[],
pat=0)
print(int_rew.shape)
self.ac_list.append(ac)
self.ps_list.append(ps)
self.rew_list.append(int_rew)
self.obs_list.append(self.buf_obs)
self.feat_list.append(feat)
#self.feat_list = tf.stack([self.feat_list, feat])
#print(self.feat_list[0])
gpu_devices = tf.config.experimental.list_physical_devices('GPU')
"""
for device in gpu_devices:
tf.config.experimental.set_memory_growth(device, True)
"""
if len(self.ac_list) > (self.nthe):
self.ac_list = self.ac_list[1:]
self.ps_list = self.ps_list[1:]
self.rew_list = self.rew_list[1:]
self.obs_list = self.obs_list[1:]
if self.step_count / self.nsteps > self.nthe:
#ac_spec = tf.one_hot(self.ac_list[0], 4, axis=2)
#ac_spec = flatten_two_dims(ac_spec)
#print("ac_speccccccccccccccccccc:",ac_spec.shape)
int_rew_now, ps_now, ac_now, feat_now = self.dynamics.calculate_loss(
ob=self.obs_list[0],
last_ob=self.buf_obs_last,
acs=self.ac_list[0],
feat_input=self.feat_list[0],
pat=1) #ps_buf_nold S_1**
print(
"Sucess///////////////////////////////////////////////////////////////"
)
sess = tf.Session()
coc = self.rew_list[0] - int_rew_now
print("coc", coc)
norm_coc = np.multiply((coc - self.mean),
np.reciprocal(np.sqrt(self.var)))
self.mean = 0.9 * self.mean + 0.1 * coc
self.var = 0.9 * self.var + 0.1 * coc**2
node = tf.math.sigmoid(norm_coc)
self.pat = sess.run(node)
print("int_rew_now", int_rew_now.shape)
print("patshape", self.pat.shape)
#여기다가 sigmoid function넣어놔야 0하고 1사이에 잘 들어간다.
#diff = sess.run(node)
#MontezumaRevengeNoFrameskip-v4
#self.patience = 0.9 * self.patience + 0.1 * diff
#########################
#self.patience.train_step()
# patience_pred
#model = Patience(self.obs_list[0],self.buf_obs_last,self.ac_list[0],self.feat_list[0])
#self.patience_pred = Patience(state = self.obs_list[0],action = self.ac_list[0], labels = self.pat, ac_space = self.ac_space, auxiliary_task = self.dynamics.auxiliary_task).get_loss()
#print("hi",self.feat_list[0].shape,self.ac_list[0].shape)
#self.patience_pred = model(self.feat_list[0],self.ac_list[0])
pat_pred = self.patience.calculate_loss(
ob=self.obs_list[0],
last_ob=self.buf_obs_last,
acs=self.ac_list[0],
feat_input=self.feat_list[0],
pat=1)
# model.calculate_loss(ob=self.obs_list[0],
# last_ob=self.buf_obs_last,
# acs=self.ac_list[0], feat_input = self.feat_list[0])
#train_step(model, self.feat_list[0],self.ac_list[0],self.pat)
#########################
#int_rew = int_rew * self.patience_pred
# elementwise multiply
#int_rew = np.multiply(int_rew, self.patience_pred)
################################################################################
self.buf_rews[:] = self.reward_fun(int_rew=int_rew,
ext_rew=self.buf_ext_rews)
def rollout_step(self):
t = self.step_count % self.nsteps
s = t % self.nsteps_per_seg
for l in range(self.nlumps):
obs, prevrews, news, infos = self.env_get(l)
# if t > 0:
# prev_feat = self.prev_feat[l]
# prev_acs = self.prev_acs[l]
for info in infos:
epinfo = info.get('episode', {})
mzepinfo = info.get('mz_episode', {})
retroepinfo = info.get('retro_episode', {})
epinfo.update(mzepinfo)
epinfo.update(retroepinfo)
if epinfo:
if "n_states_visited" in info:
epinfo["n_states_visited"] = info["n_states_visited"]
epinfo["states_visited"] = info["states_visited"]
self.ep_infos_new.append((self.step_count, epinfo))
sli = slice(l * self.lump_stride, (l + 1) * self.lump_stride)
acs, vpreds, nlps = self.policy.get_ac_value_nlp(obs)
self.env_step(l, acs)
# self.prev_feat[l] = dyn_feat
# self.prev_acs[l] = acs
self.buf_obs[sli, t] = obs
self.buf_news[sli, t] = news
self.buf_vpreds[sli, t] = vpreds
self.buf_nlps[sli, t] = nlps
self.buf_acs[sli, t] = acs
if t > 0:
self.buf_ext_rews[sli, t - 1] = prevrews
# if t > 0:
# dyn_logp = self.policy.call_reward(prev_feat, pol_feat, prev_acs)
#
# int_rew = dyn_logp.reshape(-1, )
#
# self.int_rew[sli] = int_rew
# self.buf_rews[sli, t - 1] = self.reward_fun(ext_rew=prevrews, int_rew=int_rew)
if self.recorder is not None:
self.recorder.record(timestep=self.step_count,
lump=l,
acs=acs,
infos=infos,
int_rew=self.int_rew[sli],
ext_rew=prevrews,
news=news)
self.step_count += 1
if s == self.nsteps_per_seg - 1:
for l in range(self.nlumps):
sli = slice(l * self.lump_stride, (l + 1) * self.lump_stride)
nextobs, ext_rews, nextnews, _ = self.env_get(l)
self.buf_obs_last[sli, t // self.nsteps_per_seg] = nextobs
if t == self.nsteps - 1:
self.buf_new_last[sli] = nextnews
self.buf_ext_rews[sli, t] = ext_rews
_, self.buf_vpred_last[
sli], _ = self.policy.get_ac_value_nlp(nextobs)
# dyn_logp = self.policy.call_reward(self.prev_feat[l], last_pol_feat, prev_acs)
# dyn_logp = dyn_logp.reshape(-1, )
# int_rew = dyn_logp
#
# self.int_rew[sli] = int_rew
# self.buf_rews[sli, t] = self.reward_fun(ext_rew=ext_rews, int_rew=int_rew)
def update_info(self):
all_ep_infos = MPI.COMM_WORLD.allgather(self.ep_infos_new)
all_ep_infos = sorted(sum(all_ep_infos, []), key=lambda x: x[0])
if all_ep_infos:
all_ep_infos = [i_[1]
for i_ in all_ep_infos] # remove the step_count
keys_ = all_ep_infos[0].keys()
all_ep_infos = {k: [i[k] for i in all_ep_infos] for k in keys_}
self.statlists['eprew'].extend(all_ep_infos['r'])
self.stats['eprew_recent'] = np.mean(all_ep_infos['r'])
self.statlists['eplen'].extend(all_ep_infos['l'])
self.stats['epcount'] += len(all_ep_infos['l'])
self.stats['tcount'] += sum(all_ep_infos['l'])
if 'visited_rooms' in keys_:
# Montezuma specific logging.
self.stats['visited_rooms'] = sorted(
list(set.union(*all_ep_infos['visited_rooms'])))
self.stats['pos_count'] = np.mean(all_ep_infos['pos_count'])
self.all_visited_rooms.extend(self.stats['visited_rooms'])
self.all_scores.extend(all_ep_infos["r"])
self.all_scores = sorted(list(set(self.all_scores)))
self.all_visited_rooms = sorted(
list(set(self.all_visited_rooms)))
if MPI.COMM_WORLD.Get_rank() == 0:
print("All visited rooms")
print(self.all_visited_rooms)
print("All scores")
print(self.all_scores)
if 'levels' in keys_:
# Retro logging
temp = sorted(list(set.union(*all_ep_infos['levels'])))
self.all_visited_rooms.extend(temp)
self.all_visited_rooms = sorted(
list(set(self.all_visited_rooms)))
if MPI.COMM_WORLD.Get_rank() == 0:
print("All visited levels")
print(self.all_visited_rooms)
current_max = np.max(all_ep_infos['r'])
else:
current_max = None
self.ep_infos_new = []
if current_max is not None:
if (self.best_ext_ret is None) or (current_max >
self.best_ext_ret):
self.best_ext_ret = current_max
self.current_max = current_max
def env_step(self, l, acs):
self.envs[l].step_async(acs)
self.env_results[l] = None
def env_get(self, l):
if self.step_count == 0:
ob = self.envs[l].reset()
out = self.env_results[l] = (ob, None,
np.ones(self.lump_stride, bool), {})
else:
if self.env_results[l] is None:
out = self.env_results[l] = self.envs[l].step_wait()
else:
out = self.env_results[l]
return out
class Timelapse(NSObject):
""" Creates a timelapse video """
def applicationDidFinishLaunching_(self, notification) -> None:
self.check_dependencies()
# Initialize recording
self.recording: bool = start_recording
self.recorder = None
# Set correct output paths
self.recorder_output_basedir: str = os.path.join(
dir_base, dir_pictures, dir_app)
self.encoder_output_basedir: str = os.path.join(dir_base, dir_movies)
# Create a reference to the statusbar (menubar)
self.statusbar = NSStatusBar.systemStatusBar()
# Create item in statusbar
self.statusitem = self.statusbar.statusItemWithLength_(
NSVariableStatusItemLength)
self.statusitem.setHighlightMode_(1) # Highlight upon clicking
# Create a simple menu and bind it to the status item
self.menu = self.createMenu()
self.statusitem.setMenu_(self.menu)
# Load icons and show them in the statusbar
self.loadIcons()
self.setStatus()
def loadIcons(self) -> None:
self.icon_recording = NSImage.alloc().initWithContentsOfFile_(
os.path.join(dir_resources, image_recording))
self.icon_idle = NSImage.alloc().initWithContentsOfFile_(
os.path.join(dir_resources, image_idle))
def setStatus(self) -> None:
""" Sets the image and menu text according to recording status """
if self.recording:
self.statusitem.setImage_(self.icon_recording)
self.recordButton.setTitle_(text_recorder_running)
self.statusitem.setToolTip_(tooltip_running)
else:
self.statusitem.setImage_(self.icon_idle)
self.recordButton.setTitle_(text_recorder_idle)
self.statusitem.setToolTip_(tooltip_idle)
def createMenu(self) -> NSMenu:
""" Status bar menu """
menu = NSMenu.alloc().init()
# Bind record event
self.recordButton = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
text_recorder_idle, 'startStopRecording:', '')
menu.addItem_(self.recordButton)
# Quit event
menuitem = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
'Quit', 'terminate:', '')
menu.addItem_(menuitem)
return menu
def startStopRecording_(self, notification) -> None:
if self.recording:
self.recorder.join(timeout=screenshot_interval*2)
# Create timelapse after recording?
if encode:
self.encoder = Encoder(
self.image_dir, self.encoder_output_basedir)
self.encoder.start()
else:
self.image_dir: str = self.create_dir(self.recorder_output_basedir)
self.recorder = Recorder(self.image_dir, screenshot_interval)
self.recorder.start()
notify("Timelapse started", "The recording has started")
self.recording: bool = not self.recording
self.setStatus()
@objc.python_method
def create_dir(self, base_dir: str) -> str:
""" Creates a specified directory and the path to it if necessary """
# Create a new subdirectory
output_dir: str = os.path.join(base_dir, self.get_sub_dir(base_dir))
# Create path if it doesn't exist
try:
print(f"Output directory: {output_dir}")
os.makedirs(output_dir)
except OSError as e:
notify("Timelapse error", f"Error while creating directory: {e}")
exit()
return output_dir
@objc.python_method
def get_sub_dir(self, base_dir: str) -> str:
""" Returns the subdirectory for recording, relative to base_dir """
subdir_suffix: str = "Session-" + \
time.strftime("%Y-%m-%d_%H-%M-%S")
return os.path.join(base_dir, subdir_suffix)
def check_dependencies(self) -> None:
try:
subprocess.run(['ffmpeg'], check=True,
capture_output=True, timeout=10.0)
except subprocess.CalledProcessError:
print("ffmpeg command was found")
pass # ffmpeg is found, but returns non-zero exit as expected
# This is a quick and dirty check; it leaves some spurious output
# for the user to puzzle over.
except OSError:
print(not_found_msg)
from recorder import Recorder
import argparse
import matplotlib.pyplot as plt
import numpy as np
import sys
PRINTER = Recorder()
parser = argparse.ArgumentParser()
parser.add_argument("-file")
parser.add_argument("-type")
args = parser.parse_args()
if args.file == None or args.type == None:
PRINTER.info_text(
"Specify filename and datatype with '-file <filename> -type <datatype>'"
)
sys.exit()
FILE = args.file
TYPE = args.type.lower()
if TYPE == "aia171":
plt.imshow(np.load(FILE), cmap="sdoaia171", origin="lower")
plt.title("AIA171")
plt.clim(0, 3500)
plt.show()
elif TYPE == "aia304":
plt.imshow(np.load(FILE), cmap="sdoaia304", origin="lower")
plt.title("AIA304")
plt.clim(0, 1500)
plt.show()
import speech_recognition as sr
from recorder import Recorder
r = Recorder()
r.record(15, output='output.wav')
r.play('output.wav')
AUDIO_FILE = ("output.wav")
# obtain audio from the microphone
r = sr.Recognizer()
with sr.AudioFile(AUDIO_FILE) as source:
audio = r.record(source)
# recognize speech using Sphinx
try:
print(r.recognize_google(audio))
except sr.UnknownValueError:
print("Google could not understand audio")
except sr.RequestError as e:
print("Google error; {0}".format(e))
def set_record_dir(self, record_dir, setting_file_name, system_name,
version):
self.recorder = \
Recorder(os.path.join(record_dir,system_name,version))
self.recorder.create_record_folder()
self.recorder.record_setting(setting_file_name)
pmh.daemon = True
pmh.start()
pfile = PypoFile(media_q, config['pypo'])
pfile.daemon = True
pfile.start()
pf = PypoFetch(pypoFetch_q, pypoPush_q, media_q, telnet_lock,
pypo_liquidsoap, config['pypo'])
pf.daemon = True
pf.start()
pp = PypoPush(pypoPush_q, telnet_lock, pypo_liquidsoap, config['pypo'])
pp.daemon = True
pp.start()
recorder = Recorder(recorder_q)
recorder.daemon = True
recorder.start()
stat = ListenerStat(config)
stat.daemon = True
stat.start()
# Just sleep the main thread, instead of blocking on pf.join().
# This allows CTRL-C to work!
while True:
time.sleep(1)
logger.info("System exit")
class Rollout(object):
def __init__(self, ob_space, ac_space, nenvs, nsteps_per_seg, nsegs_per_env, nlumps, envs, policy,
int_rew_coeff, ext_rew_coeff, record_rollouts, dynamics,patience, nthe):
self.nenvs = nenvs
self.nsteps_per_seg = nsteps_per_seg
self.nsegs_per_env = nsegs_per_env
self.nsteps = self.nsteps_per_seg * self.nsegs_per_env
self.ob_space = ob_space
self.ac_space = ac_space
self.nlumps = nlumps
self.lump_stride = nenvs // self.nlumps
self.envs = envs
self.policy = policy
self.dynamics = dynamics
self.patience = patience
self.reward_fun = lambda ext_rew, int_rew: ext_rew_coeff * np.clip(ext_rew, -1., 1.) + int_rew_coeff * int_rew
self.buf_vpreds = np.empty((nenvs, self.nsteps), np.float32)
self.buf_nlps = np.empty((nenvs, self.nsteps), np.float32)
self.buf_rews = np.empty((nenvs, self.nsteps), np.float32)
self.buf_ext_rews = np.empty((nenvs, self.nsteps), np.float32)
self.buf_acs = np.empty((nenvs, self.nsteps, *self.ac_space.shape), self.ac_space.dtype)
self.buf_obs = np.empty((nenvs, self.nsteps, *self.ob_space.shape), self.ob_space.dtype)
self.buf_obs_last = np.empty((nenvs, self.nsegs_per_env, *self.ob_space.shape), np.float32)
self.buf_news = np.zeros((nenvs, self.nsteps), np.float32)
self.buf_new_last = self.buf_news[:, 0, ...].copy()
self.buf_vpred_last = self.buf_vpreds[:, 0, ...].copy()
self.env_results = [None] * self.nlumps
# self.prev_feat = [None for _ in range(self.nlumps)]
# self.prev_acs = [None for _ in range(self.nlumps)]
self.int_rew = np.zeros((nenvs,), np.float32)
self.recorder = Recorder(nenvs=self.nenvs, nlumps=self.nlumps) if record_rollouts else None
self.statlists = defaultdict(lambda: deque([], maxlen=100))
self.stats = defaultdict(float)
self.best_ext_ret = None
self.all_visited_rooms = []
self.all_scores = []
self.step_count = 0
#########################################################
self.ac_buf = self.int_rew = np.zeros((nenvs,), np.float32)
self.buf_acs_nold = np.empty((nenvs, self.nsteps, *self.ac_space.shape), self.ac_space.dtype)
self.ac_buf_nold = np.empty((nenvs, self.nsteps, *self.ac_space.shape), self.ac_space.dtype)
self.nthe = nthe
self.ac_list = []
self.rew_list = []
self.obs_list = []
self.feat_list = []
self.patience_pred = 0
self.pat = 0
self.mean = np.zeros((128,128), np.float32)
self.var = np.ones((128,128), np.float32)
self.model = 0
self.flag = 1
self.flag2 = 1
#########################################################
def collect_rollout(self):
self.ep_infos_new = []
for t in range(self.nsteps):
self.rollout_step()
self.calculate_reward()
self.update_info()
def calculate_reward(self):
#여기도 수정
##############################################################################
print("fffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
int_rew, ac, feat = self.dynamics.calculate_loss(ob=self.buf_obs,
last_ob=self.buf_obs_last,
acs=self.buf_acs, feat_input = [],pat = 0)
self.ac_list.append(ac)
self.rew_list.append(int_rew)
self.obs_list.append(self.buf_obs)
self.feat_list.append(feat)
print("ac_list", len(self.ac_list))
print("rew_list", len(self.rew_list))
print("obs_list", len(self.obs_list))
print("feat_list", len(self.feat_list))
#self.feat_list = tf.stack(self.feat_list, feat)
# if len(self.ac_list) > (self.nthe):
if len(self.ac_list) > (self.nthe):
self.ac_list = self.ac_list[1:]
self.rew_list = self.rew_list[1:]
self.obs_list = self.obs_list[1:]
self.feat_list = self.feat_list[1:]
if self.step_count/self.nsteps > self.nthe and self.nthe:
self.flag2 = 0
print("ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss")
int_rew_now, ac_now, feat_now = self.dynamics.calculate_loss(ob=self.obs_list[0],
last_ob=self.buf_obs_last,
acs=self.ac_list[0],feat_input = self.feat_list[0], pat = 1)
coc = 10*abs(self.rew_list[0] - int_rew_now)
"""
if self.flag:
self.mean = coc
print("var shape: ",self.var.shape)
norm_coc = np.multiply((coc - self.mean),np.reciprocal(np.sqrt(self.var)))
else:
norm_coc = np.multiply((coc - self.mean),np.reciprocal(np.sqrt(self.var)))
"""
norm_coc = coc
#norm_coc = np.multiply((coc - self.mean),np.reciprocal(np.sqrt(self.var)))
#print("previous rew",self.rew_list[0])
#print("now rew",int_rew_now)
#self.mean = 0.8 * self.mean + 0.2 * coc
#self.var = 0.8 * self.var + 0.2 * (coc-self.mean)**2
#print("norm_coc",norm_coc)
pat = norm_coc
#pat = 1 / (1 + np.exp(-norm_coc))
#MontezumaRevengeNoFrameskip-v4
##############################################################################
# This is the training code
if self.flag:
self.model = tf.keras.models.Sequential([
tf.keras.layers.Dense(256, activation="relu"),
tf.keras.layers.Dense(128, activation="relu"),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(64, activation="relu"),
#tf.keras.layers.Dropout(0.3),
tf.keras.layers.Dense(32, activation="relu"),
tf.keras.layers.Dense(1),
#tf.keras.layers.Flatten(input_shape=(84, 84,4)),
#tf.keras.layers.Dense(128, activation='relu'),
#tf.keras.layers.Dropout(0.2),
#tf.keras.layers.Dense(1),
#tf.keras.layers.Reshape(target_shape = (128,128,-1))
])
self.flag = 0
#x = flatten_two_dims(tf.convert_to_tensor(self.feat_list[0]))
x = tf.convert_to_tensor(self.feat_list[0])
x_test = tf.convert_to_tensor(self.feat_list[-1])
#print("Feature dim before converting into Tensor: ", self.feat_list[0].shape)
#print("Feature dim after converting into Tensor", tf.convert_to_tensor(self.feat_list[0].shape))
#print("Flatten Two Dim ..Feature Dim..:", x.shape)
ac = tf.one_hot(self.ac_list[0], self.ac_space.n, axis=2)
ac_test = tf.one_hot(self.ac_list[-1], self.ac_space.n, axis=2)
#print("Action Dim ..before one hot..: ",self.ac_list[0].shape, self.ac_space.n)
#print("Action Dim ..After one hot: ", ac.shape)
sh = tf.shape(ac)
#ac = flatten_two_dims(ac)
#print("Action Dim after flatten", ac.shape)
x_new = tf.concat([x, ac], axis=-1)
x_test2 = tf.concat([x_test, ac_test], axis=-1)
#print("Input value concat ..x,ac..: ",x_new.shape)
#print("Output Dim of Patience Model: ", pat)
x_new = flatten_two_dims(x_new)
x_test2 = flatten_two_dims(x_test2)
# xnew 16384, 16384, 512+4 (train_examples, train_labels)
pat = pat.reshape((16384,1))
train_dataset = tf.data.Dataset.from_tensor_slices((tf.stop_gradient(x_new),tf.stop_gradient(pat)))
test_dataset = tf.data.Dataset.from_tensor_slices((x_new,pat))
#pred_dataset = tf.data.Dataset.from_tensor_slices((x_test2))
BATCH_SIZE = 64
SHUFFLE_BUFFER_SIZE = 10
train_dataset = train_dataset.shuffle(SHUFFLE_BUFFER_SIZE).batch(BATCH_SIZE)
test_dataset = test_dataset.batch(BATCH_SIZE)
#pred_dataset = pred_dataset.batch(BATCH_SIZE)
#print("Train Dataset Shape : ", train_dataset.shape)
self.model.compile(optimizer=keras.optimizers.Adam(learning_rate= 1e-4),loss='mean_absolute_error', metrics=['mean_absolute_error'])
# feat_list 128 x 128 x 512 action 128 x 128 x 4 hidsize 512
results = self.model.evaluate(test_dataset)
#print('test loss, test acc:', results)
#print("pred",pred)
#print("Input Dim for Patience Model: ", x_new.shape)
print("Output Dim of Patience Model: ", pat)
self.model.fit(train_dataset, epochs=20,workers = 4, verbose = 0)
print(self.model.summary())
# tf.keras.utils.plot_model(self.model, to_file="model.png",show_shapes=True,show_layer_names=True,rankdir="TB",dpi=96)
pred = self.model.predict(x_test2, steps = 1)
#print("pred shape:",pred.shape)
# elementwise multiply
#print("int_rew shape",int_rew.shape)
#print("ext rew bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", self.buf_ext_rews.shape)
#print("pred:",np.reshape(np.array(pred),(128,128)))
int_rew = np.array(int_rew) * np.reshape(np.array(pred),(128,128))
#int_rew = np.multiply(int_rew,pat_pred)
#print(int_rew.shape)
self.flag2 = 1
################################################################################
self.buf_rews[:] = self.reward_fun(int_rew=int_rew, ext_rew=self.buf_ext_rews)
def rollout_step(self):
t = self.step_count % self.nsteps
s = t % self.nsteps_per_seg
for l in range(self.nlumps):
obs, prevrews, news, infos = self.env_get(l)
# if t > 0:
# prev_feat = self.prev_feat[l]
# prev_acs = self.prev_acs[l]
for info in infos:
epinfo = info.get('episode', {})
mzepinfo = info.get('mz_episode', {})
retroepinfo = info.get('retro_episode', {})
epinfo.update(mzepinfo)
epinfo.update(retroepinfo)
if epinfo:
if "n_states_visited" in info:
epinfo["n_states_visited"] = info["n_states_visited"]
epinfo["states_visited"] = info["states_visited"]
self.ep_infos_new.append((self.step_count, epinfo))
sli = slice(l * self.lump_stride, (l + 1) * self.lump_stride)
acs, vpreds, nlps = self.policy.get_ac_value_nlp(obs)
self.env_step(l, acs)
# self.prev_feat[l] = dyn_feat
# self.prev_acs[l] = acs
self.buf_obs[sli, t] = obs
self.buf_news[sli, t] = news
self.buf_vpreds[sli, t] = vpreds
self.buf_nlps[sli, t] = nlps
self.buf_acs[sli, t] = acs
if t > 0:
self.buf_ext_rews[sli, t - 1] = prevrews
# if t > 0:
# dyn_logp = self.policy.call_reward(prev_feat, pol_feat, prev_acs)
#
# self.int_rew[sli] = int_rew
# self.buf_rews[sli, t - 1] = self.reward_fun(ext_rew=prevrews, int_rew=int_rew)
if self.recorder is not None:
self.recorder.record(timestep=self.step_count, lump=l, acs=acs, infos=infos, int_rew=self.int_rew[sli],
ext_rew=prevrews, news=news)
self.step_count += 1
if s == self.nsteps_per_seg - 1:
for l in range(self.nlumps):
sli = slice(l * self.lump_stride, (l + 1) * self.lump_stride)
nextobs, ext_rews, nextnews, _ = self.env_get(l)
self.buf_obs_last[sli, t // self.nsteps_per_seg] = nextobs
if t == self.nsteps - 1:
self.buf_new_last[sli] = nextnews
self.buf_ext_rews[sli, t] = ext_rews
_, self.buf_vpred_last[sli], _ = self.policy.get_ac_value_nlp(nextobs)
# dyn_logp = self.policy.call_reward(self.prev_feat[l], last_pol_feat, prev_acs)
# dyn_logp = dyn_logp.reshape(-1, )
# int_rew = dyn_logp
#
# self.int_rew[sli] = int_rew
# self.buf_rews[sli, t] = self.reward_fun(ext_rew=ext_rews, int_rew=int_rew)
def update_info(self):
all_ep_infos = MPI.COMM_WORLD.allgather(self.ep_infos_new)
all_ep_infos = sorted(sum(all_ep_infos, []), key=lambda x: x[0])
if all_ep_infos:
all_ep_infos = [i_[1] for i_ in all_ep_infos] # remove the step_count
keys_ = all_ep_infos[0].keys()
all_ep_infos = {k: [i[k] for i in all_ep_infos] for k in keys_}
self.statlists['eprew'].extend(all_ep_infos['r'])
self.stats['eprew_recent'] = np.mean(all_ep_infos['r'])
self.statlists['eplen'].extend(all_ep_infos['l'])
self.stats['epcount'] += len(all_ep_infos['l'])
self.stats['tcount'] += sum(all_ep_infos['l'])
if 'visited_rooms' in keys_:
# Montezuma specific logging.
self.stats['visited_rooms'] = sorted(list(set.union(*all_ep_infos['visited_rooms'])))
self.stats['pos_count'] = np.mean(all_ep_infos['pos_count'])
self.all_visited_rooms.extend(self.stats['visited_rooms'])
self.all_scores.extend(all_ep_infos["r"])
self.all_scores = sorted(list(set(self.all_scores)))
self.all_visited_rooms = sorted(list(set(self.all_visited_rooms)))
if MPI.COMM_WORLD.Get_rank() == 0:
print("All visited rooms")
print(self.all_visited_rooms)
print("All scores")
print(self.all_scores)
if 'levels' in keys_:
# Retro logging
temp = sorted(list(set.union(*all_ep_infos['levels'])))
self.all_visited_rooms.extend(temp)
self.all_visited_rooms = sorted(list(set(self.all_visited_rooms)))
if MPI.COMM_WORLD.Get_rank() == 0:
print("All visited levels")
print(self.all_visited_rooms)
current_max = np.max(all_ep_infos['r'])
else:
current_max = None
self.ep_infos_new = []
if current_max is not None:
if (self.best_ext_ret is None) or (current_max > self.best_ext_ret):
self.best_ext_ret = current_max
self.current_max = current_max
def env_step(self, l, acs):
self.envs[l].step_async(acs)
self.env_results[l] = None
def env_get(self, l):
if self.step_count == 0:
ob = self.envs[l].reset()
out = self.env_results[l] = (ob, None, np.ones(self.lump_stride, bool), {})
else:
if self.env_results[l] is None:
out = self.env_results[l] = self.envs[l].step_wait()
else:
out = self.env_results[l]
return out
