def main():
save_key = os.path.basename(__file__).split('.')[0]
### DEFINE MODEL ###
input_shape = (None, None, 6)
inputs = Input(shape=input_shape)
y1 = Conv2D(128, (5, 5), padding='same', activation='relu',
name='bendy1')(inputs)
y2 = Conv2D(64, (5, 5), padding='same', activation='relu',
name='bendy2')(y1)
y3 = Conv2D(64, (3, 3), padding='same', activation='relu',
name='smoothy1')(y2)
y4 = Conv2D(64, (3, 3), padding='same', activation='relu',
name='smoothy2')(y3)
y5 = Conv2D(8, (70, 3), padding='same', activation='relu', name='harm')(y4)
y6 = Conv2D(8, (360, 1),
padding='same',
activation='relu',
name='distribute')(y5)
y7 = Conv2D(1, (1, 1),
padding='same',
activation='sigmoid',
name='squishy')(y6)
predictions = Lambda(lambda x: K.squeeze(x, axis=3))(y7)
model = Model(inputs=inputs, outputs=predictions)
experiment.experiment(save_key, model)
def test_prob_experiment(self):
hat = Hat(blue=3, red=2, green=6)
probability = experiment(hat=hat,
expected_balls={
"blue": 2,
"green": 1
},
num_balls_drawn=4,
num_experiments=1000)
actual = probability
expected = 0.272
self.assertAlmostEqual(
actual,
expected,
delta=0.01,
msg='Expected experiemnt method to return a different probability.'
)
hat = Hat(yellow=5, red=1, green=3, blue=9, test=1)
probability = experiment(hat=hat,
expected_balls={
"yellow": 2,
"blue": 3,
"test": 1
},
num_balls_drawn=20,
num_experiments=100)
actual = probability
expected = 1.0
self.assertAlmostEqual(
actual,
expected,
delta=0.01,
msg='Expected experiment method to return a different probability.'
)
def test_experiment_mnist_custom(experiment_files_fixture):
"""
Test of a MIA on the MNIST dataset with custom model for the MNIST
model, custom mode for the MIA model and custom optimizer options
"""
experiment(academic_dataset = 'mnist',
target_model_path = target_path.as_posix(),
mia_model_path = mia_path.as_posix(),
custom_target_model = OrderedDict([
('conv1' , nn.Conv2d(1, 10, 3, 1)),
('relu1' , nn.ReLU()),
('maxpool1' , nn.MaxPool2d(2, 2)),
('conv2' , nn.Conv2d(10, 10, 3, 1)),
('relu2' , nn.ReLU()),
('maxpool2' , nn.MaxPool2d(2, 2)),
('to1d' , Flatten()),
('dense1' , nn.Linear(5*5*10, 500)),
('tanh' , nn.Tanh()),
('dense2' , nn.Linear(500, 10)),
('logsoftmax' , nn.LogSoftmax(dim=1))
]),
custom_target_optim_args = {'lr' : 0.02, 'momentum' : 0.3},
custom_mia_model = OrderedDict([
('dense1' , nn.Linear(20, 50)),
('tanh' , nn.Tanh()),
('dense2' , nn.Linear(50, 2)),
('logsoftmax' , nn.LogSoftmax(dim=1))
]),
custom_mia_optim_args = {'lr' : 0.02, 'momentum' : 0.3},
shadow_number = 50,
custom_shadow_model = OrderedDict([
('conv1' , nn.Conv2d(1, 15, 7, 1)),
('relu1' , nn.ReLU()),
('maxpool1' , nn.MaxPool2d(2, 2)),
('conv2' , nn.Conv2d(15, 25, 7, 1)),
('relu2' , nn.ReLU()),
('maxpool2' , nn.MaxPool2d(2, 2)),
('to1d' , Flatten()),
('dense1' , nn.Linear(2*2*25, 50)),
('tanh' , nn.Tanh()),
('dense2' , nn.Linear(50, 10)),
('logsoftmax' , nn.LogSoftmax(dim=1))
]),
custom_shadow_optim_args = {'lr' : 0.02, 'momentum' : 0.3},
shadow_model_base_path = shadow_base_path.as_posix(),
mia_train_ds_path = mia_train_ds_path.as_posix(),
mia_test_ds_path = mia_test_ds_path.as_posix(),
class_number = 10)
assert target_path.exists()
assert mia_path.exists()
remove_experiment_files()
def check_experiment(self, id):
"""Provide details of an experiment."""
exp = experiment.experiment(new_experiment=False, ts=id)
start_time = time.time()
condition = True
while exp.metadata is None and condition:
now = time.time()
if now - start_time > 3:
condition = False
return "Experiment is not found!"
exp = experiment.experiment(new_experiment=False, ts=id)
time.sleep(0.01)
cam_statement = str()
for i in range(7):
fname = os.path.join("data/", str(id), "/", str(i) + "/")
if os.path.exists(fname):
n = len(self.um.find_images(fname))
else:
n = 0
cam_statement += "Camera {i}: {n} images found! ".format(i=i, n=n)
date = self.um.timestamp_to_date(id / 1000)
f = os.path.join(os.path.dirname(os.path.realpath(__file__)), "backup",
str(id) + ".zip")
is_archived = self.um.check_file_exists(f)
if is_archived:
img = "true.png"
else:
img = "false.png"
try:
label = exp.metadata["label"]
except:
label = None
pd_images = exp.metadata["pose_detection"].values()
user = {
"timestamp": id,
"date": date,
"camera": exp.metadata["number_of_cameras"],
"n_images": exp.metadata["number_of_images"],
"room": exp.metadata["room"],
"label": label,
"image": img,
"exp": exp.metadata,
"pose_detection_processed_images": pd_images
}
return render_template('experiment.html', user=user)
def test_experiment_mnist_basic():
"""
Test a default MIA experiment on the MNIST dataset
"""
experiment(academic_dataset = 'mnist',
target_model_path = target_path.as_posix(),
mia_model_path = mia_path.as_posix(),
shadow_model_base_path = shadow_base_path.as_posix(),
mia_train_ds_path = mia_train_ds_path.as_posix(),
mia_test_ds_path = mia_test_ds_path.as_posix(),
class_number = 10)
assert target_path.exists()
assert mia_path.exists()
remove_experiment_files()
def draw_matchsticks(self, exp_id, camera_id):
"""
"""
v = visualization.visualization()
exp = experiment.experiment(new_experiment=False, ts=exp_id)
room_name = exp.metadata["room"]
if room_name.lower() == "cears":
room_id = 1
elif room_name.lower() == "computer_lab":
room_id = 0
devices = self.rooms[room_id]["devices"]
devices.sort()
try:
cam_name = os.path.basename(devices[int(camera_id)])
except Exception as e:
print e
self.app.logger.info(e)
return "No cam found sorry!"
fcamera_path = os.path.join("/dev/v4l/by-id", cam_name)
nframes = exp.metadata["number_of_images"][fcamera_path]
ret_combined = ""
for frame_id in range(nframes):
ret = self.skeletons(exp_id, camera_id, frame_id)
ret_combined += "<br>" + ret
return ret_combined
def default_experiment(toa_strings=(), isotope="Re-187", timestep_size=1e+6):
"""
Run a single experiment with no fudge_factor
*toa_strings* - tuple of all relevant strings (folder, name)
*isotope* - str - name of isotope to be manipulated
*timestep_size* - float - size of timestep in experiment
"""
exp_folder = toa_strings[0] #name of experiment folder
exp_name = toa_strings[1]
fudge_factor = 1.0
data_filename = exp_folder + "/" + exp_name + "default.npy"
#instance of experiment-object
exp_instance = experiment(isotope, fudge_factor, dt=timestep_size, bestfit_namespace=current_bestfit)
#save data to appropriately named file
exp_instance.save2file(data_filename, write_index_file=True)
#write number of timepoints to README
readmestring = "Data from 'default-experiment' \n"
readmestring += "timestep-number: %d \n"%len(exp_instance.history.age)
readmefilename = exp_folder + "/README.md"
with open(readmefilename, 'a') as readmefile:
readmefile.write('\n')
readmefile.write(readmestring)
#delete object
del exp_instance #delete instance
def single_experiment(experiment_index, toa_strings=(),
isotope="Re-187", timestep_size=1e+6):
"""
Run a single experiment with bestfit values, and a fudge-factor stapled
to the isotope.
*experiment_index* - int - index of experiment in queue
*toa_strings* - tuple of all relevant strings (folder, name)
*isotope* - str - name of isotope to be manipulated
*timestep_size* - float - size of timestep in experiment
"""
exp_folder = toa_strings[0] #name of experiment folder
exp_name = toa_strings[1] #name of experiments
exp_fudge = "fudge_factors.dat"
#exp_fudge = toa_strings[2] #name of datafile in folder
#bestfit_special_timesteps = 0 #disable log-timesteps
#bestfit_dt = timestep_size
fudge_factor = read_fudge_factor(filename=exp_folder+'/'+exp_fudge,
req_index=experiment_index)
data_filename = exp_folder + "/" + exp_name + str(experiment_index) + ".npy"
#instance of experiment-object
exp_instance = experiment(isotope, fudge_factor, dt=timestep_size, bestfit_namespace=current_bestfit)
#save data to appropriately named file
exp_instance.save2file(data_filename)
del exp_instance #delete instance
def get_matchstick_video(self, exp_id, camera_id):
"""
"""
exp = experiment.experiment(new_experiment=False, ts=exp_id)
room_name = exp.metadata["room"]
if room_name.lower() == "cears":
room_id = 1
elif room_name.lower() == "computer_lab":
room_id = 0
devices = self.rooms[room_id]["devices"]
devices.sort()
try:
cam_name = os.path.basename(devices[int(camera_id)])
except Exception as e:
print e
self.app.logger.info(e)
return "No cam found sorry!"
fcamera_path = os.path.join("/dev/v4l/by-id", cam_name)
nframes = exp.metadata["number_of_images"][fcamera_path]
exp_path = self.um.experiment_path(str(exp_id))
pathout = os.path.join(exp_path, "output/pose/video")
pathout = os.path.join(pathout, cam_name)
try:
return send_from_directory(pathout,
filename="video.avi",
as_attachment=True,
mimetype='video/x-msvideo')
except Exception as e:
return str(e)
def reload(self):
pmax = len(self.exp)
self.bad = []
QtGui.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
logString = 'Reloading all the curves\n'
self.simpleLogger(logString)
progress = QtGui.QProgressDialog("Reloading curves...", "Cancel reloading", 0, pmax);
i=0
tempExp = deepcopy(self.exp)
self.exp = None
self.exp = experiment.experiment()
for c in tempExp:
aligned = c[0].direction == 'far'
self.alignFlags.append(aligned)
self.badFlags.append(True)
self.ctPoints [i] = None
i+=1
progress.setValue(i)
self.exp.addFiles([c.filename])
progress.setValue(pmax)
QtGui.QApplication.restoreOverrideCursor()
tempExp = None
self.fitFlag = False
self.setStatus(2)
if np.array(self.alignFlags).all():
self.setStatus(3)
self.refillList()
self.goToCurve(1)
self.ui.slide1.setValue(0)
self.ui.slide2.setValue(0)
logString = 'Curves reloaded\n'
self.simpleLogger(logString)
def worker_task(i):
global logger
if logger is None:
logging.basicConfig(format="%(asctime)s [%(process)-4.4s--%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s")
fileHandler = logging.FileHandler('WS_log.log.{}'.format(os.getpid()),mode='w')
logger=logging.getLogger()
logger.addHandler(fileHandler)
logger.setLevel(logging.DEBUG)
rounds = 10
random.seed(datetime.now())
start_time = time.time()
logger.info("# iteration %d" % (i+1))
NODES = 7115
min_edges = 75000
max_edges = 125000
incr = 0.001
p = 0.001 # probability
seed = 100
radius = 2
weak_ties = [i*5 for i in range(0, 3)]
ret = None
avgc = 0
edges = 0
with DirectedGraph.WS2DGraph(NODES, random.randint(min_edges, max_edges), radius, weak_ties) as graph:
edges = graph.size()[1]
avgc = graph.toUndirect().average_clustering()
ret = experiment(graph, seed, rounds)
# print("# iteration %d done in %f" % (i+1, time.time() - start_time))
elapsed = time.time() - start_time
ret.append((edges, avgc, elapsed, p, radius))
logger.info("# iteration %d done in %f" % (i+1, elapsed))
logger.info("# {}".format(ret))
return ret
def label_experiment(self, exp_id):
"""Create/Update the label of an experiment."""
exp = experiment.experiment(new_experiment=False, ts=str(exp_id))
label = request.form.get('label')
exp.update_metadata(change_label=True, label=label)
return "OK"
def experiment_with_fudge_factors(isotope, loa_rel_dev):
filename = "data_5point/ism_%s"%(isotope)
loa_fudge_factors = [1+rel_dev for rel_dev in loa_rel_dev]
#Perform experiments in comprehensive list
loa_experiments = [experiment(isotope, fudge_factor,
input_timesteps=global_special_timestep,
dt=global_constant_timestep,
bestfit_namespace=cbf)
for fudge_factor in loa_fudge_factors]
#save all data
for i, exp in enumerate(loa_experiments):
data_filename = filename + "_%dm"%int(1000*loa_fudge_factors[i])
exp.save2file(filename=data_filename, write_index_file=True)
#list of names of experiments
loa_names = [r"$\hat{Y}_{%s}=%1.2f\sigma$"%(isotope, sigma)
for sigma in loa_fudge_factors]
#save figure
title = "%s abundance in proxy-MW by 'Omega'"%(isotope)
#plot ism-content for isotope in question.
vis_object = visualize(loa_experiments, loa_names, num_yaxes=2,
yields=True)
#plot spectroscopic abundance
vis_object.add_time_ism(isotope, index_yaxis=0)
vis_object.add_yields(nuclide=isotope, index_yaxis=1, time="sum", log_bool=False)
vis_object.finalize(show=False, save=filename+".png",
title=title, linewidth=3)
return
def pose_img(self, exp_id, camera_id, img_id):
"""Employ pose detection on a single image."""
pd = pose_detection()
exp = experiment.experiment(new_experiment=False, ts=exp_id)
room_name = exp.metadata["room"]
if room_name.lower() == "cears":
room_id = 1
elif room_name.lower() == "computer_lab":
room_id = 0
devices = self.rooms[room_id]["devices"]
camera_name = os.path.basename(devices[camera_id])
fname = os.path.join("data", exp_id, "raw", camera_name,
str(img_id) + ".png")
self.app.logger.info(fname)
retval = pd.detect_pose(fname)
if isinstance(retval, str):
return retval
else:
pose = retval[0]
retval, buffer = cv2.imencode('.png', pose)
print buffer.shape
response = make_response(buffer.tobytes())
response.headers['Content-Type'] = 'image/png'
self.app.logger.info(response)
return response
def make_videofrom_matchsticks(self, exp_id, camera_id, fps):
"""
"""
v = visualization.visualization()
exp = experiment.experiment(new_experiment=False, ts=exp_id)
room_name = exp.metadata["room"]
if room_name.lower() == "cears":
room_id = 1
elif room_name.lower() == "computer_lab":
room_id = 0
devices = self.rooms[room_id]["devices"]
devices.sort()
try:
cam_name = os.path.basename(devices[int(camera_id)])
except Exception as e:
print e
self.app.logger.info(e)
return "No cam found sorry!"
fcamera_path = os.path.join("/dev/v4l/by-id", cam_name)
nframes = exp.metadata["number_of_images"][fcamera_path]
exp_path = self.um.experiment_path(str(exp_id))
fourcc = cv2.VideoWriter_fourcc(*'XVID')
pathout = os.path.join(exp_path, "output/pose/video")
try:
self.um.create_folder(pathout)
except:
pass
pathout = os.path.join(pathout, cam_name)
try:
self.um.create_folder(pathout)
except:
pass
pathout = os.path.join(pathout, "video.avi")
print pathout
self.app.logger.info(pathout)
out = cv2.VideoWriter(pathout, fourcc, fps, (800, 600))
for frame_id in range(nframes):
figure = os.path.join(exp_path, "output/pose/img", cam_name,
"matchstick_" + str(frame_id) + ".png")
self.app.logger.info(figure)
img_ = cv2.imread(figure)
if img_ is None:
return "I think you forgot to draw the matchsticks!"
cv2.resize(img_, (800, 600))
out.write(img_)
out.release()
return "done"
def main(args):
seed_everything(args.seed)
# Set up data_dir, vocab_dir, and model_dir
args.vocab_dir = path.join(args.data_dir, "vocab/uci")
# Change data directory to point to UCI directory
args.data_dir = path.join(args.data_dir, "uci")
if args.max_epochs == 1000:
# Changing the default value
args.max_epochs = 10
args.save_dir = args.weights_save_path if args.weights_save_path is not None else args.base_model_dir
args.model_name = get_model_name(args)
print(f"Model name: {args.model_name}")
experiment(args)
def worker_task(i):
global logger
if logger is None:
logging.basicConfig(
format=
"%(asctime)s [%(process)-4.4s--%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s"
)
fileHandler = logging.FileHandler('RD_log.log.{}'.format(os.getpid()),
mode='w')
logger = logging.getLogger()
logger.addHandler(fileHandler)
logger.setLevel(logging.DEBUG)
random.seed(datetime.now())
start_time = time.time()
rounds = 10
NODES = 7115
min_edges = 75000
max_edges = 125000
incr = 0.001
p = random.uniform(0.0015, 0.0024) # probability
seed = 100
logger.info("# iteration {}".format(i + 1))
graph = None
edges, avgc = -1, -1
while p > 0:
logger.info("generating graph with N={} p={}".format(NODES, p))
graph = DirectedGraph.randomDirectedGraph(NODES, p)
edges = graph.size()[1]
avgc = graph.toUndirect().average_clustering()
logger.info("prob={} edges={}".format(p, edges))
if edges >= min_edges and edges <= max_edges:
break
# avgc = graph.average_clustering()
# logger.info("** avgc={}".format(avgc))
# if avgc >= 0.1 and avgc <= 0.2:
# break
# elif avgc > 0.2:
# p += ((max_edges - edges) / min_edges * 10.0) * incr
# else:
# p += ((min_edges - edges) / min_edges * 10.0) * incr
elif edges > max_edges:
p += ((max_edges - edges) / min_edges) * incr
else:
p += ((min_edges - edges) / min_edges) * incr
sys.stdout.flush()
#graph.setLogger(logger)
ret = experiment(graph, seed, rounds)
elapsed = time.time() - start_time
ret.append((edges, avgc, elapsed))
logger.info("# iteration %d done in %f" %
(i + 1, time.time() - start_time))
logger.info("# {}".format(ret))
#gc.collect()
#return [(lin_max_seed, max_lin_influenced), (eigenc_max_seed, max_eigenc_influenced), (bet_max_seed, max_bet_influenced)]
return ret
def loadExperiment(self, filename='', expid='', options={}):
try:
if self.exp is not None: ## Kill old experiment if any
self.exp.shutdown()
self.exp = experiment(filename, expid, self.ident(), options)
return 1
except Exception, self.err:
self.log.exception(self.err)
return 0
def test_plotExperiment(self):
numExperiments = 3
maxEpisodeLengths = 1000
numEpisodesPerTrial = 50
eS = experimentSet()
for i in range(numExperiments):
exp = experiment('experiment ' +str(i))
exp.addTrial(np.random.randint(maxEpisodeLengths, size=numEpisodesPerTrial))
eS.addExperiment(exp)
eS.plotExperimentSet()
def callback_edit_experiment_window(self):
if self.experiment_window==None:
self.experiment_window=experiment()
self.experiment_window.changed.connect(self.sim_mode_button.update)
help_window().help_set_help(["time.png",_("<big><b>The time mesh editor</b></big><br> To do time domain simulations one must define how voltage the light vary as a function of time. This can be done in this window. Also use this window to define the simulation length and time step.")])
if self.experiment_window.isVisible()==True:
self.experiment_window.hide()
else:
self.experiment_window.show()
def callback_edit_experiment_window(self):
if self.experiment_window==None:
self.experiment_window=experiment()
self.experiment_window.changed.connect(self.callback_experiments_changed)
help_window().help_set_help(["time.png",_("<big><b>The time mesh editor</b></big><br> To do time domain simulations one must define how voltage the light vary as a function of time. This can be done in this window. Also use this window to define the simulation length and time step.")])
if self.experiment_window.isVisible()==True:
self.experiment_window.hide()
else:
self.experiment_window.show()
def callback_edit_experiment_window(self, widget, data=None):
if self.experiment_window==None:
self.experiment_window=experiment()
self.experiment_window.init()
my_help_class.help_set_help(["time.png",_("<big><b>The time mesh editor</b></big>\n To do time domain simulations one must define how voltage the light vary as a function of time. This can be done in this window. Also use this window to define the simulation length and time step.")])
if self.experiment_window.get_property("visible")==True:
self.experiment_window.hide_all()
else:
self.experiment_window.show_all()
def worker_task(i):
global logger
if logger is None:
logging.basicConfig(format="%(asctime)s [%(process)-4.4s--%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s")
fileHandler = logging.FileHandler('RD_log.log.{}'.format(os.getpid()),mode='w')
logger=logging.getLogger()
logger.addHandler(fileHandler)
logger.setLevel(logging.DEBUG)
random.seed(datetime.now())
start_time = time.time()
rounds = 10
NODES = 7115
min_edges = 75000
max_edges = 125000
incr = 0.001
p = random.uniform(0.0015, 0.0024) # probability
seed = 100
logger.info("# iteration {}".format(i+1))
graph = None
edges, avgc = -1, -1
while p > 0:
logger.info("generating graph with N={} p={}".format(NODES, p))
graph = DirectedGraph.randomDirectedGraph(NODES, p)
edges = graph.size()[1]
avgc = graph.toUndirect().average_clustering()
logger.info("prob={} edges={}".format(p, edges))
if edges >= min_edges and edges <= max_edges:
break
# avgc = graph.average_clustering()
# logger.info("** avgc={}".format(avgc))
# if avgc >= 0.1 and avgc <= 0.2:
# break
# elif avgc > 0.2:
# p += ((max_edges - edges) / min_edges * 10.0) * incr
# else:
# p += ((min_edges - edges) / min_edges * 10.0) * incr
elif edges > max_edges:
p += ((max_edges - edges) / min_edges) * incr
else:
p += ((min_edges - edges) / min_edges) * incr
sys.stdout.flush()
#graph.setLogger(logger)
ret = experiment(graph, seed, rounds)
elapsed = time.time() - start_time
ret.append((edges, avgc, elapsed))
logger.info("# iteration %d done in %f" % (i+1, time.time() - start_time))
logger.info("# {}".format(ret))
#gc.collect()
#return [(lin_max_seed, max_lin_influenced), (eigenc_max_seed, max_eigenc_influenced), (bet_max_seed, max_bet_influenced)]
return ret
def generate_simulation_result(x21, x22, x23, x24, x25, x26,
x31, x32, x33, x34, x35, x36,
x41, x42, x43, x44, x45, x46,
x51, x52, x53, x54, x55, x56,
x61, x62, x63, x64, x65, x66,
x71, x72, x73, x74, x75, x76):
b1 = [1, 1, 1, 1, 1, 1]
b2 = [x21, x22, x23, x24, x25, x26]
b3 = [x31, x32, x33, x34, x35, x36]
b4 = [x41, x42, x43, x44, x45, x46]
b5 = [x51, x52, x53, x54, x55, x56]
b6 = [x61, x62, x63, x64, x65, x66]
b7 = [x71, x72, x73, x74, x75, x76]
model = create_map(routes_per_bus=[b1, b2, b3, b4, b5, b6, b7], name='model')
return experiment([model], 60*18, 10, output_report=False, printing=False)
def grid_search(args):
start_time = time.time()
results = []
# split args to default settings and hyperparameters
default_settings = {}
search_settings = {}
for name, value in vars(args).items():
if type(value) == list and len(value) == 1:
value = value[0]
if type(value) != list:
default_settings[name] = value
else:
search_settings[name] = value
# Search hyperparameters
for values in itertools.product(*search_settings.values()):
# Merge default and search settings
hyperparameters = dict(zip(search_settings.keys(), values))
merged_settings = {**default_settings, **hyperparameters}
settings = argparse.Namespace(**merged_settings)
# Set directory path
directory_name = '-'.join(name + str(value) for name, value in hyperparameters.items())
settings.model_directory = os.path.join(settings.model_directory, directory_name)
# Run experiment
metrics, epoch = experiment(settings)
result = (hyperparameters, metrics, epoch)
results.append(result)
# print best experiment result
hyperparameters, metrics, epoch = max(results, key=lambda x: x[1][2])
print('best experiment settings in epoch', epoch)
print(json.dumps(hyperparameters, indent=4))
print('best experiment metrics: precision: {:.2f} recall: {:.2f} f-score: {:.2f} accuracy: {:.2f}'.format(*metrics))
# save all results
results_path = os.path.join(args.model_directory, 'results.json')
json.dump(results, open(results_path, 'w'), indent=4)
# Print total time
total_time = time.time() - start_time
print('total grid search time:', total_time)
def pose_exp(self, exp_id):
"""
Given an experiment id to employ pose_detection on the whole images
collected from all the cameras.
"""
pd = pose_detection()
exp = experiment.experiment(new_experiment=False, ts=exp_id)
ncamera = exp.metadata["number_of_cameras"]
room_name = exp.metadata["room"]
if room_name.lower() == "cears":
room_id = 1
elif room_name.lower() == "computer_lab":
room_id = 0
devices = self.rooms[room_id]["devices"]
statement = ""
for camera_id in range(len(devices)):
st = self.pose_cam(str(exp_id), int(camera_id)) + "<br />"
statement += st
return statement
def list_experiments(self):
"""List all the experiments."""
subfolders = self.um.list_subfolders("data/*/")
experiment_folders = self.um.list_experiments(subfolders)
experiments = list()
for exp in experiment_folders:
try:
date = self.um.timestamp_to_date(int(exp) / 1000)
exp_class = experiment.experiment(new_experiment=False, ts=exp)
if "label" in exp_class.metadata:
label = exp_class.metadata["label"]
else:
label = None
exp_dict = {"date": date, "ts": exp, "label": label}
experiments.append(exp_dict)
except:
print "Skipped"
return render_template('experiments.html', user=experiments)
def __init__ ( self, parent = None ):
QtGui.QMainWindow.__init__( self, parent )
self.setWindowTitle( 'qtView' )
self.ui = qtView_face.Ui_facewindow()
self.ui.setupUi( self )
self.setConnections()
self.cursColors = {0: ['Magenta','m'],1: ['Cyan','c'],2: ['Green','g'],3:['Black','k']}
self.cursors = []
self.ui.cursCmpCmbBox.addItem('Select a cursor')
self.fitFlag = False
self.alignFlags = []
self.ctPoints = []
self.bad = []
self.badFlags = []
self.ui.setPathBtn.setStyleSheet('background-color: none')
self.globDir = ''
self.peaksOnPlot = False
self.peaksAlreadyPlotted = False
self.lastOperation = ''
self.exp = experiment.experiment()
self.statusDict = {1:[[self.ui.bAddDir,self.ui.bAddFiles,self.ui.convr9Btn],
[self.ui.reloadBtn,self.ui.saveBox,self.ui.removeBox,self.ui.fromFileBox,
self.ui.fitNpeakBox,self.ui.alignBox,self.ui.plotModBox,self.ui.cursorsBox,
self.ui.peaksTab]],
2:[[self.ui.removeBox,self.ui.removeBtn,self.ui.reloadBtn,self.ui.closeExpBtn,
self.ui.fromFileBox,self.ui.fitNpeakBox,self.ui.alignBox,self.ui.plotModBox,
self.ui.cursorsBox],
[self.ui.removeBOBtn,self.ui.saveBox,self.ui.peaksTab,self.ui.chgStatBtn]],
3:[[self.ui.removeBOBtn,self.ui.saveBox,self.ui.peaksTab,self.ui.chgStatBtn,self.ui.findPeaksBtn],
[self.ui.showPeakBtn,self.ui.peaksCmbBox,self.ui.alignBox,self.ui.savePeaksBox]],
4:[[self.ui.showPeakBtn,self.ui.peaksCmbBox,self.ui.savePeaksBox,self.ui.removeBOBtn],
[]]}
logString = 'Welcome!\n'
self.simpleLogger(logString)
self.setStatus(1)
def worker_task(i):
global logger
if logger is None:
logging.basicConfig(
format=
"%(asctime)s [%(process)-4.4s--%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s"
)
fileHandler = logging.FileHandler('PA_log.log.{}'.format(os.getpid()),
mode='w')
logger = logging.getLogger()
#fileHandler.setFormatter(logging.Formatter("%(asctime)s [%(process)-4.4s--%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s"))
logger.addHandler(fileHandler)
logger.setLevel(logging.DEBUG)
random.seed(datetime.now().timestamp() * i)
start_time = time.time()
rounds = 10
NODES = 7115
min_edges = 75000
max_edges = 125000
incr = 0.001
p = random.uniform(0.35, 0.45) # probability
seed = 100
d = int(random.randint(min_edges, max_edges) / NODES)
ret = None
avgc = 0
edges = 0
with DirectedGraph.preferentialAttachment(NODES, d, p) as graph:
edges = graph.size()[1]
avgc = graph.toUndirect().average_clustering()
ret = experiment(graph, seed, rounds)
# print("# iteration %d done in %f" % (i+1, time.time() - start_time))
elapsed = time.time() - start_time
ret.append((edges, avgc, elapsed, p, d))
logger.info("# iteration %d done in %f" % (i + 1, elapsed))
logger.info("# {}".format(ret))
sys.stdout.flush()
return ret
def __init__(self, devices, room_name):
self.cams = list()
self.exp = experiment.experiment(new_experiment=True,
camera_names=devices,
room=room_name)
self.exp_id = str(self.exp.ts)
self.device_ids = list()
self.img_id = dict()
self.devices = devices
for dev in devices:
print "Accessing:", dev
self.device_ids.append(os.path.basename(dev))
cam = cv2.VideoCapture(dev)
if cam.isOpened():
cam.set(cv2.CAP_PROP_FPS, 3)
cam.set(cv2.CAP_PROP_AUTOFOCUS, 0)
self.cams.append(cam)
print dev, "is opened"
else:
print "error in", dev
self.img_id[dev] = 0
def skeletons(self, exp_id, cam_id, frame_id):
"""Test skeletons."""
visualizer = visualization.visualization()
exp = experiment.experiment(new_experiment=False, ts=exp_id)
room_name = exp.metadata["room"]
if room_name.lower() == "cears":
room_id = 1
elif room_name.lower() == "computer_lab":
room_id = 0
devices = self.rooms[room_id]["devices"]
devices.sort()
try:
cam_name = os.path.basename(devices[int(cam_id)])
except:
return "No cam found sorry!"
exp_path = self.um.experiment_path(str(exp_id))
pose_detection_result = "output/pose"
json = "pose"
img = "img"
fname = os.path.join(exp_path, pose_detection_result, json, cam_name,
str(frame_id) + ".png.json")
output_fname = os.path.join(exp_path, pose_detection_result, img,
cam_name,
"matchstick_" + str(frame_id) + ".png")
print fname
self.app.logger.info(fname)
if self.um.check_file_exists(fname):
json_data = self.um.read_json(fname)
people_in_frame = people(json_data, frame_id)
visualizer.draw_matchsticks(people_in_frame, output_fname)
npeople = str(len(people_in_frame.list))
else:
npeople = 0
return "Number of people drawn: {n}".format(n=npeople)
def worker_task(i):
global logger
if logger is None:
logging.basicConfig(
format=
"%(asctime)s [%(process)-4.4s--%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s"
)
fileHandler = logging.FileHandler('WS_log.log.{}'.format(os.getpid()),
mode='w')
logger = logging.getLogger()
logger.addHandler(fileHandler)
logger.setLevel(logging.DEBUG)
rounds = 10
random.seed(datetime.now())
start_time = time.time()
logger.info("# iteration %d" % (i + 1))
NODES = 7115
min_edges = 75000
max_edges = 125000
incr = 0.001
p = 0.001 # probability
seed = 100
radius = 2
weak_ties = [i * 5 for i in range(0, 3)]
ret = None
avgc = 0
edges = 0
with DirectedGraph.WS2DGraph(NODES, random.randint(min_edges, max_edges),
radius, weak_ties) as graph:
edges = graph.size()[1]
avgc = graph.toUndirect().average_clustering()
ret = experiment(graph, seed, rounds)
# print("# iteration %d done in %f" % (i+1, time.time() - start_time))
elapsed = time.time() - start_time
ret.append((edges, avgc, elapsed, p, radius))
logger.info("# iteration %d done in %f" % (i + 1, elapsed))
logger.info("# {}".format(ret))
return ret
def demographics():
form = Demographics()
if request.method == 'POST':
if form.validate() == False:
flash('All fields are required')
return render_template('demographics.html',form=form)
this_logfile = files.get_logfile()
write_this = open(this_logfile, 'a').write(
'\nage: '+request.form['age']+
' ,gender: '+request.form['gender']+
' ,environ: '+request.form['location']+
' ,occup: '+request.form['occupation']+
' ,advert: '+request.form['advertisement']+
'\n###################################################################\n'+
'\ntime\tcumtime\texpress\tident\tbutton\tfilename\tevaluation\tstopRT\tchoiceRT\tmaskNum\tmaskList\n'
)
return experiment.experiment()
elif request.method == 'GET':
return render_template('demographics.html', form=form)
def demographics():
form = Demographics()
if request.method == 'POST':
if form.validate() == False:
flash('All fields are required')
return render_template('demographics.html', form=form)
this_logfile = files.get_logfile()
write_this = open(this_logfile, 'a').write(
'\nage: ' + request.form['age'] + ' ,gender: ' +
request.form['gender'] + ' ,environ: ' + request.form['location'] +
' ,occup: ' + request.form['occupation'] + ' ,advert: ' +
request.form['advertisement'] +
'\n###################################################################\n'
+
'\ntime\tcumtime\texpress\tident\tbutton\tfilename\tevaluation\tstopRT\tchoiceRT\tmaskNum\tmaskList\n'
)
return experiment.experiment()
elif request.method == 'GET':
return render_template('demographics.html', form=form)
def closeExp(self):
self.ui.grafo.clear()
self.exp = []
self.fitFlag = False
self.alignFlags = []
self.ctPoints = []
self.bad = []
self.badFlags = []
self.exp = experiment.experiment()
self.refillList()
logString = 'Experiment closed\n'
self.simpleLogger(logString)
self.globDir = ''
self.ui.setPathBtn.setStyleSheet('background-color: none')
self.cursors = []
for i in xrange(self.ui.cursCmbBox.count()):
self.ui.cursCmbBox.removeItem(i)
self.ui.cursCmpCmbBox.removeItem(i+1)
self.ui.currCursXvalNumDbl.setValue(0.0)
self.ui.currCursYvalNumDbl.setValue(0.0)
self.ui.currCursXdelNumDbl.setValue(0.0)
self.ui.currCursYdelNumDbl.setValue(0.0)
self.setStatus(1)
def submit():
new_experiment = experiment(self.experimentName.get(), self.experimentType.get(),\
self.experimentObjective.get("1.0", 'end-1c'))
print("new experiment created")
print(new_experiment)
self.experiment_details(experiment=new_experiment)
def run(self):
for i in range(self._experiments):
e = experiment(self._agent, self._util, self._generator, self._c,
self._n, self._alpha)
e.iterate(self._iterations)
self._list.append(e)
import config
import experiment
# initialize experiment:
# - single-class classification problem using the IRIS flower dataset
# - the model should predict the iris species
cfg = config.config()
exp = experiment.experiment(cfg.expdir + "/iris", trials = 10)
exp.set_task(cfg.task_iris())
# loss functions
exp.add_loss("logistic", cfg.loss("s-logistic"))
# trainers
epochs = 100
patience = 100
epsilon = 1e-4
for solver in cfg.batch_solvers():
exp.add_trainer(solver, cfg.batch_trainer(solver, epochs, patience, epsilon))
# models
output = {"name":"output","type":"affine","omaps":3,"orows":1,"ocols":1}
fc1 = {"name":"fc1","type":"affine","omaps":64,"orows":1,"ocols":1}
fc2 = {"name":"fc2","type":"affine","omaps":32,"orows":1,"ocols":1}
fc3 = {"name":"fc3","type":"affine","omaps":16,"orows":1,"ocols":1}
ac1 = {"name":"ac1","type":"act-snorm"}
ac2 = {"name":"ac2","type":"act-snorm"}
import config
import experiment
# initialize experiment:
# - single-class classification problem using the WINE dataset
# - the model should predict the wine quality class
cfg = config.config()
exp = experiment.experiment(cfg.expdir + "/wine", trials = 10)
exp.set_task(cfg.task_wine())
# loss functions
exp.add_loss("logistic", cfg.loss("s-logistic"))
# trainers
epochs = 100
patience = 100
epsilon = 1e-4
for solver in cfg.batch_solvers():
exp.add_trainer(solver, cfg.batch_trainer(solver, epochs, patience, epsilon))
# models
output = {"name":"output","type":"affine","omaps":3,"orows":1,"ocols":1}
fc1 = {"name":"fc1","type":"affine","omaps":64,"orows":1,"ocols":1}
fc2 = {"name":"fc2","type":"affine","omaps":32,"orows":1,"ocols":1}
fc3 = {"name":"fc3","type":"affine","omaps":16,"orows":1,"ocols":1}
ac1 = {"name":"ac1","type":"act-snorm"}
ac2 = {"name":"ac2","type":"act-snorm"}
scale = {
'off1': '../off/metadata.tsv',
'off2': '../off/metadata.tsv',
'off3': '../off/metadata.tsv',
'off4': '../off/metadata.tsv',
'on1': '../pumped1/metadata.tsv',
'on2': '../pumped1/metadata.tsv',
'on3': '../pumped1/metadata.tsv',
'on4': '../pumped1/metadata.tsv',
'on5': '../pumped1/metadata.tsv',
'on6': '../pumped1/metadata.tsv',
'on7': '../pumped1/metadata.tsv',
'on8': '../pumped1/metadata.tsv',
}
e = experiment.experiment()
c = experiment.crystal()
for k, v in data.items():
scaledict = {
i.split()[0]: float(i.split()[1])
for i in open(scale[k]).readlines()[1:]
}
c[k] = experiment.image_series(v).scale(scaledict)
if k == reference:
n = c[k].generate_nxdsin()
n.update(nxds_params)
e.append(c)
e.integrate(reference, n)
def main():
exp_stats = Statistics()
exp_stats.new_report_dir()
params = {
'academic_dataset':
'cifar10',
'target_model_path':
(models_path / 'cifar10_model_default.pt').as_posix(),
'mia_model_path':
(models_path / 'mia_model_cifar10_default').as_posix(),
'shadow_model_base_path':
(models_path / 'shadows' / 'shadow_cifar10_default').as_posix(),
'mia_train_dataset_path':
(data_path / 'mia_train_dataset_cifar10_default').as_posix(),
'mia_test_dataset_path':
(data_path / 'mia_test_dataset_cifar10_default').as_posix(),
'class_number':
10,
'target_train_epochs':
100,
'shadow_train_epochs':
100,
'mia_train_epochs':
10,
'shadow_number':
10,
# ~ 'custom_mia_model' : OrderedDict([
# ~ ('dense1' , nn.Linear(10, 128)),
# ~ ('relu1' , nn.ReLU()),
# ~ ('dropout1' , nn.Dropout(0.3)),
# ~ ('dense2' , nn.Linear(128, 64)),
# ~ ('relu2' , nn.ReLU()),
# ~ ('dropout2' , nn.Dropout(0.2)),
# ~ ('dense3' , nn.Linear(64, 2)),
# ~ ('relu3' , nn.ReLU()),
# ~ ('logsoftmax' , nn.LogSoftmax(dim=1))
# ~ ]),
'custom_mia_model':
OrderedDict([('dense1', nn.Linear(10, 25)), ('sigmo1', nn.Sigmoid()),
('dense2', nn.Linear(25, 2)),
('logsoftmax', nn.LogSoftmax(dim=1))]),
'custom_target_model':
OrderedDict([('conv1', nn.Conv2d(3, 32, 3, 1)), ('relu1', nn.ReLU()),
('maxp1', nn.MaxPool2d(2, 2)),
('conv2', nn.Conv2d(32, 64, 3, 1)), ('relu2', nn.ReLU()),
('maxp2', nn.MaxPool2d(2, 2)), ('flatt', Flatten()),
('dens1', nn.Linear(6 * 6 * 64, 512)),
('relu3', nn.ReLU()), ('dens2', nn.Linear(512, 10)),
('lsoft', nn.LogSoftmax(dim=1))]),
'custom_shadow_model':
OrderedDict([('conv1', nn.Conv2d(3, 32, 3, 1)), ('relu1', nn.ReLU()),
('maxp1', nn.MaxPool2d(2, 2)),
('conv2', nn.Conv2d(32, 64, 3, 1)), ('relu2', nn.ReLU()),
('maxp2', nn.MaxPool2d(2, 2)), ('flatt', Flatten()),
('dens1', nn.Linear(6 * 6 * 64, 512)),
('relu3', nn.ReLU()), ('dens2', nn.Linear(512, 10)),
('lsoft', nn.LogSoftmax(dim=1))]),
'use_cuda':
False,
'no_cache':
True,
'no_mia_train_dataset_cache':
False,
'no_mia_test_dataset_cache':
False,
'no_mia_models_cache':
False,
'no_shadow_cache':
False
}
exp_stats.new_experiment(f"Cifar10 MIA", params)
experiment(**params, stats=exp_stats)
# ~ params = { 'academic_dataset' : 'federal',
# ~ 'target_model_path' : (models_path/'federal_model_default.pt').as_posix(),
# ~ 'mia_model_path' : (models_path/'mia_model_federal_default').as_posix(),
# ~ 'shadow_model_base_path' : (models_path/'shadows'/'shadow_federal_default').as_posix(),
# ~ 'mia_train_dataset_path' : (data_path/'mia_train_dataset_federal_default').as_posix(),
# ~ 'mia_test_dataset_path' : (data_path/'mia_test_dataset_federal_default').as_posix(),
# ~ 'class_number' : 10,
# ~ 'target_train_epochs' : 100,
# ~ 'shadow_train_epochs' : 100,
# ~ 'shadow_number' : 2,
# ~ 'custom_mia_model' : OrderedDict([
# ~ ('dense1' , nn.Linear(10, 128)),
# ~ ('relu1' , nn.ReLU()),
# ~ ('dropout1' , nn.Dropout(0.3)),
# ~ ('dense2' , nn.Linear(128, 64)),
# ~ ('relu2' , nn.ReLU()),
# ~ ('dropout2' , nn.Dropout(0.2)),
# ~ ('dense3' , nn.Linear(64, 2)),
# ~ ('relu3' , nn.ReLU()),
# ~ ('logsoftmax' , nn.LogSoftmax(dim=1))
# ~ ]),
# ~ 'no_cache' : False,
# ~ 'no_mia_train_dataset_cache' : True,
# ~ 'no_mia_test_dataset_cache' : True,
# ~ 'no_shadow_cache' : True }
# ~ exp_stats.new_experiment(f"Federal MIA: shadow number 50", params)
# ~ experiment(**params, stats = exp_stats)
# ~ for i in range(5, 200, 5):
# ~ params = { 'academic_dataset' : 'federal',
# ~ 'target_model_path' : (models_path/'federal_model_default.pt').as_posix(),
# ~ 'mia_model_path' : (models_path/'mia_model_federal_default').as_posix(),
# ~ 'shadow_model_base_path' : (models_path/'shadows'/'shadow_federal_default').as_posix(),
# ~ 'mia_train_dataset_path' : (data_path/'mia_train_dataset_federal_default').as_posix(),
# ~ 'mia_test_dataset_path' : (data_path/'mia_test_dataset_federal_default').as_posix(),
# ~ 'class_number' : 10,
# ~ 'target_train_epochs' : 15,
# ~ 'shadow_train_epochs' : 15,
# ~ 'shadow_number' : i,
# ~ 'custom_mia_model' : OrderedDict([
# ~ ('dense1' , nn.Linear(10, 128)),
# ~ ('relu1' , nn.ReLU()),
# ~ ('dropout1' , nn.Dropout(0.3)),
# ~ ('dense2' , nn.Linear(128, 64)),
# ~ ('relu2' , nn.ReLU()),
# ~ ('dropout2' , nn.Dropout(0.2)),
# ~ ('dense3' , nn.Linear(64, 2)),
# ~ ('relu3' , nn.ReLU()),
# ~ ('logsoftmax' , nn.LogSoftmax(dim=1))
# ~ ]),
# ~ 'no_mia_train_dataset_cache' : True,
# ~ 'no_mia_test_dataset_cache' : True,
# ~ 'no_shadow_cache' : True }
# ~ for j in range(5):
# ~ exp_stats.new_experiment(f"Federal MIA: shadow number {i}", params)
# ~ experiment(**params, stats = exp_stats)
# ~ # run the code on cuda or not for all experiments
# ~ cuda = False
# ~ if cuda:
# ~ import torch.multiprocessing
# ~ torch.multiprocessing.set_start_method('spawn', force = 'True')
# ~ exp_stats = Statistics()
# ~ for i in range(1, 129, 4):
# ~ params = { 'academic_dataset' : 'cifar10',
# ~ 'target_model_path' : (models_path/'cifar10_model_default.pt').as_posix(),
# ~ 'mia_model_path' : (models_path/'mia_model_cifar10_default').as_posix(),
# ~ 'shadow_model_base_path' : (models_path/'shadows'/'shadow_cifar10_default').as_posix(),
# ~ 'mia_train_dataset_path' : (data_path/'mia_train_dataset_cifar10_default').as_posix(),
# ~ 'mia_test_dataset_path' : (data_path/'mia_test_dataset_cifar10_default').as_posix(),
# ~ 'class_number' : 10,
# ~ 'target_train_epochs' : 15,
# ~ 'shadow_train_epochs' : 15,
# ~ 'shadow_number' : 90,
# ~ 'custom_mia_model' : OrderedDict([
# ~ ('dense1' , nn.Linear(10, 128)),
# ~ ('relu1' , nn.ReLU()),
# ~ ('dropout1' , nn.Dropout(0.3)),
# ~ ('dense2' , nn.Linear(128, 64)),
# ~ ('relu2' , nn.ReLU()),
# ~ ('dropout2' , nn.Dropout(0.2)),
# ~ ('dense3' , nn.Linear(64, 2)),
# ~ ('relu3' , nn.ReLU()),
# ~ ('logsoftmax' , nn.LogSoftmax(dim=1))
# ~ ]),
# ~ 'custom_target_model' : OrderedDict([
# ~ ('conv1', nn.Conv2d(3, 32, 3, 1)),
# ~ ('relu1', nn.ReLU()),
# ~ ('maxp1', nn.MaxPool2d(2, 2)),
# ~ ('conv2', nn.Conv2d(32, 64, 3, 1)),
# ~ ('relu2', nn.ReLU()),
# ~ ('maxp2', nn.MaxPool2d(2, 2)),
# ~ ('flatt', Flatten()),
# ~ ('dens1', nn.Linear(6*6*64, 512)),
# ~ ('relu3', nn.ReLU()),
# ~ ('dens2', nn.Linear(512, 10)),
# ~ ('lsoft', nn.LogSoftmax(dim=1))
# ~ ]),
# ~ 'custom_shadow_model' : OrderedDict([
# ~ ('conv1', nn.Conv2d(3, i, 3, 1)),
# ~ ('relu1', nn.ReLU()),
# ~ ('maxp1', nn.MaxPool2d(2, 2)),
# ~ ('conv2', nn.Conv2d(i, i, 3, 1)),
# ~ ('relu2', nn.ReLU()),
# ~ ('maxp2', nn.MaxPool2d(2, 2)),
# ~ ('flatt', Flatten()),
# ~ ('dens1', nn.Linear(6*6*i, 512)),
# ~ ('relu3', nn.ReLU()),
# ~ ('dens2', nn.Linear(512, 10)),
# ~ ('lsoft', nn.LogSoftmax(dim=1))
# ~ ]),
# ~ 'use_cuda' : cuda,
# ~ 'no_mia_train_dataset_cache' : True,
# ~ 'no_mia_models_cache' : True,
# ~ 'no_shadow_cache' : True }
# ~ for j in range(5):
# ~ exp_stats.new_experiment(f"Cifar10 MIA: shadow conv filter number {i}", params)
# ~ experiment(**params, stats = exp_stats)
# ~ # default regularized purchase model
# ~ params = { 'academic_dataset' : 'purchase',
# ~ 'target_model_path' : (models_path/'purchase_model_default.pt').as_posix(),
# ~ 'mia_model_path' : (models_path/'mia_model_purchase_default').as_posix(),
# ~ 'shadow_model_base_path' : (models_path/'shadows'/'shadow_purchase_default').as_posix(),
# ~ 'mia_train_dataset_path' : (data_path/'mia_train_dataset_purchase_default').as_posix(),
# ~ 'mia_test_dataset_path' : (data_path/'mia_test_dataset_purchase_default').as_posix(),
# ~ 'class_number' : 2,
# ~ 'use_cuda' : cuda }
# ~ exp_stats.new_experiment("MIA on default Purchase model (batch norm + dropout regularization)", params)
# ~ experiment(**params, stats = exp_stats)
# ~ # default regularized mnist model
# ~ params = { 'academic_dataset' : 'mnist',
# ~ 'target_model_path' : (models_path/'mnist_model_default.pt').as_posix(),
# ~ 'mia_model_path' : (models_path/'mia_model_default').as_posix(),
# ~ 'shadow_model_base_path' : (models_path/'shadows'/'shadow_default').as_posix(),
# ~ 'mia_train_dataset_path' : (data_path/'mia_train_dataset_default').as_posix(),
# ~ 'mia_test_dataset_path' : (data_path/'mia_test_dataset_default').as_posix(),
# ~ 'class_number' : 10,
# ~ 'use_cuda' : cuda }
# ~ exp_stats.new_experiment("MIA on default Mnist (batch norm regularization)", params)
# ~ experiment(**params, stats = exp_stats)
# ~ # without regularization
# ~ params = { 'academic_dataset' : 'mnist',
# ~ 'target_model_path' : (models_path/'mnist_model_exp1.pt').as_posix(),
# ~ 'mia_model_path' : (models_path/'mia_model_exp1').as_posix(),
# ~ 'custom_target_model' : OrderedDict([
# ~ ('conv1' , nn.Conv2d(1, 10, 3, 1)),
# ~ ('relu1' , nn.ReLU()),
# ~ ('maxpool1' , nn.MaxPool2d(2, 2)),
# ~ ('conv2' , nn.Conv2d(10, 10, 3, 1)),
# ~ ('relu2' , nn.ReLU()),
# ~ ('maxpool2' , nn.MaxPool2d(2, 2)),
# ~ ('to1d' , Flatten()),
# ~ ('dense1' , nn.Linear(5*5*10, 500)),
# ~ ('tanh' , nn.Tanh()),
# ~ ('dense2' , nn.Linear(500, 10)),
# ~ ('logsoftmax' , nn.LogSoftmax(dim=1))
# ~ ]),
# ~ 'shadow_number' : 50,
# ~ 'shadow_model_base_path' : (models_path/'shadows'/'shadow_exp1').as_posix(),
# ~ 'mia_train_dataset_path' : (data_path/'mia_train_dataset_exp1').as_posix(),
# ~ 'mia_test_dataset_path' : (data_path/'mia_test_dataset_exp1').as_posix(),
# ~ 'class_number' : 10,
# ~ 'use_cuda' : cuda }
# ~ exp_stats.new_experiment("MIA on Mnist with no regularization", params)
# ~ experiment(**params, stats = exp_stats)
# ~ # with dropout regularization
# ~ params = { 'academic_dataset' : 'mnist',
# ~ 'target_model_path' : (models_path/'mnist_model_exp2.pt').as_posix(),
# ~ 'mia_model_path' : (models_path/'mia_model_exp2').as_posix(),
# ~ 'custom_target_model' : OrderedDict([
# ~ ('conv1' , nn.Conv2d(1, 10, 3, 1)),
# ~ ('relu1' , nn.ReLU()),
# ~ ('maxpool1' , nn.MaxPool2d(2, 2)),
# ~ ('dropout1' , nn.Dropout(p = 0.5)),
# ~ ('conv2' , nn.Conv2d(10, 10, 3, 1)),
# ~ ('relu2' , nn.ReLU()),
# ~ ('maxpool2' , nn.MaxPool2d(2, 2)),
# ~ ('dropout2' , nn.Dropout(p = 0.5)),
# ~ ('to1d' , Flatten()),
# ~ ('dense1' , nn.Linear(5*5*10, 500)),
# ~ ('tanh' , nn.Tanh()),
# ~ ('dropout3' , nn.Dropout(p = 0.5)),
# ~ ('dense2' , nn.Linear(500, 10)),
# ~ ('logsoftmax' , nn.LogSoftmax(dim=1))
# ~ ]),
# ~ 'shadow_number' : 50,
# ~ 'shadow_model_base_path' : (models_path/'shadows'/'shadow_exp2').as_posix(),
# ~ 'mia_train_dataset_path' : (data_path/'mia_train_dataset_exp2').as_posix(),
# ~ 'mia_test_dataset_path' : (data_path/'mia_test_dataset_exp2').as_posix(),
# ~ 'class_number' : 10,
# ~ 'use_cuda' : cuda }
# ~ exp_stats.new_experiment("MIA on Mnist with dropout regulrization", params)
# ~ experiment(**params, stats = exp_stats)
exp_stats.print_results()
exp_stats.save(dir=reports_path)
def anova(expPath, imageFile="anova.png"):
exp = e.experiment()
exp.read(expPath, loadW=True)
ret = exp.getTrainInputs()
# ret = exp.getTestInputs()
numLocations = exp.exp['num_locs']
global pval
pval = 0.001
inputs = ret['inputs']
targets = ret['targets']
inames = ret['inputNames']
rnn = exp.rnn
np.set_printoptions(edgeitems = 10)
locTrials = [list([]) for _ in range(numLocations)]
cue1locTrials = [list([]) for _ in range(numLocations)]
cue2locTrials = [list([]) for _ in range(numLocations)]
choices = [list([]) for _ in range(2)]
conjPairs = []
conjTrials = []
trialMeans = []
# The trial mean firing rates for the delay period alone
trialMeansDelayOnly = []
for trial in range(len(inputs)):
j = np.asarray(inputs[trial])
try:
info = ast.literal_eval(ret['inputNames'][trial])
except:
pass
# compute activations and select the hidden layer
hidden = rnn.forward(j, rnn.W)[1]
# eliminate this extra dimension from the outputs.
# still not exactly sure what this dimension is
hidden = hidden[:, 0, :]
means = [];
# This "meansDelayOnly" is the mean firing rate for the delay period only
meansDelayOnly = []
for unit in range(len(hidden[0])):
means.append(np.mean(hidden[:, unit]))
meansDelayOnly.append(np.mean(hidden[-10:-5, unit]))
trialMeansDelayOnly.append(meansDelayOnly)
trialMeans.append(means)
loc1 = info['inputs']['cue1']
loc2 = info['inputs']['cue2']
choice = info['inputs']['choice'] - 1
# print loc1
# print len(locTrials)
locTrials[loc1].append(trial)
locTrials[loc2].append(trial)
choices[choice].append(trial)
cue1locTrials[loc1].append(trial)
cue2locTrials[loc2].append(trial)
i = min(loc1, loc2)
j = max(loc1, loc2)
pair = [i, j]
if pair not in conjPairs:
conjPairs.append(pair)
conjTrials.append([])
conjTrials[conjPairs.index(pair)].append(trial)
count = 0
sigNeurons = []
for neuron in range(len(trialMeans[0])):
sample1=[]
sample2=[]
for trial in locTrials[0]:
sample1.append(trialMeans[trial][neuron])
for trial in locTrials[1]:
sample2.append(trialMeans[trial][neuron])
ans = f_oneway(sample1, sample2)
if ans.pvalue < pval:
count += 1
sigNeurons.append(neuron)
# print ans
# print neuron
print "# neurons prefer location 0 at cue1 to cue2".format(count, pval)
print sigNeurons
print
exit()
count = 0
sigNeurons = []
for neuron in range(len(trialMeans[0])):
sample1=[]
sample2=[]
for trial in choices[0]:
sample1.append(trialMeans[trial][neuron])
for trial in choices[1]:
sample2.append(trialMeans[trial][neuron])
ans = f_oneway(sample1, sample2)
if ans.pvalue < pval:
count += 1
sigNeurons.append(neuron)
# print ans
# print neuron
print "# neurons prefer choice selection (1st or 2nd cue,): {}, pval < {}".format(count, pval)
print sigNeurons
print
# number of significant neurons prefering that direction
numSigLoc = np.zeros(numLocations)
# some relevant neurons, just a list of some significant ones
sigNeurons = []
for loc in range(numLocations):
for neuron in range(len(trialMeans[0])):
sample1=[]
sample2=[]
for trial in locTrials[loc]:
sample1.append(trialMeans[trial][neuron])
for loc2 in range(numLocations):
if loc2 is not loc:
for trial in locTrials[loc2]:
sample2.append(trialMeans[trial][neuron])
ans = f_oneway(sample1, sample2)
if ans.pvalue < pval:
numSigLoc[loc] += 1
sigNeurons.append(neuron)
message = "# sig neurons per location: ["
for loc in range(len(numSigLoc)):
message = message + str(numSigLoc[loc]) + ", "
message = message[:-2]
message = message + "], pval < {}".format(pval)
print message
print
