def main():
np.random.seed(87655678)
numberOfNodes = 1
batch_size = 100
inputStream = inputs.higgs.HiggsStream("/home/arc/Desktop/shared/Uni Bonn Study Materials/Data Science Lab/HIGGS.csv", "higgs", batch_size=batch_size)
lossFunction = SquaredLoss()
learningRate = 0.1
lmbda = 0.0001
sigma = 4.5
kernel = GaussianKernel(sigma)
noModelComp = NoCompression()
modelComp = Projection(0.1, kernel)
linupdateRule = StochasticGradientDescent(lossFunction, lmbda, learningRate)
updateRule = KernelStochasticGradientDescent(lossFunction, lmbda, learningRate)
anchorBatchSize = 20
linmodel = LinearClassificationModel()
model = KernelClassificationModel(kernel, noModelComp)
modelComp = KernelClassificationModel(kernel, modelComp)
dnnModel = DNNModel(indim = 28, outdim = 1, hidden_layers = 5, neurons = 300, batch_size=100)
envs = [
#baselines
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linupdateRule,
model = dnnModel,
batchSizeInMacroRounds = numberOfNodes*500,
syncOperator = NoSyncOperator()),
# PredictionEnvironment( numberOfNodes = numberOfNodes,
# updateRule = linupdateRule,
# model = dnnModel,
# syncOperator = CentralSyncOperator(),
# serial = True),
# PredictionEnvironment( numberOfNodes = numberOfNodes,
# updateRule = linupdateRule,
# model = dnnModel,
# syncOperator = CentralSyncOperator(),
# serial = False),
# #static averaging
# PredictionEnvironment( numberOfNodes = numberOfNodes,
# updateRule = linupdateRule,
# model = dnnModel,
# batchSizeInMacroRounds = numberOfNodes*500,
# syncOperator = StaticSyncOperator()),
# #dynamic averaging
# PredictionEnvironment( numberOfNodes = numberOfNodes,
# updateRule = linupdateRule,
# model = dnnModel,
# batchSizeInMacroRounds = 5000,
# syncOperator = HedgedDistBaseSync(1.0),),
]
#experiment.runParameterEvaluation(inputStream, envs, numberOfNodes*100)
experiment.run(inputStream, envs, MaxNumberOfExamplesCondition(4*250000/batch_size))
def stage_master_main():
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind('tcp://*:' + STAGE_MASTER_PORT)
i = 0
settings = []
while i < get_nodes_no() - 1:
s = eval(socket.recv())
settings += [s]
print 'Received settings:', s
socket.send('ACK')
i += 1
print 'Got all peer settings:', settings, '. Starting experiment.'
run(settings)
def main():
args = get_args()
_setup_logging()
# If job_dir_reuse is False then remove the job_dir if it exists
logging.info("Resume training:", args.reuse_job_dir)
if not args.reuse_job_dir:
if tf.gfile.Exists(args.job_dir):
tf.gfile.DeleteRecursively(args.job_dir)
logging.info("Deleted job_dir {} to avoid re-use".format(
args.job_dir))
else:
logging.info("Reusing job_dir {} if it exists".format(args.job_dir))
run_config = experiment.create_run_config(args)
logging.info("Job directory:", run_config.model_dir)
# Compute the number of training steps
if args.train_size is not None and args.num_epochs is not None:
args.train_steps = int(
(args.train_size / args.batch_size) * args.num_epochs)
else:
args.train_steps = args.train_steps
logging.info("Train size: {}.".format(args.train_size))
logging.info("Epoch count: {}.".format(args.num_epochs))
logging.info("Batch size: {}.".format(args.batch_size))
logging.info("Training steps: {} ({}).".format(
args.train_steps,
"supplied" if args.train_size is None else "computed"))
logging.info("Evaluate every {} steps.".format(args.eval_frequency_secs))
# Create the estimator
estimator = model.create(args, run_config)
logging.info("creating an estimator: {}".format(type(estimator)))
# Run the train and evaluate experiment
time_start = datetime.utcnow()
logging.info("Experiment started...")
logging.info(".......................................")
# Run experiment
experiment.run(estimator, args)
time_end = datetime.utcnow()
logging.info(".......................................")
logging.info("Experiment finished.")
time_elapsed = time_end - time_start
logging.info("Experiment elapsed time: {} seconds".format(
time_elapsed.total_seconds()))
def main():
args = get_args()
_setup_logging()
# If job_dir_reuse is False then remove the job_dir if it exists
logging.info("Resume training:", args.reuse_job_dir)
if not args.reuse_job_dir:
if tf.gfile.Exists(args.job_dir):
tf.gfile.DeleteRecursively(args.job_dir)
logging.info("Deleted job_dir {} to avoid re-use".format(args.job_dir))
else:
logging.info("Reusing job_dir {} if it exists".format(args.job_dir))
run_config = experiment.create_run_config(args)
logging.info("Job directory:", run_config.model_dir)
# Compute the number of training steps
if args.train_size is not None and args.num_epochs is not None:
args.train_steps = int(
(args.train_size / args.batch_size) * args.num_epochs)
else:
args.train_steps = args.train_steps
logging.info("Train size: {}.".format(args.train_size))
logging.info("Epoch count: {}.".format(args.num_epochs))
logging.info("Batch size: {}.".format(args.batch_size))
logging.info("Training steps: {} ({}).".format(
args.train_steps, "supplied" if args.train_size is None else "computed"))
logging.info("Evaluate every {} steps.".format(args.eval_frequency_secs))
# Create the estimator
estimator = model.create(args, run_config)
logging.info("creating an estimator: {}".format(type(estimator)))
# Run the train and evaluate experiment
time_start = datetime.utcnow()
logging.info("Experiment started...")
logging.info(".......................................")
# Run experiment
experiment.run(estimator, args)
time_end = datetime.utcnow()
logging.info(".......................................")
logging.info("Experiment finished.")
time_elapsed = time_end - time_start
logging.info(
"Experiment elapsed time: {} seconds".format(time_elapsed.total_seconds()))
def main():
print("Loading models...")
with open(GRAPH_PATH, 'r') as f:
G = pickle.load(f)
with open(ETA_MODEL_PATH, 'r') as f:
eta_model = pickle.load(f)
num_fleets = NUM_FLEETS
geohash_table = pd.read_csv(GEOHASH_TABLE_PATH, index_col='geohash')
env = FleetSimulator(G, eta_model, CYCLE, ACTION_UPDATE_CYCLE)
agent = Agent(geohash_table,
CYCLE,
ACTION_UPDATE_CYCLE,
DEMAND_FORECAST_INTERVAL,
training=True,
load_network=LOAD_NETWORK)
if INITIAL_MEMORY:
with open(INITIAL_MEMORY_PATH, 'r') as f:
ex_memory = pickle.load(f)
agent.init_train(3000, ex_memory)
trip_chunks = load_trip_chunks(TRIP_PATH, NUM_TRIPS,
DURATION)[:NUM_EPISODES]
for episode, (trips, date, dayofweek, minofday) in enumerate(trip_chunks):
# num_fleets = int(np.sqrt(len(trips)/120000.0) * NUM_FLEETS)
env.reset(num_fleets, trips, dayofweek, minofday)
_, requests, _, _, _ = env.step()
agent.reset(requests, env.dayofweek, env.minofday)
num_steps = DURATION / CYCLE - NO_OP_STEPS
print(
"#############################################################################"
)
print(
"EPISODE: {:d} / DATE: {:d} / DAYOFWEEK: {:d} / MINUTES: {:d} / VEHICLES: {:d}"
.format(episode, date, env.dayofweek, env.minofday, num_fleets))
score, _ = run(env,
agent,
num_steps,
average_cycle=AVERAGE_CYCLE,
cheat=True)
describe(score)
score.to_csv(SCORE_PATH + 'score_dqn' + str(episode) + '.csv')
if episode > 0 and episode % 10 == 0:
print("Saving Experience Memory: {:d}").format(episode)
with open(SCORE_PATH + 'ex_memory' + str(episode) + '.pkl',
'wb') as f:
pickle.dump(agent.replay_memory, f)
def main():
print("Loading models...")
with open(GRAPH_PATH, 'r') as f:
G = pickle.load(f)
with open(ETA_MODEL_PATH, 'r') as f:
eta_model = pickle.load(f)
# with open(DEMAND_MODEL_PATH + 'model.json', 'r') as f:
# demand_model = f.read()
# demand_model = model_from_json(demand_model)
# demand_model.load_weights(DEMAND_MODEL_PATH + 'model.h5')
geohash_table = pd.read_csv(GEOHASH_TABLE_PATH, index_col='geohash')
# eta_table = pd.read_csv(ETA_TABLE_PATH, index_col=['dayofweek', 'hour', 'pickup_zone'])
# pdest_table = pd.read_csv(PDEST_TABLE_PATH, index_col=['dayofweek', 'hour', 'pickup_zone'])
env = FleetSimulator(G, eta_model, CYCLE, ACTION_UPDATE_CYCLE)
# agent = Agent(geohash_table, eta_table, pdest_table, demand_model, CYCLE)
agent = Agent(geohash_table,
CYCLE,
ACTION_UPDATE_CYCLE,
30,
training=False,
load_network=True)
trip_chunks = load_trip_eval(TRIP_PATH, NUM_TRIPS)
for episode, (trips, date, dayofweek, minofday) in enumerate(trip_chunks):
env.reset(NUM_FLEETS, trips, dayofweek, minofday)
print(
"#############################################################################"
)
print("EPISODE: {:d} / DATE: {:d} / DAYOFWEEK: {:d} / MINUTES: {:d}".
format(episode, date, env.dayofweek, env.minofday))
score, vscore = run(env,
agent,
NUM_STEPS,
no_op_steps=30,
average_cycle=30)
describe(score)
score.to_csv(SCORE_PATH + 'score' + str(dayofweek) + '.csv',
index=False)
vscore.to_csv(SCORE_PATH + 'vscore' + str(dayofweek) + '.csv',
index=False)
def main():
"""Main function"""
if len(argv) != 5:
parameter_error_and_exit()
try:
board_size = int(argv[1])
start_row = int(argv[2])
start_col = int(argv[3])
generation_max = int(argv[4])
except (ValueError):
parameter_error_and_exit()
print("Running on a {0}x{0} board".format(board_size))
print("With knight starting at ({},{})".format(start_row, start_col))
print("and maximum generations allowed: {}".format(generation_max))
best_path_found = experiment.run(board_size, start_row, start_col,
generation_max)
print("Output: {}".format(best_path_found))
def main():
print("Loading models...")
with open(GRAPH_PATH, 'r') as f:
G = pickle.load(f)
with open(ETA_MODEL_PATH, 'r') as f:
eta_model = pickle.load(f)
geohash_table = pd.read_csv(GEOHASH_TABLE_PATH, index_col='geohash')
env = FleetSimulator(G, eta_model, CYCLE, ACTION_UPDATE_CYCLE)
agent = Agent(geohash_table,
CYCLE,
ACTION_UPDATE_CYCLE,
training=False,
load_netword=True)
trip_chunks = ex.load_trip_eval(TRIP_PATH, NUM_TRIPS,
DURATION)[:NUM_EPISODES]
for episode, (trips, date, dayofweek, minofday) in enumerate(trip_chunks):
if minofday < 60 * 6:
num_fleets = NUM_FLEETS_MN
else:
num_fleets = NUM_FLEETS
env.reset(num_fleets, trips, dayofweek, minofday)
_, requests, _, _, _ = env.step()
for _ in range(NO_OP_STEPS - 1):
_, requests_, _, _, _ = env.step()
requests = requests.append(requests_)
agent.reset(requests, env.dayofweek, env.minofday)
print(
"#############################################################################"
)
print(
"EPISODE: {:d} / DATE: {:d} / DAYOFWEEK: {:d} / MINUTES: {:d} / VEHICLES: {:d}"
.format(episode, date, env.dayofweek, env.minofday, num_fleets))
score = ex.run(env, agent, NUM_STEPS, average_cycle=60)
ex.describe(score)
score.to_csv(SCORE_PATH + 'score_lp' + str(date) + '-' +
str(minofday / 60) + '.csv')
def frq_9():
train_images, train_labels = load_mnist('training',
selection=slice(
0, 500)) # doctest: +SKIP
test_images, test_labels = load_mnist('testing', selection=slice(0, 500))
random.seed(1)
conditions = {"kernel": ["linear", "poly", "rbf"], "C": [0.1, 1, 10]}
results = run(svm.SVC(gamma='auto'), "grid_search", conditions,
train_images, train_labels)
results = sorted(results,
key=lambda result: list(result[0].values())[0],
reverse=True)
print("results: ", results)
# # #build a table in which each row is kernel value, each column is slack value C. we know it's a 3x3 table
for row in range(3):
print_ls = []
for cln in range(3):
element = list(results.pop(0))
for index in range(1, len(element)):
element[index] = round_sig(element[index])
print_ls.append(element)
print(print_ls)
def main():
#aTargetStocks = ["ETR:ADS", "ETR:ALV", "ETR:BAS", "ETR:BEI", "ETR:BMW", "ETR:CBK", "ETR:DAI", "ETR:DB1", "ETR:DBK", "ETR:DPW", "ETR:DTE", "ETR:EOAN", "ETR:FME", "ETR:FRE", "ETR:HEI", "ETR:HEN3", "ETR:IFX", "ETR:LHA", "ETR:LIN", "ETR:MEO", "ETR:MRK", "ETR:MUV2", "ETR:RWE", "ETR:SAP", "ETR:SDF", "ETR:SIE", "ETR:TKA", "ETR:VOW3"]
#inputStream = StockPriceFeatureStream(dataset = StockPriceFeatureStream.DAX30, label = StockPriceFeatureStream.FV, targetStock=aTargetStocks)
#input_stream_pert = InputPerturbatorUnivariateGaussian(input_stream, (0.0,1.0), numberOfNodes)
#numberOfStocks = 300
numberOfNodes = 4
anchorBatchSize = 1
inputStream = DriftStockPrices(nodes = numberOfNodes, driftProb = 0.001, numberOfStocks = None, normalize=True) #driftProb of 0,028 is about once every 8970 examples
epsilon = 0.1
lossFunction = EpsilonInsensitiveLoss(epsilon)
learningRate = 0.000001
lmbda = 0.0001
sigma = 1.0
linearUpdateRule= StochasticGradientDescent(lossFunction, lmbda, learningRate)#PassAggRegression()
linearModel = LinearRegressionModel()
epsilon = 0.001
kernel = GaussianKernel(sigma)
truncOp = Projection(epsilon, kernel)# NoCompression()
kernelModel = KernelRegressionModel(kernel, truncOp)
kernelUpdateRule = KernelStochasticGradientDescent(lossFunction, lmbda, learningRate)
envs = [
#baselines
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
syncOperator = NoSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
syncOperator = NoSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
syncOperator = CentralSyncOperator(),
serial = True),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
syncOperator = CentralSyncOperator(),
serial = True),
#static averaging
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = StaticSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = 2 * anchorBatchSize,
syncOperator = StaticSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = 4*anchorBatchSize,
syncOperator = StaticSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = 8 * anchorBatchSize,
syncOperator = StaticSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = 16 * anchorBatchSize,
syncOperator = StaticSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = 32 * anchorBatchSize,
syncOperator = StaticSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = StaticSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = 2 * anchorBatchSize,
syncOperator = StaticSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = 4*anchorBatchSize,
syncOperator = StaticSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = 8 * anchorBatchSize,
syncOperator = StaticSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = 16 * anchorBatchSize,
syncOperator = StaticSyncOperator()),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = 32 * anchorBatchSize,
syncOperator = StaticSyncOperator()),
#dynamic averaging
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(0.05),),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(0.08),),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(0.1),),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(0.3),),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(0.5),),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = linearUpdateRule,
model = linearModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(1.0),),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(0.05),),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(0.08),),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(0.1),),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(0.3),),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(0.5),),
PredictionEnvironment( numberOfNodes = numberOfNodes,
updateRule = kernelUpdateRule,
model = kernelModel,
batchSizeInMacroRounds = anchorBatchSize,
syncOperator = HedgedDistBaseSync(1.0),),
]
#experiment.runParameterEvaluation(inputStream, envs, numberOfNodes*100)
experiment.run(inputStream, envs, MaxNumberOfExamplesCondition(numberOfNodes*500))
import argparse
import experiment
if __name__ == '__main__':
parser = argparse.ArgumentParser()
# NN
parser.add_argument('--in_channels', type=int, default=3)
parser.add_argument('--n_classes', type=int, default=10)
parser.add_argument('--trained', type=str, default='outputs/garbage_')
parser.add_argument('--slope', type=float, default=0.1)
# train
# parser.add_argument('--lr', type=float, default=2e-4)
parser.add_argument('--lr', type=float, default=1e-3)
# parser.add_argument('--weight_decay', type=float, default=2.5e-5)
parser.add_argument('--epochs', type=int, default=100)
# parser.add_argument('--epochs', type=int, default=512)
parser.add_argument('--batch_size', type=int, default=128)
# parser.add_argument('--betas', type=float, nargs='+', default=(.5, .999))
# misc
parser.add_argument('--device', type=str, default='cuda:0')
parser.add_argument('--n_workers', type=int, default=0)
parser.add_argument('--logdir', type=str, default='outputs/garbage1_')
parser.add_argument('--message', '-m', type=str, default='')
parser.add_argument('--mode',
type=str,
default='s2u',
choices=['m2mm', 's2u'])
args, unknown = parser.parse_known_args()
experiment.run(args)
# with Parallel():
# show(Text("Jubba",loc=(400,300)),duration=1005)
# show(Text("Jubba2",loc=(200,100)),duration=2010)
# with Serial():
# wait(1005)
# show(Text("Wubba",loc=(300,200)),duration=1005)
# show(Text("Wubba2",loc=(300,200)),duration=2010)
# with Serial():
# wait(2010)
# show(Text("Lubba",loc=(500,400)),duration=2010)
for i in range(10):
show(Text(str(i),loc=(400,300)),duration=205)
# run the experiment
run()
### Scratch
# class ShowState(ExpState):
# def __init__(self, items, duration=None,
# update_screen=True, parent=None):
# if not isinstance(items,list):
# items = [items]
# self.items = items
# self.duration = duration
# self.env.render(mode='human')
if FLAGS.random:
action = self.env.action_space.sample()
else:
action = self.agent.act(test=test)
observation, reward, term, info = self.env.step(action)
term = (t >= FLAGS.tmax) or term
r_f = self.env.filter_reward(reward) if FLAGS.autonorm else reward
self.agent.observe(r_f,term,observation,test = test and not FLAGS.tot)
if test:
self.t_test += 1
else:
self.t_train += 1
R += reward
t += 1
return R
def main():
Experiment().run()
if __name__ == '__main__':
experiment.run(main)
action = self.env.action_space.sample()
else:
action = self.agent.act(test=test)
observation, reward, term, info = self.env.step(action)
term = (t >= FLAGS.tmax) or term
r_f = self.env.filter_reward(reward)
self.agent.observe(r_f,
term,
observation,
test=test and not FLAGS.tot)
if test:
self.t_test += 1
else:
self.t_train += 1
R += reward
t += 1
return R
def main():
Experiment().run()
if __name__ == '__main__':
experiment.run(main)
parser.add_argument('--model', type=str, default='convlstm1layer')
parser.add_argument('--kernel_size', type=int, nargs='+', default=(5, 5))
parser.add_argument('--stride', type=int, default=1)
parser.add_argument('--hidden_dims', type=int, nargs='+', default=[16, ])
parser.add_argument('--n_layers', type=int, default=1)
parser.add_argument('--teacher_forcing_ratio', type=float, default=0.)
parser.add_argument('--logit_output', action='store_true', default=False)
# training
parser.add_argument('--epochs', type=int, default=100)
parser.add_argument('--batch_size', type=int, default=128)
parser.add_argument('--device', type=str, default='cuda:0')
parser.add_argument('--loss', type=str, default='loss/reduction')
# optim
parser.add_argument('--optim', type=str, default='adam')
parser.add_argument('--lr', type=float, default=0.001)
parser.add_argument('--betas', nargs='+', type=float, default=(0.9, 0.999))
parser.add_argument('--weight_decay', type=float, default=0.)
parser.add_argument('--rmsprop_alpha', type=float, default=0.99)
parser.add_argument('--scheduler', type=str, default='')
parser.add_argument('--milestones', nargs='+', type=int)
parser.add_argument('--gamma', nargs='+', type=float)
# misc
parser.add_argument('--logdir', type=str, default='./logs')
parser.add_argument('--expid', type=str, default='')
parser.add_argument('--resume', type=str, default=None)
parser.add_argument('--random_seed', type=int, default=42)
parser.add_argument('--debug', action='store_true', default=False)
args, _ = parser.parse_known_args()
run(args)
try:
if args.vmstart == 'initial':
# if configured start all vm's necessary for the whole experiment suite in the beginning
azure_vm.start(n_client=max_n_client,
n_middleware=max_n_middleware,
n_server=max_n_server)
for exp_id in tqdm(exp_ids, desc="suite"):
# ensure necessary vm's for this experiment are started
azure_vm.start(n_client=configs[exp_id]['n_client'],
n_middleware=configs[exp_id]['n_middleware'],
n_server=configs[exp_id]['n_server'])
# run the experiment on the vm's
experiment.run(experiment_suite_id=experiment_suite_id,
experiment_name=exp_id)
# allows to add some additional experiments add the end while already running simulation
with open(f"./configs/additional_names.json") as file:
additional_names = json.load(file)
for exp_id in tqdm(additional_names["exp_names"], desc="suite add"):
# run the experiment on the vm's
experiment.run(experiment_suite_id=experiment_suite_id,
experiment_name=exp_id)
finally:
# Deallocate all VM's
notify = Notify(config.NOTIFY_URL)
notify.send("Experiment Suite Stopped")
def main():
"""Setup / Start the experiment
"""
args = get_args()
experiment.run(args)
def FIDAutocalibrateLarmor_standalone(
init_gpa=False, # Starts the gpa
larmorFreq=3.075, # Larmor frequency (MHz)
rfExAmp=0.3, # RF excitation pulse amplitude (a.u.)
rfReAmp=0, # RF refocusing pulse amplitude (a.u.)
rfExPhase=0, # Phase of the excitation pulse (degrees)
rfExTime=35, # RF excitation pulse time (us)
rfReTime=0, # RF refocusing pulse time (us)
repetitionTime=500, # Repetition time
nReadout=160, # Acquisition points
acqTime=4, # Acquisition time (ms)
shimming=np.array([0, 0, 0
]), # Shimming along the X,Y and Z axes (a.u. *1e4)
dummyPulses=0, # Dummy pulses for T1 stabilization
plotSeq=0):
# Changing units
repetitionTime = repetitionTime * 1e3
acqTime = acqTime * 1e3
shimming = shimming * 1e-4
# Global variables
addRdPoints = 10 # Extra points adquired to prevent bad first adquired points by RP
# Conditions about RF
if rfReAmp == 0:
rfReAmp = 2 * rfExAmp
if rfReTime == 0:
rfReTime = rfExTime
rfExPhase = rfExPhase * np.pi / 180
rfExAmp = rfExAmp * np.exp(1j * rfExPhase)
rfRePhase = np.pi / 2
rfReAmp = rfReAmp * np.exp(1j * rfRePhase)
# Matrix size
nRD = nReadout + 2 * addRdPoints
# SEQUENCE ################################################################
# FID and calibration
acqTimeReal = FIDsequence(larmorFreq, nRD, acqTime, rfExTime, rfExAmp,
repetitionTime, shimming, dummyPulses)
#RP and data analysis
if plotSeq == 1:
ex.plot_sequence()
plt.show()
ex.__del__()
elif plotSeq == 0:
print('Running...')
rxd, msgs = ex.run()
ex.__del__()
print('End')
data = sig.decimate(rxd['rx0'] * 13.788,
conf.oversamplingFactor,
ftype='fir',
zero_phase=True)
# data = data[addRdPoints:nReadout+addRdPoints]
dataPlot(data, acqTimeReal, nRD, addRdPoints, 1)
larmorFreqCal = dataAnalysis(larmorFreq, data, acqTimeReal, nRD,
addRdPoints, 3)
plt.show()
# FID for Larmor frecuency
acqTimeReal = FIDsequence(larmorFreqCal, nRD, acqTime, rfExTime, rfExAmp,
repetitionTime, shimming, dummyPulses)
#RP and plot echo
if plotSeq == 1:
ex.plot_sequence()
plt.show()
ex.__del__()
elif plotSeq == 0:
print('Running...')
rxd, msgs = ex.run()
ex.__del__()
print('End')
data = sig.decimate(rxd['rx0'] * 13.788,
conf.oversamplingFactor,
ftype='fir',
zero_phase=True)
# data = data[addRdPoints:nReadout+addRdPoints]
dataPlot(data, acqTimeReal, nRD, addRdPoints, 4)
plt.show()
from data_sources.linear_log_popularity_data_source import MetaTagExclusiveEarlyToLatePopularityDataSource import experiment experiment.run(MetaTagExclusiveEarlyToLatePopularityDataSource)
from data_sources.linear_log_popularity_data_source import MetaTagAwareEarlyToLatePopularityDataSource import experiment experiment.run(MetaTagAwareEarlyToLatePopularityDataSource)
# with Parallel():
# show(Text("Jubba",loc=(400,300)),duration=1005)
# show(Text("Jubba2",loc=(200,100)),duration=2010)
# with Serial():
# wait(1005)
# show(Text("Wubba",loc=(300,200)),duration=1005)
# show(Text("Wubba2",loc=(300,200)),duration=2010)
# with Serial():
# wait(2010)
# show(Text("Lubba",loc=(500,400)),duration=2010)
for i in range(10):
show(Text(str(i), loc=(400, 300)), duration=205)
# run the experiment
run()
### Scratch
# class ShowState(ExpState):
# def __init__(self, items, duration=None,
# update_screen=True, parent=None):
# if not isinstance(items,list):
# items = [items]
# self.items = items
# self.duration = duration
# self.update_screen = update_screen
# ExpState.__init__(self, parent=parent)
# def onEntry(self, ev):
# self._last_time = now()
def main():
np.random.seed(87655678)
numberOfNodes = 5
dimensionality = 2
inputStream = inputs.xor.XORProblem(nodes=numberOfNodes,
dim=dimensionality)
print "Bayes Optimal Error: ",
print inputStream.computeBayesOptimalError()
lossFunction = SquaredLoss()
learningRate = 0.1
lmbda = 0.0001
sigma = 4.5
kernel = GaussianKernel(sigma)
noModelComp = NoCompression()
modelComp = Projection(0.1, kernel)
linupdateRule = StochasticGradientDescent(lossFunction, lmbda,
learningRate)
updateRule = KernelStochasticGradientDescent(lossFunction, lmbda,
learningRate)
anchorBatchSize = 20
linmodel = LinearClassificationModel()
model = KernelClassificationModel(kernel, noModelComp)
modelComp = KernelClassificationModel(kernel, modelComp)
dnnModel = DNNModel(indim=dimensionality, outdim=1)
envs = [
#baselines
# PredictionEnvironment( numberOfNodes = numberOfNodes,
# updateRule = linupdateRule,
# model = dnnModel,
# batchSizeInMacroRounds = 5000,
# syncOperator = NoSyncOperator()),
# PredictionEnvironment( numberOfNodes = numberOfNodes,
# updateRule = linupdateRule,
# model = dnnModel,
# syncOperator = CentralSyncOperator(),
# serial = True),
# PredictionEnvironment( numberOfNodes = numberOfNodes,
# updateRule = linupdateRule,
# model = dnnModel,
# syncOperator = CentralSyncOperator(),
# serial = False),
# #static averaging
# PredictionEnvironment( numberOfNodes = numberOfNodes,
# updateRule = linupdateRule,
# model = dnnModel,
# batchSizeInMacroRounds = 5000,#50000 was good
# syncOperator = StaticSyncOperator()),
# #dynamic averaging
PredictionEnvironment(
numberOfNodes=numberOfNodes,
updateRule=linupdateRule,
model=dnnModel,
batchSizeInMacroRounds=5000,
syncOperator=HedgedDistBaseSync(1.0),
),
]
#experiment.runParameterEvaluation(inputStream, envs, numberOfNodes*100)
experiment.run(inputStream, envs, MaxNumberOfExamplesCondition(100))
from mnist import load_mnist
import matplotlib.pyplot as plt
from experiment import run
from sklearn import svm
i, t = load_mnist()
"""
image = i[20]
imager = image.reshape((28,28))
plt.imshow(imager,cmap = "Greys")
plt.show()
"""
results = run(svm.SVC(gamma='auto'),
"grid_search",
{"kernel": ["linear", "poly", "rbf"], "degree": [3], "C": [0.1, 1, 10]},
i,
t)
print(results)
