def test(self, dbg=None):
npTrain = numpy.load(self.ntmTrainFpath)
l = len(npTrain)
ndX = nd.empty((l, 150))
ndY = nd.empty((l, 20))
for i, row in enumerate(npTrain):
npDescriptionVector = row[0]
ndX[i] = nd.array(npDescriptionVector)
npGeoVector = row[2]
ndY[i] = nd.array(npGeoVector)
dataset = mx.gluon.data.dataset.ArrayDataset(ndX, ndY)
#http://mxnet.incubator.apache.org/versions/master/tutorials/gluon/datasets.html
from multiprocessing import cpu_count
CPU_COUNT = cpu_count()
CPU_COUNT = 1
data_loader = mx.gluon.data.DataLoader(
dataset, batch_size=5) #, num_workers=CPU_COUNT)
for X_batch, y_batch in data_loader:
print("X_batch has shape {}, and y_batch has shape {}".format(
X_batch.shape, y_batch.shape))
ndTrain0 = nd.array(npTrain[:, 0])
mx.random.seed(42) # Fix the seed for reproducibility
X = mx.random.uniform(shape=(10, 3))
y = mx.random.uniform(shape=(10, 1))
dataset = mx.gluon.data.dataset.ArrayDataset(X, y)
x = 1
def backward(self, dZ):
ctx = context(dZ)
X, Y = self.saved_tensors
gidx, op = self.gidx, self.op
lhs_target, rhs_target = self.lhs_target, self.rhs_target
dX, dY = nd.empty((), ctx=ctx), nd.empty((), ctx=ctx)
if op != 'copy_rhs':
if lhs_target in ['u', 'v']:
_gidx = gidx if self.lhs_target == 'v' else gidx.reverse()
if op in ['add', 'sub', 'copy_lhs']:
dX = _gspmm(_gidx, 'copy_rhs', 'sum', None, dZ)[0]
else: # mul, div, dot
if rhs_target == lhs_target:
dX = _gspmm(_gidx, 'copy_rhs', 'sum', None,
dZ)[0] * _muldiv(op, Y)
elif self.rhs_target == 'e':
dX = _gspmm(_gidx, 'copy_rhs', 'sum', None,
dZ * _muldiv(op, Y))[0]
else: # rhs_target = !lhs_target
dX = _gspmm(_gidx, 'mul', 'sum', _muldiv(op, Y), dZ)[0]
else: # lhs_target == 'e'
if op in ['add', 'sub', 'copy_lhs']:
dX = dZ
else: # mul, div, dot
dX = _gsddmm(gidx, 'mul', dZ, _muldiv(op, Y), 'e',
rhs_target)
dX = _reduce_grad(dX, X.shape)
if op != 'copy_lhs':
if self.rhs_target in ['u', 'v']:
_gidx = gidx if rhs_target == 'v' else gidx.reverse()
if op in ['add', 'sub', 'copy_rhs']:
dY = _gspmm(_gidx, 'copy_rhs', 'sum', None,
_addsub(op, dZ))[0]
else: # mul, div, dot
if lhs_target == rhs_target:
dY = _gspmm(_gidx, 'copy_rhs', 'sum', None, dZ)[0] * X
elif self.lhs_target == 'e':
dY = _gspmm(_gidx, 'copy_rhs', 'sum', None, dZ * X)[0]
else: # rhs_target = !lhs_target
dY = _gspmm(_gidx, 'mul', 'sum', X, dZ)[0]
if op == 'div': dY = -dY / (Y**2)
else:
if op in ['add', 'sub', 'copy_rhs']:
dY = _addsub(op, dZ)
else: # mul, div, dot
dY = _gsddmm(gidx, 'mul', dZ, X, 'e', lhs_target)
if op == 'div': dY = -dY / (Y**2)
dY = _reduce_grad(dY, Y.shape)
self.saved_tensors = None
return dX, dY
def backward(self, dZ):
ctx = context(dZ)
X, Y, argX, argY = self.saved_tensors
gidx, op, reduce_op = self.gidx, self.op, self.reduce_op
dX, dY = nd.empty((), ctx=ctx), nd.empty((), ctx=ctx)
if op != 'copy_rhs' and X.grad is not None:
g_rev = gidx.reverse()
if reduce_op == 'sum':
if op in ['mul', 'div']:
dX = _gspmm(g_rev, 'mul', 'sum', dZ, _muldiv(op, Y))[0]
elif op in ['add', 'sub']:
dX = _gspmm(g_rev, 'copy_lhs', 'sum', dZ, Y)[0]
elif op == 'copy_lhs':
dX = _gspmm(g_rev, 'copy_lhs', 'sum', dZ, None)[0]
else:
if op in ['mul', 'div']:
dX = _scatter_nd(
argX,
_muldiv(
op,
_gather_nd(
argY,
Y.broadcast_to(
(Y.shape[0], *dZ.shape[1:])))) * dZ,
X.shape[0])
elif op in ['add', 'sub', 'copy_lhs']:
dX = _scatter_nd(argX, dZ, X.shape[0])
dX = _reduce_grad(dX, X.shape)
if op != 'copy_lhs' and Y.grad is not None:
if reduce_op == 'sum':
if op in ['mul', 'div']:
dY = _gsddmm(gidx, 'mul', X, dZ)
if op == 'div': dY = -dY / (Y**2)
elif op in ['add', 'sub', 'copy_rhs']:
dY = _gsddmm(gidx, 'copy_rhs', X, _addsub(op, dZ))
else:
if op in ['mul', 'div']:
dY = _scatter_nd(
argY,
_gather_nd(argX,
X.broadcast_to(
(X.shape[0], *dZ.shape[1:]))) * dZ,
Y.shape[0])
if op == 'div': dY = -dY / (Y**2)
elif op in ['add', 'sub', 'copy_rhs']:
dY = _scatter_nd(argY, _addsub(op, dZ), Y.shape[0])
dY = _reduce_grad(dY, Y.shape)
self.saved_tensors = None
return dX, dY
def store_samples(self, data, y, query_network, store_prob, context):
if not (self.memory_replacement_strategy == "no_replacement" and self.max_stored_samples != -1 and self.key_memory.shape[0] >= self.max_stored_samples):
num_pus = len(data)
sub_batch_sizes = [data[i][0][0].shape[0] for i in range(num_pus)]
num_inputs = len(data[0][0])
num_outputs = len(y)
mx_context = context[0]
if len(self.key_memory) == 0:
self.key_memory = nd.empty(0, ctx=mx.cpu())
self.value_memory = []
self.label_memory = []#nd.empty((num_outputs, 0), ctx=mx.cpu())
ind = [nd.sample_multinomial(store_prob, sub_batch_sizes[i]).as_in_context(mx_context) for i in range(num_pus)]
max_inds = [nd.max(ind[i]) for i in range(num_pus)]
if any(max_inds):
to_store_values = []
for i in range(num_inputs):
tmp_values = []
for j in range(0, num_pus):
if max_inds[j]:
if isinstance(tmp_values, list):
tmp_values = nd.contrib.boolean_mask(data[j][0][i].as_in_context(mx_context), ind[j])
else:
tmp_values = nd.concat(tmp_values, nd.contrib.boolean_mask(data[j][0][i].as_in_context(mx_context), ind[j]), dim=0)
to_store_values.append(tmp_values)
to_store_labels = []
for i in range(num_outputs):
tmp_labels = []
for j in range(0, num_pus):
if max_inds[j]:
if isinstance(tmp_labels, list):
tmp_labels = nd.contrib.boolean_mask(y[i][j].as_in_context(mx_context), ind[j])
else:
tmp_labels = nd.concat(tmp_labels, nd.contrib.boolean_mask(y[i][j].as_in_context(mx_context), ind[j]), dim=0)
to_store_labels.append(tmp_labels)
to_store_keys = query_network(*to_store_values[0:self.query_net_num_inputs])
if self.key_memory.shape[0] == 0:
self.key_memory = to_store_keys.as_in_context(mx.cpu())
for i in range(num_inputs):
self.value_memory.append(to_store_values[i].as_in_context(mx.cpu()))
for i in range(num_outputs):
self.label_memory.append(to_store_labels[i].as_in_context(mx.cpu()))
elif self.memory_replacement_strategy == "replace_oldest" and self.max_stored_samples != -1 and self.key_memory.shape[0] >= self.max_stored_samples:
num_to_store = to_store_keys.shape[0]
self.key_memory = nd.concat(self.key_memory[num_to_store:], to_store_keys.as_in_context(mx.cpu()), dim=0)
for i in range(num_inputs):
self.value_memory[i] = nd.concat(self.value_memory[i][num_to_store:], to_store_values[i].as_in_context(mx.cpu()), dim=0)
for i in range(num_outputs):
self.label_memory[i] = nd.concat(self.label_memory[i][num_to_store:], to_store_labels[i].as_in_context(mx.cpu()), dim=0)
else:
self.key_memory = nd.concat(self.key_memory, to_store_keys.as_in_context(mx.cpu()), dim=0)
for i in range(num_inputs):
self.value_memory[i] = nd.concat(self.value_memory[i], to_store_values[i].as_in_context(mx.cpu()), dim=0)
for i in range(num_outputs):
self.label_memory[i] = nd.concat(self.label_memory[i], to_store_labels[i].as_in_context(mx.cpu()), dim=0)
def tokenize(self, path, ctx=None):
"""Tokenizes a text file."""
assert os.path.exists(path)
# Add words to the dictionary
with open(path, 'r', encoding='utf-8') as f:
tokens = 0
for line in f:
words = line.split() + ['<eos>']
tokens += len(words)
for word in words:
self.dictionary.add_word(word)
# Tokenize file content
sents = []
with open(path, 'r', encoding='utf-8') as f:
for line in f:
if not line:
continue
words = line.split() + ['<eos>']
sent = nd.empty(len(words), ctx, dtype=np.int64)
for i, word in enumerate(words):
sent[i] = self.dictionary.word2idx[word]
sents.append(sent)
return sents
def tokenize(self, path, ctx=None):
""" Tokenizes a text file into a list of indexes of tokens."""
assert os.path.exists(path)
# Add words to the dictionary
with open(path, 'r', encoding='utf-8') as f:
tokens = 0
for line in f:
words = line.split() + ['<eos>']
tokens += len(words)
for word in words:
self.dictionary.add_word(word)
# Tokenize file content
with open(path, 'r', encoding='utf-8') as f:
ids = nd.empty(self.debug if self.debug else tokens,
ctx,
dtype=np.int64)
token = 0
for line in f:
words = line.split() + ['<eos>']
for word in words:
ids[token] = self.dictionary.word2idx[word]
token += 1
if self.debug and token >= self.debug:
return ids
return ids
def clip_grad(grads: Union[Generator[NDArray, NDArray, NDArray], List[NDArray],
Tuple[NDArray]],
clip_method: GradientClippingMethod,
clip_val: float,
inplace=True) -> List[NDArray]:
"""
Clip gradient values inplace
:param grads: gradients to be clipped
:param clip_method: clipping method
:param clip_val: clipping value. Interpreted differently depending on clipping method.
:param inplace: modify grads if True, otherwise create NDArrays
:return: clipped gradients
"""
output = list(grads) if inplace else list(nd.empty(g.shape) for g in grads)
if clip_method == GradientClippingMethod.ClipByGlobalNorm:
norm_unclipped_grads = global_norm(grads)
scale = clip_val / (norm_unclipped_grads.asscalar() + 1e-8
) # todo: use branching operators?
if scale < 1.0:
for g, o in zip(grads, output):
nd.broadcast_mul(g, nd.array([scale]), out=o)
elif clip_method == GradientClippingMethod.ClipByValue:
for g, o in zip(grads, output):
g.clip(-clip_val, clip_val, out=o)
elif clip_method == GradientClippingMethod.ClipByNorm:
for g, o in zip(grads, output):
nd.broadcast_mul(g,
nd.minimum(1.0, clip_val / (g.norm() + 1e-8)),
out=o)
else:
raise KeyError('Unsupported gradient clipping method')
return output
def data_preprocess():
'''
A is the adjacency matrix of the road graph
X is the feature matrix
'''
with open('remainID5min.json', 'r') as f:
data = json.loads(f.read().strip())
indices = sorted([int(i[:i.find(',')]) for i in data.keys()])
indices_dict = {i: index for index, i in enumerate(indices)}
new_data = {
indices_dict[int(key[:key.find(',')])]: value
for key, value in data.items()
}
with open('thre3.5twoPointIndex.txt', 'r') as f:
t = (list(map(int, i.strip().split(','))) for i in f.readlines())
A = nd.zeros(shape=(len(indices), len(indices)), ctx=ctx)
for x, y in t:
A[x, y] = 1.0
X = nd.empty(shape=(len(indices), 3, 16992), ctx=ctx)
for i in range(len(indices)):
data = new_data[i]
X[i, 0, :] = nd.array(data['flow'], ctx=ctx)
X[i, 1, :] = nd.array(data['occupy'], ctx=ctx)
X[i, 2, :] = nd.array(data['speed'], ctx=ctx)
return A, X
def step(self, s, num_steps_so_far):
# s is channel-last, NHWC
s = np.transpose(s, (0, 3, 1, 2))
s = nd.array(s, ctx=self.args.ctx)
value, logits = self.net(s)
# action = nd.argmax(logits, axis=1)
# action = self.net.sample(logits)
# logpac = self.net.log_prob(logits, action)
# Epsilon greedy exploration
eps = np.maximum(1. - num_steps_so_far / self.args.annealing_end,
self.args.epsilon_min)
action = nd.empty(shape=s.shape[0], ctx=self.args.ctx)
logits_np = logits.asnumpy()
for i in range(s.shape[0]):
sample = np.random.random()
if sample < eps:
ac = random.randint(0, self.action_dim - 1)
else:
ac = int(np.argmax(logits[i]))
action[i] = ac
# Pick the probability of the chosen action
logpac = nd.pick(logits, action, 1)
# Reshaping the output
logpac = logpac.asnumpy().reshape((-1))
action = action.asnumpy().astype(np.int32).reshape((-1))
value = value.asnumpy().reshape((-1))
return value, action, logpac
def _init_training(self):
self.frame_counter = 0. # Counts the number of steps so far
self.annealing_count = 0. # Counts the number of annealing steps
self.epis_count = 0. # Counts the number episodes so far
self.replay_memory = Replay_Buffer(
self.opt.replay_buffer_size) # Initialize the replay buffer
self.tot_clipped_reward = []
self.tot_reward = []
self.frame_count_record = []
self.moving_average_clipped = 0.
self.moving_average = 0.
self.batch_state = nd.empty((self.opt.batch_size, self.opt.frame_len,
self.opt.image_size, self.opt.image_size),
self.opt.ctx)
self.batch_state_next = nd.empty(
(self.opt.batch_size, self.opt.frame_len, self.opt.image_size,
self.opt.image_size), self.opt.ctx)
self.batches = np.arange(self.opt.batch_size)
def predict(batch_file):
batch_data = nd.empty((batch_size, 3, 224, 224), ctx)
for i in range(0, batch_size):
fn = batch_file[i]
img = mx.image.imread(fn)
img = transform(img)
batch_data[i][:] = img
# img = nd.array(img, ctx)
model.forward(Batch([batch_data]), is_train=False)
outputs = model.get_outputs()[0].asnumpy()
return outputs
def default_mp_batchify_fn(data):
"""Collate data into batch. Use shared memory for stacking."""
if isinstance(data[0], nd.NDArray):
out = nd.empty((len(data), ) + data[0].shape,
dtype=data[0].dtype,
ctx=context.Context('cpu_shared', 0))
return nd.stack(*data, out=out)
elif isinstance(data[0], tuple):
data = zip(*data)
return [default_mp_batchify_fn(i) for i in data]
else:
data = np.asarray(data)
def __init__(self, m, n, w0=None, b0=None, c0=None, ctx=mx.cpu()):
self.ctx = ctx
# Dimensions
self.m = m
self.n = n
# Parameters
if w0 is not None and b0 is not None and c0 is not None:
if w0.shape != (m, n):
raise ValueError("w0 must be an [m x n] array")
if b0.shape != (m, ):
raise ValueError("b0 must be an [m] array")
if c0.shape != (n, ):
raise ValueError("c0 must be an [n] array")
self.w = w0.as_in_context(self.ctx)
self.b = b0.as_in_context(self.ctx)
self.c = c0.as_in_context(self.ctx)
else:
self.w = nd.random.normal(scale=0.1, shape=(m, n), ctx=self.ctx)
self.b = nd.random.normal(scale=0.1, shape=m, ctx=self.ctx)
self.c = nd.random.normal(scale=0.1, shape=n, ctx=self.ctx)
# Gradients
self.dw1 = nd.empty(shape=self.w.shape, ctx=self.ctx)
self.db1 = nd.empty(shape=self.b.shape, ctx=self.ctx)
self.dc1 = nd.empty(shape=self.c.shape, ctx=self.ctx)
self.dw2 = nd.empty(shape=self.w.shape, ctx=self.ctx)
self.db2 = nd.empty(shape=self.b.shape, ctx=self.ctx)
self.dc2 = nd.empty(shape=self.c.shape, ctx=self.ctx)
def RunGAN(episode_states, discriminator, discriminator_trainer, generator, generator_trainer, should_print = False):
sampler = mx.gluon.data.SequentialSampler(len(episode_states))
batch_sampler = mx.gluon.data.BatchSampler(sampler, opt.batch_size_GAN)
batch_state_GAN = nd.empty((opt.batch_size_GAN,opt.frame_len,opt.image_size,opt.image_size), opt.ctx)
loss_disc = 0.
for batch_indices in batch_sampler:
for i in range(len(batch_indices)):
index = batch_indices[i]
batch_state_GAN[i] = nd.array(episode_states[index],opt.ctx)
loss_disc = StepGAN(batch_state_GAN, discriminator, discriminator_trainer, generator, generator_trainer, False)
results = 'Episode loss %f'%(loss_disc)
if should_print:
print(results)
def __init__(self, layer_type, input_size, output_size, learning_rate,
activation, batch_size):
self.layer_type = layer_type
self.input_size = input_size
self.output_size = output_size
self.learning_rate = learning_rate
self.batch_size = batch_size
self.act = self.act_func(activation)
self.d_act = self.d_act_func(activation)
self.output = None
self.W = None
self.b = None
self.z = None
self.forward = None
self.backward = None
if self.layer_type == "fc":
self.W = (np.random.rand(self.input_size, self.output_size) *
1) - 0.5
self.b = (np.random.rand(self.output_size) * 1) - 0.5
# self.delta_W = np.zeros((self.input_size, self.output_size))
# self.delta_b = np.zeros(self.output_size)
self.forward = self.dense_fw
self.backward = self.dense_bw
self.W = nd.array(self.W, ctx=ctx)
self.b = nd.array(self.b, ctx=ctx)
self.delta_W = nd.empty(self.W.shape, ctx=ctx)
self.delta_b = nd.empty(self.b.shape, ctx=ctx)
self.z = nd.empty((self.batch_size, self.output_size), ctx=ctx)
self.d_act_z = nd.empty(self.z.shape, ctx=ctx)
def __getitem__(self, item):
"""get the x and y
x is the [merged[0:3],trimap[3] ] ,
y is the [bg[0:3],fg[3:6],mask[6],alpha[7] ]"""
name = self.names[item]
fcount,bcount = [int(x) for x in name.split('.')[0].split('_')]
im_name = self.fg_files[fcount]
bg_name = self.bg_files[bcount]
merged,alpha,fg,bg,trimap = self.process(im_name,bg_name)
x = nd.empty((self.size,self.size,4),dtype=np.float32)
y = nd.empty((self.size,self.size,7),dtype=np.float32)
if self.transform:
merged = self.transform(nd.array(merged))
x[:,:,0:3] = nd.array(merged)
x[:,:,-1] = nd.array(trimap)
y[:,:,0:3] = nd.array(bg)
y[:,:,3:6] = nd.array(fg)
y[:,:,-1] = nd.array(alpha)
return x,y
def stack(
data,
multi_processing: bool,
dtype: DType,
single_process_ctx: Optional[mx.Context] = None,
):
"""Stack a list of data.
Used when creating a single batch from list of dicts
depending on whether multiprocessing is turned on, the batches will be
constructed using different memory allocation techniques"""
if isinstance(data[0], mx.nd.NDArray):
if multi_processing:
out = nd.empty(
(len(data), ) + data[0].shape,
dtype=data[0].dtype,
ctx=context.Context("cpu_shared", 0),
)
return mx.nd.stack(*data, out=out)
else:
return mx.nd.stack(*data)
elif isinstance(data[0], np.ndarray):
data = np.asarray(data)
if data.dtype.kind == "f":
data = data.astype(dtype)
if multi_processing:
# Workaround due to MXNet not being able to handle NDArrays with 0 in shape properly:
if 0 in data.shape:
return data
return mx.nd.array(data,
dtype=data.dtype,
ctx=context.Context("cpu_shared", 0))
else:
return mx.nd.array(data, dtype=data.dtype, ctx=single_process_ctx)
elif isinstance(data[0], list):
return list(
stack(t, multi_processing, dtype, single_process_ctx)
for t in zip(*data))
elif isinstance(data[0], tuple):
return tuple(
stack(t, multi_processing, dtype, single_process_ctx)
for t in zip(*data))
elif isinstance(data[0], (pd.Timestamp, str, int, pathlib.PosixPath)):
return data
else:
raise TypeError(
f"Invalid type of data: {type(data[0])} for argument loss_function."
)
def default_mp_pad_batchify_fn(data):
"""Use shared memory for collating data into batch, labels are padded to same shape"""
if isinstance(data[0], nd.NDArray):
out = nd.empty((len(data),) + data[0].shape, dtype=data[0].dtype,
ctx=context.Context('cpu_shared', 0))
return nd.stack(*data, out=out)
elif isinstance(data[0], tuple):
data = zip(*data)
return [default_mp_pad_batchify_fn(i) for i in data]
else:
data = np.asarray(data)
batch_size = len(data)
pad = max([l.shape[0] for l in data] + [1,])
buf = np.full((batch_size, pad, data[0].shape[-1]), -1, dtype=data[0].dtype)
for i, l in enumerate(data):
buf[i][:l.shape[0], :] = l
return nd.array(buf, dtype=data[0].dtype, ctx=context.Context('cpu_shared', 0))
def default_mp_pad_batchify_fn(data):
"""Use shared memory for collating data into batch, labels are padded to same shape"""
if isinstance(data[0], nd.NDArray):
out = nd.empty((len(data),) + data[0].shape, dtype=data[0].dtype,
ctx=context.Context('cpu_shared', 0))
return nd.stack(*data, out=out)
elif isinstance(data[0], tuple):
data = zip(*data)
return [default_mp_pad_batchify_fn(i) for i in data]
else:
data = np.asarray(data)
batch_size = len(data)
pad = max([l.shape[0] for l in data] + [1,])
buf = np.full((batch_size, pad, data[0].shape[-1]), -1, dtype=data[0].dtype)
for i, l in enumerate(data):
buf[i][:l.shape[0], :] = l
return nd.array(buf, dtype=data[0].dtype, ctx=context.Context('cpu_shared', 0))
def batchify_fn(self, data):
"""Collate data into batch. Split into supervised and unsupervised data accordingly if necessary"""
if isinstance(data[0], nd.NDArray):
out = nd.empty((len(data), ) + data[0].shape,
dtype=data[0].dtype,
ctx=context.Context('cpu_shared', 0))
return nd.stack(*data, out=out)
elif isinstance(data[0], tuple):
if data.__len__() > self._batch_size:
data_sup = zip(*[_data for _data in data if len(_data) == 3])
data_unsup = zip(*[_data for _data in data if len(_data) == 2])
return ([self.batchify_fn(i) for i in data_sup],
[self.batchify_fn(i) for i in data_unsup])
else:
data = zip(*data)
return [self.batchify_fn(i) for i in data]
else:
if isinstance(data[0][0], np.ndarray):
data = np.asarray(data).astype('float32')
return nd.array(data,
dtype=data.dtype,
ctx=context.Context('cpu_shared', 0))
return data # augmentation sequences
def check_ndarray_empty():
a = nd.empty(LARGE_X)
assert a.shape == (LARGE_X,)
hidden = hidden.detach()
return hidden
l2loss = gluon.loss.L2Loss(batch_axis=0)
frame_counter = 0.
annealing_count = 0.
epis_count = 0.
replay_memory = ReplayBuffer(opt.replay_buffer_size)
tot_clipped_reward = np.zeros(opt.num_episode)
tot_reward = np.zeros(opt.num_episode)
moving_average_clipped = 0.
moving_average = 0.
batch_state = nd.empty((opt.batch_size, opt.seq_len, opt.num_inputs), opt.ctx)
batch_state_next = nd.empty((opt.batch_size, opt.seq_len, opt.num_inputs),
opt.ctx)
for i in range(opt.num_episode):
cum_clipped_reward = 0
cum_reward = 0
state = env.reset()
t = 0.
done = False
target_dqn_hidden = target_dqn.begin_state(func=mx.nd.zeros,
batch_size=opt.batch_size,
ctx=opt.ctx)
dqn_hidden = dqn.begin_state(func=mx.nd.zeros,
batch_size=opt.batch_size,
ctx=opt.ctx)
# -*- coding: utf-8 -*- """ Created on Fri Jun 29 09:57:51 2018 @author: Taylor """ # import mxnet from mxnet import nd # this is just going to grab random rubbish from memory... x = nd.empty(shape=(2, 3)) print(x) print(type(x)) # this gives zeros x = nd.zeros(shape = (3, 2)) print(x) print(type(x)) # ones x = nd.ones(shape = (2, 3)) print(x) # ?nd.random_normal # loc = mean
def _generator(self):
"""
Yields a length `T` trajectory
(Straight from the openAI code, essentially)
"""
# Initial setup
ac = self._env.action_space.sample(
) # not used, just so we have the datatype
self.new = True # marks if we're on first timestep of an episode
self.ob = self._convert_state(self._env.reset())
T = self._timesteps
cur_ep_ret = 0 # return in current episode
cur_ep_len = 0 # len of current episode
ep_rets = [] # returns of completed episodes in this segment
ep_lens = [] # lengths of ...
# Initialize history arrays
#obs = np.array([None for _ in range(T)])
obs = nd.empty((T, ) + self._env.observation_space.shape)
rews = np.zeros(T, 'float32')
vpreds = np.zeros(T, 'float32')
news = np.zeros(T, 'int32')
acs = np.array([ac for _ in range(T)])
prevacs = acs.copy()
t = 0
while True:
ob = self.ob # Use `self.` since `_evaluate` may have reset the env
new = self.new
prevac = ac
ac, vpred = self._act(ob)
# NOTE(openAI) Slight weirdness here because we need value function at time T
# before returning segment [0, T-1] so we get the correct terminal value
if t > 0 and t % T == 0:
seg = {
"ob": obs,
"rew": rews,
"vpred": vpreds,
"new": news,
"ac": acs,
"nextvpred": vpred * (1 - new),
"ep_rets": np.array(copy.deepcopy(ep_rets)),
"ep_lens": np.array(copy.deepcopy(ep_lens))
}
self._add_vtarg_and_adv(seg, self._gamma, self._lambda)
yield seg
# NOTE: Do a deepcopy if the values formerly in these arrays are used later.
ep_rets = []
ep_lens = []
i = t % T
obs[i] = ob[0]
vpreds[i] = vpred
news[i] = new
acs[i] = ac
prevacs[i] = prevac
ob, rew, new, _ = self._env.step(ac)
ob = self._convert_state(ob)
rews[i] = rew
cur_ep_ret += rew
cur_ep_len += 1
if new:
ep_rets.append(cur_ep_ret)
ep_lens.append(cur_ep_len)
cur_ep_ret = 0
cur_ep_len = 0
ob = self._convert_state(self._env.reset())
self.new = new
self.ob = ob
t += 1
x = self.conv(concated)
return x
net = Net()
# Build network #
#################
#########################
# Weight initialization #
net.initialize(mx.init.Xavier(), ctx=ctx, force_reinit=True)
state = net.encoder.begin_state(batch_size=batch_size, ctx=ctx)
x = nd.empty(shape=(batch_size, channel, depth, size, size), ctx=ctx)
out = net(x, state)
# Weight initialization #
#########################
###################
# Data processing #
def sliding_window(array, depth, target):
length = len(array) - depth - target - 1
data, label = [], []
trans = Resize(size)
for i in range(length):
def test_ndarray_empty():
a = nd.empty((LARGE_X, SMALL_Y))
assert a.shape == (LARGE_X, SMALL_Y)
def test_ndarray_empty():
a = nd.empty((LARGE_X, SMALL_Y))
assert a.shape == (LARGE_X, SMALL_Y)
def test_ndarray_empty():
a = nd.empty(LARGE_X)
assert a.shape == (LARGE_X, )
to_str_func = np.vectorize(lambda x: np.binary_repr(x).zfill(m))
strs = to_str_func(arr)
ret = np.zeros(list(arr.shape) + [m], dtype=np.int8)
for bit_ix in range(0, m):
fetch_bit_func = np.vectorize(lambda x: x[bit_ix] == '1')
ret[..., bit_ix] = fetch_bit_func(strs).astype("int8")
return ret
# The bars-and-stripes data studied by Schulz et al. (2010)
mx.random.seed(123)
np.random.seed(123)
d = 4
m = d * d
N = 2 ** d
dat = nd.empty(shape=(2 * N, m))
bits = vec_bin_array(np.arange(N), d).astype(np.float)
for i in range(N):
mat = bits[i, :].reshape(1, -1).T.dot(np.ones(shape=(1, d)))
dat[2 * i, :] = mat.flatten()
dat[2 * i + 1, :] = mat.T.flatten()
ctx = mx.cpu()
dat = nd.array(dat, ctx=ctx)
N = dat.shape[0]
m = d * d
n = m
# Train RBM using CD-k
mx.random.seed(123)
np.random.seed(123)
def train_net(args, ctx, pretrained, epoch, prefix, begin_epoch, end_epoch, lr,
lr_step):
mx.random.seed(3)
np.random.seed(3)
if not os.path.exists(config.output_path):
os.mkdir(config.output_path)
logger, final_output_path = create_logger(config.output_path, args.cfg,
config.dataset.image_set)
prefix = os.path.join(final_output_path, prefix)
# load symbol
shutil.copy2(os.path.join(curr_path, 'symbols', config.symbol + '.py'),
final_output_path)
sym_instance = eval(config.symbol + '.' + config.symbol)()
sym = sym_instance.get_symbol(config, is_train=True)
feat_pyramid_level = np.log2(config.network.RPN_FEAT_STRIDE).astype(int)
feat_sym = [
sym.get_internals()['rpn_cls_score_p' + str(x) + '_output']
for x in feat_pyramid_level
]
# setup multi-gpu
batch_size = len(ctx)
input_batch_size = config.TRAIN.BATCH_IMAGES * batch_size
# print config
#pprint.pprint(config)
#logger.info('training config:{}\n'.format(pprint.pformat(config)))
# load dataset and prepare imdb for training
image_sets = [iset for iset in config.dataset.image_set.split('+')]
roidbs = [
load_gt_roidb(config.dataset.dataset,
image_set,
config.dataset.root_path,
config.dataset.dataset_path,
flip=config.TRAIN.FLIP) for image_set in image_sets
]
roidb = merge_roidb(roidbs)
roidb = filter_roidb(roidb, config)
# load training data
train_data = PyramidAnchorIterator(
feat_sym,
roidb,
config,
batch_size=input_batch_size,
shuffle=config.TRAIN.SHUFFLE,
ctx=ctx,
feat_strides=config.network.RPN_FEAT_STRIDE,
anchor_scales=config.network.ANCHOR_SCALES,
anchor_ratios=config.network.ANCHOR_RATIOS,
aspect_grouping=config.TRAIN.ASPECT_GROUPING,
allowed_border=np.inf)
# infer max shape
max_data_shape = [('data', (config.TRAIN.BATCH_IMAGES,
3 * config.CROP_NUM * config.CROP_NUM,
max([v[0] for v in config.SCALES]),
max([v[1] for v in config.SCALES])))]
max_data_shape, max_label_shape = train_data.infer_shape(max_data_shape)
max_data_shape.append(('gt_boxes', (config.TRAIN.BATCH_IMAGES, 100,
6))) #change gt_boxes to 1,100,6
print 'providing maximum shape', max_data_shape, max_label_shape
data_shape_dict = dict(train_data.provide_data_single +
train_data.provide_label_single)
pprint.pprint(data_shape_dict)
sym_instance.infer_shape(data_shape_dict)
# load and initialize params
if config.TRAIN.RESUME:
print('continue training from ', begin_epoch)
arg_params, aux_params = load_param(prefix, begin_epoch, convert=True)
else:
arg_params, aux_params = load_param(pretrained, epoch, convert=True)
single_shape = arg_params['conv1_weight'].shape
temp_conv1_weight = nd.empty(
(single_shape[0], single_shape[1] * config.CROP_NUM *
config.CROP_NUM, single_shape[2], single_shape[3]),
dtype=arg_params['conv1_weight'].dtype)
for i in range(config.CROP_NUM * config.CROP_NUM):
temp_conv1_weight[:, i * single_shape[1]:(i + 1) *
single_shape[1], :, :] = arg_params[
'conv1_weight'][:, :, :, :]
del arg_params['conv1_weight']
arg_params['conv1_weight'] = temp_conv1_weight
sym_instance.init_weight(config, arg_params, aux_params)
# check parameter shapes
sym_instance.check_parameter_shapes(arg_params, aux_params,
data_shape_dict)
# create solver
fixed_param_prefix = config.network.FIXED_PARAMS
data_names = [k[0] for k in train_data.provide_data_single]
label_names = [k[0] for k in train_data.provide_label_single]
mod = MutableModule(
sym,
data_names=data_names,
label_names=label_names,
logger=logger,
context=ctx,
max_data_shapes=[max_data_shape for _ in range(batch_size)],
max_label_shapes=[max_label_shape for _ in range(batch_size)],
fixed_param_prefix=fixed_param_prefix)
if config.TRAIN.RESUME:
mod._preload_opt_states = '%s-%04d.states' % (prefix, begin_epoch)
# decide training params
# metric
rpn_eval_metric = metric.RPNAccMetric()
rpn_cls_metric = metric.RPNLogLossMetric()
rpn_bbox_metric = metric.RPNL1LossMetric()
rpn_fg_metric = metric.RPNFGFraction(config)
eval_metric = metric.RCNNAccMetric(config)
eval_fg_metric = metric.RCNNFGAccuracy(config)
cls_metric = metric.RCNNLogLossMetric(config)
bbox_metric = metric.RCNNL1LossMetric(config)
#fl_metric = metric.FocalLoss()
eval_metrics = mx.metric.CompositeEvalMetric()
# rpn_eval_metric, rpn_cls_metric, rpn_bbox_metric, eval_metric, cls_metric, bbox_metric
for child_metric in [
rpn_eval_metric, rpn_cls_metric, rpn_bbox_metric, rpn_fg_metric,
eval_fg_metric, eval_metric, cls_metric, bbox_metric
]:
eval_metrics.add(child_metric)
# callback
batch_end_callback = callback.Speedometer(train_data.batch_size,
frequent=args.frequent)
means = np.tile(np.array(config.TRAIN.BBOX_MEANS),
2 if config.CLASS_AGNOSTIC else config.dataset.NUM_CLASSES)
stds = np.tile(np.array(config.TRAIN.BBOX_STDS),
2 if config.CLASS_AGNOSTIC else config.dataset.NUM_CLASSES)
epoch_end_callback = [
mx.callback.module_checkpoint(mod,
prefix,
period=1,
save_optimizer_states=True),
callback.do_checkpoint(prefix, means, stds)
]
# decide learning rate
base_lr = lr
lr_factor = config.TRAIN.lr_factor
lr_epoch = [float(epoch) for epoch in lr_step.split(',')]
lr_epoch_diff = [
epoch - begin_epoch for epoch in lr_epoch if epoch > begin_epoch
]
lr = base_lr * (lr_factor**(len(lr_epoch) - len(lr_epoch_diff)))
lr_iters = [
int(epoch * len(roidb) / batch_size) for epoch in lr_epoch_diff
]
print('lr', lr, 'lr_epoch_diff', lr_epoch_diff, 'lr_iters', lr_iters)
lr_scheduler = WarmupMultiFactorScheduler(lr_iters, lr_factor,
config.TRAIN.warmup,
config.TRAIN.warmup_lr,
config.TRAIN.warmup_step)
# optimizer
optimizer_params = {
'momentum': config.TRAIN.momentum,
'wd': config.TRAIN.wd,
'learning_rate': lr,
'lr_scheduler': lr_scheduler,
'clip_gradient': None
}
#
if not isinstance(train_data, PrefetchingIter):
train_data = PrefetchingIter(train_data)
# train
mod.fit(train_data,
eval_metric=eval_metrics,
epoch_end_callback=epoch_end_callback,
batch_end_callback=batch_end_callback,
kvstore=config.default.kvstore,
optimizer='sgd',
optimizer_params=optimizer_params,
arg_params=arg_params,
aux_params=aux_params,
begin_epoch=begin_epoch,
num_epoch=end_epoch)
def stack(
data,
multi_processing: bool,
dtype: DType,
single_process_ctx: Optional[mx.Context] = None,
variable_length: bool = False,
):
"""
Stack a list of data. Used when creating a single batch from list of dicts
depending on whether multiprocessing is turned on, the batches will be
constructed using different memory allocation techniques. If `variable_length`
is specified, the data will be 'padded' with zeros along the first axis.
Parameters
----------
data: List
Lists of array-like, stacked into data batches and loaded to appropriate
memory (according to whether `multi_processing` is specified).
multi_processing: bool
If True, data will be loaded to mxnet ndarrays on shared CPU memory.
dtype: DType
single_process_ctx: Optional[mx.Context]
variable_length: bool
If True, the function will check if the list of data are "stackable",
i.e., they have matching axes. If not, it will assume that the first
dimension of each array is heterogeneous (i.e., ragged) and will pad
this axis before stacking.
"""
if variable_length and not _is_stackable(data):
data = _pad_arrays(data, axis=0)
if isinstance(data[0], mx.nd.NDArray):
if multi_processing:
out = nd.empty(
(len(data), ) + data[0].shape,
dtype=data[0].dtype,
ctx=context.Context("cpu_shared", 0),
)
return mx.nd.stack(*data, out=out)
else:
return mx.nd.stack(*data)
elif isinstance(data[0], np.ndarray):
data = np.asarray(data)
if data.dtype.kind == "f":
data = data.astype(dtype)
if multi_processing:
# Workaround due to MXNet not being able to handle NDArrays with 0 in shape properly:
if 0 in data.shape:
return data
return mx.nd.array(data,
dtype=data.dtype,
ctx=context.Context("cpu_shared", 0))
else:
return mx.nd.array(data, dtype=data.dtype, ctx=single_process_ctx)
elif isinstance(data[0], list):
return list(
stack(t, multi_processing, dtype, single_process_ctx)
for t in zip(*data))
elif isinstance(data[0], tuple):
return tuple(
stack(t, multi_processing, dtype, single_process_ctx)
for t in zip(*data))
return data
import mxnet as mx from mxnet import nd mx.random.seed(1) x = nd.empty((3, 4)) print(x) x = nd.zeros((3, 4)) print(x) y = nd.ones((3, 4)) print(x) print(nd.dot(x, y.T))
