def test_MemOps(): error = 0 t1 = tensor.Tensor() t2 = tensor.Tensor() # arr = np.ones((2,2)) #arr = tensor.VectorDouble([2,2,2]) arr = tensor.VectorFloat([2,2,2]) t1.Reshape(tensor.VectorInt([3,1])) t1.reinit(arr, 3) # t2.reinit(arr) # k = tensor.Tensor() # k.assign( t1[0] ) # if sum(t1.data - t2.data).sum() != 0: # error += 1 # print(sum(t1.data - t3.data).sum()) # arr = np.ones((50,1)) # t1.reinit(arr) # t3 = t1 # if sum(t1.data - t3.data).sum() != 0: # error += 1 # arr = np.ones(t1.shape) # if sum(t1.data - arr).sum() != 0: # error += 1 # t1 = t2 # if sum(t3.data - arr).sum() != 0: # error += 1 return error
def apply_with_lr(self, epoch, lr, grad, value, name, step):
'''Update one parameter object.
Args:
step(int): the accumulated training iterations, not the iteration ID
'''
if grad.is_empty():
return value
assert step != -1, 'step should >= 0'
if epoch != self.last_epoch or step != self.last_step:
self.t += 1
grad = self.apply_regularizer_constraint(epoch, value, grad, name,
step)
if name is not None and name in self.learning_rate_multiplier:
lr = lr * self.learning_rate_multiplier[name]
if name not in self.m or name not in self.v:
self.m[name] = tensor.Tensor(grad.shape, grad.device, grad.dtype)
self.m[name].set_value(0)
self.v[name] = tensor.Tensor(grad.shape, grad.device, grad.dtype)
self.v[name].set_value(0)
self.m[name] *= self.beta_1
tensor.axpy(1 - self.beta_1, grad, self.m[name])
self.v[name] *= self.beta_2
tensor.axpy(1 - self.beta_2, tensor.square(grad), self.v[name])
alpha = lr * math.sqrt(1 - math.pow(self.beta_2, self.t)) \
/ (1 - math.pow(self.beta_1, self.t))
value -= alpha * self.m[name] / (tensor.sqrt(self.v[name]) +
self.epsilon)
return value
def __init__(self,
data=nn.Dataset(tensor.Tensor([1], [1]),
tensor.Tensor([1], [1])),
network=nn.Network(),
optimizer=nn.optimizer.SGD(0.01)):
self.data = data
self.network = network
self.optimizer = optimizer
def init():
array = []
table = []
for line in urlopen(
"https://archive.ics.uci.edu/ml/machine-learning-databases/tic-tac-toe/tic-tac-toe.data"
):
decoded_line = line.decode('UTF-8').lower().strip()
for i in range(0, 17, 2):
if (decoded_line[i] == 'x'):
array.extend([1., 0., 0.])
elif (decoded_line[i] == 'o'):
array.extend([0., 1., 0.])
else:
array.extend([0., 0., 0.])
if (decoded_line[18] == 'p'):
table.extend([1, 0]) #one - hot
else:
table.extend([0, 1])
data_count = len(table) // 2
if (len(table) != len(array)):
print("error")
train_count = data_count * 4 // 5
test_count = data_count - train_count
table = tensor.Tensor(table, [data_count, 2])
data = tensor.Tensor(array, [data_count, 27])
train_data = tensor.create_zeros([train_count, 27])
train_table = tensor.create_zeros([train_count, 2])
test_data = tensor.create_zeros([test_count, 27])
test_table = tensor.create_zeros([test_count, 2])
choice_list = tensor.create_arange(0, data_count)
tensor.set_shuffle(choice_list)
train_choice = tensor.create_zeros([train_count], int)
test_choice = tensor.create_zeros([test_count], int)
tensor.copy(choice_list, 0, train_count, train_choice)
tensor.copy(choice_list, train_count, test_count, test_choice)
tensor.copy_row(data, train_choice, train_data)
tensor.copy_row(table, train_choice, train_table)
tensor.copy_row(data, test_choice, test_data)
tensor.copy_row(table, test_choice, test_table)
with open('ttt_train_data.bin', 'wb') as f:
pickle.dump(train_data, f)
with open('ttt_train_table.bin', 'wb') as f:
pickle.dump(train_table, f)
with open('ttt_test_data.bin', 'wb') as f:
pickle.dump(test_data, f)
with open('ttt_test_table.bin', 'wb') as f:
pickle.dump(test_table, f)
print("done")
def backward(ctx, grad_output):
a, b = ctx.saved_tensors
grad_a = np.matmul(grad_output.data, np.transpose(b.data))
grad_b = np.matmul(np.transpose(a.data), grad_output.data)
grad_a = tensor.Tensor(grad_a)
grad_b = tensor.Tensor(grad_b)
return grad_a, grad_b
def backward(ctx, grad_output):
a, b = ctx.saved_tensors
grad_a = grad_output.data * b.data
grad_b = grad_output.data * a.data
grad_a = tensor.Tensor(unbroadcast(grad_a, a.shape))
grad_b = tensor.Tensor(unbroadcast(grad_b, b.shape))
return grad_a, grad_b
def __init__(self, w, b):
self.w = w
self.b = b
self.x = None
self.dout = None
self.max_index = 0
self.out = tensor.Tensor([0], [1, 1])
self.dx = tensor.Tensor([0], [1, 1])
self.dw = w.copy()
self.db = b.copy()
def test_relu():
relu = ReLU()
tensor = var([[1., -1.], [-1., 1.]])
forward = relu(tensor)
expected_forward = ts.Tensor([[1., 0.], [0., 1.]])
np.testing.assert_equal(forward.value.numpy, expected_forward.numpy)
d_output = ts.Tensor([[2., 2.], [2., 2.]])
relu.backward(d_output)
expected_backward = ts.Tensor([[2., 0.], [0., 2.]])
np.testing.assert_equal(tensor.grad.numpy, expected_backward.numpy)
def __next__(self) -> Tuple[ts.Tensor, ts.Tensor]:
if self._n + 1 == len(self._data) // self._batch_size:
raise StopIteration
images = self._get_chunk(self._data)
labels = self._get_chunk(self._target)
self._n += 1
if self._transform is not None:
images = self._transform(images)
return ts.Tensor(images), ts.Tensor(labels)
def __init__(self, filter, bias, stride, pad, padding):
self.filter = filter
self.bias = bias
self.dfilter = filter.copy()
self.dbias = bias.copy()
self.out = tensor.Tensor([1], [1, 1, 1, 1])
self.x = None
self.dout = None
self.dx = tensor.Tensor([1], [1, 1, 1, 1])
self.stride = stride
self.pad = pad
self.padding = padding
self.max_index = 0
def SSFC2E_F1(kets, spaceconfig, maxN=55):
'''
Sweep fidelity from center to edge, the single version taking fermionic sign into consideration.
Args:
kets (len-2 list): the kets to sweep fidelity.
spaceconfig (<SuperSpaceConfig>):
maxN (int, the maximum retained singular value for usv mode): and the maximum retained states for direct mode.
'''
nsite = kets[0].nsite
# prepair kets.
bra = kets[0].tobra(labels=[kets[0].labels[0], kets[0].labels[1] + '\''])
ket = kets[1]
ket >> (nsite / 2 - ket.l, 1e-8, Inf)
bra >> (nsite / 2 - bra.l, 1e-8, Inf)
l = kets[0].forder.index(0) - nsite / 2 # bulk size/2.
rlink_axis = kets[0].rlink_axis
edge_labels_l = [
bra.ML[bra.l - 1].labels[rlink_axis],
ket.ML[ket.l - 1].labels[rlink_axis]
]
llink_axis = kets[0].llink_axis
bra.BL[0].labels[llink_axis] += '@'
ket.BL[0].labels[llink_axis] += '@'
edge_labels_r = [
bra.BL[0].labels[llink_axis], ket.BL[0].labels[llink_axis]
]
Ci = tensor.Tensor(
diag(bra.S),
labels=[edge_labels_l[0], edge_labels_r[0]]) * tensor.Tensor(
diag(ket.S), labels=[edge_labels_l[1], edge_labels_r[1]])
fs = [1]
# get the bulk overlap matrix.
for i in range(l):
t0 = time.time()
site_l = nsite / 2 - i - 1
site_r = nsite / 2 + i
Ci = bra.get(site_l, attach_S='B') * \
(ket.get(site_l, attach_S='B') * Ci)
Ci = Ci * bra.get(site_r, attach_S='A') * ket.get(site_r, attach_S='A')
Ci = Ci.chorder(array([0, 2, 1, 3]))
t1 = time.time()
print('Update %s, Elapse->%s' % (i, t1 - t0))
S = svdvals(Ci.reshape([Ci.shape[0] * Ci.shape[1], -1]))
f = sum(S)
print('Get Fidlity for l = %s: %s.' % (l, f))
return f
def __init__(self):
self.dx = tensor.Tensor([0], [1, 1])
self.x = None
self.out = 0
self.dout = None
self.t = None
self.max_index = 0
def totensor(self):
# returns a new Tensor object that contains the same values
data = np.zeros(self.shape)
for i in range(0, len(self.vals)):
data.put(int(tools.sub2ind(self.shape, self.subs[i])),
self.vals[i])
return tensor.Tensor(data)
def prepare(
cls,
model, # type: ModelProto
device, # type: singa device
**kwargs # type: Any
): # type: (...) -> Optional[BackendRep]
'''
Args:
model: onnx model proto
device: singa device
Return:
SingaBackendRep instance
'''
super(SingaBackend, cls).prepare(model, device, **kwargs)
name2tensor = {}
for node in model.graph.node:
if (node.op_type == 'Constant'):
data = helper.get_attribute_value(node.attribute[0])
requires_grad, stores_grad = True, True
if len(node.attribute) == 3:
requires_grad = helper.get_attribute_value(
node.attribute[1])
stores_grad = helper.get_attribute_value(node.attribute[2])
t = tensor.Tensor(device=device,
data=numpy_helper.to_array(data),
requires_grad=requires_grad,
stores_grad=stores_grad)
name2tensor[node.output[0]] = t
return SingaBackendRep(model, device, name2tensor)
def SSFLR(kets, direction):
'''
Sweep fidelity for left to right or right to left.
'''
bra = kets[0].tobra(labels=[kets[0].labels[0], kets[0].labels[1] + '\''])
ket = kets[1]
nsite = ket.nsite
if direction == '->':
[keti << keti.l - 1 for keti in [bra, ket]]
step = 1
clink_axis = kets[0].llink_axis
attach_S = 'A'
edge_labels = [
bra.ML[0].labels[clink_axis], ket.ML[0].labels[clink_axis]
]
else:
step = -1
clink_axis = kets[0].rlink_axis
attach_S = 'B'
[keti >> nsite - 1 - keti.l for keti in [bra, ket]]
edge_labels = [
bra.get(nsite - 1).labels[clink_axis],
ket.get(nsite - 1).labels[clink_axis]
]
Ri = tensor.Tensor(identity(1), labels=edge_labels)
fs = [1]
for i in range(nsite):
sitei = i if direction == '->' else nsite - i - 1
Ri = (bra.get(sitei, attach_S=attach_S) * Ri *
ket.get(sitei, attach_S=attach_S))
S = svdvals(Ri)
fs.append(sum(S))
print(i, sum(S))
return fs
def backward(self, flag, grads):
assert len(grads) > 1, 'There must be multiple gradients'
dx = tensor.Tensor()
dx.reset_like(grads[0])
dx.set_value(0)
for g in grads:
dx += g
return dx, []
def test_Tensor():
error = 0
t = tensor.Tensor()
# print("tensor see {0}".format(t.count))
m = t.L2
# print("tensor see {0}".format(m))
t.Reshape(tensor.VectorInt([2, 2, 2]))
return error
def __init__(self, exp_func=math.exp, log_func=math.log):
self.exp_func = exp_func
self.log_func = log_func
self.loss = None
self.y = None
self.t = None
self.out = tensor.Tensor([0], [1])
self.tmp_sum = None
self.batch_size = 0
def forward(self, flag, inputs):
assert len(inputs) > 1, 'There must be multiple input tensors'
self.num_input = len(inputs)
output = tensor.Tensor()
output.reset_like(inputs[0])
output.set_value(0)
for x in inputs:
output += x
return output
def findAccuracy(self):
acc = tensor.Tensor([0], [1])
for i, x, y in self.data.normalRange():
self.network.setX(x)
result = self.network.forward()
for j in range(len(result.array)):
if (result.array[j] > 0.5):
acc.array[0] += y.array[j]
acc.array[0] /= y.shape[0]
return acc
def __init__(self, W, b):
self.W = W
self.dW = W.copy()
self.W_t = tensor.create_transpose(W)
self.b = b
self.db = b.copy()
self.out = tensor.Tensor([0], [1, 1])
self.dout = None
self.x = None
self.x_t = None
def accuracy(self, table):
"""forward를 반드시 해야 하고, backward 이전에 사용해야 합니다."""
out = self.layers[-1].out
out_argmax = tensor.argmax(out, -1, tensor.create_sum(out, -1))
table_argmax = tensor.argmax(table, -1, tensor.create_sum(table, -1))
eq = tensor.function_elment_wise(
out_argmax, table_argmax, Layers._equal,
tensor.create_element_wise_product(out_argmax, table_argmax, int))
reduce_sum = tensor.sum_axis(eq, 0, tensor.Tensor([1], [1]))
return reduce_sum.array[0] / len(out_argmax.array)
def forward(ctx, a):
if not type(a).__name__ == "Tensor":
raise Exception("Sigmoid can only be applied to tensors")
ctx.save_for_backward(a)
out = tensor.Tensor(sigmoid(a.data),
requires_grad=a.requires_grad,
is_leaf=not a.requires_grad)
out.children = [a]
out.op = 'sigmoid'
return out
def forward(ctx, a):
if not type(a).__name__ == "Tensor":
raise Exception(
f"Only neg of tensor is supported. Got: {type(a).__name__}")
out = tensor.Tensor(-a.data,
requires_grad=a.requires_grad,
is_leaf=not a.requires_grad)
out.children = [a]
out.op = 'neg'
return out
def forward(ctx, a):
if not type(a).__name__ == 'Tensor':
raise Exception("ReLU can only be applied to tensors")
ctx.save_for_backward(a)
out = tensor.Tensor(np.maximum(a.data, 0),
requires_grad=a.requires_grad,
is_leaf=not a.requires_grad)
out.children = [a]
out.op = 'relu'
return out
def __init__(self,
bvecs,
bvals,
odf,
iso=False,
scaling_factor=SCALE_FACTOR,
axial_diffusivity=AD,
radial_diffusivity=RD):
"""
The signal in a single voxel is computed from the convolution of a
response function with the ODF
Parameters
----------
bvecs: 3 by n array
unit vectors on the sphere.
bvals: 1 by n array
The measurement parameter defining where on the curve we measure
the exponential decay of the signal
odf: an ODF class instance
The representation of the orientation distribution function. Note
that this class also has bvecs, but these bvecs don't have to be
the same bvecs as the ones of this class. bvecs In this class refer
to measurement directions, while the bvecs in the ODF class refer
to directions of fibers within the voxel (not necessarily the
same...)
iso : float (optional)
Whether and how much of an isotropic component to add to the
signal. Default: False - no isotropic component
scaling_factor: float (optional)
To get the right units on the ADC, sometimes the b value needs to
be scaled. Typically, divided by 1000 (default).
axial_diffusivity, radial_diffusivity: float
These parameters
"""
self.bvecs = bvecs
self.bvals = bvals/scaling_factor
self.odf = odf
# We assume that the response function is a cigar shaped tensor:
self.Q = np.array([[axial_diffusivity, 0, 0],
[0, radial_diffusivity, 0],
[0, 0, radial_diffusivity]])
self.response_function = ozt.Tensor(self.Q, self.bvecs, self.bvals)
self.iso = iso
def forward(ctx, a):
if not len(a.shape) == 2:
raise Exception("Arg for Transpose must be 2D tensor: {}".format(
a.shape))
requires_grad = a.requires_grad
out = tensor.Tensor(a.data.T,
requires_grad=requires_grad,
is_leaf=not requires_grad)
out.children = [a]
out.op = 'transpose'
return out
def chlabel(self, nlabel):
'''
Change the overall labels.
'''
self.labels = nlabel
for i, (l_left, l_right) in enumerate(zip(self.SN[:-1], self.SN[1:])):
l_all = ''.join(str(i) for i in range(l_left, l_right))
self.ML[i] = tensor.Tensor(self.ML[i],
labels=[
'%s_%s' % (nlabel[1], l_left),
'%s_%s' % (nlabel[0], l_all),
'%s_%s' % (nlabel[1], l_right)
])
def backward(ctx, grad_output):
x, weight, bias = ctx.saved_tensors
x_cols = ctx.x_cols
stride, pad = ctx.stride, ctx.pad
N, C, L = x.shape
F, _, KL = weight.shape
_, _, OL = grad_output.shape
grad_bias = np.sum(grad_output.data, axis=(0, 2))
grad_bias = tensor.Tensor(grad_bias)
grad_out_reshaped = grad_output.data.transpose(1, 2, 0).reshape(F, -1)
grad_weight = (grad_out_reshaped @ x_cols.T).reshape(weight.shape)
grad_weight = tensor.Tensor(grad_weight)
grad_x_cols = weight.data.reshape(F, -1).T @ grad_out_reshaped
grad_x_cols.shape = (C, KL, N, OL)
grad_x = col2im(grad_x_cols, x.shape, 1, KL, pad, stride)
grad_x = tensor.Tensor(grad_x)
return grad_x, grad_weight, grad_bias
def forward(ctx, a, b):
if not (type(a).__name__ == 'Tensor' and type(b).__name__ == 'Tensor'):
raise Exception("Only tensors can be multiplied element-wise")
ctx.save_for_backward(a, b)
requires_grad = a.requires_grad or b.requires_grad
out = tensor.Tensor(np.multiply(a.data, b.data),
requires_grad=requires_grad,
is_leaf=not requires_grad)
out.children = [a, b]
out.op = 'mul'
return out
