def __init__(
self,
heads: List[str],
lambs: Dict[str, float],
use_uncollapsed: bool,
half_T_side_dense: int,
half_T_side_sparse_min: int,
half_T_side_sparse_max: int,
output_files: Optional[utils.OutputFiles] = None,
do_render: Optional[bool] = None,
render_limit: int = 1,
):
super(IIDLoss, self).__init__(heads=heads)
for head in heads:
if head not in lambs:
lambs[head] = 1.0
if do_render is None:
do_render = False
if do_render:
assert output_files is not None
self._lambs = lambs
self._use_uncollapsed = use_uncollapsed
self._hts_dense = half_T_side_dense
self._hts_sparse_min = half_T_side_sparse_min
self._hts_sparse_max = half_T_side_sparse_max
self._output_files = output_files
self._do_render = do_render
self._counter = utils.Counter(render_limit)
def __init__(self):
self.s = requests.session()
self.poll_s = requests.session()
self.params = {
"daid": "164",
"appid": "1003903",
"js_ver": "10052",
"js_type": "0",
"enable_qlogin": "******",
"aid": "1003903",
"h": "1",
"webqq_type": "10",
"remember_uin": "1",
"login2qq": "1",
"s_url": self.WEBQQ_URL,
"u1": self.WEBQQ_URL + "/loginproxy.html",
"ptredirect": "0",
"ptlang": "2052",
"from_ui": "1",
"pttype": "1",
"dumy": "",
"fp": "loginerroralert",
"t": "1",
"g": "1",
"action": "0-0-4400",
"mibao_css": "m_webqq",
"clientid": str(random.randint(1, 10000000))
}
self.msg_id = utils.Counter()
self.msg_handler = MessageHandler()
self.groups = {}
pass
def __init__(self, conn):
threading.Thread.__init__(self, name="ConnectionCheckAlive")
self.daemon = True
self._connection = conn
self._counter = utils.Counter()
self._connection_keepalive_send = False
self._semaphore = threading.Condition()
def train(self, training_data, training_labels):
"""
The training loop for the perceptron passes through the training data several
times and updates the weight vector for each label based on classification errors.
See the project description for details.
Use the provided self.weights[label] data structure so that
the classify method works correctly. Also, recall that a
datum is a counter from features to values for those features
(and thus represents a vector a values).
"""
errors = []
for iteration in range(self.max_iterations):
print('Starting iteration ', iteration)
err = 0
for i in range(len(training_data)):
vectors = utils.Counter()
for l in self.legal_labels:
vectors[l] = self.weights[l] * training_data[i]
# print('vector', vectors[l])
guess = vectors.argMax()
actual = training_labels[i]
if guess != actual:
self.weights[
guess] = self.weights[guess] - training_data[i]
self.weights[
actual] = self.weights[actual] + training_data[i]
err += 1
errors.append(err)
# utils.raiseNotDefined()
return errors
def __init__(self, legal_labels, max_iterations):
self.legal_labels = legal_labels
self.type = "perceptron"
self.max_iterations = max_iterations
self.weights = {}
for label in legal_labels:
self.weights[label] = utils.Counter(
) # this is the data-structure you should use
def fit_pq(feats_base_init, labels_base_init, item_ix_base_init, num_channels, spatial_feat_dim, num_codebooks,
codebook_size, batch_size=128, counter=utils.Counter()):
"""
Fit the PQ model and then quantize and store the latent codes of the data used to train the PQ in a dictionary to
be used later as a replay buffer.
:param feats_base_init: numpy array of base init features that will be used to train the PQ
:param labels_base_init: numpy array of the base init labels used to train the PQ
:param item_ix_base_init: numpy array of the item_ixs used to train the PQ
:param num_channels: number of channels in desired features
:param spatial_feat_dim: spatial dimension of desired features
:param num_codebooks: number of codebooks for PQ
:param codebook_size: size of each codebook for PQ
:param batch_size: batch size used to extract PQ features
:param counter: object to count how many latent codes are in the replay buffer/dict
:return: (trained PQ object, dictionary of latent codes, list of item_ixs for latent codes, dict of visited classes
and associated item_ixs)
"""
train_data_base_init = np.transpose(feats_base_init, (0, 2, 3, 1))
train_data_base_init = np.reshape(train_data_base_init, (-1, num_channels))
num_samples = len(train_data_base_init)
print('\nTraining Product Quantizer')
start = time.time()
nbits = int(np.log2(codebook_size))
pq = faiss.ProductQuantizer(num_channels, num_codebooks, nbits)
pq.train(train_data_base_init)
print("Completed in {} secs".format(time.time() - start))
del train_data_base_init
print('\nEncoding and Storing Base Init Codes')
start_time = time.time()
latent_dict = {}
class_id_to_item_ix_dict = defaultdict(list)
rehearsal_ixs = []
mb = min(batch_size, num_samples)
for i in range(0, num_samples, mb):
start = i
end = min(start + mb, num_samples)
data_batch = feats_base_init[start:end]
batch_labels = labels_base_init[start:end]
batch_item_ixs = item_ix_base_init[start:end]
data_batch = np.transpose(data_batch, (0, 2, 3, 1))
data_batch = np.reshape(data_batch, (-1, num_channels))
codes = pq.compute_codes(data_batch)
codes = np.reshape(codes, (-1, spatial_feat_dim, spatial_feat_dim, num_codebooks))
# put codes and labels into buffer (dictionary)
for j in range(len(batch_labels)):
ix = int(batch_item_ixs[j])
latent_dict[ix] = [codes[j], batch_labels[j]]
rehearsal_ixs.append(ix)
class_id_to_item_ix_dict[int(batch_labels[j])].append(ix)
counter.update()
print("Completed in {} secs".format(time.time() - start_time))
return pq, latent_dict, rehearsal_ixs, class_id_to_item_ix_dict
def messageObjectToKind(view, messageObject, messageText=None):
"""
This method converts a email message string to
a Chandler C{Mail.MailMessage} object
@param messageObject: A C{email.Message} object representation of a mail message
@type messageObject: C{email.Message}
@return: C{Mail.MailMessage}
"""
assert isinstance(messageObject, Message.Message), \
"messageObject must be a Python email.Message.Message instance"
assert len(messageObject.keys()) > 0, \
"messageObject data is not a valid RFC2882 message"
assert messageText is None or isinstance(messageText, str), \
"messageText can either be a string or None"
m = Mail.MailMessage(view=view)
"""Save the original message text in a text blob"""
if messageText is None:
messageText = messageObject.as_string()
m.rfc2822Message = utils.dataToBinary(m, "rfc2822Message", messageText, \
'message/rfc822', 'bz2')
counter = utils.Counter()
bodyBuffer = []
buf = None
if verbose():
if messageObject.has_key("Message-ID"):
messageId = messageObject["Message-ID"]
else:
messageId = "<Unknown Message>"
buf = ["Message: %s\n-------------------------------" % messageId]
__parsePart(view, messageObject, m, bodyBuffer, counter, buf)
"""If the message has attachments set hasMimeParts to True"""
if len(m.mimeParts) > 0:
m.hasMimeParts = True
body = (constants.LF.join(bodyBuffer)).replace(constants.CR, constants.EMPTY)
m.body = utils.unicodeToText(m, "body", body, indexText=False)
__parseHeaders(view, messageObject, m)
if verbose():
logging.warn("\n\n%s\n\n" % '\n'.join(buf))
return m
class Unit(dict):
"""Class used for all Game Elements (With the exception of heroes, who subclass it).
It's implemented following a Entity-Component Model."""
# Create a counter for each type of game element. Used to assign IDs.
counters = defaultdict(lambda: utils.Counter())
def __init__(self, **kwargs):
super(Unit, self).__init__(**kwargs)
type = kwargs['type'] # Grab type from kwargs, for cleanliness
initial_data = INITIAL_DATA[type] # Get the Unit's INITIAL_DATA
self.update(initial_data) # Set the initial data for the unit
self.update(
kwargs) # Override any data that was in different in the save.
if 'id' not in self: # Define an ID using the next number in the counter if not defined.
self['id'] = "%s-%s" % (type, self.counters[type].next())
def __repr__(self):
"""Represent the unit clearly in debug messages"""
return "<" + self['id'] + ">"
def __eq__(self, other):
"""Units are equal if their IDs are equal regardless of their other keys"""
return self['id'] == other['id']
@property
def abilities(self):
"""Helper method to get the actual ability object for every unit's abilities"""
return [getattr(abilities, ability) for ability in self['abilities']]
def get_action(self, state):
"""For AI controlled actors, find an action by looking through each
ability and seeing if it suggests and action at this time."""
for ability in self.abilities:
action = ability.get_action(self, state)
if action:
return action
return None
def threatened_cells(self, state):
"""Helper method for determining all cells from which this Unit can attack opponents.
This is particularly helpful for the Move action which uses this to find a cells to move towards."""
results = set()
for ability in self.abilities:
if hasattr(ability, "threatened_cells"):
results |= ability.threatened_cells(self, state)
return results
def targets(self, state):
"""Helper method for determining all cells this Unit can Attack at it's next turn."""
results = set()
for ability in self.abilities:
if hasattr(ability, "targets"):
results |= ability.targets(self, state)
return results
def __init__(self, env, training_iterations, testing_iterations, epsilon,
gamma, alpha):
self.env = env
self.training = training_iterations
self.testing = testing_iterations
self.epsilon = epsilon
self.gamma = gamma
self.alpha = alpha
self.QValues = utils.Counter()
self.actions = [i for i in range(self.env.action_space.n)]
def basic_feature2_extractor(self, datum):
"""
Returns a set of pixel features indicating whether
each pixel in the provided datum is white (0) or gray/black (1)
"""
features = utils.Counter()
for x in range(datum.width):
for y in range(datum.height):
features[(x, y)] = datum.get_pixel(x, y)
return features
def register_process(self, req, msgid, message, data):
# When a new process connects they need to acquire new process id
p_id = "P%s" % (guid.generate(), )
processes[p_id] = req
req.type = "CLIENT"
req.name = p_id
pthreads[p_id] = []
pthread_count[p_id] = utils.Counter()
req.send(msgid, ("RESULT_STRING", p_id))
def __init__(self, validation_config):
self._nondet_var_map = None
self.machine_model = validation_config.machine_model
self.config = validation_config
self.witness_creator = wit_gen.WitnessCreator()
self.harness_creator = harness_gen.HarnessCreator()
self.naive_verification = validation_config.naive_verification
# If a void appears in a line, there must be something between
# the void and the __VERIFIER_error() symbol - otherwise
# it is a function definition/declaration.
self.error_method_pattern = re.compile(
'((?!void).)*(void.*\S.*)?__VERIFIER_error\(\) *;.*')
self.statistics = utils.Statistics('Test Validator ' + self.get_name())
self.timer_validation = utils.Stopwatch()
self.statistics.add_value('Time for validation', self.timer_validation)
self.timer_witness_validation = utils.Stopwatch()
self.statistics.add_value('Time for witness validation',
self.timer_witness_validation)
self.counter_size_witnesses = utils.Counter()
self.statistics.add_value('Total size of witnesses',
self.counter_size_witnesses)
self.timer_execution_validation = utils.Stopwatch()
self.statistics.add_value('Time for execution validation',
self.timer_execution_validation)
self.counter_size_harnesses = utils.Counter()
self.statistics.add_value('Total size of harnesses',
self.counter_size_harnesses)
self.timer_vector_gen = utils.Stopwatch()
self.statistics.add_value("Time for test vector generation",
self.timer_vector_gen)
self.counter_handled_test_cases = utils.Counter()
self.statistics.add_value('Number of looked-at test cases',
self.counter_handled_test_cases)
self.final_test_vector_size = utils.Constant()
self.statistics.add_value("Size of successful test vector",
self.final_test_vector_size)
def predict(self, image):
img_a = utils.Counter()
img_a = image
self.distance = list(map(lambda x: (self.face_data.face_train_labels[x[0]], img_a.cosine_distance(x[1])),
enumerate(self.trainingData)))
# sort the list of tuples by distances in increasing order
sorted_dist = (sorted(self.distance, key=lambda x: x[1]))
k_neighbors = sorted_dist[:self.k]
# select k labels
klabels = [label for (label, _) in k_neighbors]
# find the mode of the list
return mode(klabels)
def basic_feature_extractor_digit(self, datum):
"""
Returns a set of pixel features indicating whether
each pixel in the provided datum is white (0) or gray/black (1)
"""
features = utils.Counter()
for x in range(self.DIGIT_DATUM_WIDTH):
for y in range(self.DIGIT_DATUM_HEIGHT):
if datum.get_pixel(x, y) > 0:
features[(x, y)] = 1
else:
features[(x, y)] = 0
return features
def classify(self, data):
"""
Classifies each datum as the label that most closely matches the prototype vector
for that label. See the project description for details.
Recall that a datum is a util.counter...
"""
guesses = []
for datum in data:
vectors = utils.Counter()
for l in self.legal_labels:
vectors[l] = self.weights[l] * datum
guesses.append(vectors.argMax())
return guesses
def __init__(
self,
image_info: utils.ImageInfo,
output_files: Optional[utils.OutputFiles] = None,
do_render: bool = False,
render_limit: int = 1,
):
if do_render:
assert output_files is not None
self._image_info = image_info
self._output = output_files
self._render = do_render
self._counter = utils.Counter(render_limit)
def getDistribution(self, state):
# Read variables from state
ghostState = state.getGhostState(self.index)
legalActions = state.getLegalActions(self.index)
pos = state.getGhostPosition(self.index)
isScared = ghostState.scaredTimer > 0
speed = 1
if isScared: speed = 0.5
actionVectors = [
Actions.directionToVector(a, speed) for a in legalActions
]
newPositions = [(pos[0] + a[0], pos[1] + a[1]) for a in actionVectors]
pacmanPosition = state.getPacmanPosition()
# Select best actions given the state
distancesToPacman = [
manhattanDistance(pos, pacmanPosition) for pos in newPositions
]
if isScared:
bestScore = max(distancesToPacman)
bestProb = self.prob_scaredFlee
else:
bestScore = min(distancesToPacman)
bestProb = self.prob_attack
bestActions = [
action for action, distance in zip(legalActions, distancesToPacman)
if distance == bestScore
]
# Construct distribution
dist = utils.Counter()
for a in bestActions:
dist[a] = bestProb / len(bestActions)
for a in legalActions:
dist[a] += (1 - bestProb) / len(legalActions)
dist.normalize()
return dist
def __init__(self, mdp, testing_iterations, discount=0.99, iterations=100):
self.mdp = mdp
self.testing_iterations = testing_iterations
self.discount = discount
self.iterations = iterations
self.values = util.Counter() # A Counter is a dict with default 0
cache = {} # caches values corresponding to a (state, iteration)
# calculates value of a state at an iteration level
def valueIteration(state, iteration=0):
try:
return cache[state, iteration]
except: # value has not already been computed
actions = self.mdp.getActions()
if actions == [] or self.mdp.isTerminal(state) \
or iteration >= self.iterations:
return 0
maxValue = None
for action in actions:
summation = 0
for nextState, prob in self.mdp.getTransitionStatesAndProbs(
state, action):
summation += prob * (self.mdp.getReward(state, action, nextState) + \
self.discount * valueIteration(nextState, iteration + 1))
if maxValue < summation:
maxValue = summation
cache[state, iteration] = maxValue
return maxValue
for state in self.mdp.getStates():
self.values[state] = valueIteration(state)
def close(self):
bsendclose = False
try:
self._semaphore.acquire()
try:
if not self._close:
self._close = True
bsendclose = True
self._on_data = None
self._on_close = None
self._on_except = None
#print "session send stream close."
finally:
self._semaphore.release()
if bsendclose:
self._send_ws_close()
#Attende lo shutdown
cnt = utils.Counter()
while not self.is_shutdown():
time.sleep(0.2)
if cnt.is_elapsed(10):
break
except:
None
from collections import namedtuple
import yaml
import ids
import utils
InstInfo = namedtuple("InstInfo", [
"name",
"opcode",
"operandCount",
"pushCount",
"popCount",
"isTerminator",
])
_c = utils.Counter()
instInfoByName = {}
instInfoByCode = []
with utils.openCommonFile("opcodes.yaml") as _opcodesFile:
for _opc in yaml.load(_opcodesFile.read()):
_info = InstInfo(_opc["name"], _c(), _opc["iops"], _opc["push"],
_opc["pop"], _opc["term"])
instInfoByName[_opc["name"]] = _info
instInfoByCode.append(_info)
# Instructions and types may have one of the widths below. This number can be added to a base
# instruction like "addi8" to get the appropriate variant.
W8 = 0
W16 = 1
W32 = 2
def main():
# ==========
# Load pre-trained model
# ==========
opts_dict = {
'radius': 3,
'stdf': {
'in_nc': 1,
'out_nc': 64,
'nf': 32,
'nb': 3,
'base_ks': 3,
'deform_ks': 3,
},
'qenet': {
'in_nc': 64,
'out_nc': 1,
'nf': 48,
'nb': 8,
'base_ks': 3,
},
}
model = MFVQE(opts_dict=opts_dict)
msg = f'loading model {ckp_path}...'
print(msg)
checkpoint = torch.load(ckp_path)
if 'module.' in list(checkpoint['state_dict'].keys())[0]: # multi-gpu training
new_state_dict = OrderedDict()
for k, v in checkpoint['state_dict'].items():
name = k[7:] # remove module
new_state_dict[name] = v
model.load_state_dict(new_state_dict)
else: # single-gpu training
model.load_state_dict(checkpoint['state_dict'])
msg = f'> model {ckp_path} loaded.'
print(msg)
model = model.cuda()
model.eval()
# ==========
# Load entire video
# ==========
msg = f'loading raw and low-quality yuv...'
print(msg)
raw_y = utils.import_yuv(
seq_path=raw_yuv_path, h=h, w=w, tot_frm=nfs, start_frm=0, only_y=True
)
lq_y, lq_u, lq_v = utils.import_yuv(
seq_path=lq_yuv_path, h=h, w=w, tot_frm=nfs, start_frm=0, only_y=False
)
raw_y = raw_y.astype(np.float32) / 255.
lq_y = lq_y.astype(np.float32) / 255.
msg = '> yuv loaded.'
print(msg)
# ==========
# Define criterion
# ==========
criterion = utils.PSNR()
unit = 'dB'
# ==========
# Test
# ==========
pbar = tqdm(total=nfs, ncols=80)
ori_psnr_counter = utils.Counter()
enh_psnr_counter = utils.Counter()
for idx in range(nfs):
# load lq
idx_list = list(range(idx-3,idx+4))
idx_list = np.clip(idx_list, 0, nfs-1)
input_data = []
for idx_ in idx_list:
input_data.append(lq_y[idx_])
input_data = torch.from_numpy(np.array(input_data))
input_data = torch.unsqueeze(input_data, 0).cuda()
# enhance
enhanced_frm = model(input_data)
# eval
gt_frm = torch.from_numpy(raw_y[idx]).cuda()
batch_ori = criterion(input_data[0, 3, ...], gt_frm)
batch_perf = criterion(enhanced_frm[0, 0, ...], gt_frm)
ori_psnr_counter.accum(volume=batch_ori)
enh_psnr_counter.accum(volume=batch_perf)
# display
pbar.set_description(
"[{:.3f}] {:s} -> [{:.3f}] {:s}"
.format(batch_ori, unit, batch_perf, unit)
)
pbar.update()
pbar.close()
ori_ = ori_psnr_counter.get_ave()
enh_ = enh_psnr_counter.get_ave()
print('ave ori [{:.3f}] {:s}, enh [{:.3f}] {:s}, delta [{:.3f}] {:s}'.format(
ori_, unit, enh_, unit, (enh_ - ori_) , unit
))
print('> done.')
def main():
# get arguments
args = arguments.args()
# build environment
env = gym.make(args.env_name)
num_observations = env.observation_space.shape[0]
num_actions = env.action_space.shape[0]
# define the global network...
critic_shared_model = models.Critic_Network(num_observations)
critic_shared_model.share_memory()
actor_shared_model = models.Actor_Network(num_observations, num_actions)
actor_shared_model.share_memory()
# define the traffic signal...
traffic_signal = utils.TrafficLight()
# define the counter
critic_counter = utils.Counter()
actor_counter = utils.Counter()
# define the shared gradient buffer...
critic_shared_grad_buffer = utils.Shared_grad_buffers(critic_shared_model)
actor_shared_grad_buffer = utils.Shared_grad_buffers(actor_shared_model)
# define shared observation state...
shared_obs_state = utils.Running_mean_filter(num_observations)
# define shared reward...
shared_reward = utils.RewardCounter()
# define the optimizer...
critic_optimizer = torch.optim.Adam(critic_shared_model.parameters(),
lr=args.value_lr)
actor_optimizer = torch.optim.Adam(actor_shared_model.parameters(),
lr=args.policy_lr)
# prepare multiprocessing
# find how many are available
total_works = mp.cpu_count() - 1
print(f'.....total available process is {total_works}')
num_of_workers = total_works
print(f'.....we set num_of_processes to {num_of_workers}')
processors = []
workers = []
# load model from check point
pass
#
p = mp.Process(target=chief_worker,
args=(num_of_workers, traffic_signal, critic_counter,
actor_counter, critic_shared_model,
actor_shared_model, critic_shared_grad_buffer,
actor_shared_grad_buffer, critic_optimizer,
actor_optimizer, shared_reward, shared_obs_state,
args.policy_update_step, args.env_name))
processors.append(p)
for idx in range(num_of_workers):
workers.append(dppo_workers(args))
for worker in workers:
p = mp.Process(target=worker.train_network,
args=(traffic_signal, critic_counter, actor_counter,
critic_shared_model, actor_shared_model,
shared_obs_state, critic_shared_grad_buffer,
actor_shared_grad_buffer, shared_reward))
processors.append(p)
for p in processors:
p.start()
for p in processors:
p.join()
def main():
# ==========
# parameters
# ==========
opts_dict = receive_arg()
rank = opts_dict['train']['rank']
unit = opts_dict['train']['criterion']['unit']
num_iter = int(opts_dict['train']['num_iter'])
interval_print = int(opts_dict['train']['interval_print'])
interval_val = int(opts_dict['train']['interval_val'])
# ==========
# init distributed training
# ==========
if opts_dict['train']['is_dist']:
utils.init_dist(
local_rank=rank,
backend='nccl'
)
# TO-DO: load resume states if exists
pass
# ==========
# create logger
# ==========
if rank == 0:
log_dir = op.join("exp", opts_dict['train']['exp_name'])
utils.mkdir(log_dir)
log_fp = open(opts_dict['train']['log_path'], 'w')
# log all parameters
msg = (
f"{'<' * 10} Hello {'>' * 10}\n"
f"Timestamp: [{utils.get_timestr()}]\n"
f"\n{'<' * 10} Options {'>' * 10}\n"
f"{utils.dict2str(opts_dict)}"
)
print(msg)
log_fp.write(msg + '\n')
log_fp.flush()
# ==========
# TO-DO: init tensorboard
# ==========
pass
# ==========
# fix random seed
# ==========
seed = opts_dict['train']['random_seed']
# >I don't know why should rs + rank
utils.set_random_seed(seed + rank)
# ==========
# Ensure reproducibility or Speed up
# ==========
#torch.backends.cudnn.benchmark = False # if reproduce
#torch.backends.cudnn.deterministic = True # if reproduce
torch.backends.cudnn.benchmark = True # speed up
# ==========
# create train and val data prefetchers
# ==========
# create datasets
train_ds_type = opts_dict['dataset']['train']['type']
val_ds_type = opts_dict['dataset']['val']['type']
radius = opts_dict['network']['radius']
assert train_ds_type in dataset.__all__, \
"Not implemented!"
assert val_ds_type in dataset.__all__, \
"Not implemented!"
train_ds_cls = getattr(dataset, train_ds_type)
val_ds_cls = getattr(dataset, val_ds_type)
train_ds = train_ds_cls(
opts_dict=opts_dict['dataset']['train'],
radius=radius
)
val_ds = val_ds_cls(
opts_dict=opts_dict['dataset']['val'],
radius=radius
)
# create datasamplers
train_sampler = utils.DistSampler(
dataset=train_ds,
num_replicas=opts_dict['train']['num_gpu'],
rank=rank,
ratio=opts_dict['dataset']['train']['enlarge_ratio']
)
val_sampler = None # no need to sample val data
# create dataloaders
train_loader = utils.create_dataloader(
dataset=train_ds,
opts_dict=opts_dict,
sampler=train_sampler,
phase='train',
seed=opts_dict['train']['random_seed']
)
val_loader = utils.create_dataloader(
dataset=val_ds,
opts_dict=opts_dict,
sampler=val_sampler,
phase='val'
)
assert train_loader is not None
batch_size = opts_dict['dataset']['train']['batch_size_per_gpu'] * \
opts_dict['train']['num_gpu'] # divided by all GPUs
num_iter_per_epoch = math.ceil(len(train_ds) * \
opts_dict['dataset']['train']['enlarge_ratio'] / batch_size)
num_epoch = math.ceil(num_iter / num_iter_per_epoch)
val_num = len(val_ds)
# create dataloader prefetchers
tra_prefetcher = utils.CPUPrefetcher(train_loader)
val_prefetcher = utils.CPUPrefetcher(val_loader)
# ==========
# create model
# ==========
model = MFVQE(opts_dict=opts_dict['network'])
model = model.to(rank)
if opts_dict['train']['is_dist']:
model = DDP(model, device_ids=[rank])
"""
# load pre-trained generator
ckp_path = opts_dict['network']['stdf']['load_path']
checkpoint = torch.load(ckp_path)
state_dict = checkpoint['state_dict']
if ('module.' in list(state_dict.keys())[0]) and (not opts_dict['train']['is_dist']): # multi-gpu pre-trained -> single-gpu training
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k[7:] # remove module
new_state_dict[name] = v
model.load_state_dict(new_state_dict)
print(f'loaded from {ckp_path}')
elif ('module.' not in list(state_dict.keys())[0]) and (opts_dict['train']['is_dist']): # single-gpu pre-trained -> multi-gpu training
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = 'module.' + k # add module
new_state_dict[name] = v
model.load_state_dict(new_state_dict)
print(f'loaded from {ckp_path}')
else: # the same way of training
model.load_state_dict(state_dict)
print(f'loaded from {ckp_path}')
"""
# ==========
# define loss func & optimizer & scheduler & scheduler & criterion
# ==========
# define loss func
assert opts_dict['train']['loss'].pop('type') == 'CharbonnierLoss', \
"Not implemented."
loss_func = utils.CharbonnierLoss(**opts_dict['train']['loss'])
# define optimizer
assert opts_dict['train']['optim'].pop('type') == 'Adam', \
"Not implemented."
optimizer = optim.Adam(
model.parameters(),
**opts_dict['train']['optim']
)
# define scheduler
if opts_dict['train']['scheduler']['is_on']:
assert opts_dict['train']['scheduler'].pop('type') == \
'CosineAnnealingRestartLR', "Not implemented."
del opts_dict['train']['scheduler']['is_on']
scheduler = utils.CosineAnnealingRestartLR(
optimizer,
**opts_dict['train']['scheduler']
)
opts_dict['train']['scheduler']['is_on'] = True
# define criterion
assert opts_dict['train']['criterion'].pop('type') == \
'PSNR', "Not implemented."
criterion = utils.PSNR()
#
start_iter = 0 # should be restored
start_epoch = start_iter // num_iter_per_epoch
# display and log
if rank == 0:
msg = (
f"\n{'<' * 10} Dataloader {'>' * 10}\n"
f"total iters: [{num_iter}]\n"
f"total epochs: [{num_epoch}]\n"
f"iter per epoch: [{num_iter_per_epoch}]\n"
f"val sequence: [{val_num}]\n"
f"start from iter: [{start_iter}]\n"
f"start from epoch: [{start_epoch}]"
)
print(msg)
log_fp.write(msg + '\n')
log_fp.flush()
# ==========
# evaluate original performance, e.g., PSNR before enhancement
# ==========
vid_num = val_ds.get_vid_num()
if opts_dict['train']['pre-val'] and rank == 0:
msg = f"\n{'<' * 10} Pre-evaluation {'>' * 10}"
print(msg)
log_fp.write(msg + '\n')
per_aver_dict = {}
for i in range(vid_num):
per_aver_dict[i] = utils.Counter()
pbar = tqdm(
total=val_num,
ncols=opts_dict['train']['pbar_len']
)
# fetch the first batch
val_prefetcher.reset()
val_data = val_prefetcher.next()
while val_data is not None:
# get data
gt_data = val_data['gt'].to(rank) # (B [RGB] H W)
lq_data = val_data['lq'].to(rank) # (B T [RGB] H W)
index_vid = val_data['index_vid'].item()
name_vid = val_data['name_vid'][0] # bs must be 1!
b, _, _, _, _ = lq_data.shape
# eval
batch_perf = np.mean(
[criterion(lq_data[i,radius,...], gt_data[i]) for i in range(b)]
) # bs must be 1!
# log
per_aver_dict[index_vid].accum(volume=batch_perf)
# display
pbar.set_description(
"{:s}: [{:.3f}] {:s}".format(name_vid, batch_perf, unit)
)
pbar.update()
# fetch next batch
val_data = val_prefetcher.next()
pbar.close()
# log
ave_performance = np.mean([
per_aver_dict[index_vid].get_ave() for index_vid in range(vid_num)
])
msg = "> ori performance: [{:.3f}] {:s}".format(ave_performance, unit)
print(msg)
log_fp.write(msg + '\n')
log_fp.flush()
if opts_dict['train']['is_dist']:
torch.distributed.barrier() # all processes wait for ending
if rank == 0:
msg = f"\n{'<' * 10} Training {'>' * 10}"
print(msg)
log_fp.write(msg + '\n')
# create timer
total_timer = utils.Timer() # total tra + val time of each epoch
# ==========
# start training + validation (test)
# ==========
model.train()
num_iter_accum = start_iter
for current_epoch in range(start_epoch, num_epoch + 1):
# shuffle distributed subsamplers before each epoch
if opts_dict['train']['is_dist']:
train_sampler.set_epoch(current_epoch)
# fetch the first batch
tra_prefetcher.reset()
train_data = tra_prefetcher.next()
# train this epoch
while train_data is not None:
# over sign
num_iter_accum += 1
if num_iter_accum > num_iter:
break
# get data
gt_data = train_data['gt'].to(rank) # (B [RGB] H W)
lq_data = train_data['lq'].to(rank) # (B T [RGB] H W)
b, _, c, _, _ = lq_data.shape
input_data = torch.cat(
[lq_data[:,:,i,...] for i in range(c)],
dim=1
) # B [R1 ... R7 G1 ... G7 B1 ... B7] H W
enhanced_data = model(input_data)
# get loss
optimizer.zero_grad() # zero grad
loss = torch.mean(torch.stack(
[loss_func(enhanced_data[i], gt_data[i]) for i in range(b)]
)) # cal loss
loss.backward() # cal grad
optimizer.step() # update parameters
# update learning rate
if opts_dict['train']['scheduler']['is_on']:
scheduler.step() # should after optimizer.step()
if (num_iter_accum % interval_print == 0) and (rank == 0):
# display & log
lr = optimizer.param_groups[0]['lr']
loss_item = loss.item()
msg = (
f"iter: [{num_iter_accum}]/{num_iter}, "
f"epoch: [{current_epoch}]/{num_epoch - 1}, "
"lr: [{:.3f}]x1e-4, loss: [{:.4f}]".format(
lr*1e4, loss_item
)
)
print(msg)
log_fp.write(msg + '\n')
if ((num_iter_accum % interval_val == 0) or \
(num_iter_accum == num_iter)) and (rank == 0):
# save model
checkpoint_save_path = (
f"{opts_dict['train']['checkpoint_save_path_pre']}"
f"{num_iter_accum}"
".pt"
)
state = {
'num_iter_accum': num_iter_accum,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
}
if opts_dict['train']['scheduler']['is_on']:
state['scheduler'] = scheduler.state_dict()
torch.save(state, checkpoint_save_path)
# validation
with torch.no_grad():
per_aver_dict = {}
for index_vid in range(vid_num):
per_aver_dict[index_vid] = utils.Counter()
pbar = tqdm(
total=val_num,
ncols=opts_dict['train']['pbar_len']
)
# train -> eval
model.eval()
# fetch the first batch
val_prefetcher.reset()
val_data = val_prefetcher.next()
while val_data is not None:
# get data
gt_data = val_data['gt'].to(rank) # (B [RGB] H W)
lq_data = val_data['lq'].to(rank) # (B T [RGB] H W)
index_vid = val_data['index_vid'].item()
name_vid = val_data['name_vid'][0] # bs must be 1!
b, _, c, _, _ = lq_data.shape
input_data = torch.cat(
[lq_data[:,:,i,...] for i in range(c)],
dim=1
) # B [R1 ... R7 G1 ... G7 B1 ... B7] H W
enhanced_data = model(input_data) # (B [RGB] H W)
# eval
batch_perf = np.mean(
[criterion(enhanced_data[i], gt_data[i]) for i in range(b)]
) # bs must be 1!
# display
pbar.set_description(
"{:s}: [{:.3f}] {:s}"
.format(name_vid, batch_perf, unit)
)
pbar.update()
# log
per_aver_dict[index_vid].accum(volume=batch_perf)
# fetch next batch
val_data = val_prefetcher.next()
# end of val
pbar.close()
# eval -> train
model.train()
# log
ave_per = np.mean([
per_aver_dict[index_vid].get_ave() for index_vid in range(vid_num)
])
msg = (
"> model saved at {:s}\n"
"> ave val per: [{:.3f}] {:s}"
).format(
checkpoint_save_path, ave_per, unit
)
print(msg)
log_fp.write(msg + '\n')
log_fp.flush()
if opts_dict['train']['is_dist']:
torch.distributed.barrier() # all processes wait for ending
# fetch next batch
train_data = tra_prefetcher.next()
# end of this epoch (training dataloader exhausted)
# end of all epochs
# ==========
# final log & close logger
# ==========
if rank == 0:
total_time = total_timer.get_interval() / 3600
msg = "TOTAL TIME: [{:.1f}] h".format(total_time)
print(msg)
log_fp.write(msg + '\n')
msg = (
f"\n{'<' * 10} Goodbye {'>' * 10}\n"
f"Timestamp: [{utils.get_timestr()}]"
)
print(msg)
log_fp.write(msg + '\n')
log_fp.close()
act_net = networks.LinearNetwork(inputs=state_dim,
outputs=act_dim,
n_hidden_layers=3,
n_hidden_units=128)
shared_model = networks.DiscreteActorCriticSplit(actor=act_net,
critic=value_net,
add_softmax=True)
shared_average_model = copy.deepcopy(shared_model)
shared_average_model.no_grads(
) # Set requires_grad to false for all parameters
shared_model.share_memory()
shared_average_model.share_memory()
shared_opt = optimizers.SharedAdam(shared_model.parameters(), lr=args.lr)
# Create shared variables
shared_counter = utils.Counter()
shared_model_lock = mp.Lock() if not args.no_lock else None
summary_queue = mp.Queue()
processes = []
workers = []
for i in range(args.num_workers):
w = worker.Worker(worker_id=i,
env_name=args.env_name,
n_steps=args.worker_steps,
max_steps=args.t_max,
shared_model=shared_model,
shared_avg_model=shared_average_model,
shared_optimizer=shared_opt,
shared_counter=shared_counter,
df=args.discount,
def getDistribution(self, state):
dist = utils.Counter()
for a in state.getLegalActions(self.index):
dist[a] = 1.0
dist.normalize()
return dist
def td_cap(self,
tdc_params: Dict[str, Any],
update_snap: bool = True) -> Tuple[Any]:
"""Performs a capacitive touchdown.
Args:
tdc_params: Dict of capacitive touchdown parameters as defined
in measurement configuration file.
update_snap: Whether to update the microscope snapshot. Default True.
(You may want this to be False when getting a plane or approaching.)
Returns:
Tuple[qcodes.DataSet, plots.TDCPlot]: data, tdc_plot
DataSet and plot generated by the touchdown Loop.
"""
old_pos = self.scanner.position()
constants = tdc_params['constants']
daq_config = self.config['instruments']['daq']
daq_name = daq_config['name']
ai_channels = daq_config['channels']['analog_inputs']
meas_channels = tdc_params['channels']
channels = {}
for ch in meas_channels:
channels.update({ch: ai_channels[ch]})
nchannels = len(channels.keys())
daq_rate = self.Q_(daq_config['rate']).to('Hz').magnitude / nchannels
self.set_lockins(tdc_params)
self.snapshot(update=update_snap)
#: z position voltage step
dV = self.Q_(tdc_params['dV']).to('V').magnitude
#: Start and end z position voltages
startV, endV = sorted(
[self.Q_(lim).to('V').magnitude for lim in tdc_params['range']])
delay = constants['wait_factor'] * max(
self.CAP_lockin.time_constant(), self.SUSC_lockin.time_constant())
prefactors = self.get_prefactors(tdc_params)
#: get channel prefactors in string form so they can be saved in metadata
prefactor_strs = {}
for ch, prefac in prefactors.items():
unit = tdc_params['channels'][ch]['unit']
pre = prefac.to('{}/V'.format(unit))
prefactor_strs.update(
{ch: '{} {}'.format(pre.magnitude, pre.units)})
ai_task = nidaqmx.Task('td_cap_ai_task')
self.remove_component('daq_ai')
if hasattr(self, 'daq_ai'):
#self.daq_ai.clear_instances()
self.daq_ai.close()
self.daq_ai = DAQAnalogInputs('daq_ai', daq_name, daq_rate, channels,
ai_task)
loop_counter = utils.Counter()
tdc_plot = TDCPlot(tdc_params, self.ureg)
loop = qc.Loop(self.scanner.position_z.sweep(startV, endV, dV)).each(
qc.Task(time.sleep, delay), self.daq_ai.voltage,
qc.Task(self.scanner.check_for_td, tdc_plot,
qc.loops.active_data_set, loop_counter),
qc.Task(self.scanner.get_td_height, tdc_plot),
qc.BreakIf(lambda scanner=self.scanner: scanner.break_loop or
scanner.td_has_occurred), qc.Task(loop_counter.advance)
).then(
qc
.Task(ai_task.stop),
qc.
Task(ai_task.close
),
#qc.Task(self.CAP_lockin.amplitude, 0.004),
#qc.Task(self.SUSC_lockin.amplitude, 0.004),
qc.Task(self.scanner.retract),
qc.Task(tdc_plot.fig.show),
qc.Task(tdc_plot.save))
#: loop.metadata will be saved in DataSet
loop.metadata.update(tdc_params)
loop.metadata.update({'prefactors': prefactor_strs})
for idx, ch in enumerate(meas_channels):
loop.metadata['channels'][ch].update({'idx': idx})
data = loop.get_data_set(name=tdc_params['fname'], write_period=None)
try:
log.info('Starting capacitive touchdown.')
loop.run()
if self.scanner.td_height is not None:
data.metadata['loop']['metadata'].update(
{'td_height': self.scanner.td_height})
if abs(old_pos[0]) < 0.01 and abs(old_pos[1]) < 0.01:
self.scanner.metadata['plane'].update(
{'z': self.scanner.td_height})
except KeyboardInterrupt:
log.warning(
'Touchdown interrupted by user. Retracting scanner. DataSet saved to {}.'
.format(data.location))
#: Set break_loop = True so that get_plane() and approach() will be aborted
self.scanner.break_loop = True
finally:
try:
#: Stop 'td_cap_ai_task' so that we can read our current position
ai_task.stop()
ai_task.close()
self.scanner.retract()
#self.CAP_lockin.amplitude(0.004)
tdc_plot.fig.show()
tdc_plot.save()
except:
pass
utils.td_to_mat_file(data, real_units=True)
return data, tdc_plot
def fit_incremental_batch(self,
curr_loader,
latent_dict,
pq,
rehearsal_ixs=None,
class_id_to_item_ix_dict=None,
verbose=True,
counter=utils.Counter()):
"""
Fit REMIND on samples from a data loader one at a time.
:param curr_loader: the data loader of new samples to be fit (returns (images, labels, item_ixs)
:param latent_dict: dictionary containing latent codes for replay samples
:param pq: trained PQ object for decoding latent codes
:param rehearsal_ixs: list of item_ixs eligible for replay
:param class_id_to_item_ix_dict: dictionary of visited classes with associated item_ixs visited
:param verbose: true for printing loss to console
:param counter: object to track how many samples are in buffer
:return: None
"""
ongoing_class = None
# put classifiers on GPU and set plastic portion of network to train
classifier_F = self.classifier_F.cuda()
classifier_F.train()
classifier_G = self.classifier_G.cuda()
classifier_G.eval()
criterion = nn.CrossEntropyLoss(reduction='none')
msg = '\rSample %d -- train_loss=%1.6f -- elapsed_time=%d secs'
start_time = time.time()
total_loss = utils.CMA()
c = 0
for batch_images, batch_labels, batch_item_ixs in curr_loader:
# get features from G and latent codes from PQ
data_batch = classifier_G(batch_images.cuda()).cpu().numpy()
data_batch = np.transpose(data_batch, (0, 2, 3, 1))
data_batch = np.reshape(data_batch, (-1, self.num_channels))
codes = pq.compute_codes(data_batch)
codes = np.reshape(
codes,
(-1, self.num_feats, self.num_feats, self.num_codebooks))
# train REMIND on one new sample at a time
for x, y, item_ix in zip(codes, batch_labels, batch_item_ixs):
if self.lr_mode == 'step_lr_per_class' and (
ongoing_class is None or ongoing_class != y):
ongoing_class = y
if self.use_mixup:
# gather two batches of previous data for mixup and replay
data_codes = np.empty(
(2 * self.num_samples + 1, self.num_feats,
self.num_feats, self.num_codebooks),
dtype=np.uint8)
data_labels = torch.empty((2 * self.num_samples + 1),
dtype=torch.int).cuda()
data_codes[0] = x
data_labels[0] = y
ixs = randint(len(rehearsal_ixs), 2 * self.num_samples)
ixs = [rehearsal_ixs[_curr_ix] for _curr_ix in ixs]
for ii, v in enumerate(ixs):
data_codes[ii + 1] = latent_dict[v][0]
data_labels[ii + 1] = torch.from_numpy(
latent_dict[v][1])
# reconstruct/decode samples with PQ
data_codes = np.reshape(
data_codes,
((2 * self.num_samples + 1) * self.num_feats *
self.num_feats, self.num_codebooks))
data_batch_reconstructed = pq.decode(data_codes)
data_batch_reconstructed = np.reshape(
data_batch_reconstructed,
(-1, self.num_feats, self.num_feats,
self.num_channels))
data_batch_reconstructed = torch.from_numpy(
np.transpose(data_batch_reconstructed,
(0, 3, 1, 2))).cuda()
# perform random resize crop augmentation on each tensor
if self.use_random_resize_crops:
transform_data_batch = torch.empty_like(
data_batch_reconstructed)
for tens_ix, tens in enumerate(
data_batch_reconstructed):
transform_data_batch[
tens_ix] = self.random_resize_crop(tens)
data_batch_reconstructed = transform_data_batch
# MIXUP: Do mixup between two batches of previous data
x_prev_mixed, prev_labels_a, prev_labels_b, lam = self.mixup_data(
data_batch_reconstructed[1:1 + self.num_samples],
data_labels[1:1 + self.num_samples],
data_batch_reconstructed[1 + self.num_samples:],
data_labels[1 + self.num_samples:],
alpha=self.mixup_alpha)
data = torch.empty(
(self.num_samples + 1, self.num_channels,
self.num_feats, self.num_feats))
data[0] = data_batch_reconstructed[0]
data[1:] = x_prev_mixed.clone()
labels_a = torch.zeros(self.num_samples + 1).long()
labels_b = torch.zeros(self.num_samples + 1).long()
labels_a[0] = y.squeeze()
labels_b[0] = y.squeeze()
labels_a[1:] = prev_labels_a
labels_b[1:] = prev_labels_b
# fit on replay mini-batch plus new sample
output = classifier_F(data.cuda())
loss = self.mixup_criterion(criterion, output,
labels_a.cuda(),
labels_b.cuda(), lam)
else:
# gather previous data for replay
data_codes = np.empty(
(self.num_samples + 1, self.num_feats, self.num_feats,
self.num_codebooks),
dtype=np.uint8)
data_labels = torch.empty((self.num_samples + 1),
dtype=torch.long).cuda()
data_codes[0] = x
data_labels[0] = y
ixs = randint(len(rehearsal_ixs), self.num_samples)
ixs = [rehearsal_ixs[_curr_ix] for _curr_ix in ixs]
for ii, v in enumerate(ixs):
data_codes[ii + 1] = latent_dict[v][0]
data_labels[ii + 1] = torch.from_numpy(
latent_dict[v][1])
# reconstruct/decode samples with PQ
data_codes = np.reshape(
data_codes, ((self.num_samples + 1) * self.num_feats *
self.num_feats, self.num_codebooks))
data_batch_reconstructed = pq.decode(data_codes)
data_batch_reconstructed = np.reshape(
data_batch_reconstructed,
(-1, self.num_feats, self.num_feats,
self.num_channels))
data_batch_reconstructed = torch.from_numpy(
np.transpose(data_batch_reconstructed,
(0, 3, 1, 2))).cuda()
# perform random resize crop augmentation on each tensor
if self.use_random_resize_crops:
transform_data_batch = torch.empty_like(
data_batch_reconstructed)
for tens_ix, tens in enumerate(
data_batch_reconstructed):
transform_data_batch[
tens_ix] = self.random_resize_crop(tens)
data_batch_reconstructed = transform_data_batch
# fit on replay mini-batch plus new sample
output = classifier_F(data_batch_reconstructed)
loss = criterion(output, data_labels)
loss = loss.mean()
self.optimizer.zero_grad(
) # zero out grads before backward pass because they are accumulated
loss.backward()
# if gradient clipping is desired
if self.grad_clip is not None:
nn.utils.clip_grad_norm_(classifier_F.parameters(),
self.grad_clip)
self.optimizer.step()
total_loss.update(loss.item())
if verbose:
print(msg % (c, total_loss.avg, time.time() - start_time),
end="")
c += 1
# since we have visited item_ix, it is now eligible for replay
rehearsal_ixs.append(int(item_ix.numpy()))
latent_dict[int(item_ix.numpy())] = [x, y.numpy()]
class_id_to_item_ix_dict[int(y.numpy())].append(
int(item_ix.numpy()))
# if buffer is full, randomly replace previous example from class with most samples
if self.max_buffer_size is not None and counter.count >= self.max_buffer_size:
# class with most samples and random item_ix from it
max_key = max(
class_id_to_item_ix_dict,
key=lambda x: len(class_id_to_item_ix_dict[x]))
max_class_list = class_id_to_item_ix_dict[max_key]
rand_item_ix = random.choice(max_class_list)
# remove the random_item_ix from all buffer references
max_class_list.remove(rand_item_ix)
latent_dict.pop(rand_item_ix)
rehearsal_ixs.remove(rand_item_ix)
else:
counter.update()
# update lr scheduler
if self.lr_scheduler_per_class is not None:
self.lr_scheduler_per_class[int(y)].step()
def scan_surface(self, scan_params: Dict[str, Any]) -> None:
"""
Scan the current surface while acquiring data in the channels defined in
measurement configuration file (e.g. MAG, SUSCX, SUSCY, CAP).
Args:
scan_params: Dict of scan parameters as defined
in measuremnt configuration file.
Returns:
None
"""
if not self.atto.surface_is_current:
raise RuntimeError('Surface is not current. Aborting scan.')
surface_type = scan_params['surface_type'].lower()
if surface_type not in ['plane', 'surface']:
raise ValueError('surface_type must be "plane" or "surface".')
old_pos = self.scanner.position()
daq_config = self.config['instruments']['daq']
ao_channels = daq_config['channels']['analog_outputs']
ai_channels = daq_config['channels']['analog_inputs']
meas_channels = scan_params['channels']
channels = {}
for ch in meas_channels:
channels.update({ch: ai_channels[ch]})
nchannels = len(channels.keys())
daq_name = daq_config['name']
#: DAQ AI sampling rate is divided amongst all active AI channels
daq_rate = self.Q_(daq_config['rate']).to('Hz').magnitude / nchannels
fast_ax = scan_params['fast_ax'].lower()
slow_ax = 'x' if fast_ax == 'y' else 'y'
pix_per_line = scan_params['scan_size'][fast_ax]
line_duration = pix_per_line * self.ureg('pixels') / self.Q_(
scan_params['scan_rate'])
pts_per_line = int(daq_rate * line_duration.to('s').magnitude)
height = self.Q_(scan_params['height']).to('V').magnitude
if 1 / self.Q_(scan_params['scan_rate']).to(
'pixels/s').magnitude < self.SUSC_lockin.time_constant():
warning = 'Averaging time per pixel is less than the SUSC_lockin time constant. '
warning += 'For reliable susceptibility data, averaging time per pixel should be '
warning += 'significantly greater than the SUSC_lockin time constant.'
log.warning(warning)
scan_vectors = utils.make_scan_vectors(scan_params, self.ureg)
#scan_grids = utils.make_scan_grids(scan_vectors, slow_ax, fast_ax,
# pts_per_line, plane, height)
plane = self.scanner.metadata['plane']
if surface_type == 'plane':
scan_grids = utils.make_scan_surface(surface_type, scan_vectors,
slow_ax, fast_ax,
pts_per_line, plane, height)
else:
scan_grids = utils.make_scan_surface(
surface_type,
scan_vectors,
slow_ax,
fast_ax,
pts_per_line,
plane,
height,
interpolator=self.scanner.surface_interp)
utils.validate_scan_params(self.scanner.metadata, scan_params,
scan_grids, pix_per_line, pts_per_line,
self.temp, self.ureg, log)
self.scanner.goto([scan_grids[axis][0][0] for axis in ['x', 'y', 'z']])
self.set_lockins(scan_params)
#: get channel prefactors in pint Quantity form
prefactors = self.get_prefactors(scan_params)
#: get channel prefactors in string form so they can be saved in metadata
prefactor_strs = {}
for ch, prefac in prefactors.items():
unit = scan_params['channels'][ch]['unit']
pre = prefac.to('{}/V'.format(unit))
prefactor_strs.update(
{ch: '{} {}'.format(pre.magnitude, pre.units)})
ai_task = nidaqmx.Task('scan_plane_ai_task')
self.remove_component('daq_ai')
if hasattr(self, 'daq_ai'):
#self.daq_ai.clear_instances()
self.daq_ai.close()
self.daq_ai = DAQAnalogInputs(
'daq_ai',
daq_name,
daq_rate,
channels,
ai_task,
samples_to_read=pts_per_line,
target_points=pix_per_line,
#: Very important to synchronize AOs and AIs
clock_src='ao/SampleClock')
self.add_component(self.daq_ai)
slow_ax_position = getattr(self.scanner, 'position_{}'.format(slow_ax))
slow_ax_start = scan_vectors[slow_ax][0]
slow_ax_end = scan_vectors[slow_ax][-1]
slow_ax_step = scan_vectors[slow_ax][1] - scan_vectors[slow_ax][0]
#: There is probably a counter built in to qc.Loop, but I couldn't find it
loop_counter = utils.Counter()
scan_plot = ScanPlot(scan_params, self.ureg)
loop = qc.Loop(
slow_ax_position.sweep(start=slow_ax_start,
stop=slow_ax_end,
step=slow_ax_step),
delay=0.1
).each(
#: Create AO task and queue data to be written to AOs
qc.Task(self.scanner.scan_line, scan_grids, ao_channels, daq_rate,
loop_counter),
#: Start AI task; acquisition won't start until AO task is started
qc.Task(ai_task.start),
#: Start AO task
qc.Task(self.scanner.control_ao_task, 'start'),
#: Acquire voltage from all active AI channels
self.daq_ai.voltage,
qc.Task(ai_task.wait_until_done),
qc.Task(self.scanner.control_ao_task, 'wait_until_done'),
qc.Task(ai_task.stop),
#: Stop and close AO task so that AOs can be used for goto
qc.Task(self.scanner.control_ao_task, 'stop'),
qc.Task(self.scanner.control_ao_task, 'close'),
qc.Task(self.scanner.goto_start_of_next_line, scan_grids,
loop_counter),
#: Update and save plot
qc.Task(scan_plot.update, qc.loops.active_data_set, loop_counter),
qc.Task(scan_plot.save),
qc.Task(loop_counter.advance)
).then(
qc.Task(ai_task.stop),
qc.Task(ai_task.close),
qc.Task(self.daq_ai.close),
#qc.Task(self.daq_ai.clear_instances),
qc.Task(self.scanner.goto, old_pos),
#qc.Task(self.CAP_lockin.amplitude, 0.004),
#qc.Task(self.SUSC_lockin.amplitude, 0.004)
)
#: loop.metadata will be saved in DataSet
loop.metadata.update(scan_params)
loop.metadata.update({'prefactors': prefactor_strs})
for idx, ch in enumerate(meas_channels):
loop.metadata['channels'][ch].update({'idx': idx})
data = loop.get_data_set(name=scan_params['fname'])
#: Run the loop
try:
loop.run()
log.info('Scan completed. DataSet saved to {}.'.format(
data.location))
#: If loop is aborted by user:
except KeyboardInterrupt:
log.warning(
'Scan aborted by user. Going to [0,0,0] V. DataSet saved to {}.'
.format(data.location))
finally:
try:
#: Stop 'scan_plane_ai_task' so that we can read our current position
ai_task.stop()
ai_task.close()
#: If there's an active AO task, close it so that we can use goto
self.scanner.control_ao_task('stop')
self.scanner.control_ao_task('close')
self.remove_component('daq_ai')
except:
pass
self.scanner.goto([0, 0, 0])
#self.CAP_lockin.amplitude(0.004)
#self.SUSC_lockin.amplitude(0.004)
utils.scan_to_mat_file(data,
real_units=True,
interpolator=self.scanner.surface_interp)
# build up the environment and extract some informations...
env = gym.make(args.env_name)
num_inputs = env.observation_space.shape[0]
num_actions = env.action_space.shape[0]
# define the global network...
critic_shared_model = models.Critic_Network(num_inputs)
critic_shared_model.share_memory()
actor_shared_model = models.Actor_Network(num_inputs, num_actions)
actor_shared_model.share_memory()
# define the traffic signal...
traffic_signal = utils.TrafficLight()
# define the counter
critic_counter = utils.Counter()
actor_counter = utils.Counter()
# define the shared gradient buffer...
critic_shared_grad_buffer = utils.Shared_grad_buffers(critic_shared_model)
actor_shared_grad_buffer = utils.Shared_grad_buffers(actor_shared_model)
# define shared observation state...
shared_obs_state = utils.Running_mean_filter(num_inputs)
# define shared reward...
shared_reward = utils.RewardCounter()
# define the optimizer...
critic_optimizer = torch.optim.Adam(critic_shared_model.parameters(), lr=args.value_lr)
actor_optimizer = torch.optim.Adam(actor_shared_model.parameters(), lr=args.policy_lr)
# find how many processor is available...
num_of_workers = mp.cpu_count() - 1
processor = []
def broadcast_tonodes(nodes, firstreplyonly, *args):
todo = nodes[:]
r = []
for n in todo:
n = str(n)
assert utils.isNodeId(n)
m = sendMessageToNode(n, None, *args)
if m is None or m[0] == dont_know:
pass
elif firstreplyonly:
return m
else:
r.append(m)
if firstreplyonly:
return dont_know
else:
return r
import utils
getMsgId = utils.Counter()
import server
from autoregister import convertTo, convertFrom
import thread_pool
