def _test_clamp_scalar_max(test_case, shape, device):
input = flow.tensor(np.random.randn(*shape),
dtype=flow.float32,
device=flow.device(device))
of_out = flow.clamp(input, None, 0.5)
np_out = np.clip(input.numpy(), None, 0.5)
test_case.assertTrue(np.allclose(of_out.numpy(), np_out, 1e-05, 1e-05))
def forward(self, inputs, targets):
"""
Args:
inputs (torch.Tensor): feature matrix with shape (batch_size, feat_dim).
targets (torch.LongTensor): ground truth labels with shape (num_classes).
"""
n = inputs.size(0)
# Compute pairwise distance, replace by the official when merged
dist = flow.pow(inputs, 2).sum(dim=1).expand(n, n)
dist = dist + flow.transpose(dist, dim0=1, dim1=0)
temp1 = -2 * flow.matmul(inputs, flow.transpose(inputs, dim0=1,
dim1=0))
dist = flow.add(dist, temp1)
dist = flow.sqrt(flow.clamp(dist, min=1e-12))
# For each anchor, find the hardest positive and negative
mask = targets.expand(n, n).eq(
flow.transpose(targets.expand(n, n), dim0=1, dim1=0))
dist_ap, dist_an = [], []
y1 = flow.zeros((1, n), dtype=flow.float32).to("cuda")
y2 = flow.Tensor(np.exp(100 * np.ones((1, n)))).to("cuda")
for i in range(n):
temp_dist = flow.slice(dist, [(i, i + 1, 1)])
temp_mask = flow.slice(mask, [(i, i + 1, 1)])
temp_mask_rev = flow.slice(1 - mask, [(i, i + 1, 1)])
dist_ap.append(temp_mask.where(temp_dist, y1).max().unsqueeze(0))
dist_an.append(
temp_mask_rev.where(temp_dist, y2).min().unsqueeze(0))
dist_ap = flow.cat(dist_ap)
dist_an = flow.cat(dist_an)
# Compute ranking hinge loss
y = flow.ones_like(dist_an)
return self.ranking_loss(dist_an, dist_ap, y)
def build(self,inputs,targets):
n=inputs.shape[0]
if self.distance=='euclidean':
dist=flow.math.pow(inputs,2)
dist=flow.math.reduce_sum(dist, axis=1, keepdims=True)
dist=np.tile(dist,(n, n))
dist_t=flow.transpose(dist)
dist=dist+dist_t
inputs_t=flow.transpose(inputs)
dist=addmm(dist,inputs,inputs_t,beta=1,alpha=-2)
dist=flow.clamp(min_value=1e-12)
dist=flow.math.sqrt(dist)
elif self.distance == 'cosine':
fnorm=np.linalg.norm(inputs,ord=2,axis=1,keepdims=True)
l2norm=np.tile(inputs,(inputs.shape))
l2norm=inputs/l2norm
l2norm_t=flow.transpose(l2norm)
dist=-np.matmul(l2norm,l2norm_t)
target_expand=np.tile(targets,(n,n))
target_expand_t=flow.transpose(target_expand)
mask=flow.math.equal(target_expand,target_expand_t)
dist_ap, dist_an = [], []
for i in range(n):
temp=np.ndarray.max(dist[i][mask[i]])
temp=flow.expand_dims(temp,axis=0)
dist_ap.append(temp)
temp=np.ndarray.min(dist[i][mask[i]==0])
temp=flow.expand_dims(temp,axis=0)
dist_an.append(temp)
dist_ap=flow.concat(dist_ap)
dist_an=flow.concat(dist_an)
y=flow.ones_like(dist_an)
loss=self.ranking_loss(dist_an, dist_ap, y,margin=self.margin)
return loss
def styleNet(input, trainable=True):
with flow.scope.namespace("style_transfer"):
# Initial convolution layers
conv1 = conv2d_layer("first_conv",
input,
32,
kernel_size=9,
strides=1,
trainable=trainable)
in1 = instance_norm(conv1, "first_conv_in", trainable=trainable)
in1 = flow.nn.relu(in1)
conv2 = conv2d_layer("second_conv",
in1,
64,
kernel_size=3,
strides=2,
trainable=trainable)
in2 = instance_norm(conv2, "second_conv_in", trainable=trainable)
in2 = flow.nn.relu(in2)
conv3 = conv2d_layer("third_conv",
in2,
128,
kernel_size=3,
strides=2,
trainable=trainable)
in3 = instance_norm(conv3, "third_conv_in", trainable=trainable)
in3 = flow.nn.relu(in3)
# Residual layers
res1 = resBlock(in3, 128, "res1", trainable=trainable)
res2 = resBlock(res1, 128, "res2", trainable=trainable)
res3 = resBlock(res2, 128, "res3", trainable=trainable)
res4 = resBlock(res3, 128, "res4", trainable=trainable)
res5 = resBlock(res4, 128, "res5", trainable=trainable)
# Upsampling Layers
upsample1 = upsampleConvLayer(res5,
"upsample1",
64,
3,
trainable=trainable)
# upsample1 = deconv(res5, 64, "upsample1", kernel_size = 4, strides = [2, 2], trainable = True)
in4 = instance_norm(upsample1, "upsample1_in", trainable=trainable)
in4 = flow.nn.relu(in4)
upsample2 = upsampleConvLayer(in4,
"upsample2",
32,
3,
trainable=trainable)
# upsample2 = deconv(in4, 32, "upsample2", kernel_size = 4, strides = [2, 2], trainable = True)
in5 = instance_norm(upsample2, "upsample2_in", trainable=trainable)
in5 = flow.nn.relu(in5)
conv1 = conv2d_layer("last_conv",
in5,
3,
kernel_size=9,
strides=1,
trainable=trainable)
out = flow.clamp(conv1, 0, 255)
return out
def build(self, inputs, targets):
"""
Args:
inputs (torch.Tensor): feature matrix with shape (batch_size, feat_dim).
targets (torch.LongTensor): ground truth labels with shape (num_classes).
"""
n = inputs.shape[0]
dist = math.reduce_sum(math.pow(
inputs, flow.constant_like(inputs, 2, dtype=flow.float32)),
axis=1)
shape_tensor = flow.constant(value=0.0,
dtype=flow.float32,
shape=(n, n))
dist = flow.broadcast_like(dist, like=shape_tensor, broadcast_axes=[1])
dist = math.add(
dist, flow.transpose(dist, perm=(1, 0),
batch_axis_non_change=True))
temp1 = math.multiply(
-2,
flow.matmul(
inputs,
flow.transpose(inputs, perm=(1, 0),
batch_axis_non_change=True)))
dist = math.add(dist, temp1)
dist = math.sqrt(flow.clamp(dist, min_value=1e-12))
mask = math.equal(
flow.broadcast_like(targets, like=shape_tensor,
broadcast_axes=[1]),
flow.transpose(flow.broadcast_like(targets,
like=shape_tensor,
broadcast_axes=[1]),
perm=(1, 0),
batch_axis_non_change=True))
mask_rev = math.not_equal(
flow.broadcast_like(targets, like=shape_tensor,
broadcast_axes=[1]),
flow.transpose(flow.broadcast_like(targets,
like=shape_tensor,
broadcast_axes=[1]),
perm=(1, 0),
batch_axis_non_change=True))
dist_ap, dist_an = [], []
for i in range(n):
temp_dist = flow.slice_v2(dist, [(i, i + 1, 1)])
temp_mask = flow.slice_v2(mask, [(i, i + 1, 1)])
temp_mask_rev = flow.slice_v2(mask_rev, [(i, i + 1, 1)])
dist_ap.append(
math.reduce_max(
flow.gather_nd(temp_dist, flow.where(temp_mask))))
dist_an.append(
math.reduce_min(
flow.gather_nd(temp_dist, flow.where(temp_mask_rev))))
dist_ap = flow.concat(dist_ap, 0)
dist_an = flow.concat(dist_an, 0)
y = flow.ones_like(dist_an)
# return dist_an, dist_ap, y
return self._MarginRankingLoss(dist_an, dist_ap, y)
def _trunc_normal_(
self,
mean=0.0,
std=1.0,
a=-2.0,
b=2.0,
):
initializer_conf = flow.truncated_normal_initializer(mean=mean, stddev=std)
res = _init_by_initializer_conf(self, initializer_conf)
res = flow.clamp(res, min=a, max=b)
return res
def _test_clamp_backward(test_case, shape, device):
x = flow.tensor(
np.random.randn(*shape),
dtype=flow.float32,
device=flow.device(device),
requires_grad=True,
)
y = flow.clamp(x, 0.1, 0.5).sum()
y.backward()
test_case.assertTrue(
np.allclose(x.grad.numpy(), _numpy_clamp_grad(x.numpy(), 0.1, 0.5),
1e-05, 1e-05))
def forward(self, X):
y = self.relu(self.in1(self.conv1(X)))
y = self.relu(self.in2(self.conv2(y)))
y = self.relu(self.in3(self.conv3(y)))
y = self.res1(y)
y = self.res2(y)
y = self.res3(y)
y = self.res4(y)
y = self.res5(y)
y = self.relu(self.in4(self.deconv1(y)))
y = self.relu(self.in5(self.deconv2(y)))
y = self.deconv3(y)
y = flow.clamp(y, 0, 255)
return y
def forward(self, waveforms):
"""
Parameters
----------
waveforms : `oneflow.Tensor` (batch_size, 1, n_samples)
Batch of waveforms.
Returns
-------
features : `oneflow.Tensor` (batch_size, out_channels, n_samples_out)
Batch of sinc filters activations.
"""
self.n_ = self.n_.to(waveforms.device)
self.window_ = self.window_.to(waveforms.device)
low = self.min_low_hz + flow.abs(self.low_hz_)
high = flow.clamp(
low + self.min_band_hz + flow.abs(self.band_hz_),
self.min_low_hz,
self.sample_rate / 2,
)
band = (high - low)[:, 0]
f_times_t_low = flow.matmul(low, self.n_)
f_times_t_high = flow.matmul(high, self.n_)
band_pass_left = (
(flow.sin(f_times_t_high) - flow.sin(f_times_t_low)) / (self.n_ / 2)
) * self.window_
band_pass_center = 2 * band.reshape(-1, 1)
band_pass_right = flow.flip(band_pass_left, dims=[1])
band_pass = flow.cat([band_pass_left, band_pass_center, band_pass_right], dim=1)
band_pass = band_pass / (2 * band[:, None])
self.filters = (band_pass).reshape(self.out_channels, 1, self.kernel_size)
output = F.conv1d(
waveforms,
self.filters,
stride=[self.stride],
padding=[self.padding],
dilation=[self.dilation],
bias=None,
groups=1,
)
return output
def MergeTail(x1, x2, x3, trainable=True):
x13 = flow.layers.upsample_2d(x1, (4, 4),
interpolation='bilinear',
name='upsanple7')
x13 = conv1x1(x13, 64, "MergeTail_0", trainable=trainable)
x13 = flow.math.relu(x13)
x23 = flow.layers.upsample_2d(x2, (2, 2),
interpolation='bilinear',
name='upsanple8')
x23 = conv1x1(x23, 64, "MergeTail_1", trainable=trainable)
x23 = flow.math.relu(x23)
x = conv3x3(flow.concat((x3, x13, x23), axis=1),
64,
"MergeTail_2",
trainable=trainable)
x = flow.math.relu(x)
x = conv3x3(x, 32, "MergeTail_3", trainable=trainable)
x = conv1x1(x, 3, "MergeTail_4", trainable=trainable)
x = flow.clamp(x, -1, 1)
return x
def _test_clamp_integral(test_case, shape, device):
input = flow.tensor(np.random.randint(3, 10, shape),
device=flow.device(device))
of_out = flow.clamp(input, 1, 5)
np_out = np.clip(input.numpy(), 1, 5)
test_case.assertTrue(np.allclose(of_out.numpy(), np_out, 1e-05, 1e-05))
def forward(self, inputs, targets):
n = inputs.shape[0]
# Compute pairwise distance, replace by the official when merged
tempname = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S.%f')
shape_tensor = flow.constant(value=0.0,
dtype=flow.float32,
shape=(n, n))
if self.distance == 'euclidean':
blob_2 = flow.get_variable(
"blob_2_" + tempname,
shape=inputs.shape,
initializer=flow.constant_initializer(2),
dtype=inputs.dtype)
dist = flow.math.pow(inputs, blob_2)
dist = flow.math.reduce_sum(dist, axis=1, keepdims=True)
dist = flow.broadcast_like(dist, shape_tensor)
tempdist = flow.transpose(dist)
dist = dist + tempdist
inputs_t = flow.transpose(inputs)
dist = addmm(dist, inputs, inputs_t, beta=1, alpha=-2)
dist = flow.clamp(dist, min_value=1e-12)
dist = flow.math.sqrt(dist)
elif self.distance == 'cosine':
#fnorm=flow.math.l2_normalize(inputs, axis=1)
fnorm = flow.math.reduce_mean(flow.math.divide(
inputs, flow.math.l2_normalize(inputs, axis=1)),
axis=1,
keepdims=True)
expand_fnorm = flow.broadcast_like(fnorm,
like=inputs,
broadcast_axes=[1])
l2norm = flow.math.divide(inputs, expand_fnorm)
l2norm_t = flow.transpose(l2norm, perm=(1, 0))
dist = flow.math.negative(flow.matmul(l2norm, l2norm_t))
# For each anchor, find the hardest positive and negative
mask = math.equal(
flow.broadcast_like(targets, like=shape_tensor,
broadcast_axes=[1]),
flow.transpose(flow.broadcast_like(targets,
like=shape_tensor,
broadcast_axes=[1]),
perm=(1, 0),
batch_axis_non_change=True))
mask_rev = math.not_equal(
flow.broadcast_like(targets, like=shape_tensor,
broadcast_axes=[1]),
flow.transpose(flow.broadcast_like(targets,
like=shape_tensor,
broadcast_axes=[1]),
perm=(1, 0),
batch_axis_non_change=True))
dist_ap, dist_an = [], []
for i in range(n):
temp_dist = flow.slice_v2(dist, [(i, i + 1, 1)])
temp_mask = flow.slice_v2(mask, [(i, i + 1, 1)])
temp_mask_rev = flow.slice_v2(mask_rev, [(i, i + 1, 1)])
temp_dist_ap = flow.expand_dims(
math.reduce_max(
flow.gather_nd(temp_dist, flow.where(temp_mask))), 0)
temp_dist_an = flow.expand_dims(
math.reduce_min(
flow.gather_nd(temp_dist, flow.where(temp_mask_rev))), 0)
dist_ap.append(temp_dist_ap)
dist_an.append(temp_dist_an)
dist_ap = flow.concat(dist_ap, 0)
dist_an = flow.concat(dist_an, 0)
y = flow.ones_like(dist_an)
return self._MarginRankingLoss(dist_an, dist_ap, y)