def main():
params = Params()
mp.set_start_method('spawn')
lock = mp.Lock()
actions = mp.Array('i', [-1] * params.n_process, lock=lock)
count = mp.Value('i', 0)
best_acc = mp.Value('d', 0.0)
state_Queue = mp.JoinableQueue()
action_done = mp.SimpleQueue()
reward_Queue = mp.JoinableQueue()
# shared_model = A3C_LSTM_GA()
# shared_model = shared_model.share_memory()
#
# shared_optimizer = SharedAdam(shared_model.parameters(), lr=params.lr, amsgrad=params.amsgrad, weight_decay=params.weight_decay)
# shared_optimizer.share_memory()
#run_sim(0, params, shared_model, None, count, lock)
#test(params, shared_model, count, lock, best_acc)
processes = []
train_process = 0
test_process = 0
p = mp.Process(target=learning,
args=(
params,
state_Queue,
action_done,
actions,
reward_Queue,
))
p.start()
processes.append(p)
# test_process += 1
for rank in range(params.n_process):
p = mp.Process(target=run_sim,
args=(
train_process,
params,
state_Queue,
action_done,
actions,
reward_Queue,
lock,
))
train_process += 1
p.start()
processes.append(p)
for p in processes:
p.join()
def eval_net(dataloader, model, opts):
torch.manual_seed(23)
queue = mp.JoinableQueue()
_outputs, _indices = mp.Queue(), mp.Queue()
consumer = Consumer(queue, _outputs, _indices, dataloader, opts)
consumer.start()
dataset = dataloader.dataset
model.eval()
dataset_len = 100
with tqdm(total=dataset_len) as t:
for i in range(dataset_len):
img, heatmap_t, paf_t, ignore_mask_t = dataset.get_img(i,
flip=False)
img_batch = np.zeros(
(1, 3, opts["train"]["imgSize"], opts["train"]["imgSize"]))
img_batch[0, :, :, :] = img
with torch.no_grad():
imgs_torch = torch.from_numpy(img_batch).float().cuda()
heatmaps, pafs = model(imgs_torch)
heatmap = heatmaps[-1][0].data.cpu().numpy()
paf = pafs[-1][0].data.cpu().numpy()
# print(heatmap_t.shape)
queue.put(
(i, img, heatmap_t, heatmap, paf_t, paf, ignore_mask_t[0]))
t.update()
consumer.join()
outputs, indices = [], []
for _ in range(100):
outputs.append(_outputs.get())
indices.append(_indices.get())
print(outputs)
return outputs, indices
def __init__(self, env_name, env_kwargs, batch_size, policy, baseline,
env=None, seed=None, num_workers=1):
super(MultiTaskSampler, self).__init__(env_name, env_kwargs, batch_size,
policy, seed=seed, env=env)
self.num_workers = num_workers
self.task_queue = mp.JoinableQueue()
self.train_episodes_queue = mp.Queue()
self.valid_episodes_queue = mp.Queue()
policy_lock = mp.Lock()
self.workers = [SamplerWorker(index, env_name, env_kwargs, batch_size,
self.env.observation_space, self.env.action_space,
self.policy, deepcopy(baseline), self.seed,
self.task_queue, self.train_episodes_queue,
self.valid_episodes_queue, policy_lock)
for index in range(num_workers)]
for worker in self.workers:
worker.daemon = True # this makes all the threads stop when main process ends
worker.start()
self._waiting_sample = False
self._event_loop = asyncio.get_event_loop()
self._train_consumer_thread = None
self._valid_consumer_thread = None
def generate_walks(self):
g = self.graph
assert g.is_homogeneous
all_nodes = g.nodes().numpy().tolist() * self.num_walks
random.shuffle(all_nodes)
queue = mp.JoinableQueue()
per_worker = len(all_nodes) // commons.workers + 1
ps = []
for i in range(commons.workers):
chunk = all_nodes[i * per_worker:(i + 1) * per_worker]
ps.append(
mp.Process(target=self.sample,
args=(g, chunk, self.walk_length, queue))),
for p in ps:
p.start()
all_walks = []
for i in range(commons.workers):
all_walks.extend(queue.get())
for p in ps:
p.terminate()
with open(self.walks_file, 'w') as f:
for walk in all_walks:
walk = self.simple_filter(walk)
f.write(' '.join(walk))
f.write('\n')
def __init__(self,
env_name,
env_kwargs,
batch_size,
policy,
baseline,
env=None,
seed=None,
num_workers=1):
# 多重继承类，调用类MultiTaskSampler
super(MultiTaskSampler, self).__init__(env_name,
env_kwargs,
batch_size,
policy,
seed=seed,
env=env)
self.num_workers = num_workers
# 初始化队列 训练队列与测试队列 用于提取多进程数据
self.task_queue = mp.JoinableQueue()
self.train_episodes_queue = mp.Queue()
self.valid_episodes_queue = mp.Queue()
policy_lock = mp.Lock()
# self.Original_policy = self.policy
# temporary_policy = self.Original_policy
# 构建 num_workers 个 workers；调用 num_workers 次
self.workers = [SamplerWorker(index,
env_name,
env_kwargs,
batch_size,
self.env.observation_space,
self.env.action_space,
self.policy,
deepcopy(baseline),
self.seed,
self.task_queue,
self.train_episodes_queue,
self.valid_episodes_queue,
policy_lock)
for index in range(num_workers)]
for worker in self.workers:
# 守护进程 主进程代码运行结束，守护进程随即终止
worker.daemon = True
"""
启动worker (SamplerWorker(index)) 跳转至类SamplerWorker 中的函数 run(self)，
触发采样训练轨迹，inner更新网络，采样验证轨迹数据
"""
worker.start()
self._waiting_sample = False
# 创建事件循环以及训练、验证双线程
self._event_loop = asyncio.get_event_loop()
self._train_consumer_thread = None
self._valid_consumer_thread = None
def eval_wer(loader, criterion, lm_weight, index2letter, n_processes=32):
criterion.eval()
bar = progressbar.ProgressBar(len(loader))
bar.start()
task_q, result_q = mp.JoinableQueue(), mp.Queue()
processes = []
for _ in range(n_processes):
p = mp.Process(
target=Worker(lm_weight, index2letter, task_q, result_q))
p.start()
processes.append(p)
tasks_fed = 0
mean_wer = 0.0
results = 0.0
for index, data in enumerate(loader):
bar.update(index)
batch_size = data[0].size(0)
tasks_fed += batch_size
with torch.no_grad():
seq, seq_lengths, labels, label_lengths = prepare_data(
data, put_on_cuda=False)
seq = seq.cuda()
predictions = criterion.letter_classifier(seq).log_softmax(
dim=-1).cpu()
for k in range(batch_size):
p_ = predictions[k, :, :]
labels_ = (labels[k, :label_lengths[k]])
task_q.put((p_, labels_))
task_q.join()
while not result_q.empty():
mean_wer += result_q.get()
results += 1
assert results == tasks_fed
bar.finish()
for _ in processes:
task_q.put(None)
for p in processes:
p.join()
mean_wer /= results
return mean_wer
def reset(self, items: TfmdSource, train_setup=False):
pv('reset', self.verbose)
self.step_idx = 0
self.close(items)
self.cancel.clear()
self.queue = mp.JoinableQueue(maxsize=self.n_processes)
items.items = [
self.process_cls(start=True,
items=self.cached_items,
train_queue=self.queue,
cancel=self.cancel)
for _ in range(self.n_processes)
]
if not all([p.is_alive() for p in items.items]):
raise CancelFitException()
def __init__(self,
n_processes: int = 1,
process_cls=None,
cancel=None,
verbose: str = False,
regular_get: bool = True,
tracker=None):
store_attr(but='process_cls')
self.process_cls = ifnone(process_cls, DataFitProcess)
self.queue = mp.JoinableQueue(maxsize=self.n_processes)
self.cancel = ifnone(self.cancel, mp.Event())
self.pipe_in, self.pipe_out = mp.Pipe(False) if self.verbose else (
None, None)
self.cached_items = []
self._place_holder_out = None
self.step_idx = 0
def __init__(
self,
policy_container,
opposing_policy_container,
env_gen,
evaluation_policy_container=None,
network=None,
swap_sides=True,
save_dir="saves",
epoch_length=500,
initial_games=64,
self_play=False,
lr=0.001,
stagger=False,
evaluation_games=100,
):
self.policy_container = policy_container
self.opposing_policy_container = opposing_policy_container
self.evaluation_policy_container = evaluation_policy_container
self.env_gen = env_gen
self.swap_sides = swap_sides
self.save_dir = save_dir
self.epoch_length = epoch_length
self.self_play = self_play
self.lr = lr
self.stagger = stagger
self.network = network
self.evaluation_games = evaluation_games
self.start_time = datetime.datetime.now().isoformat()
self.task_queue = multiprocessing.JoinableQueue()
self.memory_queue = multiprocessing.Queue()
self.result_queue = multiprocessing.Queue()
self.initial_games = initial_games
self.writer = SummaryWriter()
if save_dir:
os.mkdir(os.path.join(save_dir, self.start_time))
logging.basicConfig(filename=join(save_dir, self.start_time,
"log"),
level=logging.INFO)
multiprocessing_logging.install_mp_handler()
def run_batch_iter(batch):
q = mp.JoinableQueue(maxsize=10)
fetch_p = mp.Process(target=run_fetch, args=(batch, q))
fetch_p.daemon = True
fetch_p.start()
# print('fork fetch process')
while 1:
try:
res = q.get(timeout=1)
q.task_done()
# print('get fetched')
if res is None:
break
yield res
except Exception as e:
if fetch_p.is_alive():
continue
else:
break
fetch_p.terminate()
fetch_p.join()
import torch.multiprocessing as mp
from option import opt
import process as proc
MAX_FPS = 30
MAX_SEGMENT_LENGTH = 4
SHARED_QUEUE_LEN = MAX_FPS * MAX_SEGMENT_LENGTH #Regulate GPU memory usage (> 3 would be fine)
if __name__ == "__main__":
mp.set_start_method('spawn', force=True)
torch.multiprocessing.set_sharing_strategy('file_descriptor')
#create Queue, Pipe
decode_queue = mp.Queue()
dnn_queue = mp.JoinableQueue()
data_queue = mp.JoinableQueue()
encode_queue = mp.JoinableQueue()
output_output, output_input = mp.Pipe(duplex=False)
#create shared tensor
shared_tensor_list = {}
res_list = [(270, 480), (360, 640), (540, 960), (1080, 1920)]
for res in res_list:
shared_tensor_list[res[0]] = []
for _ in range(SHARED_QUEUE_LEN):
shared_tensor_list[res[0]].append(
torch.ByteTensor(res[0], res[1], 3).cuda().share_memory_())
#create processes
decode_process = mp.Process(target=proc.decode,
import gym
from copy import deepcopy
import matplotlib.pyplot as plt
from tqdm import tqdm
import numpy as np
'''
Let's see how just non-MAML version adapts
'''
task_queue = mp.JoinableQueue()
train_episodes_queue = mp.Queue()
valid_episodes_queue = mp.Queue()
policy_lock = mp.Lock()
env_name = "2DNavigation-v0"
env_kwargs = {
"low": -0.5,
"high": 0.5,
"task": {"goal": np.array([1, 1])}
}
env = gym.make(env_name, **env_kwargs)
print(env.)
policy = get_policy_for_env(env,
hidden_sizes=(64, 64),
nonlinearity='tanh')
def __init__(self, processes) -> None:
super().__init__()
self.n_jobs = processes
# self.init_fun = init_fun
self.task_queue = multiprocessing.JoinableQueue()
self.results_queue = multiprocessing.Queue()
print("assembly complete: " + str(name))
if seq:
pickle.dump(
result,
open(
"/tigress/noamm/schapiro/gpu/nets_seq_" + str(num_networks) +
"_" + str(num_trials) + "_" + str(name) + ".pkl", "wb"))
else:
pickle.dump(
result,
open(
"/tigress/noamm/schapiro/gpu/nets_sep_" + str(num_networks) +
"_" + str(num_trials) + "_" + str(name) + ".pkl", "wb"))
q_sep = mp.JoinableQueue()
q_seq = mp.JoinableQueue()
process_sep = [
mp.Process(target=assemble, args=(i, False, num_trials))
for i in range(num_networks)
]
process_seq = [
mp.Process(target=assemble, args=(i, True, num_trials))
for i in range(num_networks)
]
print("sep")
for process in process_sep:
process.start()
def __init__(
self,
video_path,
output_path,
realtime,
start,
duration,
show_time,
confidence_threshold=0.5,
exclude_class=None,
common_cate=False,
):
self.vid_info = cv2_video_info(video_path)
fps = self.vid_info["fps"]
if fps == 0 or fps > 100:
print(
"Warning: The detected frame rate {} could be wrong. The behavior of this demo code can be abnormal.".format(
fps))
self.realtime = realtime
self.start = start
self.duration = duration
self.show_time = show_time
self.confidence_threshold = confidence_threshold
if common_cate:
self.cate_to_show = self.COMMON_CATES
self.category_split = (6, 11)
else:
self.cate_to_show = self.CATEGORIES
self.category_split = (14, 63)
self.cls2label = {class_name: i for i, class_name in enumerate(self.cate_to_show)}
if exclude_class is None:
exclude_class = self.EXCLUSION
self.exclude_id = [self.cls2label[cls_name] for cls_name in exclude_class if cls_name in self.cls2label]
self.width = self.vid_info["width"]
self.height = self.vid_info["height"]
long_side = min(self.width, self.height)
self.font_size = max(int(round((long_side / 40))), 1)
self.box_width = max(int(round(long_side / 180)), 1)
self.font = ImageFont.truetype("./Roboto-Bold.ttf", self.font_size)
self.box_color = (191, 40, 41)
self.category_colors = ((176, 85, 234), (87, 118, 198), (52, 189, 199))
self.category_trans = int(0.6 * 255)
self.action_dictionary = dict()
if realtime:
# Output Video
width = self.vid_info["width"]
height = self.vid_info["height"]
fps = self.vid_info["fps"]
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
self.out_vid = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
else:
self.frame_queue = mp.JoinableQueue(512)
self.result_queue = mp.JoinableQueue()
self.track_queue = mp.JoinableQueue()
self.done_queue = mp.Queue()
self.frame_loader = mp.Process(target=self._load_frame, args=(video_path,))
self.frame_loader.start()
self.video_writer = mp.Process(target=self._wirte_frame, args=(output_path,))
self.video_writer.start()
def ft(ft_dir, app_args, cleanup_ft_dir=False):
"""Fine tune all the checkpoint files we find in the immediate-directory specified.
For each checkpoint file we find, we create and queue a FinetuningTask.
A FinetuningProcess will pickup the FinetuningTask and process it.
"""
print("Fine-tuning directory %s" % ft_dir)
checkpoints = glob.glob(os.path.join(ft_dir, "*checkpoint.pth.tar"))
assert checkpoints
# We create a subdirectory, where we will write all of our output
ft_output_dir = os.path.join(ft_dir, 'ft')
os.makedirs(ft_output_dir, exist_ok=True)
print("Writing results to directory %s" % ft_output_dir)
app_args.output_dir = ft_output_dir
# Multi-process queues
tasks = multiprocessing.JoinableQueue()
results = multiprocessing.Queue()
# Create and launch the fine-tuning processes
processes = []
n_processes = min(app_args.processes, len(checkpoints))
for i in range(n_processes):
# Pre-load the data-loaders of each fine-tuning process once
app = classifier.ClassifierCompressor(
app_args, script_dir=os.path.dirname(__file__))
data_loader = classifier.load_data(app.args)
# Delete log directories
shutil.rmtree(app.logdir)
processes.append(FinetuningProcess(tasks, results, data_loader))
# Start the process
processes[-1].start()
n_gpus = torch.cuda.device_count()
# Enqueue all of the fine-tuning tasks
for (instance, ckpt_file) in enumerate(checkpoints):
tasks.put(FinetuningTask(args=(ckpt_file, instance % n_gpus,
app_args)))
# Push an end-of-tasks marker
for i in range(len(processes)):
tasks.put(None)
# Wait until all tasks finish
tasks.join()
# Start printing results
results_dict = OrderedDict()
while not results.empty():
result = results.get()
results_dict[result[0]] = result[1]
# Read the results of the AMC experiment (we'll want to use some of the data)
# import pandas as pd
# df = pd.read_csv(os.path.join(ft_dir, "amc.csv"))
# assert len(results_dict) > 0
if cleanup_ft_dir:
# cleanup: remove the "ft" directory
shutil.rmtree(ft_output_dir)
def __init__(self,
env_name,
env_kwargs,
batch_size,
policy,
baseline,
dynamics=None,
inverse_dynamics=False,
env=None,
seed=None,
num_workers=1,
epochs_counter=None,
act_prev_mean=None,
obs_prev_mean=None,
eta=None,
benchmark=None,
pre_epochs=-1,
normalize_spaces=True,
add_noise=False):
super(MultiTaskSampler, self).__init__(env_name,
env_kwargs,
batch_size,
policy,
seed=seed,
env=env)
# Metaworld
self.benchmark = benchmark
### Dynamics
self.env_name = env_name
self.epochs_counter = epochs_counter
self.pre_epochs = pre_epochs
self.dynamics = dynamics
if self.dynamics is not None:
self.kl_previous = mp.Manager().list()
kl_previous_lock = mp.Manager().RLock()
dynamics_lock = mp.Lock()
else:
dynamics_lock = None
self.kl_previous = None
kl_previous_lock = None
self.inverse_dynamics = inverse_dynamics
self.act_prev_mean = act_prev_mean
self.obs_prev_mean = obs_prev_mean
act_prev_lock = mp.Manager().RLock()
obs_prev_lock = mp.Manager().RLock()
self.num_workers = num_workers
self.task_queue = mp.JoinableQueue()
self.train_episodes_queue = mp.Queue()
self.valid_episodes_queue = mp.Queue()
policy_lock = mp.Lock()
self.workers = [
SamplerWorker(
index,
env_name,
env_kwargs,
batch_size,
self.env.observation_space,
self.env.action_space,
self.policy,
deepcopy(baseline),
self.seed,
self.task_queue,
self.train_episodes_queue,
self.valid_episodes_queue,
policy_lock,
# Queues and Epochs
epochs_counter=epochs_counter,
pre_epochs=pre_epochs,
act_prev_lock=act_prev_lock,
obs_prev_lock=obs_prev_lock,
act_prev_mean=self.act_prev_mean,
obs_prev_mean=self.obs_prev_mean,
# Dynamics
dynamics=self.dynamics,
dynamics_lock=dynamics_lock,
kl_previous=self.kl_previous,
kl_previous_lock=kl_previous_lock,
inverse_dynamics=self.inverse_dynamics,
eta=eta,
# Metaworld
benchmark=benchmark,
normalize_spaces=normalize_spaces,
add_noise=add_noise) for index in range(num_workers)
]
for worker in self.workers:
worker.daemon = True
worker.start()
self._waiting_sample = False
self._event_loop = asyncio.get_event_loop()
self._train_consumer_thread = None
self._valid_consumer_thread = None
def finetune_directory(ft_dir,
stats_file,
app_args,
cleanup_ft_dir=False,
checkpoints=None):
"""Fine tune all the checkpoint files we find in the immediate-directory specified.
For each checkpoint file we find, we create and queue a FinetuningTask.
A FinetuningProcess will pickup the FinetuningTask and process it.
"""
print("Fine-tuning directory %s" % ft_dir)
if not checkpoints:
# Get a list of the checkpoint files
checkpoints = glob.glob(os.path.join(ft_dir, "*checkpoint.pth.tar"))
assert checkpoints
# We create a subdirectory, where we will write all of our output
ft_output_dir = os.path.join(ft_dir, "ft")
os.makedirs(ft_output_dir, exist_ok=True)
print("Writing results to directory %s" % ft_output_dir)
app_args.output_dir = ft_output_dir
# Multi-process queues
tasks = multiprocessing.JoinableQueue()
results = multiprocessing.Queue()
# Create and launch the fine-tuning processes
processes = []
n_processes = min(app_args.processes, len(checkpoints))
for i in range(n_processes):
# Pre-load the data-loaders of each fine-tuning process once
app = classifier.ClassifierCompressor(
app_args, script_dir=os.path.dirname(__file__))
data_loader = classifier.load_data(app.args)
# Delete log directories
shutil.rmtree(app.logdir)
processes.append(FinetuningProcess(tasks, results, data_loader))
# Start the process
processes[-1].start()
n_gpus = torch.cuda.device_count()
# Enqueue all of the fine-tuning tasks
for (instance, ckpt_file) in enumerate(checkpoints):
tasks.put(FinetuningTask(args=(ckpt_file, instance % n_gpus,
app_args)))
# Push an end-of-tasks marker
for i in range(len(processes)):
tasks.put(None)
# Wait until all tasks finish
tasks.join()
# Start printing results
results_dict = OrderedDict()
while not results.empty():
result = results.get()
results_dict[result[0]] = result[1]
# Read the results of the AMC experiment (we'll want to use some of the data)
import pandas as pd
df = pd.read_csv(os.path.join(ft_dir, "amc.csv"))
assert len(results_dict) > 0
# Log some info for each checkpoint
for ckpt_name in sorted(results_dict.keys()):
net_search_results = df[df["ckpt_name"] ==
ckpt_name[:-len("_checkpoint.pth.tar")]]
search_top1 = net_search_results["top1"].iloc[0]
normalized_macs = net_search_results["normalized_macs"].iloc[0]
log_entry = (ft_output_dir, ckpt_name, normalized_macs, search_top1,
*results_dict[ckpt_name])
print("%s <> %s: %.2f %.2f %.2f %.2f %.2f" % log_entry)
stats_file.add_record(log_entry)
if cleanup_ft_dir:
# cleanup: remove the "ft" directory
shutil.rmtree(ft_output_dir)
def __init__(self):
self.queue = mp.JoinableQueue(1)
self._put_end = False
self._got_end = False
def train_model(self,
num_epochs=10,
resume_model=False,
resume_memory=False,
num_workers=None):
try:
evaluator = self.network
optim = torch.optim.SGD(evaluator.parameters(),
weight_decay=0.0001,
momentum=0.9,
lr=self.lr)
evaluator.share_memory()
num_workers = num_workers or multiprocessing.cpu_count()
player_workers = [
SelfPlayWorker(
self.task_queue,
self.memory_queue,
self.result_queue,
self.env_gen,
evaluator=evaluator,
start_time=self.start_time,
policy_container=self.policy_container,
opposing_policy_container=self.opposing_policy_container,
evaluation_policy_container=self.
evaluation_policy_container,
save_dir=self.save_dir,
resume=resume_model,
self_play=self.self_play,
) for _ in range(num_workers - 1)
]
for w in player_workers:
w.start()
update_worker_queue = multiprocessing.JoinableQueue()
update_flag = multiprocessing.Event()
update_flag.clear()
update_worker = UpdateWorker(
memory_queue=self.memory_queue,
policy_container=self.policy_container,
evaluator=evaluator,
optim=optim,
update_flag=update_flag,
update_worker_queue=update_worker_queue,
save_dir=self.save_dir,
resume=resume_memory,
start_time=self.start_time,
stagger=self.stagger,
)
update_worker.start()
for i in range(self.initial_games):
swap_sides = not i % 2 == 0
self.task_queue.put(
{"play": {
"swap_sides": swap_sides,
"update": False
}})
self.task_queue.join()
while not self.result_queue.empty():
self.result_queue.get()
saved_model_name = None
reward = self.evaluate_policy(-1)
for epoch in range(num_epochs):
update_flag.set()
for i in range(self.epoch_length):
swap_sides = not i % 2 == 0
self.task_queue.put({
"play": {
"swap_sides": swap_sides,
"update": True
},
"saved_name": saved_model_name,
})
self.task_queue.join()
saved_model_name = os.path.join(
self.save_dir,
self.start_time,
"model-" + datetime.datetime.now().isoformat() + ":" +
str(self.epoch_length * epoch),
)
update_flag.clear()
update_worker_queue.put({"saved_name": saved_model_name})
reward = self.evaluate_policy(epoch)
update_worker_queue.join()
update_worker_queue.put({"reward": reward})
# Do some evaluation?
# Clean up
update_worker.terminate()
[w.terminate() for w in player_workers]
del self.memory_queue
del self.task_queue
del self.result_queue
except Exception as e:
logging.exception("error in main loop" + str(e))
