def prop(n):
save = toList(n)
save.sort()
factors = [2, 3, 4, 5, 6]
for i in factors:
tmp = toList(i*n)
tmp.sort()
if tmp != save:
return False
return True
def predict(self, dataset):
self.model.eval()
bar = tqdm(dataset, smoothing=0)
r = []
for i, (x, y) in enumerate(bar):
x, y = [createVariable(z, self.use_cuda) for z in [x, y]]
prob = self.model(x)
prob = F.softmax(prob)
conf, pred = torch.max(prob, 1)
r.extend(
zip(x.data.cpu().numpy(), toList(pred), toList(y),
toList(conf)))
bar.close()
return r
def fit(self, dataset):
self.model.train()
bar = tqdm(dataset, smoothing=0)
avgLoss = Average('Loss', num=20)
acc = Average('TAcc')
for i, (x, y) in enumerate(bar):
x, y = [createVariable(z, self.use_cuda) for z in [x, y]]
prob = self.model(x)
loss = F.cross_entropy(prob, y)
avgLoss.append(toList(loss)[0])
pred = torch.max(prob.data, 1)[1]
corr = (pred == y.data).sum()
total = y.size(0)
acc.append(corr / total)
self.optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm(self.model.parameters(), 10)
self.optimizer.step()
logs = logging((avgLoss, acc))
bar.desc = logs
bar.close()
return [avgLoss, acc]
def score(self, n):
list_n = toList(n)
if len(list_n) > len(self.patterns[0]):
self.upgrade_patterns(len(list_n))
max_score = 0
min_prime = n**2
for pattern in self.patterns:
# print(pattern)
local_score = 0
local_min = min_prime
for i in range(10):
replaced = self.replace(list_n, pattern, i)
if replaced >= n and self.pc.prime(replaced):
# print(replaced)
local_min = min(local_min, replaced)
local_score += 1
# print(local_score)
if local_score > max_score:
max_score = local_score
min_prime = local_min
return max_score, min_prime
def movingAverage(interval, window_size, factor):
interval = pu.toList(interval)
if(window_size %2 == 0):
window_size += 1
window = np.ones(int(window_size))
half = int(window_size/2)
center = half + 1
for i in xrange(1, center):
window[half + i] = window[half + i -1]/float(factor)
window[half - i] = window[half - i + 1]/float(factor)
s = np.sum(window)
window = [x/s for x in window]
head = [np.mean(interval[:window_size])]*window_size
tail = [np.mean(interval[-window_size:])]*window_size
conv = np.convolve(head + interval + tail, window, 'same')
retVal = conv[window_size:-window_size]
return pu.toList(retVal)
def predict(self, illums):
# FIXME:
self.G.train()
self.D.eval()
bar = tqdm(illums, smoothing=0)
r = []
for i, illum in enumerate(bar):
illum = torch.FloatTensor([illum])
# Training Generator
noise = createVariable(torch.randn(1, noiseDim), self.use_cuda,
True)
illum = createVariable(illum, self.use_cuda, True)
x = self.G(noise, illum)
# x = torch.clamp(x, 0, 1)
isReal, illum = self.D(x)
r.append(
(x.data.cpu().numpy()[0], toList(isReal)[0], toList(illum)[0]))
bar.close()
return r
def addFile(db, samid, procid, file, sample_name, file_type):
## Make sure file is a list
file = utils.toList(file)
for f in file:
## Compute md5sum, file size in bytes
file_md5 = utils.md5(f)
file_size = os.path.getsize(f)
## Open the connection, get the cursor
conn = sqlite3.connect(db, timeout=1000)
c = conn.cursor()
## Add file to table
c.execute(
'''INSERT INTO file (sample_id, process_id, file_path, file_name, file_md5, file_bytes, file_type) VALUES (?, ?, ?, ?, ?, ?, ?)''',
(samid, procid, f, sample_name, file_md5, file_size, file_type))
## Commit and close the connection
conn.commit()
conn.close()
def fit(self, dataset):
bar = tqdm(dataset, smoothing=0)
avgDLoss = Average('DL', num=4)
realRealAcc = Average('DR', num=4)
avgGLoss = Average('GL', num=4)
fakeRealAcc = Average('GR', num=4)
realIlluAcc = Average('TI', num=4)
fakeIlluAcc = Average('GI', num=4)
for i, (x, y) in enumerate(bar):
self.step += 1
batchSZ = y.size(0)
x, y = [createVariable(z, self.use_cuda) for z in [x, y]]
true = createVariable(torch.ones(batchSZ).float(), self.use_cuda)
false = createVariable(torch.zeros(batchSZ).float(), self.use_cuda)
# lr decay
if self.step % 50000 == 0:
for param_group in self.optimD.param_groups:
param_group['lr'] = param_group['lr'] * 0.5
for param_group in self.optimG.param_groups:
param_group['lr'] = param_group['lr'] * 0.5
# tagger pretrain
# if self.step < 4000:
# self.G.eval()
# self.D.train()
# self.optimD.zero_grad()
# dloss = 0
# # Real data
# isReal, tags = self.D(x)
# lossHair = F.cross_entropy(tags[:, 0, :], y[:, 0])
# lossEyes = F.cross_entropy(tags[:, 1, :], y[:, 1])
# realHairAcc.append(toList((torch.max(tags[:, 0, :], 1)[1] == y[:, 0]).sum())[0] / batchSZ)
# realEyesAcc.append(toList((torch.max(tags[:, 1, :], 1)[1] == y[:, 1]).sum())[0] / batchSZ)
# lossRealTags = lossHair * 0.6 + lossEyes
# loss = lossRealTags
# dloss += loss.data.cpu().numpy().tolist()[0]
# loss.backward()
# # Gradient penalty
# alpha = createVariable(torch.rand(batchSZ, 1, 1, 1), self.use_cuda)
# beta = createVariable(torch.randn(x.size()), self.use_cuda)
# gradientPenalty = 0
# x = alpha * x + (1 - alpha) * (x + 0.5 * x.std() * beta)
# x = x.detach()
# x.requires_grad = True
# isReal, tags = self.D(x)
# hair = tags[:,0,:12]
# eyes = tags[:,1,:11]
# hairGrad = createVariable(torch.ones(batchSZ, 12).float(), self.use_cuda)
# hairGrad = grad(hair, x, hairGrad, create_graph=True,
# retain_graph=True, only_inputs=True)[0].view(batchSZ, -1)
# gradientPenalty += ((hairGrad.norm(p=2, dim=1) - 1)**2).mean()
# eyesGrad = createVariable(torch.ones(batchSZ, 11).float(), self.use_cuda)
# eyesGrad = grad(eyes, x, eyesGrad, create_graph=True,
# retain_graph=True, only_inputs=True)[0].view(batchSZ, -1)
# gradientPenalty += ((eyesGrad.norm(p=2, dim=1) - 1)**2).mean()
# gradientPenalty *= 0.5
# dloss += gradientPenalty.data.cpu().numpy().tolist()[0]
# gradientPenalty.backward()
# avgDLoss.append(dloss)
# torch.nn.utils.clip_grad_norm(self.D.parameters(), 1)
# self.optimD.step()
# logs = logging((avgDLoss, avgGLoss, realRealAcc, fakeRealAcc, realHairAcc, fakeHairAcc, realEyesAcc, fakeEyesAcc))
# bar.desc = logs
# continue
lambdaAdvMax = 1
# lambdaAdv = min(1, self.step / 4000) ** 2
# lambdaAdv = lambdaAdv * 0.8 + 0.2
# lambdaAdv = lambdaAdv * lambdaAdvMax
lambdaAdv = lambdaAdvMax
skipD = False
if lambdaAdv >= lambdaAdvMax - 1e-10:
# gap skip
gap = max(realRealAcc.value() - fakeRealAcc.value(), 0)
gap = min(1, gap * 2)
r = random.random()
if r > 1 - gap * 0.9:
skipD = True
pass
if not skipD:
for _ in range(1):
# Training Discriminator
self.G.eval()
self.D.train()
self.optimD.zero_grad()
self.optimG.zero_grad()
dloss = 0
# Real data
isReal, illum = self.D(x)
lossRealLabel = F.binary_cross_entropy_with_logits(
isReal, true)
realRealAcc.append(toList(F.sigmoid(isReal).mean())[0])
lossIllu = F.mse_loss(illum, y)
realIlluAcc.append(toList(lossIllu)[0])
loss = lossRealLabel * lambdaAdv + lossIllu
dloss += loss.data.cpu().numpy().tolist()[0]
loss.backward()
# Gradient penalty
alpha = createVariable(torch.rand(batchSZ, 1, 1, 1),
self.use_cuda)
beta = createVariable(torch.randn(x.size()), self.use_cuda)
gradientPenalty = 0
x = alpha * x + (1 - alpha) * (x + 0.5 * x.std() * beta)
x = x.detach()
x.requires_grad = True
isReal, illum = self.D(x)
# isReal = F.sigmoid(isReal)
realGrad = grad(isReal,
x,
true,
create_graph=True,
retain_graph=True,
only_inputs=True)[0].view(batchSZ, -1)
gradientPenalty += ((realGrad.norm(p=2, dim=1) -
1)**2).mean()
gradientPenalty *= 0.5
dloss += gradientPenalty.data.cpu().numpy().tolist()[0]
gradientPenalty.backward()
# Fake data
noise = createVariable(torch.randn(batchSZ, noiseDim),
self.use_cuda)
illum = createVariable(
torch.FloatTensor(batchSZ).uniform_(0.3, 1),
self.use_cuda)
x = self.G(noise, illum)
# x = torch.clamp(x, 0, 1)
x = x.detach()
isReal, illum = self.D(x)
lossRealLabel = F.binary_cross_entropy_with_logits(
isReal, false)
loss = lossRealLabel * lambdaAdv
loss = loss * 0.1
dloss += loss.data.cpu().numpy().tolist()[0]
loss.backward()
# Fake data history
if len(self.memory) > batchSZ:
x = random.sample(self.memory, batchSZ)
x = createVariable(torch.stack(x, 0), self.use_cuda)
isReal, illum = self.D(x)
lossRealLabel = F.binary_cross_entropy_with_logits(
isReal, false)
loss = lossRealLabel * lambdaAdv
loss = loss * 0.9
dloss += loss.data.cpu().numpy().tolist()[0]
loss.backward()
avgDLoss.append(dloss)
torch.nn.utils.clip_grad_norm(self.D.parameters(), 1)
self.optimD.step()
# Training Generator
for i in range(1):
self.optimD.zero_grad()
self.optimG.zero_grad()
self.D.eval()
self.G.train()
noise = createVariable(torch.randn(batchSZ, noiseDim),
self.use_cuda)
illum = createVariable(
torch.FloatTensor(batchSZ).uniform_(0.3, 1), self.use_cuda)
gloss = 0
x = self.G(noise, illum)
isReal, _illum = self.D(x)
self.memory.append(x[0].data.cpu())
if len(self.memory) > 1e6: self.memory = self.memory[-1e6:]
if self.step % 15 == 0 and i == 0:
img = x.data[0].cpu().numpy()
img, org = toImage(img)
try:
img.save(
os.path.join('output', 'training', 'norm',
'%d-0.jpg' % (self.step)))
org.save(
os.path.join('output', 'training', 'orig',
'%d-0.jpg' % (self.step)))
except:
pass
lossRealLabel = F.binary_cross_entropy_with_logits(
isReal, true)
fakeRealAcc.append(toList(F.sigmoid(isReal).mean())[0])
lossIllu = F.mse_loss(_illum, illum)
fakeIlluAcc.append(toList(lossIllu)[0])
loss = lossRealLabel * lambdaAdv + lossIllu
gloss += loss.data.cpu().numpy().tolist()[0]
loss.backward()
avgGLoss.append(gloss)
torch.nn.utils.clip_grad_norm(self.G.parameters(), 1)
self.optimG.step()
logs = logging((avgDLoss, avgGLoss, realRealAcc, fakeRealAcc,
realIlluAcc, fakeIlluAcc))
bar.desc = logs
bar.close()
return [
avgDLoss, avgGLoss, realRealAcc, fakeRealAcc, realIlluAcc,
fakeIlluAcc
]
