def __init__(self):
log_dir = os.path.join(util.default_root_dir(), self.LOG_DIR)
if not os.path.exists(log_dir):
os.makedirs(log_dir)
LOG_FILE = os.path.join(log_dir, '{}.log'.format(__file__))
self.log = logger.get_logger(__file__, LOG_FILE)
Frame.__init__(self, name='camaro_gen_tool')
self.master.title('Camaro Generation File Tool')
self.pack(expand=Y, fill=BOTH)
self.root_dir = os.path.abspath(
os.path.join(os.getcwd(), self.ROOT_DIR))
self.ftp_popup = None
# Visual separation in the log
self.log.info('Log Start')
# File dialogs
self.ifile_var = StringVar()
self.pfile_var = StringVar()
self.do_erase = IntVar()
self.do_copy_original = IntVar()
self.do_copy_pdf = IntVar()
self.size0 = IntVar()
self.size1 = IntVar()
self.size2t = IntVar()
self.size2 = IntVar()
self.size0.set(50)
self.size1.set(100)
self.size2t.set(150)
self.size2.set(500)
self.session = None
self.server = StringVar()
self.user = StringVar()
self.pwd = StringVar()
self.server.set('')
self.user.set('')
self.pwd.set('')
self.thumbnail_listbox = None
self.err_count = 0
self.img_list_file = ''
self.product_list_file = ''
# Create input folders if not already there
dirs = []
root_dir = os.path.abspath(
os.path.join(os.getcwd(), ScrapeImages.ROOT_DIR))
dirs.append(os.path.join(root_dir, ScrapeImages.INPUT_DIR))
dirs.append(os.path.join(root_dir, ReorderCsv.INPUT_DIR))
dirs.append(os.path.join(root_dir, ScrapeImages.IMG_LIST_DIR))
for dir in dirs:
util.make_sure_path_exists(dir)
# Create UI
self.create_panel()
def oauth_submit():
# Get the oauth_key from the page form
oauth_key = request.forms.get('oauth_key')
try:
credentials = oauth2_flow.step2_exchange(oauth_key)
except Exception as e:
return "Error with login: %s" % e
else:
# Get the user's email and add it to the session
email = get_email(credentials.access_token)
# Store the oauth credentials
oauth_path = DirInfo.get_oauth_file_path(email)
util.make_sure_path_exists(os.path.dirname(oauth_path))
storage = oauth2client.file.Storage(oauth_path)
storage.put(credentials)
# Create the user instance and have it login/initialize
user = User(email, DirInfo.BaseAppDataDir)
users[email] = user
if not user.init(credentials):
return "Error with login, incorrect code?"
else:
global logged_in
logged_in = True
session = get_session()
session["email"] = email
redirect("/main")
def main():
logger.info("Starting google music uploader")
pidfile = None
if len(sys.argv) > 1:
if sys.argv[1] == "--pidfile":
if len(sys.argv) < 3:
logger.error("Missing pidfile path")
return
pidfile = sys.argv[2]
if pidfile:
if not util.make_sure_path_exists(os.path.dirname(pidfile)):
logger.warning("Error creating pidfile directory %s" % os.path.dirname(pidfile))
return
with open(pidfile, "w+") as f:
logger.debug("Writing pidfile to %s" % pidfile)
f.write(str(os.getpid()))
config = util.read_config(DirInfo.AppConfig)
session_opts = {
'session.type': 'memory',
'session.auto': 'true'
}
app = SessionMiddleware(bottle.app(), session_opts)
run(app=app, host='0.0.0.0', port=config['PORT'], debug=True)
def get_args():
parser = ArgumentParser(prog="GravLens")
io = parser.add_argument_group("IO")
val = parser.add_argument_group("Values")
io.add_argument("-o", "--output",
required=True,
help="Output directory.")
val.add_argument("--radius", type=float,
default=2.2,
help="Radius of galaxy cluster in Mpc (default 2.2)")
val.add_argument("--dist-lens", type=float,
default=54.0,
help="Distance to galaxy cluster in Mpc (default 54.0)")
val.add_argument("--dist-source", type=float,
default=10.0,
help="Distance to source in units of distance to lens (default 10.0)")
val.add_argument("--angle-source", type=float,
default=100.0,
help="Angle between source and lens in units of inverse angular "
"radius of lens (default 10.0)")
val.add_argument("--mass", type=float,
default=1.2e15,
help="Mass of galaxy cluster in Msun (default 1.2e15)")
val.add_argument("--profile-index", type=float,
default=0.1,
help="Index on mass profile, i.e. 'γ' (default 1.0)")
val.add_argument("--scaling-radius", type=float,
default=1e-2,
help="Scaling radius on mass profile, i.e. 'a' (default 1e-10)")
val.add_argument("--frequencies", type=float, nargs="+",
default=[0.9, 1.0, 1.1],
help="List of photon frequencies in GHz (default 0.9, 1.0, 1.1)")
val.add_argument("--fraction-plasma", type=float,
default=0.10,
help="Fraction of total mass in plasma (default 0.10)")
args = parser.parse_args()
args.dist_source *= args.dist_lens
args.frequencies = np.multiply(1e9, args.frequencies)
make_sure_path_exists(args.output)
return args
def extract(datalist, like, bbox, dst_crs, out_path):
"""Extract/reproject data within lat/lon bbox
"""
# check that enough options are provided
if not like and not bbox:
util.error("Provide bounds as either a 'like' dataset or a bbox")
# read input csv listing layers
layers = [s for s in csv.DictReader(open(datalist, 'rb'))]
# parse bbox
if bbox:
bbox = tuple(map(float, bbox.split(',')))
# derive bbox/crs from aoi/like layer (ignoring any provided bbox)
if like:
bbox = util.get_bbox(like)
dst_crs = util.get_crs(like)
# parse provided epsg code
elif dst_crs:
dst_crs = from_epsg(dst_crs.split(':')[1])
# name is derived from config file name
if not out_path:
b = os.path.basename(datalist)
out_path = os.path.join(os.getcwd(), os.path.splitext(b)[0])
util.make_sure_path_exists(out_path)
# process each layer
for layer in layers:
click.echo('Extracting %s' % layer['name'])
if util.describe(layer['path'])['type'] == 'VECTOR':
util.bbox_copy(layer['path'],
os.path.join(out_path, layer['name'] + ".shp"),
bbox,
in_layer=layer['layer'],
dst_crs=dst_crs)
elif util.describe(layer['path'])['type'] == 'RASTER':
util.bbox_copyraster(layer['path'],
os.path.join(out_path,
layer['name'] + '.tif'),
bbox,
dst_crs=dst_crs)
def close_current_assignment(config, current_station):
"""
Zatvara trenutno otvoreni studentski zadatak
config - globalna konfiguracija alata za pregled
current_station - oznaka trenutno selektovanog računara
"""
print 'Zatvaranje studentskog zadatka {0}, posto se prelazi na drugi...'.format(current_station)
onlyfiles = [f for f in os.listdir(config.CURRENT_ALT_ASSIGNMENT_PATH)
if path.isfile(join(config.CURRENT_ALT_ASSIGNMENT_PATH, f))]
if len(onlyfiles) > 0:
print('Postoji alternativna verzija zadatka, pa se ona kopira u {0}'.format(config.ALTERED_ASSIGNMENTS_PATH))
altered = join(config.ALTERED_ASSIGNMENTS_PATH, current_station)
util.make_sure_path_exists(altered)
logging.info('Detektovano je da postoji alternativna varijanta zadatka, koja je kopirana u: {0}'
.format(altered))
print('Kopiranje fajlova iz "{0}" u "{1}"'.format(config.CURRENT_ALT_ASSIGNMENT_PATH, altered))
for f in onlyfiles:
copyfile(join(config.CURRENT_ALT_ASSIGNMENT_PATH, f), join(altered, f))
def post(self):
# validate data first
if not self.validate_post_data():
return
gopca_config = self.get_gopca_config_from_post_data()
#gopca_config.validate()
# write config to a ini file
# generate job ID
job_id = ''
while not job_id:
job_id = self.generate_session_id()
if job_id in self.jobs:
# very unlikely
job_id = ''
#self.set_secure_cookie('session_id',session_id)
#self.write(session_id)
#self.logger.debug('Value of disable_local: %s', self.get_body_argument('disable_local',default=0))
#self.logger.debug('Value of disable_global: %s', self.get_body_argument('disable_global',default=0))
species = self.get_body_argument('species')
description = self.get_body_argument('description',default='')
job = GSJob(session_id, GSJob.get_current_time(),self.run_dir,species,description)
self.logger.debug('Created job %s', str(job))
# create the directory
run_dir = self.run_dir + os.sep + session_id
self.logger.debug('GOPCAHandler: Creating directory "%s"...', run_dir)
util.make_sure_path_exists(run_dir)
# store run data
r.store_data()
# create bash file
species_name = self.species_names[species]
gene_annotation_file = self.data_dir + os.sep + self.get_body_argument('gene_annotation') + '.gtf.gz'
expression_url = self.get_body_argument('expression')
go_annotation = self.get_body_argument('go_annotation')
gene_ontology_file = self.data_dir + os.sep + go_annotation + '.obo'
go_association_file = self.data_dir + os.sep + go_annotation + '.gaf.gz'
evidence = self.get_body_arguments('go_evidence')
min_genes = str(int(self.get_body_argument('go_min_genes')))
max_genes = str(int(self.get_body_argument('go_max_genes')))
self.logger.debug('Evidence: %s', str(evidence))
#evidence_str = ' '.join(['"%s"' %(str(e)) for e in evidence])
#def esc(fn):
# return fn.replace(' ',r'\ ')
max_file_size = int(self.max_file_size * 1e6)
template = self.get_template('gopca.sh')
script = template.render(
species_name = species_name,
# expression data
expression_url = expression_url,
max_file_size = max_file_size,
# Gene annotations
gene_annotation_file = gene_annotation_file,
# GO annotations
gene_ontology_file = gene_ontology_file,
go_association_file = go_association_file,
go_evidence = evidence,
go_min_genes = min_genes,
go_max_genes = max_genes,
# GO-PCA
gopca_config = gopca_config
)
assert isinstance(script, unicode)
output_file = run_dir + os.sep + 'gopca.sh'
with codecs.open(output_file, 'wb', encoding = 'utf-8') as ofh:
ofh.write(script)
self.logger.debug('Wrote file "%s".',output_file)
# run the script
st = os.stat(output_file)
os.chmod(output_file, st.st_mode | stat.S_IXUSR)
log_file = run_dir + os.sep + 'gopca_pipeline_log.txt'
cmd = '"%s" > "%s" 2>&1' %(output_file, log_file)
logger.debug('Command: %s', cmd)
subproc.Popen(cmd, shell = True, executable = '/bin/bash')
# update run status
r.update_status()
r.store_data()
# write html
template = self.get_template('submit.html')
html_output = template.render(timestamp=self.ts,title='Submission',run_id=session_id)
self.write(html_output)
self.runs[session_id] = r
def duel_rank_train(env, exploreScheduler, betaScheduler, optimizer_constructor, model_type, batch_size, rp_start, rp_size,
exp_frame, exp_initial, exp_final, prob_alpha, gamma, target_update_steps, frames_per_epoch,
frames_per_state, output_directory, last_checkpoint, max_frames, envo):
"""
Implementation of the training algorithm for Dueling Network Architecture using Rank-based prioritization.
Information with regards to the algorithm can be found in the paper,
"Dueling Network Architectures for Deep Reinforcement Learning" by Ziyu Wang et al.
Refer to section 4.2 in the paper for more implementation info.
"""
gym.undo_logger_setup()
logging.basicConfig(filename=envo+'_'+'duel_rank_training.log',level=logging.INFO)
num_actions = env.action_space.n
env.reset()
print('No. of actions: ', num_actions)
print(env.unwrapped.get_action_meanings())
# initialize action value and target network with the same weights
model = DUEL(num_actions)
target = DUEL(num_actions)
if use_cuda:
model.cuda()
target.cuda()
frames_count = 1
if last_checkpoint:
model.load_state_dict(torch.load(last_checkpoint))
print(last_checkpoint)
print('weights loaded...')
exp_replay = util.initialize_rank_replay_resume(env, rp_start, rp_size, frames_per_state,
model, target, gamma, batch_size)
frames_count = get_index_from_checkpoint_path(last_checkpoint)
else:
exp_replay = util.initialize_rank_replay(env, rp_start, rp_size, frames_per_state,
model, target, gamma, prob_alpha)
target.load_state_dict(model.state_dict())
optimizer = optimizer_constructor.type(model.parameters(), lr=optimizer_constructor.kwargs['lr'],
alpha=optimizer_constructor.kwargs['alpha'], eps=optimizer_constructor.kwargs['eps'] )
episodes_count = 1
frames_per_episode = 1
epsiodes_durations = []
rewards_per_episode = 0
rewards_duration = []
loss_per_epoch = []
wLoss_func = Weighted_Loss()
current_state, _, _, _ = util.play_game(env, frames_per_state)
print('Starting training...')
for frames_count in range(1, max_frames):
epsilon=exploreScheduler.anneal_linear(frames_count)
beta = betaScheduler.anneal_linear(frames_count)
choice = random.uniform(0,1)
# epsilon greedy algorithm
if choice <= epsilon:
action = LongTensor([[random.randrange(num_actions)]])
else:
action = util.get_greedy_action(model, current_state)
curr_obs, reward, done, _ = util.play_game(env, frames_per_state, action[0][0])
rewards_per_episode += reward
reward = Tensor([[reward]])
current_state_ex = Variable(current_state, volatile=True)
curr_obs_ex = Variable(curr_obs, volatile=True)
action_ex = Variable(action, volatile=True)
reward_ex = Variable(reward, volatile=True)
#compute td-error for one sample
td_error = duel_compute_td_error(batch_size=1, state_batch=current_state_ex, reward_batch=reward_ex, action_batch=action_ex,
next_state_batch=curr_obs_ex, model=model, target=target, gamma=gamma)
td_error = torch.pow(torch.abs(td_error)+1e-6, prob_alpha)
exp_replay.push(current_state, action, reward, curr_obs, td_error)
current_state = curr_obs
# compute y
if len(exp_replay) >= batch_size:
# Get batch samples
obs_samples, obs_ranks, obs_priorityVals = exp_replay.sample(batch_size)
num_samples_per_batch = len(obs_samples)
obs_priorityTensor = torch.from_numpy(np.array(obs_priorityVals))
p_batch = 1/ obs_priorityTensor
w_batch = (1/len(exp_replay) * p_batch)**beta
max_weight = exp_replay.get_max_weight(beta)
w_batch /= max_weight
w_batch = w_batch.type(Tensor)
batch = Experience(*zip(*obs_samples))
loss, new_weights = duel_compute_y(batch, num_samples_per_batch, model, target, gamma, w_batch, wLoss_func)
loss_abs = torch.abs(new_weights)
exp_replay.update(obs_ranks, loss_abs)
currentLOSS = loss.data.cpu().numpy()[0]
optimizer.zero_grad()
loss.backward()
grad_index = 0
for param in model.parameters():
#Clip the combined gradient entering the last conv layer by 1/sqrt(2)
if grad_index == 4:
param.grad.data.mul_(1/math.sqrt(2))
#Clip gradients to have their norm less than or equal to 10
grad_norm = torch.norm(param.grad.data)
if grad_norm > 10:
param.grad.data.div_(grad_norm).mul_(10)
grad_index += 1
optimizer.step()
loss_per_epoch.append(loss.data.cpu().numpy()[0])
frames_per_episode+= frames_per_state
if done:
rewards_duration.append(rewards_per_episode)
rewards_per_episode = 0
frames_per_episode=1
episodes_count+=1
env.reset()
current_state, _, _, _ = util.play_game(env, frames_per_state)
if episodes_count % 100 == 0:
avg_episode_reward = sum(rewards_duration)/100.0
avg_reward_content = 'Episode from', episodes_count-99, ' to ', episodes_count, ' has an average of ', avg_episode_reward, ' reward and loss of ', sum(loss_per_epoch)
print(avg_reward_content)
logging.info(avg_reward_content)
rewards_duration = []
loss_per_epoch = []
# update weights of target network for every TARGET_UPDATE_FREQ steps
if frames_count % target_update_steps == 0:
target.load_state_dict(model.state_dict())
# print('weights updated at frame no. ', frames_count)
# sort memory replay every half of it's capacity iterations
if frames_count % int(rp_size/2) == 0:
exp_replay.sort()
#Save weights every 250k frames
if frames_count % 250000 == 0:
util.make_sure_path_exists(output_directory+'/'+envo+'/')
torch.save(model.state_dict(), output_directory+envo+'/rank_duel_'+ str(frames_count)+'.pth')
#Print frame count and sort experience replay for every 1000000 (one million) frames:
if frames_count % 1000000 == 0:
training_update = 'frame count: ', frames_count, 'episode count: ', episodes_count, 'epsilon: ', epsilon
print(training_update)
logging.info(training_update)
def execute_run_tests_command(backend, config, criteria, stations, run_path,
comp):
"""
Izvršenje komande koja obavlja pokretanje svih testova za zadatak
backend - back-end koji se trenutno koristi
config - globalna konfiguracija alata za pregled
criteria - kriterijum pregleda zadatka (bodovanje, način izvršavanja itd.)
stations - kolekcija računara i studenata koji su radili zadatak (ključ - oznaka računara, podatak - lista - broj
indeksa i ime/prezime studenta)
run_path - putanja na kojoj se nalazi studentski zadatak čiji se testovi izvršavaju
comp - oznaka računara na kojem je urađen zadatak koji se pregleda
"""
if not path.isdir(config.AUTOTEST_PATH):
util.fatal_error(
'''Prilikom postavljanja zadatka nije postavljena autotest varijanta zadatka.\n'
Ako zelite da koristite automatsko testiranje, kreirajte direktorijum "{0}" i postavite autotest varijantu u njega.'''
.format(config.AUTOTEST_PATH))
if not path.isdir(run_path):
util.fatal_error(
'Ne mogu se pokrenuti testovi jer projekat nije prethodno kompajliran.\n'
+ 'Upotrebite komandu build za kompajliranje projekta.')
util.make_sure_path_exists(config.REPORTS_PATH)
current_reports_path = join(config.REPORTS_PATH, comp)
util.make_sure_path_exists(current_reports_path)
util.clear_directory(current_reports_path)
logging.info(
'Pokrenuti su automatski testovi tekuceg projekta u direktorijumu: {0}'
.format(run_path))
proj = util.identify_project_file(backend, run_path)
executable = backend.identify_project_executable(proj)
all_results = []
tests = []
for s in criteria.score_distribution:
tests.append(s.keys()[0])
# Zakazivanje izvršenja testova od strane (potencijalno) više niti za izvršenje testova:
print('Sledeci testovi ce biti izvrseni: {0}'.format(', '.join(tests)))
print('Svaki test se izvrsava {0} put(a)'.format(
criteria.runs_spec['total']))
for t in tests:
execution_results[t] = [None] * criteria.runs_spec['total']
for i in range(backend.get_parallel_testing_threads_count()):
t = Thread(target=execution_worker_thread,
args=(backend, criteria, i, run_path, executable))
t.daemon = True
t.start()
for t in tests:
test_index = 0
for run in range(1, criteria.runs_spec['total'] + 1):
execution_queue.put([
test_index, t,
get_console_report_path(config, comp, t, test_index)
])
test_index += 1
execution_queue.join()
# Grupisanje dobijenih rezultata - konsolidacija rezultata po svakom pojedinačnom testu (po nazivu testa):
for t in tests:
results = execution_results[t]
# Određivanje najdužeg vremena izvršenja ovog testa:
max_duration = results[0].duration
executions = []
for r in results:
if r.duration > max_duration:
max_duration = r.duration
executions.append(r.result == 'passed')
passes = sum(1 for x in results if x.result == 'passed')
entry = TestResults(
name=t,
runs=criteria.runs_spec['total'],
passes=passes,
failures=sum(1 for x in results if x.result != 'passed'),
test_fails=sum(1 for x in results if x.result == 'failed'),
crashes=sum(1 for x in results if x.result == 'crashed'),
time_outs=sum(1 for x in results if x.result == 'timed-out'),
total_duration=sum(x.duration for x in results),
max_duration=max_duration,
score=get_score(criteria, t)["percent"],
factor=get_score(criteria, t)["factor"],
success=(passes / float(criteria.runs_spec['total'])) >=
criteria.runs_spec['pass_limit'],
executions=executions)
all_results.append(entry)
# Ispis rezimea pokretanja testova na konzolu:
total = len(criteria.score_distribution)
passed = 0
score = 0
blockers = False
for t in all_results:
print ''
header_line = 'TEST: {0}, ukupno izvrsenja: {1}'.format(t.name, t.runs)
print '*' * len(header_line)
print bcolors.BOLD + header_line + bcolors.ENDC
print '*' * len(header_line)
if t.runs < criteria.runs_spec['total']:
print bcolors.FAIL \
+ 'Detektovano je dovoljno negativnih ishoda pa nije obavljeno svih {0} zahtevanih pokretanja'\
.format(criteria.runs_spec['total']) + bcolors.ENDC
if t.passes > 0:
print bcolors.OKGREEN + 'PROSAO: {0} put(a)'.format(
t.passes) + bcolors.ENDC
if t.failures > 0:
print bcolors.FAIL + 'PAO: {0} put(a), od toga:'.format(
t.failures) + bcolors.ENDC
if t.test_fails > 0:
print bcolors.FAIL + ' Formirao los rezultat: {0} put(a)'.format(
t.test_fails) + bcolors.ENDC
if t.crashes > 0:
print bcolors.FAIL + ' Nasilno prekinuo izvrsenje: {0} put(a)'.format(
t.crashes) + bcolors.ENDC
if t.time_outs > 0:
print bcolors.FAIL + ' Prekoracio dozvoljeno vreme: {0} put(a)'.format(
t.time_outs) + bcolors.ENDC
print 'Ukupno vreme izvrsenja: {0}, najduze pokretanje: {1}'.format(
t.total_duration, t.max_duration)
if t.success:
print bcolors.OKGREEN + 'Test se smatra uspesnim, tezina: {0} (od ukupno {1}), procentualno: {2:.2f}%'\
.format(t.factor, criteria.total_weight, t.score) + bcolors.ENDC
passed += 1
score += t.score
else:
print bcolors.FAIL + 'Test se smatra neuspesnim' + bcolors.ENDC
if t in criteria.blocking_tests:
blockers = True
print bcolors.FAIL + 'Ovo je blokirajuci test!' + bcolors.ENDC
print ''
if passed == total:
print bcolors.OKGREEN \
+ '''Uspesno su izvrseni svi testovi (ukupno je: {0} testova).\nUkupno ostvareno procenata: {1:.2f}%'''.format(total, score) + bcolors.ENDC
else:
failed = total - passed
print bcolors.FAIL + '''Palo je {0} testova, od ukupno {1}!
Procenat testova koji prolaze: {2:.2f}%, procentualni ucinak: {3:.2f}%'''.format(
failed, total,
float(passed) / total * 100.0, score) + bcolors.ENDC
status = ASSIGNMENT_STATUS_OK
if blockers:
print bcolors.FAIL + bcolors.BOLD \
+ 'Pao je makar jedan blokirajuci test! U izvestaju je naznaceno da u ovom radu postoje takvi testovi.' \
+ bcolors.ENDC
status = ASSIGNMENT_STATUS_BLOCKED
final_report.update_final_report(config,
criteria,
stations,
comp,
datetime.datetime.now().isoformat(),
status=status,
results=all_results)
def internal_build_project(backend, config, criteria, current_assignment_path,
autobuild_path):
"""
Interna pomoćna metoda koja vrši kompajliranje projekta (studentskog zadatka)
backend - back-end koji se trenutno koristi
config - globalna konfiguracija alata za pregled
criteria - kriterijum pregleda zadatka (bodovanje, način izvršavanja itd.)
current_assignment_path - putanja do zadatka koji se kompajlira
autobuild_path - putanja na kojoj se nalazi autobuild varijanta tekućeg zadatka
Vraća indikaciju da li je kompajliranje uspešno obavljeno
0 - kompajliranje je uspešno
1 - produkovan je izvršni fajl ali je kompajliranje vratilo upozorenja
2 - kompajliranje je neuspešno
"""
logging.info(
'Pokrenuto je kompajliranje projekta u direktorijumu: {0}'.format(
current_assignment_path))
# Brisanje trenutnog sadrzaja autobuild direktorijuma:
print('Brisanje sadrzaja direktorijuma "{0}"'.format(autobuild_path))
util.make_sure_path_exists(autobuild_path)
util.clear_directory(autobuild_path)
# Kopiranje svih fajlova iz osnovnog direktorijuma u autobuild poddirektorijum:
print('Kopiranje izvornih fajlova iz "{0}" u "{1}"'.format(
current_assignment_path, autobuild_path))
onlyfiles = [
f for f in os.listdir(current_assignment_path)
if path.isfile(join(current_assignment_path, f))
]
autotestfiles = [
f for f in os.listdir(config.AUTOTEST_PATH)
if path.isfile(join(config.AUTOTEST_PATH, f))
]
for f in onlyfiles:
if (f in criteria.assignment_files) or (
f not in autotestfiles
and filename_matches_assignment_pattern(backend, f)):
copyfile(join(current_assignment_path, f), join(autobuild_path, f))
# Obrada događaja koji se inicira pre nego što se obavi kompajliranje zadatka:
try:
backend.before_build(autobuild_path)
except RuntimeError as err:
util.fatal_error(err.message)
# Kopiranje dodatnih fajlova iz autotest direktorijuma u autobuild poddirektorijum:
print('Kopiranje autotest fajlova iz "{0}" u "{1}"'.format(
config.AUTOTEST_PATH, autobuild_path))
if len(autotestfiles) == 0:
util.fatal_error(
'Projekat se ne moze kompajlirati jer autotest varijanta zadatka nije postavljena u direktorijum: "{0}"!'
.format(config.AUTOTEST_PATH))
for f in autotestfiles:
# Proverava se da li je fajl naveden u listi fajlova u kojima studenti unose resenje zadatka.
# Ako je tako, onda taj fajl ne bi smeo da bude postavljen u autotest folder.
if f in criteria.assignment_files:
util.fatal_error(
'''Fajl "{0}" je postavljen u "{1}" direktorijum a ocekuje se da studenti unose svoje resenje u taj fajl.
Fajlovi iz "{1}" direktorijuma kopiraju se preko studentskog resenja, tako da bi kopiranjem ovog fajla unistili kljucni deo resenja.
Molim da procitate deo uputstva za koriscenje alata za pregled koji se odnosi na postavljanje fajlova u ovaj direktorijum.'''
.format(f, config.AUTOTEST_PATH))
copyfile(join(config.AUTOTEST_PATH, f), join(autobuild_path, f))
# Potom, sledi kompajliranje projekta:
ret = backend.build_project(
util.identify_project_file(backend, autobuild_path))
# Poslednja linija izvešaja o kompajliranju treba da sadrži informaciju o potencijalnim upozorenjima i greškama tokom kompajliranja:
f = open(join(autobuild_path, backend.get_build_report_filename()), 'r')
lines = f.readlines()
last_line = lines[len(lines) - 1]
regex = re.compile(
'(?P<errors>\d+)\serror\(s\),\s(?P<warnings>\d+)\swarning\(s\)',
re.IGNORECASE)
m = regex.match(last_line)
if m:
errors = int(m.group('errors'))
warnings = int(m.group('warnings'))
if (errors == 0 and warnings == 0):
return 0
if (errors == 0):
return 1
return 2
else:
util.fatal_error(
'''Interna greska: izvestaj o kompajliranju ne sadrzi poslednju liniju sa brojem gresaka i upozorenja.
Nije moguce utvrditi ishod kompajliranja. Potrebno je kontaktirati autora alata.'''
)
def execute_init_command(config, stations, all_backends, log_filename):
"""
Izvršavanje komande za inicijalizaciju pregleda (postavljanje materijala i određivanje kriterijuma pregleda)
config - globalna konfiguracija alata za pregled
stations - kolekcija računara i studenata koji su radili zadatak (ključ - oznaka računara, podatak - lista - broj
indeksa i ime/prezime studenta)
all_backends - lista instanci klase Backend - sve raspoložive implementacije back-end-a
"""
# Pribavljanje sadržaja tekućeg direktorijuma kako bi se proverilo da li je on prazan:
lista = os.listdir('.')
# Ako u tekućem direktorijumu postoji log fajl, on se ignoriše:
lista.remove(log_filename)
# Tekući direktorijum mora biti prazan da bi se dozvolila inicijalizacija projekta:
if lista != []:
print bcolors.FAIL + 'Tekuci direktorijum nije prazan!' + bcolors.ENDC
print 'Ne moze se inicirati pregled zadataka u ovom direktorijumu.'
sys.exit(1)
print 'Inicijalizacija pregleda je pokrenuta, molim pratite instrukcije na ekranu.'
print 'Izbor predmeta/backend-a za kompajliranje i pokretanje zadataka'
print 'Alat je trenutno konfigurisan da podrzava sledece varijante backend-a:'
option = 1
for b in all_backends:
print '{0}) Naziv: {1}, Ver: {2}, Opis: {3}'.format(
option, b.name(), b.version(), b.description())
option += 1
izbor = util.get_option_answer(1, option - 1)
backend = all_backends[izbor - 1]
grupe = util.get_yesno_answer('Da li u ovoj proveri postoje grupe A i B?')
autotest = util.get_yesno_answer(
'Da li ce pregled biti obavljen automatizovano?')
# Kreiranje dva poddirektorijuma za pregled po grupama:
if grupe:
util.make_sure_path_exists(config.GROUP1_DIR)
util.make_sure_path_exists(config.GROUP2_DIR)
print ''
print bcolors.OKBLUE + 'Zadaci grupa A i B tretirace se kao dva odvojena zadatka koji se pregledaju.' \
+ bcolors.ENDC
print 'Za zadatke grupe A kreiran je direktorijum "{0}" u kojem ce se postaviti fajlovi za pregled.'\
.format(config.GROUP1_DIR)
print 'Za zadatke grupe B kreiran je direktorijum "{0}" sa istom svrhom.'.format(
config.GROUP2_DIR)
print ''
print 'Kopiranje neophodnih fajlova u tekuci direktorijum...'
# Kopiranje XSLT fajla:
dir = os.path.dirname(__file__)
xslt_path = join(dir, config.FINAL_REPORT_XSLT_FILENAME)
if grupe:
copyfile(xslt_path,
join(config.GROUP1_DIR, config.FINAL_REPORT_XSLT_FILENAME))
copyfile(xslt_path,
join(config.GROUP2_DIR, config.FINAL_REPORT_XSLT_FILENAME))
else:
copyfile(xslt_path, join('.', config.FINAL_REPORT_XSLT_FILENAME))
# Priprema direktorijuma u koje će se raspakovati zadaci:
if grupe:
util.make_sure_path_exists(
join(config.GROUP1_DIR, config.ASSIGNMENTS_PATH))
util.make_sure_path_exists(
join(config.GROUP2_DIR, config.ASSIGNMENTS_PATH))
else:
util.make_sure_path_exists(config.ASSIGNMENTS_PATH)
util.make_sure_path_exists(config.ARCHIVE_PATH)
print 'Postaviti sledeci sadrzaj u poddirektorijume:'
print '\n1) Arhivu sa svim uradjenim zadacima u direktorijum "{0}"'.format(
config.ARCHIVE_PATH)
print 'Naziv arhive treba da bude u formatu: "{0}"'.format(
config.ASSIGNMENTS_ARCHIVE_PATTERN)
wait_until_files_are_set(config.ARCHIVE_PATH)
unpack_assignments(config, stations, grupe)
os.rename(config.ARCHIVE_PATH, config.BACKUP_PATH)
print ''
# Kopiranje postavke zadatka u odgovarajući direktorijum:
if grupe:
group1_initial_path = join(config.GROUP1_DIR,
config.INITIAL_PROJECT_PATH)
util.make_sure_path_exists(group1_initial_path)
group2_initial_path = join(config.GROUP2_DIR,
config.INITIAL_PROJECT_PATH)
util.make_sure_path_exists(group2_initial_path)
print '2A) Postavku zadatka grupe A koja je data studentima u direktorijum "{0}"'.format(
group1_initial_path)
wait_until_files_are_set(group1_initial_path)
print '2B) Postavku zadatka grupe B koja je data studentima u direktorijum "{0}"'.format(
group2_initial_path)
wait_until_files_are_set(group2_initial_path)
else:
util.make_sure_path_exists(config.INITIAL_PROJECT_PATH)
print '2) Postavku zadatka koja je data studentima u direktorijum "{0}"'.format(
config.INITIAL_PROJECT_PATH)
wait_until_files_are_set(config.INITIAL_PROJECT_PATH)
print ''
# Kopiranje autotest varijante zadatka u odgovarajući direktorijum:
if autotest:
if grupe:
group1_autotest_path = join(config.GROUP1_DIR,
config.AUTOTEST_PATH)
util.make_sure_path_exists(group1_autotest_path)
group2_autotest_path = join(config.GROUP2_DIR,
config.AUTOTEST_PATH)
util.make_sure_path_exists(group2_autotest_path)
print '\n3A) Autotest varijantu zadatka grupe A u direktorijum "{0}"'.format(
group1_autotest_path)
wait_until_files_are_set(group1_autotest_path)
print '\n3B) Autotest varijantu zadatka grupe B u direktorijum "{0}"'.format(
group2_autotest_path)
wait_until_files_are_set(group2_autotest_path)
else:
util.make_sure_path_exists(config.AUTOTEST_PATH)
print '\n3) Autotest varijantu zadatka u direktorijum "{0}"'.format(
config.AUTOTEST_PATH)
wait_until_files_are_set(config.AUTOTEST_PATH)
print ''
# Kreiranje dodatnih poddirektorijuma koji se koriste u pregledu:
if grupe:
util.make_sure_path_exists(
join(config.GROUP1_DIR, config.ALTERED_ASSIGNMENTS_PATH))
util.make_sure_path_exists(
join(config.GROUP1_DIR, config.CURRENT_ASSIGNMENT_PATH))
util.make_sure_path_exists(
join(config.GROUP1_DIR, config.CURRENT_ALT_ASSIGNMENT_PATH))
util.make_sure_path_exists(join(config.GROUP1_DIR,
config.REPORTS_PATH))
util.make_sure_path_exists(
join(config.GROUP2_DIR, config.ALTERED_ASSIGNMENTS_PATH))
util.make_sure_path_exists(
join(config.GROUP2_DIR, config.CURRENT_ASSIGNMENT_PATH))
util.make_sure_path_exists(
join(config.GROUP2_DIR, config.CURRENT_ALT_ASSIGNMENT_PATH))
util.make_sure_path_exists(join(config.GROUP2_DIR,
config.REPORTS_PATH))
else:
util.make_sure_path_exists(config.ALTERED_ASSIGNMENTS_PATH)
util.make_sure_path_exists(config.CURRENT_ASSIGNMENT_PATH)
util.make_sure_path_exists(config.CURRENT_ALT_ASSIGNMENT_PATH)
util.make_sure_path_exists(config.REPORTS_PATH)
# Definisanje kriterijuma za ocenjivanje zadatka.
# Mora se izvršavati posle postavljanja inicijalne verzije zadatka, jer koristi putanje koje ona definiše.
if autotest:
if grupe:
group1_criteria_path = join(config.GROUP1_DIR,
config.RATING_CRITERIA_FILENAME)
group2_criteria_path = join(config.GROUP2_DIR,
config.RATING_CRITERIA_FILENAME)
raw_input(
'''U tekst editoru bice otvoren fajl "{0}" u kojem se definise kriterijum za zadatak grupe A.
Pritisnite <ENTER> za nastavak.'''.format(group1_criteria_path))
generate_empty_criteria_file(backend, group1_criteria_path,
group1_initial_path,
group1_autotest_path)
util.show_text_edit(config, group1_criteria_path)
raw_input(
'Pritisnite <ENTER> kada ste zavrsili sa izmenama u fajlu...')
raw_input(
'''U tekst editoru bice otvoren fajl "{0}" u kojem se definise kriterijum za zadatak grupe A.
Pritisnite <ENTER> za nastavak.'''.format(group2_criteria_path))
generate_empty_criteria_file(backend, group2_criteria_path,
group2_initial_path,
group2_autotest_path)
util.show_text_edit(config, group2_criteria_path)
raw_input(
'Pritisnite <ENTER> kada ste zavrsili sa izmenama u fajlu...')
else:
raw_input(
'''U tekst editoru bice otvoren fajl "{0}" u kojem se definise kriterijum (nacin bodovanja).
Pritisnite <ENTER> za nastavak.'''.format(config.RATING_CRITERIA_FILENAME))
generate_empty_criteria_file(backend,
config.RATING_CRITERIA_FILENAME,
config.INITIAL_PROJECT_PATH,
config.AUTOTEST_PATH)
util.show_text_edit(config, config.RATING_CRITERIA_FILENAME)
raw_input(
'Pritisnite <ENTER> kada ste zavrsili sa izmenama u fajlu...')
print ''
print 'Svi materijali su postavljeni na odgovarajuce pozicije, mozete poceti sa pregledom zadataka.'
sys.exit(0)
def ddqn_rank_train(env, exploreScheduler, betaScheduler,
optimizer_constructor, model_type, batch_size, rp_start,
rp_size, exp_frame, exp_initial, exp_final, prob_alpha,
gamma, target_update_steps, frames_per_epoch,
frames_per_state, output_directory, last_checkpoint,
max_frames, envo):
"""
Implementation of the training algorithm for DDQN using Rank-based prioritization.
Information with regards to the algorithm can be found in the paper,
"Prioritized Experience Replay" by Tom Schaul, John Quan, Ioannis Antonoglou and
David Silver. Refer to section 3.3 in the paper for more info.
"""
gym.undo_logger_setup()
logging.basicConfig(filename=envo + '_' +
'ddqn_rank_weighted_training.log',
level=logging.INFO)
num_actions = env.action_space.n
env.reset()
print('No. of actions: ', num_actions)
print(env.unwrapped.get_action_meanings())
# initialize action value and target network with the same weights
model = DQN(num_actions)
target = DQN(num_actions)
if use_cuda:
model.cuda()
target.cuda()
frames_count = 1
if last_checkpoint:
model.load_state_dict(torch.load(last_checkpoint))
print(last_checkpoint)
print('weights loaded...')
#TODO: Implementation of resume
# exp_replay = util.initialize_rank_replay_resume(env, rp_start, rp_size, frames_per_state,
# model, target, gamma, batch_size)
# frames_count = get_index_from_checkpoint_path(last_checkpoint)
else:
exp_replay = util.initialize_rank_replay(env, rp_start, rp_size,
frames_per_state, model,
target, gamma, prob_alpha)
target.load_state_dict(model.state_dict())
optimizer = optimizer_constructor.type(
model.parameters(),
lr=optimizer_constructor.kwargs['lr'],
alpha=optimizer_constructor.kwargs['alpha'],
eps=optimizer_constructor.kwargs['eps'])
episodes_count = 1
epsiodes_durations = []
rewards_per_episode = 0
rewards_duration = []
loss_per_epoch = []
current_state, _, _, _ = util.play_game(env, frames_per_state)
wLoss_func = Weighted_Loss()
print('Starting training...')
for frames_count in range(1, max_frames):
epsilon = exploreScheduler.anneal_linear(frames_count)
beta = betaScheduler.anneal_linear(frames_count)
choice = random.uniform(0, 1)
# epsilon greedy algorithm
if choice <= epsilon:
action = LongTensor([[random.randrange(num_actions)]])
else:
action = util.get_greedy_action(model, current_state)
curr_obs, reward, done, _ = util.play_game(env, frames_per_state,
action[0][0])
rewards_per_episode += reward
reward = Tensor([[reward]])
td_error = 1
temp_exp = Experience(current_state, action, reward, curr_obs,
td_error)
current_state = curr_obs
# compute y
if len(exp_replay) >= batch_size:
# Get batch samples
# start = time.time()
if frames_count % rp_size == 0:
obs_samples, obs_priorityVals = exp_replay.sample(batch_size -
1,
prob_alpha,
sort=True)
else:
obs_samples, obs_priorityVals = exp_replay.sample(batch_size -
1,
prob_alpha,
sort=False)
obs_samples.append(temp_exp)
obs_priorityVals.append(td_error)
obs_pVals_tensor = torch.from_numpy(np.array(obs_priorityVals))
# print("P(i): ", obs_pVals_tensor)
IS_weights = torch.pow((obs_pVals_tensor * rp_size), -beta)
max_weight = torch.max(IS_weights)
IS_weights_norm = torch.div(IS_weights, max_weight).type(Tensor)
IS_weights_norm[-1] = torch.max(IS_weights_norm)
# print("Norm W(i): ", IS_weights_norm)
batch = Experience(*zip(*obs_samples))
loss, new_weights = ddqn_compute_y(batch, batch_size, model,
target, gamma, IS_weights_norm,
wLoss_func)
new_weights = torch.pow(new_weights, prob_alpha)
new_exp = Experience(temp_exp.state, temp_exp.action,
temp_exp.reward, temp_exp.next_state,
new_weights[batch_size - 1])
exp_replay.update(obs_samples, new_weights, new_exp)
optimizer.zero_grad()
loss.backward()
# print("loss: ", loss.data)
optimizer.step()
loss_per_epoch.append(loss.data.cpu().numpy()[0])
else:
exp_replay.push(new_exp.state, new_exp.action, new_exp.reward,
new_exp.next_state, td_error)
# end = time.time()
# duration = end-start
# print('duration : ', duration)
if done:
# print('Game: ', rewards_per_episode)
rewards_duration.append(rewards_per_episode)
rewards_per_episode = 0
episodes_count += 1
env.reset()
current_state, _, _, _ = util.play_game(env, frames_per_state)
if episodes_count % 100 == 0:
avg_episode_reward = sum(rewards_duration) / 100.0
avg_reward_content = 'Episode from', episodes_count - 99, ' to ', episodes_count, ' has an average of ', avg_episode_reward, ' reward and loss of ', sum(
loss_per_epoch)
print(avg_reward_content)
logging.info(avg_reward_content)
rewards_duration = []
loss_per_epoch = []
# update weights of target network for every TARGET_UPDATE_FREQ steps
if frames_count % target_update_steps == 0:
target.load_state_dict(model.state_dict())
#Save weights every 250k frames
if frames_count % 250000 == 0:
util.make_sure_path_exists(output_directory + '/' + envo + '/')
torch.save(
model.state_dict(), output_directory + '/' + envo +
'/rank_uniform' + str(frames_count) + '.pth')
#Print frame count and sort experience replay for every 1000000 (one million) frames:
if frames_count % 1000000 == 0:
training_update = 'frame count: ', frames_count, 'episode count: ', episodes_count, 'epsilon: ', epsilon
print(training_update)
logging.info(training_update)
def dqn_train(env, scheduler, optimizer_constructor, model_type, batch_size,
rp_start, rp_size, exp_frame, exp_initial, exp_final, gamma,
target_update_steps, frames_per_epoch, frames_per_state,
output_directory, last_checkpoint, envo):
gym.undo_logger_setup()
logging.basicConfig(filename=envo + '_' + model_type + '_training.log',
level=logging.INFO)
num_actions = env.action_space.n
print('No. of actions: ', num_actions)
print(env.unwrapped.get_action_meanings())
# initialize action value and target network with the same weights
model = DQN(num_actions, use_bn=False)
target = DQN(num_actions, use_bn=False)
if use_cuda:
model.cuda()
target.cuda()
exp_replay = None
episodes_count = 1
if last_checkpoint != '':
model.load_state_dict(torch.load(last_checkpoint))
exp_replay = util.initialize_replay_resume(env, rp_start, rp_size,
frames_per_state, model)
episodes_count = get_index_from_checkpoint_path(last_checkpoint)
else:
exp_replay = util.initialize_replay(env, rp_start, rp_size,
frames_per_state)
target.load_state_dict(model.state_dict())
print('weights loaded...')
optimizer = optimizer_constructor.type(
model.parameters(),
lr=optimizer_constructor.kwargs['lr'],
alpha=optimizer_constructor.kwargs['alpha'],
eps=optimizer_constructor.kwargs['eps'])
frames_count = 1
frames_per_episode = 1
epsiodes_durations = []
rewards_per_episode = 0
rewards_duration = []
loss_per_epoch = []
env.reset()
current_state, _, _, _ = util.play_game(env, frames_per_state)
print('Starting training...')
count = 0
while True:
epsilon = scheduler.anneal_linear(frames_count)
choice = random.uniform(0, 1)
# epsilon greedy algorithm
if choice <= epsilon:
action = LongTensor([[random.randrange(num_actions)]])
else:
action = util.get_greedy_action(model, current_state)
curr_obs, reward, done, _ = util.play_game(env, frames_per_state,
action[0][0])
rewards_per_episode += reward
reward = Tensor([reward])
exp_replay.push(current_state, action, reward, curr_obs)
current_state = curr_obs
#sample random mini-batch
obs_sample = exp_replay.sample(batch_size)
batch = Experience(
*zip(*obs_sample)
) #unpack the batch into states, actions, rewards and next_states
#compute y
if len(exp_replay) >= batch_size:
loss = dqn_compute_y(batch, batch_size, model, target, gamma)
optimizer.zero_grad()
loss.backward()
for param in model.parameters():
param.grad.data.clamp_(-1, 1)
optimizer.step()
loss_per_epoch.append(loss.data.cpu().numpy()[0])
frames_count += 1
frames_per_episode += frames_per_state
if done:
rewards_duration.append(rewards_per_episode)
rewards_per_episode = 0
frames_per_episode = 1
episodes_count += 1
env.reset()
current_state, _, _, _ = util.play_game(env, frames_per_state)
if episodes_count % 100 == 0:
avg_episode_reward = sum(rewards_duration) / 100.0
avg_reward_content = 'Episode from', episodes_count - 99, ' to ', episodes_count, ' has an average of ', avg_episode_reward, ' reward and loss of ', sum(
loss_per_epoch)
print(avg_reward_content)
logging.info(avg_reward_content)
rewards_duration = []
loss_per_epoch = []
# update weights of target network for every TARGET_UPDATE_FREQ steps
if frames_count % target_update_steps == 0:
target.load_state_dict(model.state_dict())
# print('weights updated at frame no. ', frames_count)
#Save weights every 250k frames
if frames_count % 250000 == 0:
util.make_sure_path_exists(output_directory + envo + '/' +
model_type + '/')
torch.save(
model.state_dict(), output_directory + envo + '/' +
model_type + '/weights_' + str(frames_count) + '.pth')
#Print frame count for every 1000000 (one million) frames:
if frames_count % 1000000 == 0:
training_update = 'frame count: ', frames_count, 'episode count: ', episodes_count, 'epsilon: ', epsilon
print(training_update)
logging.info(training_update)
print("[***] {0} TEST: One vs.".format(dataset),
"Rest" if one_vs_rest else "Other")
data_all = run_test(
dataset=dataset,
clf_type=clf_type,
epochs=epochs,
true_rh1=true_rh1,
downsample_ratio=downsample_ratio,
ordered_models_keys=[model],
list_of_images=[image],
suppress_error=suppress_error,
verbose=verbose,
pi1=pi1,
one_vs_rest=one_vs_rest,
cv_n_folds=cv_n_folds,
early_stopping=early_stopping,
pulearning=pulearning,
)
print("Completed: model", model, "and image", image)
# Before we store results, create folder if needed.
make_sure_path_exists("data/")
pickle.dump(
data_all,
open(
"data/metrics_{0}_{1}_{2}_epochs_rh1_{3}_downsample_{4}_model_{5}_image_{6}_pi1_{7}.p"
.format(dataset, clf_type, epochs, true_rh1,
downsample_ratio, model, image, pi1), "wb"))
def unpack_assignments(config, stations, two_groups):
"""
Raspakuje arhivu sa svim studentskim radovima iz direktorijuma config.ARCHIVE_PATH
config - globalna konfiguracija alata za pregled
stations - kolekcija računara i studenata koji su radili zadatak (ključ - oznaka računara, podatak - lista - broj
indeksa i ime/prezime studenta)
two_groups - boolean koji indikuje da li je zadatak rađen u dve grupe (A i B)
"""
util.make_sure_path_exists(config.TEMP_PATH)
# Ukoliko se u prihvatnom direktorijumu nalazi arhiva, ona će biti raspakovana u direktorijum sa studentskim
# zadacima i potom premeštena u backup direktorijum:
archives = glob.glob(
join(config.ARCHIVE_PATH, config.ASSIGNMENTS_ARCHIVE_PATTERN))
found = 0
for a in archives:
found = found + 1
print 'Pronadjena je nova arhiva sa zadacima koja ce biti obradjena'
print 'Raspakivanje arhive "{0}" u direktorijum "{1}"...'.format(
a, config.TEMP_PATH)
command = config.EXTRACT_ASSIGNMENTS_CMD.format(a, config.TEMP_PATH)
ret = call(command, shell=True)
if ret != 0:
util.fatal_error(
'Raspakivanje arhive sa zadacima je neuspesno!\nKomanda koja je pokrenuta:\n{0}'
.format(command))
if found == 0:
util.fatal_error('''Nije pronadjena arhiva sa zadacima!
Molim proverite da li arhiva koju ste prilozili ima adekvatan naziv i adekvatnu ekstenziju!
Ocekuje se naziv poput sledeceg: {0}'''.format(
config.ASSIGNMENTS_ARCHIVE_PATTERN))
# Učitavanje liste studenata iz raspakovanog sadrzaja arhive:
matches = glob.glob(join(config.TEMP_PATH, config.STUDENTS_LIST_PATTERN))
if len(matches) == 0:
util.fatal_error(
'Nije pronadjena lista studenata (pattern za trazenje: "{0}")'.
format(config.STUDENTS_LIST_PATTERN))
if len(matches) > 1:
util.fatal_error(
'Pronadjen je vise od jednog fajla koji je kandidat za listu studenata. Kandidati: {0}'
.format(matches))
# Ako zadatak ima samo jednu grupu (nema grupe A i B), onda se lista studenata samo kopira na destinaciju
# (neće biti njene podele na dve podgrupe):
if not two_groups:
copyfile(matches[0], join(config.ASSIGNMENTS_PATH,
basename(matches[0])))
logging.debug(
'Ucitavanje spiska studenata prilikom raspakivanja arhive...')
ifile = open(matches[0], "rb")
reader = csv.DictReader(ifile,
dialect='excel',
fieldnames=['station', 'id', 'name'])
for row in reader:
station = row['station'].strip()
id = row['id'].strip()
name = row['name'].strip()
if id:
logging.debug(
'Ucitano: Stanica: {0}, Broj indeksa: {1}, Ime: {2}'.format(
station, id, name))
stations[station] = [id, name]
ifile.close()
logging.debug('Ucitavanje spiska studenata zavrseno')
if two_groups:
group1_list = open(
join(config.GROUP1_DIR, config.ASSIGNMENTS_PATH,
"spisak_stud_koji_trenutno_rade_proveru.txt"), "a+")
group2_list = open(
join(config.GROUP2_DIR, config.ASSIGNMENTS_PATH,
"spisak_stud_koji_trenutno_rade_proveru.txt"), "a+")
# Arhive koje su pronađene u direktorijumu sa studentskim zadacima biće raspakovane i potom obrisane:
archives = sorted(
glob.glob(
join(config.TEMP_PATH, config.SINGLE_ASSIGNMENT_ARCHIVE_PATTERN)))
for a in archives:
logging.debug(
'Pronadjena je sledeca arhiva sa pojedinacnim zadatkom: {0}'.
format(a))
# Manipulacija nazivom arhive, kako bi se došlo do oznake stanice na kojoj je student radio:
name = os.path.basename(a)[:-len(config.SINGLE_ASSIGNMENT_ARCHIVE_EXT)]
tokens = name.split('_')
station = tokens[len(tokens) - 1]
# Proces kopiranja zadataka vođen je spiskom studenata koji su radili proveru.
# Ako stanica nije na tom spisku, znači da je u pitanju blanko direktorijum i on se preskače.
if station in stations:
if two_groups:
station_num = int(station[1:])
if station_num % 2 == 0:
station_directory = join(config.GROUP1_DIR,
config.ASSIGNMENTS_PATH, station)
if not station in stations:
util.fatal_error(
'Racunar sa oznakom "{0}" nije pronadjen u spisku studenata koji rade proveru!'
.format(station))
group1_list.write('{0}, {1}, {2}\n'.format(
station, stations[station][0], stations[station][1]))
else:
station_directory = join(config.GROUP2_DIR,
config.ASSIGNMENTS_PATH, station)
if not station in stations:
util.fatal_error(
'Racunar sa oznakom "{0}" nije pronadjen u spisku studenata koji rade proveru!'
.format(station))
group2_list.write('{0}, {1}, {2}\n'.format(
station, stations[station][0], stations[station][1]))
else:
station_directory = join(config.ASSIGNMENTS_PATH, station)
logging.debug(
'Raspakivanje zadatka "{0}" u direktorijum "{1}"'.format(
a, station_directory))
util.make_sure_path_exists(station_directory)
command = config.EXTRACT_SINGLE_ASSIGNMENT_CMD.format(
a, station_directory)
ret = call(command, shell=True)
if ret != 0:
util.fatal_error(
'Raspakivanje pojedinacnog zadatka je neuspesno!\nKomanda koja je pokrenuta:\n{0}'
.format(command))
os.remove(a)
util.clear_directory(config.TEMP_PATH)
def run_test(
dataset,
clf_type,
epochs,
true_rh1,
downsample_ratio,
ordered_models_keys,
list_of_images=range(10),
suppress_error=False,
verbose=False,
pi1=0.0,
one_vs_rest=True,
cv_n_folds=3,
early_stopping=True,
pulearning=None,
):
# Cast types to ensure consistency for 1 and 1.0, 0 and 0.0
true_rh1 = float(true_rh1)
downsample_ratio = float(downsample_ratio)
pi1 = float(pi1)
# Load MNIST or CIFAR data
(X_train_original,
y_train_original), (X_test_original,
y_test_original) = get_dataset(dataset=dataset)
X_train_original, y_train_original = downsample(X_train_original,
y_train_original,
downsample_ratio)
# Initialize models and result storage
metrics = {key: [] for key in ordered_models_keys}
data_all = {"metrics": metrics, "calculated": {}, "errors": {}}
start_time = dt.now()
# Run through the ten images class of 0, 1, ..., 9
for image in list_of_images:
if one_vs_rest:
# X_train and X_test will not be modified. All data will be used. Adjust pointers.
X_train = X_train_original
X_test = X_test_original
# Relabel the image data. Make label 1 only for given image.
y_train = np.array(y_train_original == image, dtype=int)
y_test = np.array(y_test_original == image, dtype=int)
else: # one_vs_other
# Reducing the dataset to just contain our image and image = 4
other_image = 4 if image != 4 else 7
X_train = X_train_original[(y_train_original == image) |
(y_train_original == other_image)]
y_train = y_train_original[(y_train_original == image) |
(y_train_original == other_image)]
X_test = X_test_original[(y_test_original == image) |
(y_test_original == other_image)]
y_test = y_test_original[(y_test_original == image) |
(y_test_original == other_image)]
# Relabel the data. Make label 1 only for given image.
y_train = np.array(y_train == image, dtype=int)
y_test = np.array(y_test == image, dtype=int)
print()
print("Evaluating image:", image)
print("Number of positives in y:", sum(y_train))
print()
sys.stdout.flush()
s = y_train * (np.cumsum(y_train) < (1 - true_rh1) * sum(y_train))
# In the presence of mislabeled negative (negative incorrectly labeled positive):
# pi1 is the fraction of mislabeled negative in the labeled set:
num_mislabeled = int(sum(y_train) * (1 - true_rh1) * pi1 / (1 - pi1))
if num_mislabeled > 0:
negative_set = s[y_train == 0]
mislabeled = np.random.choice(len(negative_set),
num_mislabeled,
replace=False)
negative_set[mislabeled] = 1
s[y_train == 0] = negative_set
print("image = {0}".format(image))
print(
"Training set: total = {0}, positives = {1}, negatives = {2}, P_noisy = {3}, N_noisy = {4}"
.format(len(X_train), sum(y_train),
len(y_train) - sum(y_train), sum(s),
len(s) - sum(s)))
print("Testing set: total = {0}, positives = {1}, negatives = {2}".
format(len(X_test), sum(y_test),
len(y_test) - sum(y_test)))
# Fit different models for PU learning
for key in ordered_models_keys:
fit_start_time = dt.now()
print("\n\nFitting {0} classifier. Default classifier is {1}.".
format(key, clf_type))
if clf_type == "logreg":
clf = LogisticRegression()
elif clf_type == "cnn":
from classifier_cnn import CNN
from keras import backend as K
K.clear_session()
clf = CNN(
dataset_name=dataset,
num_category=2,
epochs=epochs,
early_stopping=early_stopping,
verbose=1,
)
else:
raise ValueError(
"clf_type must be either logreg or cnn for this testing file."
)
ps1 = sum(s) / float(len(s))
py1 = sum(y_train) / float(len(y_train))
true_rh0 = pi1 * ps1 / float(1 - py1)
model = get_model(
key=key,
rh1=true_rh1,
rh0=true_rh0,
clf=clf,
)
try:
if key == "True Classifier":
model.fit(X_train, y_train)
elif key in [
"Rank Pruning", "Rank Pruning (noise rates given)",
"Liu16 (noise rates given)"
]:
model.fit(X_train,
s,
pulearning=pulearning,
cv_n_folds=cv_n_folds)
elif key in ["Nat13 (noise rates given)"]:
model.fit(X_train, s, pulearning=pulearning)
else: # Elk08, Baseline
model.fit(X_train, s)
pred = model.predict(X_test)
# Produces only P(y=1|x) for pulearning models because they are binary
pred_prob = model.predict_proba(X_test)
pred_prob = pred_prob[:,
1] if key == "True Classifier" else pred_prob
# Compute metrics
metrics_dict = get_metrics(pred, pred_prob, y_test)
elapsed = (dt.now() - fit_start_time).total_seconds()
if verbose:
print(
"\n{0} Model Performance at image {1}:\n=================\n"
.format(key, image))
print("Time Required", elapsed)
print("AUC:", metrics_dict["AUC"])
print("Error:", metrics_dict["Error"])
print("Precision:", metrics_dict["Precision"])
print("Recall:", metrics_dict["Recall"])
print("F1 score:", metrics_dict["F1 score"])
print("rh1:", model.rh1 if hasattr(model, 'rh1') else None)
print("rh0:", model.rh0 if hasattr(model, 'rh0') else None)
print()
metrics_dict["image"] = image
metrics_dict["time_seconds"] = elapsed
metrics_dict["rh1"] = model.rh1 if hasattr(model,
'rh1') else None
metrics_dict["rh0"] = model.rh0 if hasattr(model,
'rh0') else None
# Append dictionary of error and loss metrics
if key not in data_all["metrics"]:
data_all["metrics"][key] = [metrics_dict]
else:
data_all["metrics"][key].append(metrics_dict)
data_all["calculated"][(key, image)] = True
except Exception as e:
msg = "Error in {0}, image {1}, rh1 {2}, m {3}: {4}\n".format(
key, image, true_rh1, pi1, e)
print(msg)
make_sure_path_exists("failed_models/")
with open("failed_models/" + key + ".txt", "ab") as f:
f.write(msg)
if suppress_error:
continue
else:
raise
return data_all
def ddqn_rankBatch_train(env, scheduler, optimizer_constructor, model_type,
batch_size, rp_start, rp_size, exp_frame, exp_initial,
exp_final, inital_beta, gamma, target_update_steps,
frames_per_epoch, frames_per_state, output_directory,
last_checkpoint):
"""
Implementation of the training algorithm for DDQN using Rank-based prioritization.
Information with regards to the algorithm can be found in the paper,
"Prioritized Experience Replay" by Tom Schaul, John Quan, Ioannis Antonoglou and
David Silver. Refer to section 3.3 in the paper for more info.
"""
gym.undo_logger_setup()
logging.basicConfig(filename='ddqn_rank_training.log', level=logging.INFO)
num_actions = env.action_space.n
env.reset()
print('No. of actions: ', num_actions)
print(env.unwrapped.get_action_meanings())
# initialize action value and target network with the same weights
model = DQN(num_actions, use_bn=False)
target = DQN(num_actions, use_bn=False)
if use_cuda:
model.cuda()
target.cuda()
frames_count = 1
if last_checkpoint:
model.load_state_dict(torch.load(last_checkpoint))
print(last_checkpoint)
print('weights loaded...')
exp_replay = util.initialize_rank_replay_resume(
env, rp_start, rp_size, frames_per_state, model, target, gamma,
batch_size)
frames_count = get_index_from_checkpoint_path(last_checkpoint)
else:
exp_replay = util.initialize_rank_replay(env, rp_start, rp_size,
frames_per_state, model,
target, gamma)
target.load_state_dict(model.state_dict())
optimizer = optimizer_constructor.type(
model.parameters(),
lr=optimizer_constructor.kwargs['lr'],
alpha=optimizer_constructor.kwargs['alpha'],
eps=optimizer_constructor.kwargs['eps'])
episodes_count = 1
frames_per_episode = 1
epsiodes_durations = []
rewards_per_episode = 0
rewards_duration = []
loss_per_epoch = []
current_state, _, _, _ = util.play_game(env, frames_per_state)
print('Starting training...')
count = 0
while True:
epsilon = scheduler.anneal_linear(frames_count)
choice = random.uniform(0, 1)
# epsilon greedy algorithm
if choice <= epsilon:
action = LongTensor([[random.randrange(num_actions)]])
else:
action = util.get_greedy_action(model, current_state)
curr_obs, reward, done, _ = util.play_game(env, frames_per_state,
action[0][0])
rewards_per_episode += reward
reward = Tensor([[reward]])
current_state_ex = Variable(current_state, volatile=True)
curr_obs_ex = Variable(curr_obs, volatile=True)
action_ex = Variable(action, volatile=True)
reward_ex = Variable(reward, volatile=True)
#compute td-error for one sample
td_error = ddqn_compute_td_error(batch_size=1,
state_batch=current_state_ex,
reward_batch=reward_ex,
action_batch=action_ex,
next_state_batch=curr_obs_ex,
model=model,
target=target,
gamma=gamma)
td_error = torch.abs(td_error)
exp_replay.push(current_state_ex, action_ex, reward_ex, curr_obs_ex,
td_error)
current_state = curr_obs
# compute y
if len(exp_replay) >= batch_size:
# Get batch samples
obs_samples, obs_ranks, obs_priorityVals = exp_replay.sample(
batch_size)
obs_priorityTensor = torch.from_numpy(np.array(obs_priorityVals))
p_batch = 1 / obs_priorityTensor
w_batch = (1 / len(exp_replay) * p_batch)**inital_beta
max_weight = exp_replay.get_max_weight(inital_beta)
params_grad = []
for i in range(len(obs_samples)):
sample = obs_samples[i]
sample.state.volatile = False
sample.next_state.volatile = False
sample.reward.volatile = False
sample.action.volatile = False
loss = ddqn_compute_y(batch_size=1,
state_batch=sample.state,
reward_batch=sample.reward,
action_batch=sample.action,
next_state_batch=sample.next_state,
model=model,
target=target,
gamma=gamma)
loss_abs = torch.abs(loss)
exp_replay.update(obs_ranks[i], loss_abs)
for param in model.parameters():
if param.grad is not None:
param.grad.data.zero_()
loss.backward()
#accumulate weight change
if i == 0:
for param in model.parameters():
tmp = ((w_batch[i] / max_weight) *
loss.data[0]) * param.grad.data
params_grad.append(tmp)
else:
paramIndex = 0
for param in model.parameters():
tmp = ((w_batch[i] / max_weight) *
loss.data[0]) * param.grad.data
params_grad[paramIndex] = tmp + params_grad[paramIndex]
paramIndex += 1
# update weights
paramIndex = 0
for param in model.parameters():
param.data += params_grad[paramIndex].mul(
optimizer_constructor.kwargs['lr']).type(Tensor)
paramIndex += 1
frames_count += 1
frames_per_episode += frames_per_state
if done:
rewards_duration.append(rewards_per_episode)
rewards_per_episode = 0
frames_per_episode = 1
episodes_count += 1
env.reset()
current_state, _, _, _ = util.play_game(env, frames_per_state)
if episodes_count % 100 == 0:
avg_episode_reward = sum(rewards_duration) / 100.0
avg_reward_content = 'Episode from', episodes_count - 99, ' to ', episodes_count, ' has an average of ', avg_episode_reward, ' reward and loss of ', sum(
loss_per_epoch)
print(avg_reward_content)
logging.info(avg_reward_content)
rewards_duration = []
loss_per_epoch = []
# update weights of target network for every TARGET_UPDATE_FREQ steps
if frames_count % target_update_steps == 0:
target.load_state_dict(model.state_dict())
# print('weights updated at frame no. ', frames_count)
#Save weights every 250k frames
if frames_count % 250000 == 0:
util.make_sure_path_exists(output_directory + model_type + '/')
torch.save(model.state_dict(),
'rank_weights_' + str(frames_count) + '.pth')
#Print frame count and sort experience replay for every 1000000 (one million) frames:
if frames_count % 1000000 == 0:
training_update = 'frame count: ', frames_count, 'episode count: ', episodes_count, 'epsilon: ', epsilon
print(training_update)
logging.info(training_update)
exp_replay.sort()
