def main():
args = process_args()
print("using:", device)
# dataset setup
XYtrainLoader, XYvalidLoader, XYtestLoader, prior, dim = load_dataset(
args.dataset,
args.labeled,
args.unlabeled,
args.batchsize,
with_bias=True,
resample_model=args.model)
# model setup
loss_type = select_loss(args.loss)
selected_model = select_model(args.model)
model = selected_model(dim)
models = {
"nnPU": copy.deepcopy(model).to(device),
"nnPUSB": copy.deepcopy(model).to(device)
}
loss_funcs = {
"nnPU": nnPUloss(prior,
loss=loss_type,
gamma=args.gamma,
beta=args.beta),
"nnPUSB": nnPUSBloss(prior, gamma=args.gamma, beta=args.beta)
}
# trainer setup
optimizers = {
k: make_optimizer(v, args.stepsize)
for k, v in models.items()
}
print("input dim: {}".format(dim))
print("prior: {}".format(prior))
print("loss: {}".format(args.loss))
print("batchsize: {}".format(args.batchsize))
print("model: {}".format(selected_model))
print("beta: {}".format(args.beta))
print("gamma: {}".format(args.gamma))
print("")
# run training
# training
PUtrainer = trainer(models, loss_funcs, optimizers, XYtrainLoader,
XYvalidLoader, XYtestLoader, prior)
PUtrainer.run(args.epoch)
layer5 = self._compute_cond_module(self.res5, layer4)
ref1 = self.refine1([layer5], layer5.shape[2:])
ref2 = self.refine2([layer4, ref1], layer4.shape[2:])
ref31 = self.refine31([layer31, ref2], layer31.shape[2:])
ref3 = self.refine3([layer3, ref31], layer3.shape[2:])
ref4 = self.refine4([layer2, ref3], layer2.shape[2:])
output = self.refine5([layer1, ref4], layer1.shape[2:])
output = self.normalizer(output)
output = self.act(output)
output = self.end_conv(output)
return output
if __name__ == '__main__':
from args import process_args
args = process_args()
if args.model_choice == 'ncsnv2':
model = NCSNv2(norm_type=args.norm_type,act_type=args.act)
elif args.model_choice == 'ncsnv2_deeper':
model = NCSNv2Deeper(norm_type=args.norm_type,act_type=args.act)
elif args.model_choice == 'ncsnv2_deepest':
model = NCSNv2Deepest(norm_type=args.norm_type,act_type=args.act)
print(model)
print(torch.rand(64,3,32,32).shape, model(torch.rand(64,3,32,32)).shape)
args.exp_dir, "finetune_%s_generator_complete.pth" % task.name
)
save_model(finetune_generator_complete_ckpt, sup_model["generator"])
finetune_discriminator_complete_ckpt = os.path.join(
args.exp_dir, "finetune_%s_discriminator_complete.pth" % task.name
)
save_model(finetune_discriminator_complete_ckpt, sup_model["discriminator"])
else:
finetune_complete_ckpt = os.path.join(
args.exp_dir, "finetune_%s_complete.pth" % task.name
)
save_model(finetune_complete_ckpt, sup_model)
# evaluate
# TODO: evaluate result on test split, write prediction for leaderboard submission (for dataset
# without test labels)
log.info("Done")
return
if __name__ == "__main__":
args = parser.parse_args()
process_args(args)
main(args)
from transactions import TransactionsList
from args import process_args
from apriori import Apriori
from dic import Dic
from stats import Stats
from rules import RulesGenerator
from writer import Writer
def main(args):
stats = Stats()
transactions = TransactionsList(args.infile)
if args.algorithm == 'apriori':
algorithm = Apriori(transactions, args.minsup)
else:
algorithm = Dic(transactions, args.minsup, args.m)
large_sets, counter = algorithm.get_large_sets_and_counter()
stats.record_post_large_sets()
rules = RulesGenerator.generate_rules(large_sets, args.minconf, counter, transactions)
stats.record_post_rules()
writer = Writer(args.outfile)
writer.add_args(args)
writer.add_stats(stats)
writer.add_rules(rules)
writer.write()
if __name__ == '__main__':
args = process_args()
main(args)
shadow_buffers = OrderedDict(self.shadow.named_buffers())
# check if both model contains the same set of keys
assert model_buffers.keys() == shadow_buffers.keys()
for name, buffer in model_buffers.items():
# buffers are copied
shadow_buffers[name].copy_(buffer)
def forward(self, inputs):
return self.shadow(inputs)
if __name__ == '__main__':
import args
args = args.process_args()
import data
test_data = data.Data(args, 'test')
r = torch.normal(mean=10, std=1, size=[64, 2048]).numpy()
m = np.mean(r, axis=0)
c = np.cov(r, rowvar=False)
print(m.shape, c.shape, (m + 1).shape, (c + 1).shape)
print(calculate_frechet_distance(m, c, m + 1e-1, c + 1e-1))
loader = torch.utils.data.DataLoader(test_data, 5000)
for i, batch in enumerate(loader):
if i > 1:
break
# print(torch.unique(batch))
batch = (batch * 2) - 1
print(inception_score(batch, False, 8, True, 10))