def test_mse_loss(self):
jt_loss=jnn.MSELoss()
tc_loss=tnn.MSELoss()
output=np.random.randn(10,100).astype(np.float32)
target=np.random.randn(10,100).astype(np.float32)
jt_y=jt_loss(jt.array(output), jt.array(target))
tc_y=tc_loss(torch.from_numpy(output), torch.from_numpy(target))
assert np.allclose(jt_y.numpy(), tc_y.numpy())
nn.Linear((opt.n_classes + int(np.prod(img_shape))), 512),
nn.LeakyReLU(0.2), nn.Linear(512, 512), nn.Dropout(0.4),
nn.LeakyReLU(0.2), nn.Linear(512, 512), nn.Dropout(0.4),
nn.LeakyReLU(0.2), nn.Linear(512, 1))
def execute(self, img, labels):
d_in = jt.contrib.concat((img.view(
(img.shape[0], (-1))), self.label_embedding(labels)),
dim=1)
return self.model(d_in)
# 损失函数：平方误差
# 调用方法：adversarial_loss(网络输出A, 分类标签B)
# 计算结果：(A-B)^2
adversarial_loss = nn.MSELoss()
generator = Generator()
discriminator = Discriminator()
# 导入MNIST数据集
from jittor.dataset.mnist import MNIST
import jittor.transform as transform
transform = transform.Compose([
transform.Resize(opt.img_size),
transform.Gray(),
transform.ImageNormalize(mean=[0.5], std=[0.5]),
])
dataloader = MNIST(train=True,
transform=transform).set_attrs(batch_size=opt.batch_size,
shuffle=True)
b2 = 0.9
decay = (2.5 * 1e-05)
n_skip_iter = args.n_critic
img_size = args.img_size
channels = 1
latent_dim = args.latent_dim
n_c = 10
betan = 10
betac = 10
wass_metric = args.wass_flag
print(wass_metric)
x_shape = (channels, img_size, img_size)
bce_loss = nn.BCELoss()
xe_loss = nn.CrossEntropyLoss()
mse_loss = nn.MSELoss()
# Initialize generator and discriminator
generator = Generator_CNN(latent_dim, n_c, x_shape)
encoder = Encoder_CNN(latent_dim, n_c)
discriminator = Discriminator_CNN(wass_metric=wass_metric)
# Configure data loader
transform = transform.Compose([
transform.Resize(size=img_size),
transform.Gray(),
])
dataloader = MNIST(train=True,
transform=transform).set_attrs(batch_size=batch_size,
shuffle=True)
testdata = MNIST(train=False,
img = np.concatenate(
[img, img2[:, W * ncol * i:W * ncol * (i + 1), :]], axis=2)
min_ = img.min()
max_ = img.max()
img = (img - min_) / (max_ - min_) * 255
img = img.transpose((1, 2, 0))
if C == 3:
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
cv2.imwrite(path, img)
os.makedirs("images/%s" % opt.dataset_name, exist_ok=True)
os.makedirs("saved_models/%s" % opt.dataset_name, exist_ok=True)
# Loss functions
criterion_GAN = nn.MSELoss()
criterion_pixelwise = nn.L1Loss()
# Loss weight of L1 pixel-wise loss between translated image and real image
lambda_pixel = 100
# Calculate output of image discriminator (PatchGAN)
patch = (1, opt.img_height // 2**4, opt.img_width // 2**4)
# Initialize generator and discriminator
generator = GeneratorUNet()
discriminator = Discriminator()
if opt.epoch != 0:
# Load pretrained models
generator.load("saved_models/%s/generator_last.pkl" % (opt.dataset_name))
nn.Linear((128 * (ds_size**2)), opt.code_dim))
for m in self.modules():
weights_init_normal(m)
def execute(self, img):
out = self.conv_blocks(img)
out = out.view((out.shape[0], (-1)))
validity = self.adv_layer(out)
label = self.aux_layer(out)
latent_code = self.latent_layer(out)
return (validity, label, latent_code)
# Loss functions
adversarial_loss = nn.MSELoss()
categorical_loss = nn.CrossEntropyLoss()
continuous_loss = nn.MSELoss()
# Loss weights
lambda_cat = 1
lambda_con = 0.1
# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()
# Configure data loader
from jittor.dataset.mnist import MNIST
import jittor.transform as transform
nn.ReLU(),
nn.Linear(32, down_dim),
nn.BatchNorm1d(down_dim),
nn.ReLU()
)
self.up = nn.Sequential(nn.Upsample(scale_factor=2), nn.Conv(64, opt.channels, 3, stride=1, padding=1))
def execute(self, img):
out = self.down(img)
embedding = self.embedding(out.reshape((out.shape[0], (- 1))))
out = self.fc(embedding)
out = self.up(out.reshape((out.shape[0], 64, self.down_size, self.down_size)))
return (out, embedding)
# Reconstruction loss of AE
pixelwise_loss = nn.MSELoss()
# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()
# Optimizers
optimizer_G = jt.optim.Adam(generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
optimizer_D = jt.optim.Adam(discriminator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
def pullaway_loss(embeddings):
norm = jt.sqrt((embeddings ** 2).sum(1,keepdims=True))
normalized_emb = embeddings / norm
similarity = jt.matmul(normalized_emb, normalized_emb.transpose(1, 0))
batch_size = embeddings.size(0)
loss_pt = (jt.sum(similarity) - batch_size) / (batch_size * (batch_size - 1))
