def run_small_net():
global training_data2, n2, t2, testing_data
layers = []
layers.append({'type': 'input', 'out_sx': 24, 'out_sy': 24, 'out_depth': 1})
#layers.append({'type': 'fc', 'num_neurons': 50, 'activation': 'relu'})
layers.append({'type': 'softmax', 'num_classes': 10})
print 'Layers made...'
n2 = Net(layers)
print 'Smaller Net made...'
print n2
t2 = Trainer(n2, {'method': 'sgd', 'momentum': 0.0})
print 'Trainer made for smaller net...'
print 'In training of smaller net...'
print 'k', 'time\t\t ', 'loss\t ', 'training accuracy'
print '----------------------------------------------------'
try:
for x, y in training_data2:
stats = t2.train(x, y)
print stats['k'], stats['time'], stats['loss'], stats['accuracy']
except: #hit control-c or other
pass
print 'Testing smaller net: 5000 trials'
right = 0
count = 5000
for x, y in sample(testing_data, count):
n2.forward(x)
right += n2.getPrediction() == y
accuracy = float(right) / count * 100
print accuracy
def OpenNET(url):
try:
net = Net(cookie_file=cookiejar)
#net = Net(cookiejar)
try:
second_response = net.http_GET(url)
except:
second_response = net.http_GET(url.encode("utf-8"))
return second_response.content
except:
d = xbmcgui.Dialog()
d.ok(url,"Can't Connect to site",'Try again in a moment')
class FeatureExtractor:
''' Class for extracting trained features
Feature will be stored in a txt file as a matrix. The size of the feature matrix is [num_img, feature_dimension]
Run it as::
>>> extractor = FeatureExtractor(solver_file, snapshot, gpu_idx)
>>> extractor.build_net()
>>> extractor.run(layer_name, feature_path)
:ivar str solver_file: path of the solver file in Caffe's proto format
:ivar int snapshot: the snapshot for testing
:ivar str layer_name: name of the ayer that produce feature
:ivar int gpu_idx: which gpu to perform the test
'''
def __init__(self, solver_file, snapshot, gpu_idx = 0):
self.solver_file = solver_file
self.snapshot = snapshot
self.gpu = owl.create_gpu_device(gpu_idx)
owl.set_device(self.gpu)
def build_net(self):
self.owl_net = Net()
self.builder = CaffeNetBuilder(self.solver_file)
self.snapshot_dir = self.builder.snapshot_dir
self.builder.build_net(self.owl_net)
self.owl_net.compute_size('TEST')
self.builder.init_net_from_file(self.owl_net, self.snapshot_dir, self.snapshot)
def run(s, layer_name, feature_path):
''' Run feature extractor
:param str layer_name: the layer to extract feature from
:param str feature_path: feature output path
'''
feature_unit = s.owl_net.units[s.owl_net.name_to_uid[layer_name][0]]
feature_file = open(feature_path, 'w')
batch_dir = 0
for testiteridx in range(s.owl_net.solver.test_iter[0]):
s.owl_net.forward('TEST')
feature = feature_unit.out.to_numpy()
feature_shape = np.shape(feature)
img_num = feature_shape[0]
feature_length = np.prod(feature_shape[1:len(feature_shape)])
feature = np.reshape(feature, [img_num, feature_length])
for imgidx in range(img_num):
for feaidx in range(feature_length):
info ='%f ' % (feature[imgidx, feaidx])
feature_file.write(info)
feature_file.write('\n')
print "Finish One Batch %d" % (batch_dir)
batch_dir += 1
feature_file.close()
class MultiviewTester:
''' Class for performing multi-view testing
Run it as::
>>> tester = MultiviewTester(solver_file, softmax_layer, snapshot, gpu_idx)
>>> tester.build_net()
>>> tester.run()
:ivar str solver_file: path of the solver file in Caffe's proto format
:ivar int snapshot: the snapshot for testing
:ivar str softmax_layer_name: name of the softmax layer that produce prediction
:ivar int gpu_idx: which gpu to perform the test
'''
def __init__(self, solver_file, softmax_layer_name, snapshot, gpu_idx = 0):
self.solver_file = solver_file
self.softmax_layer_name = softmax_layer_name
self.snapshot = snapshot
self.gpu = owl.create_gpu_device(gpu_idx)
owl.set_device(self.gpu)
def build_net(self):
self.owl_net = Net()
self.builder = CaffeNetBuilder(self.solver_file)
self.snapshot_dir = self.builder.snapshot_dir
self.builder.build_net(self.owl_net)
self.owl_net.compute_size('MULTI_VIEW')
self.builder.init_net_from_file(self.owl_net, self.snapshot_dir, self.snapshot)
def run(s):
#multi-view test
acc_num = 0
test_num = 0
loss_unit = s.owl_net.units[s.owl_net.name_to_uid[s.softmax_layer_name][0]]
for testiteridx in range(s.owl_net.solver.test_iter[0]):
for i in range(10):
s.owl_net.forward('MULTI_VIEW')
if i == 0:
softmax_val = loss_unit.ff_y
batch_size = softmax_val.shape[1]
softmax_label = loss_unit.y
else:
softmax_val = softmax_val + loss_unit.ff_y
test_num += batch_size
predict = softmax_val.argmax(0)
truth = softmax_label.argmax(0)
correct = (predict - truth).count_zero()
acc_num += correct
print "Accuracy the %d mb: %f, batch_size: %d" % (testiteridx, correct, batch_size)
sys.stdout.flush()
print "Testing Accuracy: %f" % (float(acc_num)/test_num)
def test_basic():
net = Net([2, 2, 1], 1, weights=1)
err = net.train([0, 0], [1])
for a, b in zip(basic_weights1, net.weights):
print a
print b
print a == b
n.testing.assert_array_almost_equal(a, b)
err = net.train([0, 1], [0])
for a, b in zip(basic_weights2, net.weights):
print a
print b
print a == b
n.testing.assert_array_almost_equal(a, b)
def __init__(self, verbose=1, maxq=200):
Net.__init__(self)
Tools.__init__(self)
"""
Multithreaded network tools
"""
self.verbose = verbose
self.maxq = maxq
self.timeout = 0.2 #
self.buffers = 256 #for check_port
class Solver():
def __init__(self, args):
# prepare a datasets
self.train_data = Dataset(train=True,
data_root=args.data_root,
size=args.image_size)
self.test_data = Dataset(train=False,
data_root=args.data_root,
size=args.image_size)
self.train_loader = DataLoader(self.train_data,
batch_size=args.batch_size,
num_workers=1,
shuffle=True, drop_last=True)
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.net = Net().to(self.device)
self.loss_fn = torch.nn.L1Loss()
self.optim = torch.optim.Adam(self.net.parameters(), args.lr)
self.args = args
if not os.path.exists(args.ckpt_dir):
os.makedirs(args.ckpt_dir)
def fit(self):
args = self.args
for epoch in range(args.max_epochs):
self.net.train()
for step, inputs in enumerate(self.train_loader):
gt_gray = inputs[0].to(self.device)
gt_ab = inputs[1].to(self.device)
pred_ab = self.net(gt_gray)
loss = self.loss_fn(pred_ab, gt_ab)
self.optim.zero_grad()
loss.backward()
self.optim.step()
if (epoch+1) % args.print_every == 0:
print("Epoch [{}/{}] loss: {:.6f}".format(epoch+1, args.max_epochs, loss.item()))
self.save(args.ckpt_dir, args.ckpt_name, epoch+1)
def save(self, ckpt_dir, ckpt_name, global_step):
save_path = os.path.join(
ckpt_dir, "{}_{}.pth".format(ckpt_name, global_step))
torch.save(self.net.state_dict(), save_path)
def train(args):
# prepare the MNIST dataset
train_dataset = datasets.MNIST(root="./data/",
train=True,
transform=transforms.ToTensor(),
download=True)
test_dataset = datasets.MNIST(root="./data/",
train=False,
transform=transforms.ToTensor())
# create the data loader
train_loader = DataLoader(dataset=train_dataset,
batch_size=args.batch_size,
shuffle=True, drop_last=True)
test_loader = DataLoader(dataset=test_dataset,
batch_size=args.batch_size,
shuffle=False)
# turn on the CUDA if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
net = Net().to(device)
loss_op = nn.CrossEntropyLoss()
optim = torch.optim.Adam(net.parameters(), lr=args.lr)
for epoch in range(args.max_epochs):
net.train()
for step, inputs in enumerate(train_loader):
images = inputs[0].to(device)
labels = inputs[1].to(device)
# forward-propagation
outputs = net(images)
loss = loss_op(outputs, labels)
# back-propagation
optim.zero_grad()
loss.backward()
optim.step()
acc = evaluate(net, test_loader, device)
print("Epoch [{}/{}] loss: {:.5f} test acc: {:.3f}"
.format(epoch+1, args.max_epochs, loss.item(), acc))
torch.save(net.state_dict(), "mnist-final.pth")
def __init__(self, args): self.epsilonStart = args.epsilonStart self.epsilonEnd = args.epsilonEnd self.epsilonDecayLength = args.epsilonDecayLength self.testEpsilon = args.testEpsilon self.replaySize = args.replaySize self.minReplaySize = args.minReplaySize self.framesPerState = args.framesPerState self.learnFrequency = args.learnFrequency self.targetNetworkUpdateFrequency = args.targetNetworkUpdateFrequency self.batchSize = args.batchSize self.actionNb = args.actionNb self.lastAction = 0 self.lastFrame = None self.rng = np.random.RandomState(42) self.data = Data(self.replaySize, self.framesPerState, (100,100)) self.tickCount = 0 self.learnCount = 0 self.rewardAcc = 0.0 self.episodeNb = 0 self.qValueAcc = 0.0 self.qValueNb = 0 self.maxReward = 0 self.episodeReward = 0 self.test = False self.lastQs = collections.deque(maxlen=60) self.net = Net(args) self.qValues = [] self.rewards = [] self.tickCount = 0
def __init__(self, meta, layers=[], rate=.05, target=None, momentum=None, trans=None, wrange=100):
Learner.__init__(self, meta, target)
inputs = len(self.meta.names()) - 1
_, possible = self.meta[self.target]
self.outputs = possible
self.net = Net([inputs] + layers + [len(possible)], rate=rate, momentum=momentum, wrange=wrange, trans=trans)
def build_net(self):
self.owl_net = Net()
self.builder = CaffeNetBuilder(self.solver_file)
self.snapshot_dir = self.builder.snapshot_dir
self.builder.build_net(self.owl_net)
self.owl_net.compute_size('TEST')
self.builder.init_net_from_file(self.owl_net, self.snapshot_dir, self.snapshot)
def __init__(self, args):
# prepare a datasets
self.train_data = Dataset(args.scale, train=True,
data_root=args.data_root,
size=args.image_size)
self.test_data = Dataset(args.scale, train=False,
data_root=args.data_root,
size=args.image_size)
self.train_loader = DataLoader(self.train_data,
batch_size=args.batch_size,
num_workers=1,
shuffle=True, drop_last=True)
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.net = Net(args.scale).to(self.device)
self.loss_fn = torch.nn.L1Loss()
self.optim = torch.optim.Adam(self.net.parameters(), args.lr)
self.args = args
if not os.path.exists(args.ckpt_dir):
os.makedirs(args.ckpt_dir)
if not os.path.exists(args.result_dir):
os.makedirs(args.result_dir)
def __init__(self, args):
# prepare SST dataset
train_iter, val_iter, test_iter, sst_info = load_sst(args.batch_size, args.max_vocab)
vocab_size = sst_info["vocab_size"]
num_class = sst_info["num_class"]
TEXT = sst_info["TEXT"]
print("[!] vocab_size: {}, num_class: {}".format(vocab_size, num_class))
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.net = Net(TEXT,
args.hidden_dim,
args.num_layers, num_class).to(self.device)
self.optim = torch.optim.Adam(
filter(lambda p: p.requires_grad, self.net.parameters()),
args.lr, weight_decay=args.weight_decay)
self.loss_fn = torch.nn.CrossEntropyLoss()
self.args = args
self.train_iter = train_iter
self.val_iter = val_iter
self.test_iter = test_iter
if not os.path.exists(args.ckpt_dir):
os.makedirs(args.ckpt_dir)
class Solver(object):
"""Docstring for Solver. """
def __init__(self, param):
"""TODO: to be defined1. """
self.param = param
self.init_train_net(param)
def init_train_net(self, param):
net_param = pb.NetParameter()
with open(param.net, "rb") as f:
text_format.Merge(f.read(), net_param)
net_state = pb.NetState()
net_state.phase = pb.TRAIN
# net_state.MergeFrom(net_param.state)
# net_state.MergeFrom(param.train_state)
net_param.state.CopyFrom(net_state)
self.train_net = Net(net_param)
def step(self, iters):
avg_loss = self.param.average_loss
losses = []
smoothed_loss = 0
for i in range(iters):
loss = self.train_net.forward_backward()
if len(losses) < avg_loss:
losses.append(loss)
size = len(losses)
smoothed_loss = (smoothed_loss * (size - 1) + loss) / size
else:
idx = (i - 0) % avg_loss
smoothed_loss += (loss - losses[idx]) / avg_loss
log.info("Iteration %d, loss %f", i, smoothed_loss)
self.compute_update_value(i)
# self.train_net.update()
def compute_update_value(self, i):
current_step = i / 100000.0
base_lr = 0.01
gamma = 0.1
rate = base_lr * pow(gamma, current_step)
weight_decay = 0.0005
momentum = 0.9
self.train_net.update_params(rate, weight_decay, momentum)
def setup_net(self):
if not self.setup:
self.setup = True
self.net = Net(*SimpleParser(open(self.sisc_file)).parse(), **self.options)
for c,i in enumerate(self.net.inputs):
self.net.inputs[i] = self.inputs[c] == 1
for c,i in enumerate(self.net.outputs):
self.net.outputs[i] = self.outputs[c] == 1
self.components = TwoWayDict(dict(enumerate(self.net.gates.keys())))
class BackProp(Learner):
def __init__(self, meta, layers=[], rate=.05, target=None, momentum=None, trans=None, wrange=100):
Learner.__init__(self, meta, target)
inputs = len(self.meta.names()) - 1
_, possible = self.meta[self.target]
self.outputs = possible
self.net = Net([inputs] + layers + [len(possible)], rate=rate, momentum=momentum, wrange=wrange, trans=trans)
def state(self):
return [x.copy() for x in self.net.weights]
def use_state(self, state):
self.net.weights = state
def classify(self, data):
output = self.net.classify(data)
# print 'result'
# print output
# print 'result', output, self.outputs
return self.outputs[output[-1].argmax()]
def validate(self, data, real):
output = self.net.classify(data)[-1]
label = self.outputs[output.argmax()]
target = n.zeros(len(self.outputs))
target[self.outputs.index(real)] = 1
squerr = (target - output)**2
return label, squerr.mean()
def train(self, data, target):
output = n.zeros(len(self.outputs))
# print self.outputs, target
output[self.outputs.index(target)] = 1
if LOG:
print 'training'
print 'data', data
print 'expected', output
print 'weights'
for level in self.net.weights:
print ' ', level
err = self.net.train(data, output)
return err
def run_big_net():
global training_data, testing_data, n, t, training_data2
training_data = load_data()
testing_data = load_data(False)
training_data2 = []
print 'Data loaded...'
layers = []
layers.append({'type': 'input', 'out_sx': 24, 'out_sy': 24, 'out_depth': 1})
layers.append({'type': 'fc', 'num_neurons': 100, 'activation': 'relu', 'drop_prob': 0.5})
#layers.append({'type': 'fc', 'num_neurons': 800, 'activation': 'relu', 'drop_prob': 0.5})
layers.append({'type': 'softmax', 'num_classes': 10})
print 'Layers made...'
n = Net(layers)
print 'Net made...'
print n
t = Trainer(n, {'method': 'sgd', 'momentum': 0.0})
print 'Trainer made...'
print 'In training...'
print 'k', 'time\t\t ', 'loss\t ', 'training accuracy'
print '----------------------------------------------------'
try:
for x, y in training_data:
stats = t.train(x, y)
print stats['k'], stats['time'], stats['loss'], stats['accuracy']
training_data2.append((x, n.getPrediction()))
except: #hit control-c or other
pass
print 'In testing: 5000 trials'
right = 0
count = 5000
for x, y in sample(testing_data, count):
n.forward(x)
right += n.getPrediction() == y
accuracy = float(right) / count * 100
print accuracy
def init_train_net(self, param):
net_param = pb.NetParameter()
with open(param.net, "rb") as f:
text_format.Merge(f.read(), net_param)
net_state = pb.NetState()
net_state.phase = pb.TRAIN
# net_state.MergeFrom(net_param.state)
# net_state.MergeFrom(param.train_state)
net_param.state.CopyFrom(net_state)
self.train_net = Net(net_param)
class IscasOracleOld(IscasOracle):
def __init__(self, sisc_file, inputs, mutated_gates, **options):
super(IscasOracleOld, self).__init__(None, [], [], **options)
self.sisc_file = sisc_file
self.mutated_gates = mutated_gates
self.net = Net(*SimpleParser(open(sisc_file)).parse(), **options)
for c,i in enumerate(self.net.inputs):
self.net.inputs[i] = inputs[c] == 1
orig_gates = self.net.mutate_net(mutated_gates)
self.net.calculate_outputs()
self.net.mutate_net(orig_gates)
self.comp_calls = 0
self.check_calls = 0
self.comp_time = 0
self.check_time = 0
self.scs = set()
self.components = TwoWayDict(dict(enumerate(self.net.gates.keys())))
def setup_net(self):
pass
def build_net(self):
''' Build network structure using Caffe's proto definition. It will also initialize
the network either from given snapshot or from scratch (using proper initializer).
During initialization, it will first try to load weight from snapshot. If failed, it
will then initialize the weight accordingly.
'''
self.owl_net = Net()
self.builder = CaffeNetBuilder(self.solver_file)
self.snapshot_dir = self.builder.snapshot_dir
self.builder.build_net(self.owl_net, self.num_gpu)
self.owl_net.compute_size()
self.builder.init_net_from_file(self.owl_net, self.snapshot_dir, self.snapshot)
def __init__(self, grid, mdp, moves=40):
self.grid = grid
self.mdp = mdp
self.svm = LinearSVM(grid, mdp)
self.net = Net(grid,mdp)
self.moves = moves
#self.reward = np.zeros(40)
self.super_pi = mdp.pi
self.reward = np.zeros(self.moves)
self.animate = False
self.record = True
self.recent_rollout_states = None
def __init__(self, grid, mdp, moves=40,net = 'Net'):
self.grid = grid
self.mdp = mdp
self.net_name = net
self.svm = LinearSVM(grid, mdp)
self.net = Net(grid,mdp,net,T=moves)
self.moves = moves
#self.reward = np.zeros(40)
self.super_pi = mdp.pi
self.mdp.pi_noise = False
self.reward = np.zeros(self.moves)
self.animate = False
self.train_loss = 0
self.test_loss = 0
self.record = True
def __init__(self, args):
# prepare shakespeare dataset
train_iter, data_info = load_shakespeare(args.batch_size, args.bptt_len)
self.vocab_size = data_info["vocab_size"]
self.TEXT = data_info["TEXT"]
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.net = Net(self.vocab_size, args.embed_dim,
args.hidden_dim, args.num_layers).to(self.device)
self.loss_fn = torch.nn.CrossEntropyLoss(ignore_index=1) # <pad>: 1
self.optim = torch.optim.Adam(self.net.parameters(), args.lr)
self.args = args
self.train_iter = train_iter
if not os.path.exists(args.ckpt_dir):
os.makedirs(args.ckpt_dir)
def predict(weights_path, image_path):
'''
Function: loads a trained model and predicts the class of given image
Input: weights_path (.h5 file, prefer adding absolute path)
image_path (image to predict, prefer adding absolute path)
Returns: none
'''
model = Net.build(32, 32, 3, weights_path)
image = load_image(image_path, show=True) # load image, rescale to 0 to 1
class_ = model.predict(image) # predict the output, returns 36 length array
print("Detected: ", class_[0]) # print what is predicted
output_indice = -1 # set it initially to -1
# get class index having maximum predicted score
for i in range(36):
if(i == 0):
max = class_[0][i]
output_indice = 0
else:
if(class_[0][i] > max):
max = class_[0][i]
output_indice = i
# append 26 characters (A to Z) to list characters
characters = []
for i in range(65, 65+26):
characters.append(chr(i))
# if output indice > 9 (means characters)
if(output_indice > 9):
final_result = characters[(output_indice - 9) - 1]
print("Predicted: ", final_result)
print("value: ", max) # print predicted score
# else it's a digit, print directly
else:
print("Predicted: ", output_indice)
print("value: ", max) # print it's predicted score
class HeatmapVisualizer:
''' Class of heatmap visualizer.
Heat map can reveal which part of the activation is important. This information is useful when conducting detection and segmentation tasks.
:ivar str solver_file: name of the solver_file, it will tell Minerva the network configuration and model saving path
:ivar snapshot: saved model snapshot index
:ivar str layer_name: name of the layer whose activation will be viusualized as heatmap
:ivar str result_path: path for the result of visualization, heatmapvisualizer will generate a heatmap jpg for each testing image and save the image under result path.
:ivar gpu: the gpu to run testing
'''
def __init__(self, solver_file, snapshot, gpu_idx = 0):
self.solver_file = solver_file
self.snapshot = snapshot
self.gpu = owl.create_gpu_device(gpu_idx)
owl.set_device(self.gpu)
def build_net(self):
self.owl_net = Net()
self.builder = CaffeNetBuilder(self.solver_file)
self.snapshot_dir = self.builder.snapshot_dir
self.builder.build_net(self.owl_net)
self.owl_net.compute_size('TEST')
self.builder.init_net_from_file(self.owl_net, self.snapshot_dir, self.snapshot)
def run(s, layer_name, result_path):
''' Run heatmap visualizer
:param str layer_name: the layer to visualize
:param str result_path: the path to save heatmap
'''
feature_unit = s.owl_net.units[s.owl_net.name_to_uid[layer_name][0]]
#We need the testing data unit
data_unit = None
for i in range(len(s.owl_net.name_to_uid['data'])):
if s.owl_net.units[s.owl_net.name_to_uid['data'][i]].params.include[0].phase == 1:
data_unit = s.owl_net.units[s.owl_net.name_to_uid['data'][i]]
assert(data_unit)
#get the mean data
bp = BlobProto()
#get mean file
if len(data_unit.params.transform_param.mean_file) == 0:
mean_data = np.ones([3, 256, 256], dtype=np.float32)
assert(len(data_unit.params.transform_param.mean_value) == 3)
mean_data[0] = data_unit.params.transform_param.mean_value[0]
mean_data[1] = data_unit.params.transform_param.mean_value[1]
mean_data[2] = data_unit.params.transform_param.mean_value[2]
h_w = 256
else:
with open(data_unit.params.transform_param.mean_file, 'rb') as f:
bp.ParseFromString(f.read())
mean_narray = np.array(bp.data, dtype=np.float32)
h_w = np.sqrt(np.shape(mean_narray)[0] / 3)
mean_data = np.array(bp.data, dtype=np.float32).reshape([3, h_w, h_w])
#get the cropped img
crop_size = data_unit.params.transform_param.crop_size
crop_h_w = (h_w - crop_size) / 2
mean_data = mean_data[:, crop_h_w:crop_h_w + crop_size, crop_h_w:crop_h_w + crop_size]
cur_img = 0
for testiteridx in range(s.owl_net.solver.test_iter[0]):
s.owl_net.forward('TEST')
feature = feature_unit.out.to_numpy()
feature_shape = np.shape(feature)
data = data_unit.out.to_numpy()
img_num = feature_shape[0]
#processing each image
for imgidx in range(img_num):
img_feature = feature[imgidx,:]
#get the image
gbr_img_data = data[imgidx,:] + mean_data
img_data = np.zeros([data_unit.crop_size, data_unit.crop_size, 3], dtype=np.float32)
img_data[:,:,0] = gbr_img_data[2,:,:]
img_data[:,:,1] = gbr_img_data[1,:,:]
img_data[:,:,2] = gbr_img_data[0,:,:]
img_data /= 256
#get the heatmap
f_h = feature_shape[2]
f_w = feature_shape[3]
f_c = feature_shape[1]
heatmap = np.zeros([f_h, f_w], dtype=np.float32)
for cidx in range(f_c):
feature_map = img_feature[cidx,:]
f = np.max(np.max(feature_map)) - np.mean(np.mean(feature_map))
heatmap = heatmap + f * f * feature_map
#resize
heatmap = scipy.misc.imresize(heatmap,[data_unit.crop_size, data_unit.crop_size])
#save
fig, ax = plt.subplots(1,2)
ax[0].axis('off')
ax[1].axis('off')
ax[0].imshow(img_data, aspect='equal')
ax[1].imshow(heatmap, aspect='equal')
#ax[1] = plt.pcolor(heatmap)
info = '%s/%d.jpg' % (result_path, cur_img)
print info
fig.savefig(info)
plt.close('all')
cur_img += 1
if cur_img == 100:
exit(0)
print "Finish One Batch %d" % (batch_dir)
batch_dir += 1
feature_file.close()
result[i][targets[i]] = 1
return result
train = 60000
iteratin = 20
test = 10000
train_images, train_labels = load_mnist_train('ANN\\mnist', 'train')
train_images = train_images / 255
train_goals = onehot(train_labels, 10)
test_images, test_labels = load_mnist_train('ANN\\mnist', 't10k')
test_images = test_images / 255
test_goals = onehot(test_labels, 10)
recognizeFigure = Net([784, 14, 14, 10])
print('Training: 0.00%')
for j in range(iteratin):
for i in range(train):
train_results = recognizeFigure.train(train_images[i], train_goals[i])
if i == train - 1:
loss = np.sqrt(np.sum((train_results - train_goals[i])**2) / 10)
print('Training: {:.2f}%----Loss: {:.4f}'.format(
(j + 1) * 100 / iteratin, loss))
precison = 0
test_results = np.empty(test, dtype=int)
for i in range(test):
test_results[i] = np.argmax(recognizeFigure.recognize(test_images[i]))
if test_results[i] == test_labels[i]:
precison += 1
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
pbar.close()
print('Epoch - {} --> Loss - {}'.format(epoch + 1,
running_loss / STEPS))
#get_grad(epoch)
if __name__ == '__main__':
mnist_dataset = MNISTDataset()
mnist_loader = DataLoader(mnist_dataset,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=2)
net = Net()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Assuming that we are on a CUDA machine, this should print a CUDA device:
print(device)
net.to(device)
train(net, mnist_loader)
class Brain:
def __init__(self, pool):
self.pool = pool
self.model = Net()
self.model_ = Net()
print("Network architecture:\n" + str(self.model))
def _load(self):
self.model.load_state_dict(torch.load("model"))
self.model_.load_state_dict(torch.load("model_"))
def _save(self):
torch.save(self.model.state_dict(), "model")
torch.save(self.model_.state_dict(), "model_")
def predict_pt(self, s, target):
s = Variable(s)
if target:
return self.model_(s).data
else:
return self.model(s).data
def predict_np(self, s, target=False):
s = torch.from_numpy(s).cuda()
res = self.predict_pt(s, target)
return res.cpu().numpy()
def train(self):
s, a, r, s_ = self.pool.sample(BATCH_SIZE)
# extract the mask
m_ = torch.FloatTensor(BATCH_SIZE, ACTION_DIM).zero_().cuda()
m_[:, CLASSES:] = s_[:, FEATURE_DIM:]
# compute
q_current = self.predict_pt(s_, target=False) - (
MAX_MASK_CONST * m_) # masked actions do not influence the max
q_target = self.predict_pt(s_, target=True)
_, amax = q_current.max(1, keepdim=True)
q_ = q_target.gather(1, amax)
q_[a < CLASSES] = 0
q_ = q_ + r
# bound the values to theoretical q function range
q_.clamp_(-1, 0)
self.model.train_network(s, a, q_)
self.model_.copy_weights(self.model)
def update_lr(self, epoch):
lr = OPT_LR * (LR_SC_FACTOR**(epoch // LR_SC_EPOCHS))
lr = max(lr, LR_SC_MIN)
self.model.set_lr(lr)
print("Setting LR:", lr)
##程式沒修改(部分理解)
from net import Net
net = Net()
x = net.variable(1)
y = net.variable(3)
x2 = net.mul(x, x)
y2 = net.mul(y, y)
o = net.add(x2, y2)
'''
print('net.forward()=', net.forward())
print('net.backward()')
net.backward()
print('x=', x, 'y=', y, 'o=', o)
print('gfx = x.g/o.g = ', x.g/o.g, 'gfy = y.g/o.g=', y.g/o.g)
print('x2=', x2, 'y2=', y2)
'''
net.gradient_descendent()
print('x=', x.v, 'y=', y.v)
import theano.tensor as T
from theano import shared
from theano import function
import theano.printing as pp
import layer
from layer import Layer
import math
import sys
import matplotlib.pyplot as plt
import six.moves.cPickle as pickle
import shutil
from shutil import copyfile
import net
from net import Net
ANN = Net()
saves = []
fileName = 'model.zip'
if args.fileName is not None:
fileName = args.fileName
saves.extend([fileName])
ANN.showPlot = True
if args.noPlot:
ANN.showPlot = False
layerCount = 1
if args.layerCount is not None:
layerCount = args.layerCount
#coding: utf-8
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
# ネットワークの読み込み
from net import Net
model = Net()
def predict(X):
X = torch.as_tensor(torch.from_numpy(np.array(X)).float())
outputs = model(X)
print(outputs)
return np.argmax(outputs.data.numpy())
model.load_state_dict(torch.load("./iris_model.pth"))
model.eval()
print("predict[5.6, 4.3, 1.5, 0.35] => " + str(predict((5.6, 4.3, 1.5, 0.35))))
print("predict[5.9, 3. , 5.1, 1.8] => " + str(predict((5.9, 3., 5.1, 1.8))))
class TFProcess:
def __init__(self, cfg):
self.cfg = cfg
self.net = Net()
self.root_dir = os.path.join(self.cfg['training']['path'],
self.cfg['name'])
# Network structure
self.RESIDUAL_FILTERS = self.cfg['model']['filters']
self.RESIDUAL_BLOCKS = self.cfg['model']['residual_blocks']
self.SE_ratio = self.cfg['model']['se_ratio']
self.policy_channels = self.cfg['model'].get('policy_channels', 32)
precision = self.cfg['training'].get('precision', 'single')
loss_scale = self.cfg['training'].get('loss_scale', 128)
self.virtual_batch_size = self.cfg['model'].get(
'virtual_batch_size', None)
if precision == 'single':
self.model_dtype = tf.float32
elif precision == 'half':
self.model_dtype = tf.float16
else:
raise ValueError("Unknown precision: {}".format(precision))
# Scale the loss to prevent gradient underflow
self.loss_scale = 1 if self.model_dtype == tf.float32 else loss_scale
policy_head = self.cfg['model'].get('policy', 'convolution')
value_head = self.cfg['model'].get('value', 'wdl')
moves_left_head = self.cfg['model'].get('moves_left', 'v1')
input_mode = self.cfg['model'].get('input_type', 'classic')
self.POLICY_HEAD = None
self.VALUE_HEAD = None
self.MOVES_LEFT_HEAD = None
self.INPUT_MODE = None
if policy_head == "classical":
self.POLICY_HEAD = pb.NetworkFormat.POLICY_CLASSICAL
elif policy_head == "convolution":
self.POLICY_HEAD = pb.NetworkFormat.POLICY_CONVOLUTION
else:
raise ValueError(
"Unknown policy head format: {}".format(policy_head))
self.net.set_policyformat(self.POLICY_HEAD)
if value_head == "classical":
self.VALUE_HEAD = pb.NetworkFormat.VALUE_CLASSICAL
self.wdl = False
elif value_head == "wdl":
self.VALUE_HEAD = pb.NetworkFormat.VALUE_WDL
self.wdl = True
else:
raise ValueError(
"Unknown value head format: {}".format(value_head))
self.net.set_valueformat(self.VALUE_HEAD)
if moves_left_head == "none":
self.MOVES_LEFT_HEAD = pb.NetworkFormat.MOVES_LEFT_NONE
self.moves_left = False
elif moves_left_head == "v1":
self.MOVES_LEFT_HEAD = pb.NetworkFormat.MOVES_LEFT_V1
self.moves_left = True
else:
raise ValueError(
"Unknown moves left head format: {}".format(moves_left_head))
self.net.set_movesleftformat(self.MOVES_LEFT_HEAD)
if input_mode == "classic":
self.INPUT_MODE = pb.NetworkFormat.INPUT_CLASSICAL_112_PLANE
elif input_mode == "frc_castling":
self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CASTLING_PLANE
elif input_mode == "canonical":
self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION
elif input_mode == "canonical_100":
self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION_HECTOPLIES
elif input_mode == "canonical_armageddon":
self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION_HECTOPLIES_ARMAGEDDON
else:
raise ValueError(
"Unknown input mode format: {}".format(input_mode))
self.net.set_input(self.INPUT_MODE)
self.swa_enabled = self.cfg['training'].get('swa', False)
# Limit momentum of SWA exponential average to 1 - 1/(swa_max_n + 1)
self.swa_max_n = self.cfg['training'].get('swa_max_n', 0)
self.renorm_enabled = self.cfg['training'].get('renorm', False)
self.renorm_max_r = self.cfg['training'].get('renorm_max_r', 1)
self.renorm_max_d = self.cfg['training'].get('renorm_max_d', 0)
self.renorm_momentum = self.cfg['training'].get(
'renorm_momentum', 0.99)
gpus = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_visible_devices(gpus[self.cfg['gpu']],
'GPU')
tf.config.experimental.set_memory_growth(gpus[self.cfg['gpu']], True)
if self.model_dtype == tf.float16:
tf.keras.mixed_precision.experimental.set_policy('mixed_float16')
self.global_step = tf.Variable(0,
name='global_step',
trainable=False,
dtype=tf.int64)
def init_v2(self, train_dataset, test_dataset, validation_dataset=None):
self.train_dataset = train_dataset
self.train_iter = iter(train_dataset)
self.test_dataset = test_dataset
self.test_iter = iter(test_dataset)
self.validation_dataset = validation_dataset
self.init_net_v2()
def init_net_v2(self):
self.l2reg = tf.keras.regularizers.l2(l=0.5 * (0.0001))
input_var = tf.keras.Input(shape=(112, 8 * 8))
x_planes = tf.keras.layers.Reshape([112, 8, 8])(input_var)
policy, value, moves_left = self.construct_net_v2(x_planes)
if self.moves_left:
outputs = [policy, value, moves_left]
else:
outputs = [policy, value]
self.model = tf.keras.Model(inputs=input_var, outputs=outputs)
# swa_count initialized reguardless to make checkpoint code simpler.
self.swa_count = tf.Variable(0., name='swa_count', trainable=False)
self.swa_weights = None
if self.swa_enabled:
# Count of networks accumulated into SWA
self.swa_weights = [
tf.Variable(w, trainable=False) for w in self.model.weights
]
self.active_lr = 0.01
self.optimizer = tf.keras.optimizers.SGD(
learning_rate=lambda: self.active_lr, momentum=0.9, nesterov=True)
self.orig_optimizer = self.optimizer
if self.loss_scale != 1:
self.optimizer = tf.keras.mixed_precision.experimental.LossScaleOptimizer(
self.optimizer, self.loss_scale)
def correct_policy(target, output):
output = tf.cast(output, tf.float32)
# Calculate loss on policy head
if self.cfg['training'].get('mask_legal_moves'):
# extract mask for legal moves from target policy
move_is_legal = tf.greater_equal(target, 0)
# replace logits of illegal moves with large negative value (so that it doesn't affect policy of legal moves) without gradient
illegal_filler = tf.zeros_like(output) - 1.0e10
output = tf.where(move_is_legal, output, illegal_filler)
# y_ still has -1 on illegal moves, flush them to 0
target = tf.nn.relu(target)
return target, output
def policy_loss(target, output):
target, output = correct_policy(target, output)
policy_cross_entropy = tf.nn.softmax_cross_entropy_with_logits(
labels=tf.stop_gradient(target), logits=output)
return tf.reduce_mean(input_tensor=policy_cross_entropy)
self.policy_loss_fn = policy_loss
def policy_accuracy(target, output):
target, output = correct_policy(target, output)
return tf.reduce_mean(
tf.cast(
tf.equal(tf.argmax(input=target, axis=1),
tf.argmax(input=output, axis=1)), tf.float32))
self.policy_accuracy_fn = policy_accuracy
self.policy_accuracy_fn = policy_accuracy
def moves_left_mean_error_fn(target, output):
output = tf.cast(output, tf.float32)
return tf.reduce_mean(tf.abs(target - output))
self.moves_left_mean_error = moves_left_mean_error_fn
q_ratio = self.cfg['training'].get('q_ratio', 0)
assert 0 <= q_ratio <= 1
# Linear conversion to scalar to compute MSE with, for comparison to old values
wdl = tf.expand_dims(tf.constant([1.0, 0.0, -1.0]), 1)
self.qMix = lambda z, q: q * q_ratio + z * (1 - q_ratio)
# Loss on value head
if self.wdl:
def value_loss(target, output):
output = tf.cast(output, tf.float32)
value_cross_entropy = tf.nn.softmax_cross_entropy_with_logits(
labels=tf.stop_gradient(target), logits=output)
return tf.reduce_mean(input_tensor=value_cross_entropy)
self.value_loss_fn = value_loss
def mse_loss(target, output):
output = tf.cast(output, tf.float32)
scalar_z_conv = tf.matmul(tf.nn.softmax(output), wdl)
scalar_target = tf.matmul(target, wdl)
return tf.reduce_mean(input_tensor=tf.math.squared_difference(
scalar_target, scalar_z_conv))
self.mse_loss_fn = mse_loss
else:
def value_loss(target, output):
return tf.constant(0)
self.value_loss_fn = value_loss
def mse_loss(target, output):
output = tf.cast(output, tf.float32)
scalar_target = tf.matmul(target, wdl)
return tf.reduce_mean(input_tensor=tf.math.squared_difference(
scalar_target, output))
self.mse_loss_fn = mse_loss
if self.moves_left:
def moves_left_loss(target, output):
# Scale the loss to similar range as other losses.
scale = 20.0
# Bigger loss for low amount of moves left.
# We care more about the accuracy of the prediction
# when close to the end of the game.
importance = tf.square(30.0 / (target + 30.0))
importance = importance / tf.reduce_mean(importance)
target = target / scale
output = tf.cast(output, tf.float32) / scale
huber = tf.keras.losses.Huber(10.0 / scale)
return tf.reduce_mean(importance * huber(target, output))
else:
moves_left_loss = None
self.moves_left_loss_fn = moves_left_loss
pol_loss_w = self.cfg['training']['policy_loss_weight']
val_loss_w = self.cfg['training']['value_loss_weight']
if self.moves_left:
moves_loss_w = self.cfg['training']['moves_left_loss_weight']
else:
moves_loss_w = tf.constant(0.0, dtype=tf.float32)
def _lossMix(policy, value, moves_left):
return pol_loss_w * policy + val_loss_w * value + moves_loss_w * moves_left
self.lossMix = _lossMix
def accuracy(target, output):
output = tf.cast(output, tf.float32)
return tf.reduce_mean(
tf.cast(
tf.equal(tf.argmax(input=target, axis=1),
tf.argmax(input=output, axis=1)), tf.float32))
self.accuracy_fn = accuracy
self.avg_policy_loss = []
self.avg_value_loss = []
self.avg_moves_left_loss = []
self.avg_mse_loss = []
self.avg_reg_term = []
self.time_start = None
self.last_steps = None
# Set adaptive learning rate during training
self.cfg['training']['lr_boundaries'].sort()
self.warmup_steps = self.cfg['training'].get('warmup_steps', 0)
self.lr = self.cfg['training']['lr_values'][0]
self.test_writer = tf.summary.create_file_writer(
os.path.join(os.getcwd(),
"leelalogs/{}-test".format(self.cfg['name'])))
self.train_writer = tf.summary.create_file_writer(
os.path.join(os.getcwd(),
"leelalogs/{}-train".format(self.cfg['name'])))
if vars(self).get('validation_dataset', None) is not None:
self.validation_writer = tf.summary.create_file_writer(
os.path.join(
os.getcwd(),
"leelalogs/{}-validation".format(self.cfg['name'])))
if self.swa_enabled:
self.swa_writer = tf.summary.create_file_writer(
os.path.join(os.getcwd(),
"leelalogs/{}-swa-test".format(self.cfg['name'])))
self.swa_validation_writer = tf.summary.create_file_writer(
os.path.join(
os.getcwd(),
"leelalogs/{}-swa-validation".format(self.cfg['name'])))
self.checkpoint = tf.train.Checkpoint(optimizer=self.orig_optimizer,
model=self.model,
global_step=self.global_step,
swa_count=self.swa_count)
self.checkpoint.listed = self.swa_weights
self.manager = tf.train.CheckpointManager(
self.checkpoint,
directory=self.root_dir,
max_to_keep=50,
keep_checkpoint_every_n_hours=24,
checkpoint_name=self.cfg['name'])
def replace_weights_v2(self, proto_filename, ignore_errors=False):
self.net.parse_proto(proto_filename)
filters, blocks = self.net.filters(), self.net.blocks()
if not ignore_errors:
if self.RESIDUAL_FILTERS != filters:
raise ValueError("Number of filters doesn't match the network")
if self.RESIDUAL_BLOCKS != blocks:
raise ValueError("Number of blocks doesn't match the network")
if self.POLICY_HEAD != self.net.pb.format.network_format.policy:
raise ValueError("Policy head type doesn't match the network")
if self.VALUE_HEAD != self.net.pb.format.network_format.value:
raise ValueError("Value head type doesn't match the network")
# List all tensor names we need weights for.
names = []
for weight in self.model.weights:
names.append(weight.name)
new_weights = self.net.get_weights_v2(names)
for weight in self.model.weights:
if 'renorm' in weight.name:
# Renorm variables are not populated.
continue
try:
new_weight = new_weights[weight.name]
except KeyError:
error_string = 'No values for tensor {} in protobuf'.format(
weight.name)
if ignore_errors:
print(error_string)
continue
else:
raise KeyError(error_string)
if reduce(operator.mul, weight.shape.as_list(),
1) != len(new_weight):
error_string = 'Tensor {} has wrong length. Tensorflow shape {}, size in protobuf {}'.format(
weight.name, weight.shape.as_list(), len(new_weight))
if ignore_errors:
print(error_string)
continue
else:
raise KeyError(error_string)
if weight.shape.ndims == 4:
# Rescale rule50 related weights as clients do not normalize the input.
if weight.name == 'input/conv2d/kernel:0' and self.net.pb.format.network_format.input < pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION_HECTOPLIES:
num_inputs = 112
# 50 move rule is the 110th input, or 109 starting from 0.
rule50_input = 109
for i in range(len(new_weight)):
if (i % (num_inputs * 9)) // 9 == rule50_input:
new_weight[i] = new_weight[i] * 99
# Convolution weights need a transpose
#
# TF (kYXInputOutput)
# [filter_height, filter_width, in_channels, out_channels]
#
# Leela/cuDNN/Caffe (kOutputInputYX)
# [output, input, filter_size, filter_size]
s = weight.shape.as_list()
shape = [s[i] for i in [3, 2, 0, 1]]
new_weight = tf.constant(new_weight, shape=shape)
weight.assign(tf.transpose(a=new_weight, perm=[2, 3, 1, 0]))
elif weight.shape.ndims == 2:
# Fully connected layers are [in, out] in TF
#
# [out, in] in Leela
#
s = weight.shape.as_list()
shape = [s[i] for i in [1, 0]]
new_weight = tf.constant(new_weight, shape=shape)
weight.assign(tf.transpose(a=new_weight, perm=[1, 0]))
else:
# Biases, batchnorm etc
new_weight = tf.constant(new_weight, shape=weight.shape)
weight.assign(new_weight)
# Replace the SWA weights as well, ensuring swa accumulation is reset.
if self.swa_enabled:
self.swa_count.assign(tf.constant(0.))
self.update_swa_v2()
# This should result in identical file to the starting one
# self.save_leelaz_weights_v2('restored.pb.gz')
def restore_v2(self):
if self.manager.latest_checkpoint is not None:
print("Restoring from {0}".format(self.manager.latest_checkpoint))
self.checkpoint.restore(self.manager.latest_checkpoint)
def process_loop_v2(self, batch_size, test_batches, batch_splits=1):
# Get the initial steps value in case this is a resume from a step count
# which is not a multiple of total_steps.
steps = self.global_step.read_value()
total_steps = self.cfg['training']['total_steps']
for _ in range(steps % total_steps, total_steps):
self.process_v2(batch_size,
test_batches,
batch_splits=batch_splits)
@tf.function()
def read_weights(self):
return [w.read_value() for w in self.model.weights]
@tf.function()
def process_inner_loop(self, x, y, z, q, m):
with tf.GradientTape() as tape:
outputs = self.model(x, training=True)
policy = outputs[0]
value = outputs[1]
policy_loss = self.policy_loss_fn(y, policy)
reg_term = sum(self.model.losses)
if self.wdl:
value_ce_loss = self.value_loss_fn(self.qMix(z, q), value)
value_loss = value_ce_loss
else:
value_mse_loss = self.mse_loss_fn(self.qMix(z, q), value)
value_loss = value_mse_loss
if self.moves_left:
moves_left = outputs[2]
moves_left_loss = self.moves_left_loss_fn(m, moves_left)
else:
moves_left_loss = tf.constant(0.)
total_loss = self.lossMix(policy_loss, value_loss,
moves_left_loss) + reg_term
if self.loss_scale != 1:
total_loss = self.optimizer.get_scaled_loss(total_loss)
if self.wdl:
mse_loss = self.mse_loss_fn(self.qMix(z, q), value)
else:
value_loss = self.value_loss_fn(self.qMix(z, q), value)
return policy_loss, value_loss, mse_loss, moves_left_loss, reg_term, tape.gradient(
total_loss, self.model.trainable_weights)
def process_v2(self, batch_size, test_batches, batch_splits=1):
if not self.time_start:
self.time_start = time.time()
# Get the initial steps value before we do a training step.
steps = self.global_step.read_value()
if not self.last_steps:
self.last_steps = steps
if self.swa_enabled:
# split half of test_batches between testing regular weights and SWA weights
test_batches //= 2
# Run test before first step to see delta since end of last run.
if steps % self.cfg['training']['total_steps'] == 0:
# Steps is given as one higher than current in order to avoid it
# being equal to the value the end of a run is stored against.
self.calculate_test_summaries_v2(test_batches, steps + 1)
if self.swa_enabled:
self.calculate_swa_summaries_v2(test_batches, steps + 1)
# Make sure that ghost batch norm can be applied
if self.virtual_batch_size and batch_size % self.virtual_batch_size != 0:
# Adjust required batch size for batch splitting.
required_factor = self.virtual_batch_size * self.cfg[
'training'].get('num_batch_splits', 1)
raise ValueError(
'batch_size must be a multiple of {}'.format(required_factor))
# Determine learning rate
lr_values = self.cfg['training']['lr_values']
lr_boundaries = self.cfg['training']['lr_boundaries']
steps_total = steps % self.cfg['training']['total_steps']
self.lr = lr_values[bisect.bisect_right(lr_boundaries, steps_total)]
if self.warmup_steps > 0 and steps < self.warmup_steps:
self.lr = self.lr * tf.cast(steps + 1,
tf.float32) / self.warmup_steps
# need to add 1 to steps because steps will be incremented after gradient update
if (steps +
1) % self.cfg['training']['train_avg_report_steps'] == 0 or (
steps + 1) % self.cfg['training']['total_steps'] == 0:
before_weights = self.read_weights()
# Run training for this batch
grads = None
for _ in range(batch_splits):
x, y, z, q, m = next(self.train_iter)
policy_loss, value_loss, mse_loss, moves_left_loss, reg_term, new_grads = self.process_inner_loop(
x, y, z, q, m)
if not grads:
grads = new_grads
else:
grads = [tf.math.add(a, b) for (a, b) in zip(grads, new_grads)]
# Keep running averages
# Google's paper scales MSE by 1/4 to a [0, 1] range, so do the same to
# get comparable values.
mse_loss /= 4.0
self.avg_policy_loss.append(policy_loss)
if self.wdl:
self.avg_value_loss.append(value_loss)
if self.moves_left:
self.avg_moves_left_loss.append(moves_left_loss)
self.avg_mse_loss.append(mse_loss)
self.avg_reg_term.append(reg_term)
# Gradients of batch splits are summed, not averaged like usual, so need to scale lr accordingly to correct for this.
self.active_lr = self.lr / batch_splits
if self.loss_scale != 1:
grads = self.optimizer.get_unscaled_gradients(grads)
max_grad_norm = self.cfg['training'].get('max_grad_norm',
10000.0) * batch_splits
grads, grad_norm = tf.clip_by_global_norm(grads, max_grad_norm)
self.optimizer.apply_gradients(zip(grads,
self.model.trainable_weights))
# Update steps.
self.global_step.assign_add(1)
steps = self.global_step.read_value()
if steps % self.cfg['training'][
'train_avg_report_steps'] == 0 or steps % self.cfg['training'][
'total_steps'] == 0:
pol_loss_w = self.cfg['training']['policy_loss_weight']
val_loss_w = self.cfg['training']['value_loss_weight']
moves_loss_w = self.cfg['training']['moves_left_loss_weight']
time_end = time.time()
speed = 0
if self.time_start:
elapsed = time_end - self.time_start
steps_elapsed = steps - self.last_steps
speed = batch_size * (tf.cast(steps_elapsed, tf.float32) /
elapsed)
avg_policy_loss = np.mean(self.avg_policy_loss or [0])
avg_moves_left_loss = np.mean(self.avg_moves_left_loss or [0])
avg_value_loss = np.mean(self.avg_value_loss or [0])
avg_mse_loss = np.mean(self.avg_mse_loss or [0])
avg_reg_term = np.mean(self.avg_reg_term or [0])
print(
"step {}, lr={:g} policy={:g} value={:g} mse={:g} moves={:g} reg={:g} total={:g} ({:g} pos/s)"
.format(
steps, self.lr, avg_policy_loss, avg_value_loss,
avg_mse_loss, avg_moves_left_loss, avg_reg_term,
pol_loss_w * avg_policy_loss +
val_loss_w * avg_value_loss + avg_reg_term +
moves_loss_w * avg_moves_left_loss, speed))
after_weights = self.read_weights()
with self.train_writer.as_default():
tf.summary.scalar("Policy Loss", avg_policy_loss, step=steps)
tf.summary.scalar("Value Loss", avg_value_loss, step=steps)
if self.moves_left:
tf.summary.scalar("Moves Left Loss",
avg_moves_left_loss,
step=steps)
tf.summary.scalar("Reg term", avg_reg_term, step=steps)
tf.summary.scalar("LR", self.lr, step=steps)
tf.summary.scalar("Gradient norm",
grad_norm / batch_splits,
step=steps)
tf.summary.scalar("MSE Loss", avg_mse_loss, step=steps)
self.compute_update_ratio_v2(before_weights, after_weights,
steps)
self.train_writer.flush()
self.time_start = time_end
self.last_steps = steps
self.avg_policy_loss = []
self.avg_moves_left_loss = []
self.avg_value_loss = []
self.avg_mse_loss = []
self.avg_reg_term = []
if self.swa_enabled and steps % self.cfg['training']['swa_steps'] == 0:
self.update_swa_v2()
# Calculate test values every 'test_steps', but also ensure there is
# one at the final step so the delta to the first step can be calculted.
if steps % self.cfg['training']['test_steps'] == 0 or steps % self.cfg[
'training']['total_steps'] == 0:
self.calculate_test_summaries_v2(test_batches, steps)
if self.swa_enabled:
self.calculate_swa_summaries_v2(test_batches, steps)
if self.validation_dataset is not None and (
steps % self.cfg['training']['validation_steps'] == 0
or steps % self.cfg['training']['total_steps'] == 0):
if self.swa_enabled:
self.calculate_swa_validations_v2(steps)
else:
self.calculate_test_validations_v2(steps)
# Save session and weights at end, and also optionally every 'checkpoint_steps'.
if steps % self.cfg['training']['total_steps'] == 0 or (
'checkpoint_steps' in self.cfg['training']
and steps % self.cfg['training']['checkpoint_steps'] == 0):
evaled_steps = steps.numpy()
self.manager.save(checkpoint_number=evaled_steps)
print("Model saved in file: {}".format(
self.manager.latest_checkpoint))
path = os.path.join(self.root_dir, self.cfg['name'])
leela_path = path + "-" + str(evaled_steps)
swa_path = path + "-swa-" + str(evaled_steps)
self.net.pb.training_params.training_steps = evaled_steps
self.save_leelaz_weights_v2(leela_path)
if self.swa_enabled:
self.save_swa_weights_v2(swa_path)
def calculate_swa_summaries_v2(self, test_batches, steps):
backup = self.read_weights()
for (swa, w) in zip(self.swa_weights, self.model.weights):
w.assign(swa.read_value())
true_test_writer, self.test_writer = self.test_writer, self.swa_writer
print('swa', end=' ')
self.calculate_test_summaries_v2(test_batches, steps)
self.test_writer = true_test_writer
for (old, w) in zip(backup, self.model.weights):
w.assign(old)
@tf.function()
def calculate_test_summaries_inner_loop(self, x, y, z, q, m):
outputs = self.model(x, training=False)
policy = outputs[0]
value = outputs[1]
policy_loss = self.policy_loss_fn(y, policy)
policy_accuracy = self.policy_accuracy_fn(y, policy)
if self.wdl:
value_loss = self.value_loss_fn(self.qMix(z, q), value)
mse_loss = self.mse_loss_fn(self.qMix(z, q), value)
value_accuracy = self.accuracy_fn(self.qMix(z, q), value)
else:
value_loss = self.value_loss_fn(self.qMix(z, q), value)
mse_loss = self.mse_loss_fn(self.qMix(z, q), value)
value_accuracy = tf.constant(0.)
if self.moves_left:
moves_left = outputs[2]
moves_left_loss = self.moves_left_loss_fn(m, moves_left)
moves_left_mean_error = self.moves_left_mean_error(m, moves_left)
else:
moves_left_loss = tf.constant(0.)
moves_left_mean_error = tf.constant(0.)
return policy_loss, value_loss, moves_left_loss, mse_loss, policy_accuracy, value_accuracy, moves_left_mean_error
def calculate_test_summaries_v2(self, test_batches, steps):
sum_policy_accuracy = 0
sum_value_accuracy = 0
sum_moves_left = 0
sum_moves_left_mean_error = 0
sum_mse = 0
sum_policy = 0
sum_value = 0
for _ in range(0, test_batches):
x, y, z, q, m = next(self.test_iter)
policy_loss, value_loss, moves_left_loss, mse_loss, policy_accuracy, value_accuracy, moves_left_mean_error = self.calculate_test_summaries_inner_loop(
x, y, z, q, m)
sum_policy_accuracy += policy_accuracy
sum_mse += mse_loss
sum_policy += policy_loss
if self.wdl:
sum_value_accuracy += value_accuracy
sum_value += value_loss
if self.moves_left:
sum_moves_left += moves_left_loss
sum_moves_left_mean_error += moves_left_mean_error
sum_policy_accuracy /= test_batches
sum_policy_accuracy *= 100
sum_policy /= test_batches
sum_value /= test_batches
if self.wdl:
sum_value_accuracy /= test_batches
sum_value_accuracy *= 100
# Additionally rescale to [0, 1] so divide by 4
sum_mse /= (4.0 * test_batches)
if self.moves_left:
sum_moves_left /= test_batches
sum_moves_left_mean_error /= test_batches
self.net.pb.training_params.learning_rate = self.lr
self.net.pb.training_params.mse_loss = sum_mse
self.net.pb.training_params.policy_loss = sum_policy
# TODO store value and value accuracy in pb
self.net.pb.training_params.accuracy = sum_policy_accuracy
with self.test_writer.as_default():
tf.summary.scalar("Policy Loss", sum_policy, step=steps)
tf.summary.scalar("Value Loss", sum_value, step=steps)
tf.summary.scalar("MSE Loss", sum_mse, step=steps)
tf.summary.scalar("Policy Accuracy",
sum_policy_accuracy,
step=steps)
if self.wdl:
tf.summary.scalar("Value Accuracy",
sum_value_accuracy,
step=steps)
if self.moves_left:
tf.summary.scalar("Moves Left Loss",
sum_moves_left,
step=steps)
tf.summary.scalar("Moves Left Mean Error",
sum_moves_left_mean_error,
step=steps)
for w in self.model.weights:
tf.summary.histogram(w.name, w, step=steps)
self.test_writer.flush()
print("step {}, policy={:g} value={:g} policy accuracy={:g}% value accuracy={:g}% mse={:g}".\
format(steps, sum_policy, sum_value, sum_policy_accuracy, sum_value_accuracy, sum_mse), end = '')
if self.moves_left:
print(" moves={:g} moves mean={:g}".format(
sum_moves_left, sum_moves_left_mean_error))
else:
print()
def calculate_swa_validations_v2(self, steps):
backup = self.read_weights()
for (swa, w) in zip(self.swa_weights, self.model.weights):
w.assign(swa.read_value())
true_validation_writer, self.validation_writer = self.validation_writer, self.swa_validation_writer
print('swa', end=' ')
self.calculate_test_validations_v2(steps)
self.validation_writer = true_validation_writer
for (old, w) in zip(backup, self.model.weights):
w.assign(old)
def calculate_test_validations_v2(self, steps):
sum_policy_accuracy = 0
sum_value_accuracy = 0
sum_moves_left = 0
sum_moves_left_mean_error = 0
sum_mse = 0
sum_policy = 0
sum_value = 0
counter = 0
for (x, y, z, q, m) in self.validation_dataset:
policy_loss, value_loss, moves_left_loss, mse_loss, policy_accuracy, value_accuracy, moves_left_mean_error = self.calculate_test_summaries_inner_loop(
x, y, z, q, m)
sum_policy_accuracy += policy_accuracy
sum_mse += mse_loss
sum_policy += policy_loss
if self.moves_left:
sum_moves_left += moves_left_loss
sum_moves_left_mean_error += moves_left_mean_error
counter += 1
if self.wdl:
sum_value_accuracy += value_accuracy
sum_value += value_loss
sum_policy_accuracy /= counter
sum_policy_accuracy *= 100
sum_policy /= counter
sum_value /= counter
if self.wdl:
sum_value_accuracy /= counter
sum_value_accuracy *= 100
if self.moves_left:
sum_moves_left /= counter
sum_moves_left_mean_error /= counter
# Additionally rescale to [0, 1] so divide by 4
sum_mse /= (4.0 * counter)
with self.validation_writer.as_default():
tf.summary.scalar("Policy Loss", sum_policy, step=steps)
tf.summary.scalar("Value Loss", sum_value, step=steps)
tf.summary.scalar("MSE Loss", sum_mse, step=steps)
tf.summary.scalar("Policy Accuracy",
sum_policy_accuracy,
step=steps)
if self.wdl:
tf.summary.scalar("Value Accuracy",
sum_value_accuracy,
step=steps)
if self.moves_left:
tf.summary.scalar("Moves Left Loss",
sum_moves_left,
step=steps)
tf.summary.scalar("Moves Left Mean Error",
sum_moves_left_mean_error,
step=steps)
self.validation_writer.flush()
print("step {}, validation: policy={:g} value={:g} policy accuracy={:g}% value accuracy={:g}% mse={:g}".\
format(steps, sum_policy, sum_value, sum_policy_accuracy, sum_value_accuracy, sum_mse), end='')
if self.moves_left:
print(" moves={:g} moves mean={:g}".format(
sum_moves_left, sum_moves_left_mean_error))
else:
print()
@tf.function()
def compute_update_ratio_v2(self, before_weights, after_weights, steps):
"""Compute the ratio of gradient norm to weight norm.
Adapted from https://github.com/tensorflow/minigo/blob/c923cd5b11f7d417c9541ad61414bf175a84dc31/dual_net.py#L567
"""
deltas = [
after - before
for after, before in zip(after_weights, before_weights)
]
delta_norms = [tf.math.reduce_euclidean_norm(d) for d in deltas]
weight_norms = [
tf.math.reduce_euclidean_norm(w) for w in before_weights
]
ratios = [(tensor.name, tf.cond(w != 0., lambda: d / w, lambda: -1.))
for d, w, tensor in zip(delta_norms, weight_norms,
self.model.weights)
if not 'moving' in tensor.name]
for name, ratio in ratios:
tf.summary.scalar('update_ratios/' + name, ratio, step=steps)
# Filtering is hard, so just push infinities/NaNs to an unreasonably large value.
ratios = [
tf.cond(r > 0, lambda: tf.math.log(r) / 2.30258509299,
lambda: 200.) for (_, r) in ratios
]
tf.summary.histogram('update_ratios_log10',
tf.stack(ratios),
buckets=1000,
step=steps)
def update_swa_v2(self):
num = self.swa_count.read_value()
for (w, swa) in zip(self.model.weights, self.swa_weights):
swa.assign(swa.read_value() * (num / (num + 1.)) + w.read_value() *
(1. / (num + 1.)))
self.swa_count.assign(min(num + 1., self.swa_max_n))
def save_swa_weights_v2(self, filename):
backup = self.read_weights()
for (swa, w) in zip(self.swa_weights, self.model.weights):
w.assign(swa.read_value())
self.save_leelaz_weights_v2(filename)
for (old, w) in zip(backup, self.model.weights):
w.assign(old)
def save_leelaz_weights_v2(self, filename):
numpy_weights = []
for weight in self.model.weights:
numpy_weights.append([weight.name, weight.numpy()])
self.net.fill_net_v2(numpy_weights)
self.net.save_proto(filename)
def batch_norm_v2(self, input, name, scale=False):
if self.renorm_enabled:
clipping = {
"rmin": 1.0 / self.renorm_max_r,
"rmax": self.renorm_max_r,
"dmax": self.renorm_max_d
}
return tf.keras.layers.BatchNormalization(
epsilon=1e-5,
axis=1,
fused=False,
center=True,
scale=scale,
renorm=True,
renorm_clipping=clipping,
renorm_momentum=self.renorm_momentum,
name=name)(input)
else:
return tf.keras.layers.BatchNormalization(
epsilon=1e-5,
axis=1,
center=True,
scale=scale,
virtual_batch_size=self.virtual_batch_size,
name=name)(input)
def squeeze_excitation_v2(self, inputs, channels, name):
assert channels % self.SE_ratio == 0
pooled = tf.keras.layers.GlobalAveragePooling2D(
data_format='channels_first')(inputs)
squeezed = tf.keras.layers.Activation('relu')(tf.keras.layers.Dense(
channels // self.SE_ratio,
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
name=name + '/se/dense1')(pooled))
excited = tf.keras.layers.Dense(2 * channels,
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
name=name + '/se/dense2')(squeezed)
return ApplySqueezeExcitation()([inputs, excited])
def conv_block_v2(self,
inputs,
filter_size,
output_channels,
name,
bn_scale=False):
conv = tf.keras.layers.Conv2D(output_channels,
filter_size,
use_bias=False,
padding='same',
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
data_format='channels_first',
name=name + '/conv2d')(inputs)
return tf.keras.layers.Activation('relu')(self.batch_norm_v2(
conv, name=name + '/bn', scale=bn_scale))
def residual_block_v2(self, inputs, channels, name):
conv1 = tf.keras.layers.Conv2D(channels,
3,
use_bias=False,
padding='same',
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
data_format='channels_first',
name=name + '/1/conv2d')(inputs)
out1 = tf.keras.layers.Activation('relu')(self.batch_norm_v2(
conv1, name + '/1/bn', scale=False))
conv2 = tf.keras.layers.Conv2D(channels,
3,
use_bias=False,
padding='same',
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
data_format='channels_first',
name=name + '/2/conv2d')(out1)
out2 = self.squeeze_excitation_v2(self.batch_norm_v2(conv2,
name + '/2/bn',
scale=True),
channels,
name=name + '/se')
return tf.keras.layers.Activation('relu')(tf.keras.layers.add(
[inputs, out2]))
def construct_net_v2(self, inputs):
flow = self.conv_block_v2(inputs,
filter_size=3,
output_channels=self.RESIDUAL_FILTERS,
name='input',
bn_scale=True)
for i in range(self.RESIDUAL_BLOCKS):
flow = self.residual_block_v2(flow,
self.RESIDUAL_FILTERS,
name='residual_{}'.format(i + 1))
# Policy head
if self.POLICY_HEAD == pb.NetworkFormat.POLICY_CONVOLUTION:
conv_pol = self.conv_block_v2(
flow,
filter_size=3,
output_channels=self.RESIDUAL_FILTERS,
name='policy1')
conv_pol2 = tf.keras.layers.Conv2D(
80,
3,
use_bias=True,
padding='same',
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
bias_regularizer=self.l2reg,
data_format='channels_first',
name='policy')(conv_pol)
h_fc1 = ApplyPolicyMap()(conv_pol2)
elif self.POLICY_HEAD == pb.NetworkFormat.POLICY_CLASSICAL:
conv_pol = self.conv_block_v2(flow,
filter_size=1,
output_channels=self.policy_channels,
name='policy')
h_conv_pol_flat = tf.keras.layers.Flatten()(conv_pol)
h_fc1 = tf.keras.layers.Dense(1858,
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
bias_regularizer=self.l2reg,
name='policy/dense')(h_conv_pol_flat)
else:
raise ValueError("Unknown policy head type {}".format(
self.POLICY_HEAD))
# Value head
conv_val = self.conv_block_v2(flow,
filter_size=1,
output_channels=32,
name='value')
h_conv_val_flat = tf.keras.layers.Flatten()(conv_val)
h_fc2 = tf.keras.layers.Dense(128,
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
activation='relu',
name='value/dense1')(h_conv_val_flat)
if self.wdl:
h_fc3 = tf.keras.layers.Dense(3,
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
bias_regularizer=self.l2reg,
name='value/dense2')(h_fc2)
else:
h_fc3 = tf.keras.layers.Dense(1,
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
activation='tanh',
name='value/dense2')(h_fc2)
# Moves left head
if self.moves_left:
conv_mov = self.conv_block_v2(flow,
filter_size=1,
output_channels=8,
name='moves_left')
h_conv_mov_flat = tf.keras.layers.Flatten()(conv_mov)
h_fc4 = tf.keras.layers.Dense(
128,
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
activation='relu',
name='moves_left/dense1')(h_conv_mov_flat)
h_fc5 = tf.keras.layers.Dense(1,
kernel_initializer='glorot_normal',
kernel_regularizer=self.l2reg,
activation='relu',
name='moves_left/dense2')(h_fc4)
else:
h_fc5 = None
return h_fc1, h_fc3, h_fc5
def __init__(self, cfg):
self.cfg = cfg
self.net = Net()
self.root_dir = os.path.join(self.cfg['training']['path'],
self.cfg['name'])
# Network structure
self.RESIDUAL_FILTERS = self.cfg['model']['filters']
self.RESIDUAL_BLOCKS = self.cfg['model']['residual_blocks']
self.SE_ratio = self.cfg['model']['se_ratio']
self.policy_channels = self.cfg['model'].get('policy_channels', 32)
precision = self.cfg['training'].get('precision', 'single')
loss_scale = self.cfg['training'].get('loss_scale', 128)
self.virtual_batch_size = self.cfg['model'].get(
'virtual_batch_size', None)
if precision == 'single':
self.model_dtype = tf.float32
elif precision == 'half':
self.model_dtype = tf.float16
else:
raise ValueError("Unknown precision: {}".format(precision))
# Scale the loss to prevent gradient underflow
self.loss_scale = 1 if self.model_dtype == tf.float32 else loss_scale
policy_head = self.cfg['model'].get('policy', 'convolution')
value_head = self.cfg['model'].get('value', 'wdl')
moves_left_head = self.cfg['model'].get('moves_left', 'v1')
input_mode = self.cfg['model'].get('input_type', 'classic')
self.POLICY_HEAD = None
self.VALUE_HEAD = None
self.MOVES_LEFT_HEAD = None
self.INPUT_MODE = None
if policy_head == "classical":
self.POLICY_HEAD = pb.NetworkFormat.POLICY_CLASSICAL
elif policy_head == "convolution":
self.POLICY_HEAD = pb.NetworkFormat.POLICY_CONVOLUTION
else:
raise ValueError(
"Unknown policy head format: {}".format(policy_head))
self.net.set_policyformat(self.POLICY_HEAD)
if value_head == "classical":
self.VALUE_HEAD = pb.NetworkFormat.VALUE_CLASSICAL
self.wdl = False
elif value_head == "wdl":
self.VALUE_HEAD = pb.NetworkFormat.VALUE_WDL
self.wdl = True
else:
raise ValueError(
"Unknown value head format: {}".format(value_head))
self.net.set_valueformat(self.VALUE_HEAD)
if moves_left_head == "none":
self.MOVES_LEFT_HEAD = pb.NetworkFormat.MOVES_LEFT_NONE
self.moves_left = False
elif moves_left_head == "v1":
self.MOVES_LEFT_HEAD = pb.NetworkFormat.MOVES_LEFT_V1
self.moves_left = True
else:
raise ValueError(
"Unknown moves left head format: {}".format(moves_left_head))
self.net.set_movesleftformat(self.MOVES_LEFT_HEAD)
if input_mode == "classic":
self.INPUT_MODE = pb.NetworkFormat.INPUT_CLASSICAL_112_PLANE
elif input_mode == "frc_castling":
self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CASTLING_PLANE
elif input_mode == "canonical":
self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION
elif input_mode == "canonical_100":
self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION_HECTOPLIES
elif input_mode == "canonical_armageddon":
self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION_HECTOPLIES_ARMAGEDDON
else:
raise ValueError(
"Unknown input mode format: {}".format(input_mode))
self.net.set_input(self.INPUT_MODE)
self.swa_enabled = self.cfg['training'].get('swa', False)
# Limit momentum of SWA exponential average to 1 - 1/(swa_max_n + 1)
self.swa_max_n = self.cfg['training'].get('swa_max_n', 0)
self.renorm_enabled = self.cfg['training'].get('renorm', False)
self.renorm_max_r = self.cfg['training'].get('renorm_max_r', 1)
self.renorm_max_d = self.cfg['training'].get('renorm_max_d', 0)
self.renorm_momentum = self.cfg['training'].get(
'renorm_momentum', 0.99)
gpus = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_visible_devices(gpus[self.cfg['gpu']],
'GPU')
tf.config.experimental.set_memory_growth(gpus[self.cfg['gpu']], True)
if self.model_dtype == tf.float16:
tf.keras.mixed_precision.experimental.set_policy('mixed_float16')
self.global_step = tf.Variable(0,
name='global_step',
trainable=False,
dtype=tf.int64)
def train():
check_point_path = ''
transform = transforms.Compose([transforms.Scale(IMAGE_SIZE),
transforms.CenterCrop(IMAGE_SIZE),
transforms.ToTensor(),
transforms.Lambda(lambda x: x.mul(255))])
train_dataset = datasets.ImageFolder(DATASET_FOLDER, transform)
train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE)
style_model = Net(ngf=FILTER_CHANNEL, dv=device).to(device)
if RESUME is not None:
print('Resuming, initializing using weight from {}.'.format(RESUME))
style_model.load_state_dict(torch.load(RESUME))
print(style_model)
optimizer = Adam(style_model.parameters(), LEARNING_RATE)
mse_loss = torch.nn.MSELoss()
vgg = Vgg16()
utils.init_vgg16(VGG_DIR)
vgg.load_state_dict(torch.load(os.path.join(VGG_DIR, "vgg16.weight")))
vgg.to(device)
style_loader = utils.StyleLoader(STYLE_FOLDER, IMAGE_SIZE, device)
tbar = tqdm(range(EPOCHS))
for e in tbar:
style_model.train()
agg_content_loss = 0.
agg_style_loss = 0.
count = 0
for batch_id, (x, _) in enumerate(train_loader):
n_batch = len(x)
count += n_batch
optimizer.zero_grad()
x = Variable(utils.preprocess_batch(x)).to(device)
style_v = style_loader.get(batch_id)
style_model.setTarget(style_v)
style_v = utils.subtract_imagenet_mean_batch(style_v, device)
features_style = vgg(style_v)
gram_style = [utils.gram_matrix(y) for y in features_style]
y = style_model(x)
xc = Variable(x.data.clone())
y = utils.subtract_imagenet_mean_batch(y, device)
xc = utils.subtract_imagenet_mean_batch(xc, device)
features_y = vgg(y)
features_xc = vgg(xc)
f_xc_c = Variable(features_xc[1].data, requires_grad=False)
content_loss = CONT_WEIGHT * mse_loss(features_y[1], f_xc_c)
style_loss = 0.
for m in range(len(features_y)):
gram_y = utils.gram_matrix(features_y[m])
gram_s = Variable(gram_style[m].data, requires_grad=False).repeat(BATCH_SIZE, 1, 1, 1)
style_loss += STYLE_WEIGHT * mse_loss(gram_y.unsqueeze_(1), gram_s[:n_batch, :, :])
total_loss = content_loss + style_loss
total_loss.backward()
optimizer.step()
agg_content_loss += content_loss.data[0]
agg_style_loss += style_loss.data[0]
if (batch_id + 1) % 100 == 0:
mesg = "{}\tEpoch {}:\t[{}/{}]\tcontent: {:.6f}\tstyle: {:.6f}\ttotal: {:.6f}".format(
time.ctime(), e + 1, count, len(train_dataset),
agg_content_loss / (batch_id + 1),
agg_style_loss / (batch_id + 1),
(agg_content_loss + agg_style_loss) / (batch_id + 1)
)
tbar.set_description(mesg)
if (batch_id + 1) % (4 * 100) == 0:
# save model
style_model.eval()
style_model.cpu()
save_model_filename = "Epoch_" + str(e) + "iters_" + str(count) + "_" + str(time.ctime()).replace(' ', '_') + "_" + str(
CONT_WEIGHT) + "_" + str(STYLE_WEIGHT) + ".model"
save_model_path = os.path.join(SAVE_MODEL_DIR, save_model_filename)
torch.save(style_model.state_dict(), save_model_path)
if check_point_path:
os.remove(check_point_path)
check_point_path = save_model_path
style_model.train()
style_model.cuda()
tbar.set_description("\nCheckpoint, trained model saved at", save_model_path)
# save model
style_model.eval()
style_model.cpu()
save_model_filename = "Final_epoch_" + str(EPOCHS) + "_" + str(time.ctime()).replace(' ', '_') + "_" + str(
CONT_WEIGHT) + "_" + str(STYLE_WEIGHT) + ".model"
save_model_path = os.path.join(SAVE_MODEL_DIR, save_model_filename)
torch.save(style_model.state_dict(), save_model_path)
print("\nDone, trained model saved at", save_model_path)
import os
import cv2
import pickle
from skimage import color
from net import Net
from utils import *
import tensorflowjs as tfjs
img = cv2.imread('./demo/ILSVRC2012_val_00046524.JPEG')
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_rgb = (img_rgb.astype(dtype=np.float32)) / 255.0
img_rs = cv2.resize(img_rgb, (224, 224), interpolation=cv2.INTER_NEAREST)
img_lab_rs = color.rgb2lab(img_rs)
img_l_rs = img_lab_rs[:, :, 0] - 50
img_l_rs = img_l_rs[None, :, :, None]
autocolor = Net(train=False)
model = autocolor.create_model([1, 224, 224, 1])
file_name = '{}.pkl'.format('caffe_weights')
with open(file_name, 'rb') as f:
layer_dict = pickle.load(f)
layer_name_dict = dict([(layer.name, i)
for i, layer in enumerate(model.layers)])
for layer in layer_dict:
if layer['type'] != 'Convolution' and layer['type'] != 'Deconvolution':
continue
if layer['name'] == 'class8_ab':
continue
from net import Net
net = Net()
x = net.variable(1)
y = net.variable(2)
z = net.variable(3)
x2 = net.mul(x, x)
y2 = net.mul(y, y)
z2 = net.mul(z, z)
o1 = net.add(x2, y2)
o = net.add(o1, z2)
net.gradient_descendent()
print('x=', x.v, 'y=', y.v, 'z=', z.v)
import torch
import cv2
import numpy as np
from torch.autograd import Variable
from net import Net
from util import prep_image
def get_test_input():
img = cv2.imread("dog-cycle-car.png")
img = cv2.resize(img, (416, 416)) # Resize to the input dimension
img_ = img[:, :, ::-1].transpose((2, 0, 1)) # BGR -> RGB | H X W C -> C X H X W
img_ = img_[np.newaxis, :, :, :] / 255.0 # Add a channel at 0 (for batch) | Normalise
img_ = torch.from_numpy(img_).float() # Convert to float
img_ = Variable(img_) # Convert to Variable
return img_
model = Net("cfg/yolov3.cfg")
inp = prep_image(cv2.imread("image/dog-cycle-car.png"), int(model.net_info['width']))
pred = model(inp)
print(pred)
net = Net(
module=RNNModel,
max_epochs=args.epochs,
batch_size=args.batch_size,
use_cuda=args.cuda,
callbacks=[
skorch.callbacks.Checkpoint(),
skorch.callbacks.ProgressBar(),
LRAnnealing(),
ExamplePrinter()
],
module__rnn_type='LSTM',
module__ntoken=ntokens,
module__ninp=200,
module__nhid=200,
module__nlayers=2,
# Use (corpus.train, corpus.valid) as validation split.
# Even though we are doing a grid search, we use an internal
# validation set to determine when to save (Checkpoint callback)
# and when to decrease the learning rate (LRAnnealing callback).
train_split=my_train_split,
# To demonstrate that skorch is able to use already available
# data loaders as well, we use the data loader from the word
# language model.
iterator_train=data.Loader,
iterator_train__use_cuda=args.cuda,
iterator_train__bptt=args.bptt,
iterator_valid=data.Loader,
iterator_valid__use_cuda=args.cuda,
iterator_valid__bptt=args.bptt)
def preprocessing(x):
x = np.expand_dims(x, 1)
x = x.astype(np.float)
x /= 255.0
x -= x.mean()
x /= x.std()
return x
x = preprocessing(x)
xt = preprocessing(xt)
#x = np.random.random((n, 1, 28, 28))
#y = np.random.randint(2, size=(n))
# Model
net = Net()
net.push(Conv2d(5, 5, 1, 6)) # 1x28x28 -> 6x24x24
net.push(Relu())
net.push(Maxpooling(2, 2)) # 6x24x24 -> 6x12x12
net.push(Conv2d(5, 5, 6, 16)) # 6x12x12 -> 16x8x8
net.push(Relu())
net.push(Maxpooling(2, 2)) # 16x8x8 -> 16x4x4
net.push(Reshape((256)))
net.push(Linear(256, 84))
net.push(Relu())
net.push(Softmax(84, 10))
# Data
data = DataProvider()
n = 10000
data.train_input(x[:n], y[:n])
def test_pg(args=get_args()):
env = gym.make(args.task)
args.state_shape = env.observation_space.shape or env.observation_space.n
args.action_shape = env.action_space.shape or env.action_space.n
# train_envs = gym.make(args.task)
# you can also use tianshou.env.SubprocVectorEnv
train_envs = VectorEnv(
[lambda: gym.make(args.task) for _ in range(args.training_num)])
# test_envs = gym.make(args.task)
test_envs = VectorEnv(
[lambda: gym.make(args.task) for _ in range(args.test_num)])
# seed
np.random.seed(args.seed)
torch.manual_seed(args.seed)
train_envs.seed(args.seed)
test_envs.seed(args.seed)
# model
net = Net(args.layer_num,
args.state_shape,
args.action_shape,
device=args.device,
softmax=True)
net = net.to(args.device)
optim = torch.optim.Adam(net.parameters(), lr=args.lr)
dist = torch.distributions.Categorical
policy = PGPolicy(net, optim, dist, args.gamma)
# collector
train_collector = Collector(policy, train_envs,
ReplayBuffer(args.buffer_size))
test_collector = Collector(policy, test_envs)
# log
log_path = os.path.join(args.logdir, args.task, 'pg')
writer = SummaryWriter(log_path)
def save_fn(policy):
torch.save(policy.state_dict(), os.path.join(log_path, 'policy.pth'))
def stop_fn(x):
return x >= env.spec.reward_threshold
# trainer
result = onpolicy_trainer(policy,
train_collector,
test_collector,
args.epoch,
args.step_per_epoch,
args.collect_per_step,
args.repeat_per_collect,
args.test_num,
args.batch_size,
stop_fn=stop_fn,
save_fn=save_fn,
writer=writer)
assert stop_fn(result['best_reward'])
train_collector.close()
test_collector.close()
if __name__ == '__main__':
pprint.pprint(result)
# Let's watch its performance!
env = gym.make(args.task)
collector = Collector(policy, env)
result = collector.collect(n_episode=1, render=args.render)
print(f'Final reward: {result["rew"]}, length: {result["len"]}')
collector.close()
def loadModel():
global ANN, learningRate, patienceThreshold, fileName
ANN = Net.loadModel(fileName)
ANN.patienceThreshold = patienceThreshold
ANN.setLearningRate(learningRate)
)
# 检查cuda是否可用
use_cuda = torch.cuda.is_available()
# 生成log
now_time = datetime.now()
time_str = datetime.strftime(now_time, '%m-%d_%H-%M-%S')
log_path = os.path.join(os.getcwd(), "log")
log_dir = os.path.join(log_path, time_str)
if not os.path.exists(log_dir):
os.makedirs(log_dir)
writer = SummaryWriter(log_dir)
# ---------------------搭建网络--------------------------
cnn = Net() # 创建CNN
cnn.init_weights() # 初始化权值
cnn = cnn.double()
# --------------------设置损失函数和优化器----------------------
optimizer = optim.Adam(cnn.parameters()) # lr:(default: 1e-3)优化器
criterion = nn.CrossEntropyLoss() # 损失函数
scheduler = torch.optim.lr_scheduler.StepLR(
optimizer, step_size=EPOCH/2, gamma=0.5) # 设置学习率下降策略
# --------------------训练------------------------------
if(use_cuda): # 使用GPU
cnn = cnn.cuda()
for epoch in range(EPOCH):
loss_sigma = 0.0 # 记录一个epoch的loss之和
correct = 0.0
from keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
from keras import optimizers
from net import Net # creating modelNameName
wdthIm, hghtIm = 32, 32 # set image size
channelNo = 3 # set image number
data_dir_train = 'test_together/'
data_dirc_validation = 'test_together/'
epochNo = 120
batchSize = 52
modelName = Net.build(width=wdthIm, height=hghtIm,
depth=channelNo) #modelName name
print('building done!!')
Rms = optimizers.Rmsprop(lr=0.001, rho=0.9, epsilon=None,
decay=0.0) #compiling model
print('optimizing done!!')
modelName.compile(loss='categorical_crossentropy',
optimizer=Rms,
metrics=['accuracy'])
print('compiling.....')
train_datagenerator = ImageDataGenerator(
featurewise_centering=True,
featurewise_std_normaliztn=True,
shear_ranges=0.1,
zoom_ranges=0.1,
rotation_ranges=5,
from torch import jit
from net import Net
import torch
if __name__ == '__main__':
model = Net()
model.load_state_dict(torch.load("./params/9.t"))
# 模拟一个输入
input = torch.randn(1, 784)
# 打包
traced_script_moudle = torch.jit.trace(model, input)
traced_script_moudle.save("mnist.pt")
def train_regression(config, checkpoint_dir=None, data_dir=None):
net = Net(config["l1"], config["l2"])
net.to(device)
criterion = nn.MSELoss()
optimizer = optim.Adam(net.parameters(), lr=config["lr"])
# if checkpoint_dir:
# model_state, optimizer_state = torch.load(
# os.path.join(checkpoint_dir, "checkpoint"))
# net.load_state_dict(model_state)
# optimizer.load_state_dict(optimizer_state)
trainset = get_dataloader(data_dir, 'train')
valset = get_dataloader(data_dir, 'validation')
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=int(
config["batch_size"]))
valloader = torch.utils.data.DataLoader(valset,
batch_size=int(
config["batch_size"]))
for epoch in range(50): # loop over the dataset multiple times
running_loss = 0.0
epoch_steps = 0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data
inputs, labels = inputs.to(device), labels.to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = torch.sqrt(criterion(outputs, labels))
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
epoch_steps += 1
if i % 2000 == 1999: # print every 2000 mini-batches
print("[%d, %5d] loss: %.3f" %
(epoch + 1, i + 1, running_loss / epoch_steps))
running_loss = 0.0
# Validation loss
val_loss = 0.0
val_steps = 0
total = 0
correct = 0
for i, data in enumerate(valloader, 0):
with torch.no_grad():
inputs, labels = data
inputs, labels = inputs.to(device), labels.to(device)
outputs = net(inputs)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
loss = torch.sqrt(criterion(outputs, labels))
val_loss += loss.cpu().numpy()
val_steps += 1
with tune.checkpoint_dir(epoch) as checkpoint_dir:
path = os.path.join(checkpoint_dir, "checkpoint")
torch.save((net.state_dict(), optimizer.state_dict()), path)
tune.report(loss=(val_loss / val_steps))
print("Finished Training")
def main():
# Training settings
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs', type=int, default=10, metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='disables CUDA training')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=10, metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument("--index-array", help="lr array", type=int, default=None)
parser.add_argument("-o", help="save folder", default=None)
args = parser.parse_args()
if args.index_array is not None:
lin = np.linspace(0.0001, 0.5, 50)
args.lr = lin[args.index_array]
prep_output(args)
use_cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
train_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data', train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])),
batch_size=args.batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data', train=False, transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])),
batch_size=args.test_batch_size, shuffle=True, **kwargs)
model = Net().to(device)
optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
if args.o is not None:
f = open(os.path.join(args.o, "log.csv"), "w")
print("epoch, loss, test loss, test acc", file=f)
for epoch in tqdm(range(1, args.epochs + 1), desc="epoch"):
loss = train(args, model, device, train_loader, optimizer, epoch)
test_loss, acc = test(args, model, device, test_loader)
if args.o is not None:
print("%d, %f, %f, %.2f" % (epoch, loss, test_loss, acc), file=f)
class Solver_Heatmap(object):
def __init__(self, train=True, common_params=None, solver_params=None, net_params=None, dataset_params=None):
if common_params:
self.device_id = int(common_params['gpus'])
self.image_size = int(common_params['image_size'])
self.height = self.image_size
self.width = self.image_size
self.batch_size = int(common_params['batch_size'])
self.num_gpus = 1
self.restore_model = True
self.logs_dir = "logs/"
self.data_dir = "Data_zoo/flowers"
if solver_params:
self.learning_rate = float(solver_params['learning_rate'])
self.moment = float(solver_params['moment'])
self.max_steps = int(solver_params['max_iterators'])
self.train_dir = str(solver_params['train_dir'])
self.lr_decay = float(solver_params['lr_decay'])
self.decay_steps = int(solver_params['decay_steps'])
self.train = train
self.net = Net(train=train, common_params=common_params, net_params=net_params)
#self.dataset = DataSet(common_params=common_params, dataset_params=dataset_params)
self.train_images, self.test_images = flowers.read_dataset(self.data_dir)
image_options = {"resize": True, "resize_size": 224, "color": "LAB"}
self.batch_reader = dataset.BatchDatset(self.train_images, image_options)
self.batch_reader_test = dataset.BatchDatset(self.test_images, image_options)
def construct_graph(self, scope):
with tf.device('/gpu:' + str(self.device_id)):
self.data_l = tf.placeholder(tf.float32, (self.batch_size, self.height, self.width, 1))
self.gt_ab_313 = tf.placeholder(tf.float32, (self.batch_size, int(self.height / 4), int(self.width / 4), 313))
self.prior_boost_nongray = tf.placeholder(tf.float32, (self.batch_size, int(self.height / 4), int(self.width / 4), 1))
self.conv8_313 = self.net.inference(self.data_l)
new_loss, g_loss = self.net.loss_heatmap(scope, self.conv8_313, self.prior_boost_nongray, self.gt_ab_313)
tf.summary.scalar('new_loss', new_loss)
tf.summary.scalar('total_loss', g_loss)
return new_loss, g_loss, self.conv8_313
def pred_image(self, images):
#img = img[None, :, :, None]
#data_l = (img.astype(dtype=np.float32)) / 255.0 * 100 - 50
#data_l = tf.placeholder(tf.float32, shape=(None, None, None, 1))
autocolor = Net(train=False)
conv8_313 = autocolor.inference(images)
return conv8_313
#imsave('color.jpg', img_rgb)
def train_model(self):
with tf.device('/gpu:' + str(self.device_id)):
tf.reset_default_graph()
self.global_step = tf.get_variable('global_step', [], initializer=tf.constant_initializer(0), trainable=False)
learning_rate = tf.train.exponential_decay(self.learning_rate, self.global_step,
self.decay_steps, self.lr_decay, staircase=True)
opt = tf.train.AdamOptimizer(learning_rate=learning_rate, beta2=0.99)
images = tf.placeholder(tf.float32, shape=[None, None, None, 1], name='L_image')
with tf.name_scope('gpu') as scope:
self.data_l = tf.placeholder(tf.float32, (self.batch_size, self.height, self.width, 1))
self.gt_ab_313 = tf.placeholder(tf.float32, (self.batch_size, int(self.height / 4), int(self.width / 4), 313))
self.prior_boost_nongray = tf.placeholder(tf.float32, (self.batch_size, int(self.height / 4), int(self.width / 4), 1))
self.heat_maps = tf.placeholder(tf.float32, (self.batch_size, int(self.height / 4), int(self.width / 4), 313), name="heat_map")
conv8_313 = self.net.inference(self.data_l)
new_loss, g_loss = self.net.loss_heatmap(scope, conv8_313, self.prior_boost_nongray, self.gt_ab_313, self.heat_maps)
tf.summary.scalar('new_loss', new_loss)
tf.summary.scalar('total_loss', g_loss)
self.total_loss = g_loss
self.summaries = tf.get_collection(tf.GraphKeys.SUMMARIES, scope)
grads = opt.compute_gradients(new_loss)
self.summaries.append(tf.summary.scalar('learning_rate', learning_rate))
for grad, var in grads:
if grad is not None:
self.summaries.append(tf.summary.histogram(var.op.name + '/gradients', grad))
apply_gradient_op = opt.apply_gradients(grads, global_step=self.global_step)
for var in tf.trainable_variables():
self.summaries.append(tf.summary.histogram(var.op.name, var))
variable_averages = tf.train.ExponentialMovingAverage(
0.999, self.global_step)
variables_averages_op = variable_averages.apply(tf.trainable_variables())
train_op = tf.group(apply_gradient_op, variables_averages_op, conv8_313)
saver = tf.train.Saver(write_version=1)
summary_op = tf.summary.merge(self.summaries)
init = tf.global_variables_initializer()
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
sess.run(init)
#saver1.restore(sess, './models/model.ckpt')
#nilboy
if self.restore_model:
ckpt = tf.train.get_checkpoint_state(self.logs_dir + 'model_without_heatmap/')
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print("Model restored...")
summary_writer = tf.summary.FileWriter(self.train_dir, sess.graph)
for step in range(self.max_steps):
print(step)
start_time = time.time()
t1 = time.time()
data_l, gt_ab_313, prior_boost_nongray,color_image, hm_ab_313 = self.batch_reader.next_batch(16)
t2 = time.time()
_, loss_value = sess.run([train_op, self.total_loss], feed_dict={self.data_l:data_l, self.gt_ab_313:gt_ab_313, self.prior_boost_nongray:prior_boost_nongray, self.heat_maps:hm_ab_313})
duration = time.time() - start_time
t3 = time.time()
print('io: ' + str(t2 - t1) + '; compute: ' + str(t3 - t2))
assert not np.isnan(loss_value), 'Model diverged with loss = NaN'
if step % 1 == 0:
num_examples_per_step = self.batch_size * self.num_gpus
examples_per_sec = num_examples_per_step / duration
sec_per_batch = duration / self.num_gpus
format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '
'sec/batch)')
print (format_str % (datetime.now(), step, loss_value,
examples_per_sec, sec_per_batch))
if step % 10 == 0:
summary_str = sess.run(summary_op, feed_dict={self.data_l:data_l, self.gt_ab_313:gt_ab_313, self.prior_boost_nongray:prior_boost_nongray, self.heat_maps:hm_ab_313})
summary_writer.add_summary(summary_str, step)
# Save the model checkpoint periodically.
if step % 100 == 0:
checkpoint_path = os.path.join(self.train_dir, 'model.ckpt')
saver.save(sess, self.logs_dir + "model_with_heatmap/model.ckpt", global_step=step)
pred = sess.run(conv8_313, feed_dict={self.data_l:data_l, self.gt_ab_313:gt_ab_313, self.prior_boost_nongray:prior_boost_nongray})
idx = np.random.randint(0, self.batch_size)
save_dir = os.path.join(self.logs_dir, "image_checkpoints")
save_image(color_image[idx], save_dir, "gt" + str(step // 1))
print (pred[idx].shape)
#pred[idx] = tf.expand_dims(pred[idx], 0)
#print (pred[idx].shape)
predict = decode(data_l[idx:idx+1], pred[idx:idx+1],2.63)
save_image(predict.astype(np.float64), save_dir, "pred" + str(step // 1))
print("%s --> Model saved" % datetime.now())
if step % 1000 == 0:
count = 16
data_l_test, gt_ab_313_test, prior_boost_nongray_test, color_image_test, hm_ab_313 = self.batch_reader_test.get_random_batch(count)
feed_dict = {self.data_l:data_l_test, self.gt_ab_313:gt_ab_313_test, self.prior_boost_nongray:prior_boost_nongray_test}
save_dir = os.path.join(self.logs_dir, "image_pred_withhm/")
pred = sess.run(conv8_313, feed_dict=feed_dict)
for itr in range(count):
save_image(color_image_test[itr], save_dir, "gt" + str(itr))
predict = decode(data_l_test[itr:itr+1], pred[itr:itr+1],2.63)
save_image(predict, save_dir, "pred" + str(itr))
print("--- Images saved on test run ---")
class Brain(object):
def __init__(self, num_states, num_actions, opt={}):
"""
in number of time steps, of temporal memory
the ACTUAL input to the net will be (x,a) temporal_window times, and followed by current x
so to have no information from previous time step going into value function, set to 0.
"""
self.temporal_window = getopt(opt, 'temporal_window', 1)
"""size of experience replay memory"""
self.experience_size = getopt(opt, 'experience_size', 30000)
"""number of examples in experience replay memory before we begin learning"""
self.start_learn_threshold = getopt(opt, 'start_learn_threshold',
int(min(self.experience_size * 0.1, 1000)))
"""gamma is a crucial parameter that controls how much plan-ahead the agent does. In [0,1]"""
self.gamma = getopt(opt, 'gamma', 0.8)
"""number of steps we will learn for"""
self.learning_steps_total = getopt(opt, 'learning_steps_total', 100000)
"""how many steps of the above to perform only random actions (in the beginning)?"""
self.learning_steps_burnin = getopt(opt, 'learning_steps_burnin', 3000)
"""what epsilon value do we bottom out on? 0.0 => purely deterministic policy at end"""
self.epsilon_min = getopt(opt, 'epsilon_min', 0.05)
"""what epsilon to use at test time? (i.e. when learning is disabled)"""
self.epsilon_test_time = getopt(opt, 'epsilon_test_time', 0.01)
"""
advanced feature. Sometimes a random action should be biased towards some values
for example in flappy bird, we may want to choose to not flap more often
"""
if 'random_action_distribution' in opt:
#this better sum to 1 by the way, and be of length this.num_actions
self.random_action_distribution = opt['random_action_distribution']
if len(self.random_action_distribution) != num_actions:
print 'TROUBLE. random_action_distribution should be same length as num_actions.'
a = self.random_action_distribution
s = sum(a)
if abs(s - 1.0) > 0.0001:
print 'TROUBLE. random_action_distribution should sum to 1!'
else:
self.random_action_distribution = []
"""
states that go into neural net to predict optimal action look as
x0,a0,x1,a1,x2,a2,...xt
this variable controls the size of that temporal window. Actions are
encoded as 1-of-k hot vectors
"""
self.net_inputs = num_states * self.temporal_window + num_actions * self.temporal_window + num_states
self.num_states = num_states
self.num_actions = num_actions
self.window_size = max(self.temporal_window, 2) #must be at least 2, but if we want more context even more
self.state_window = zeros(self.window_size)
self.action_window = zeros(self.window_size)
self.reward_window = zeros(self.window_size)
self.net_window = zeros(self.window_size)
#create [state -> value of all possible actions] modeling net for the value function
layers = []
if 'layers' in opt:
"""
this is an advanced usage feature, because size of the input to the network, and number of
actions must check out.
"""
layers = opt['layers']
if len(layers) < 2:
print 'TROUBLE! must have at least 2 layers'
if layers[0]['type'] != 'input':
print 'TROUBLE! first layer must be input layer!'
if layers[-1]['type'] != 'regression':
print 'TROUBLE! last layer must be input regression!'
if layers[0]['out_depth'] * layers[0]['out_sx'] * layers[0]['out_sy'] != self.net_inputs:
print 'TROUBLE! Number of inputs must be num_states * temporal_window + num_actions * temporal_window + num_states!'
if layers[-1]['num_neurons'] != self.num_actions:
print 'TROUBLE! Number of regression neurons should be num_actions!'
else:
#create a very simple neural net by default
layers.append({'type': 'input', 'out_sx': 1, 'out_sy': 1, 'out_depth': self.net_inputs})
if 'hidden_layer_sizes' in opt:
#allow user to specify this via the option, for convenience
for size in opt['hidden_layer_sizes']:
layers.append({'type': 'fc', 'num_neurons': size, 'activation': 'relu'})
layers.append({'type': 'regression', 'num_neurons': self.num_actions}) #value function output
self.value_net = Net(layers)
#and finally we need a Temporal Difference Learning trainer!
trainer_ops_default = {'learning_rate': 0.01, 'momentum': 0.0, 'batch_size': 64, 'l2_decay': 0.01}
tdtrainer_options = getopt(opt, 'tdtrainer_options', trainer_ops_default)
self.tdtrainer = Trainer(self.value_net, tdtrainer_options)
#experience replay
self.experience = []
#various housekeeping variables
self.age = 0 #incremented every backward()
self.forward_passes = 0 #incremented every forward()
self.epsilon = 1.0 #controls exploration exploitation tradeoff. Should be annealed over time
self.latest_reward = 0
self.last_input_array = []
self.average_reward_window = Window(1000, 10)
self.average_loss_window = Window(1000, 10)
self.learning = True
def random_action(self):
"""
a bit of a helper function. It returns a random action
we are abstracting this away because in future we may want to
do more sophisticated things. For example some actions could be more
or less likely at "rest"/default state.
"""
if len(random_action_distribution) == 0:
return randi(0, self.num_actions)
else:
#okay, lets do some fancier sampling
p = randf(0, 1.0)
cumprob = 0.0
for k in xrange(self.num_actions):
cumprob += self.random_action_distribution[k]
if p < cumprob:
return k
def policy(self, s):
"""
compute the value of doing any action in this state
and return the argmax action and its value
"""
V = Vol(s)
action_values = self.value_net.forward(V)
weights = action_values.w
max_val = max(weights)
max_k = weights.index(maxval)
return {
'action': max_k,
'value': max_val
}
def getNetInput(self, xt):
"""
return s = (x,a,x,a,x,a,xt) state vector
It's a concatenation of last window_size (x,a) pairs and current state x
"""
w = []
w.extend(xt) #start with current state
#and now go backwards and append states and actions from history temporal_window times
n = self.window_size
for k in xrange(self.temporal_window):
index = n - 1 - k
w.extend(self.state_window[index]) #state
#action, encoded as 1-of-k indicator vector. We scale it up a bit because
#we dont want weight regularization to undervalue this information, as it only exists once
action1ofk = zeros(self.num_actions)
action1ofk[index] = 1.0 * self.num_states
w.extend(action1ofk)
return w
def forward(self, input_array):
self.forward_passes += 1
self.last_input_array = input_array
# create network input
action = None
if self.forward_passes > self.temporal_window:
#we have enough to actually do something reasonable
net_input = self.getNetInput(input_array)
if self.learning:
#compute epsilon for the epsilon-greedy policy
self.epsilon = min(
1.0,
max(
self.epsilon_min,
1.0 - \
(self.age - self.learning_steps_burnin) / \
(self.learning_steps_total - self.learning_steps_burnin)
)
)
else:
self.epsilon = self.epsilon_test_time #use test-time value
rf = randf(0, 1)
if rf < self.epsilon:
#choose a random action with epsilon probability
action = self.random_action()
else:
#otherwise use our policy to make decision
maxact = self.policy(net_input)
action = maxact['action']
else:
#pathological case that happens first few iterations
#before we accumulate window_size inputs
net_input = []
action = self.random_action()
#remember the state and action we took for backward pass
self.net_window.pop(0)
self.net_window.append(net_input)
self.state_window.pop(0)
self.state_window.append(input_array)
self.action_window.pop(0)
self.action_window.append(action)
def backward(self, reward):
self.latest_reward = reward
self.average_reward_window.add(reward)
self.reward_window.pop(0)
self.reward_window.append(reward)
if not self.learning:
return
self.age += 1
#it is time t+1 and we have to store (s_t, a_t, r_t, s_{t+1}) as new experience
#(given that an appropriate number of state measurements already exist, of course)
if self.forward_passes > self.temporal_window + 1:
n = self.window_size
e = Experience(
self.net_window[n - 2],
self.action_window[n - 2],
self.reward_window[n - 2],
self.net_window[n - 1]
)
if len(self.experience) < self.experience_size:
self.experience.append(e)
else:
ri = randi(0, self.experience_size)
self.experience[ri] = e
#learn based on experience, once we have some samples to go on
#this is where the magic happens...
if len(self.experience) > self.start_learn_threshold:
avcost = 0.0
for k in xrange(self.tdtrainer.batch_size):
re = randi(0, len(self.experience))
e = self.experience[re]
x = Vol(1, 1, self.net_inputs)
x.w = e.state0
maxact = self.policy(e.state1)
r = e.reward0 + self.gamma * maxact.value
ystruct = {'dim': e.action0, 'val': r}
stats = self.tdtrainer.train(x, ystruct)
avcost += stats['loss']
avcost /= self.tdtrainer.batch_size
self.average_loss_window.add(avcost)
def __init__(self):
self.quality = ''
self.net = Net()
class Dagger():
def __init__(self, grid, mdp, moves=40):
self.grid = grid
self.mdp = mdp
self.svm = LinearSVM(grid, mdp)
self.net = Net(grid,mdp)
self.moves = moves
#self.reward = np.zeros(40)
self.super_pi = mdp.pi
self.reward = np.zeros(self.moves)
self.animate = False
self.record = True
self.recent_rollout_states = None
def rollout(self):
self.grid.reset_mdp()
self.reward = np.zeros(self.moves)
self.recent_rollout_states = [self.mdp.state]
self.mistakes = 0.0
for t in range(self.moves):
if self.record:
assert self.super_pi.desc == ClassicPolicy.desc
self.net.add_datum(self.mdp.state, self.super_pi.get_next(self.mdp.state))
#Get current state and action
x_t = self.mdp.state
a_t = self.mdp.pi.get_next(x_t)
self.compare_policies(x_t, a_t)
#Take next step
self.grid.step(self.mdp)
x_t_1 = self.mdp.state
#Evaualte reward recieved
self.reward[t] = self.grid.reward(x_t,a_t,x_t_1)
self.recent_rollout_states.append(self.mdp.state)
if(self.animate):
self.grid.show_recording()
#print self.svm.data
def compare_policies(self, x, a):
if self.super_pi.get_next(x) != a:
self.mistakes += 1
def get_states(self):
return self.net.get_states()
def get_reward(self):
return np.sum(self.reward)
def set_supervisor_pi(self, pi):
self.super_pi = pi
def get_loss(self):
return float(self.mistakes) / float(self.moves)
def get_recent_rollout_states(self):
N = len(self.recent_rollout_states)
states = np.zeros([N,2])
for i in range(N):
x = self.recent_rollout_states[i].toArray()
states[i,:] = x
return states
def retrain(self):
self.net.fit()
self.mdp.pi = NetPolicy(self.net)
"""random split
TODO: various distribution methods
"""
splited_trainset = torch.utils.data.random_split(
trainset, [int(len(trainset) / ns) for _ in range(ns)])
splited_testset = torch.utils.data.random_split(
testset, [int(len(testset) / ns) for _ in range(ns)])
# print(len(splited_trainset[0]), len(splited_trainset[1]), len(splited_trainset[2]))
"""set nodes"""
clients = []
for i in range(ns):
clients.append(
Client(trainset=splited_trainset[i],
testset=splited_testset[i],
net=Net(),
_id=i))
tmp_client = Client( # tmp
trainset=None, testset=splited_testset[i], net=Net(), _id=-1)
"""set DAG"""
global_id = -1
nodes = []
genesis = Node(r=-1, w=clients[0].get_weights(), _id=global_id)
nodes.append(genesis)
global_id += 1
"""run simulator"""
latest_nodes = deepcopy(nodes) # in DAG
for r in range(rs):
#libs = []
libs = ["/mnt/Multimedia_NV/","/mnt/Anime/Filmes/","/mnt/Filmes/"]
plexserver = "192.168.1.71"
finalpath = True
finalpathloc = "/mnt/Filmes/Filmes"
filepath = "movieList.txt"
deleteonError = True
plexUpdate = True
user_agent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.10; rv:40.0) Gecko/20100101 Firefox/40.0'
cf_cookie_file = os.path.join(os.path.dirname(__file__), 'tugaio.cache')
net = Net()
net.set_cookies(cf_cookie_file)
net.set_user_agent(user_agent)
#####Codigo Addon Kodi
def cf_decrypt_ddos(url, agent, cookie_file):
class NoRedirection(urllib2.HTTPErrorProcessor):
def http_response(self, request, response):
return response
if len(agent) == 0:
agent = 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:6.0) Gecko/20100101 Firefox/6.0'
cj = cookielib.CookieJar()
opener = urllib2.build_opener(NoRedirection, urllib2.HTTPCookieProcessor(cj))
def train(args):
check_paths(args)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
kwargs = {'num_workers': 0, 'pin_memory': False}
else:
kwargs = {}
transform = transforms.Compose([
transforms.Scale(args.image_size),
transforms.CenterCrop(args.image_size),
transforms.ToTensor(),
transforms.Lambda(lambda x: x.mul(255))
])
train_dataset = datasets.ImageFolder(args.dataset, transform)
train_loader = DataLoader(train_dataset,
batch_size=args.batch_size,
**kwargs)
style_model = Net(ngf=args.ngf)
if args.resume is not None:
print('Resuming, initializing using weight from {}.'.format(
args.resume))
style_model.load_state_dict(torch.load(args.resume))
print(style_model)
optimizer = Adam(style_model.parameters(), args.lr)
mse_loss = torch.nn.MSELoss()
vgg = Vgg16()
utils.init_vgg16(args.vgg_model_dir)
vgg.load_state_dict(
torch.load(os.path.join(args.vgg_model_dir, "vgg16.weight")))
if args.cuda:
style_model.cuda()
vgg.cuda()
style_loader = utils.StyleLoader(args.style_folder, args.style_size)
tbar = trange(args.epochs)
for e in tbar:
style_model.train()
agg_content_loss = 0.
agg_style_loss = 0.
count = 0
for batch_id, (x, _) in enumerate(train_loader):
n_batch = len(x)
count += n_batch
optimizer.zero_grad()
x = Variable(utils.preprocess_batch(x))
if args.cuda:
x = x.cuda()
style_v = style_loader.get(batch_id)
style_model.setTarget(style_v)
style_v = utils.subtract_imagenet_mean_batch(style_v)
features_style = vgg(style_v)
gram_style = [utils.gram_matrix(y) for y in features_style]
y = style_model(x)
xc = Variable(x.data.clone())
y = utils.subtract_imagenet_mean_batch(y)
xc = utils.subtract_imagenet_mean_batch(xc)
features_y = vgg(y)
features_xc = vgg(xc)
f_xc_c = Variable(features_xc[1].data, requires_grad=False)
content_loss = args.content_weight * mse_loss(
features_y[1], f_xc_c)
style_loss = 0.
for m in range(len(features_y)):
gram_y = utils.gram_matrix(features_y[m])
gram_s = Variable(gram_style[m].data,
requires_grad=False).repeat(
args.batch_size, 1, 1, 1)
style_loss += args.style_weight * mse_loss(
gram_y, gram_s[:n_batch, :, :])
total_loss = content_loss + style_loss
total_loss.backward()
optimizer.step()
agg_content_loss += content_loss.data[0]
agg_style_loss += style_loss.data[0]
if (batch_id + 1) % args.log_interval == 0:
mesg = "{}\tEpoch {}:\t[{}/{}]\tcontent: {:.6f}\tstyle: {:.6f}\ttotal: {:.6f}".format(
time.ctime(), e + 1, count, len(train_dataset),
agg_content_loss / (batch_id + 1),
agg_style_loss / (batch_id + 1),
(agg_content_loss + agg_style_loss) / (batch_id + 1))
tbar.set_description(mesg)
if (batch_id + 1) % (4 * args.log_interval) == 0:
# save model
style_model.eval()
style_model.cpu()
save_model_filename = "Epoch_" + str(e) + "iters_" + str(count) + "_" + \
str(time.ctime()).replace(' ', '_') + "_" + str(
args.content_weight) + "_" + str(args.style_weight) + ".model"
save_model_path = os.path.join(args.save_model_dir,
save_model_filename)
torch.save(style_model.state_dict(), save_model_path)
style_model.train()
style_model.cuda()
tbar.set_description("\nCheckpoint, trained model saved at",
save_model_path)
# save model
style_model.eval()
style_model.cpu()
save_model_filename = "Final_epoch_" + str(args.epochs) + "_" + \
str(time.ctime()).replace(' ', '_') + "_" + str(
args.content_weight) + "_" + str(args.style_weight) + ".model"
save_model_path = os.path.join(args.save_model_dir, save_model_filename)
torch.save(style_model.state_dict(), save_model_path)
print("\nDone, trained model saved at", save_model_path)
import torch.nn.functional as F
from torchvision import transforms
from net import Net
from tqdm import tqdm
# parser = argparse.ArgumentParser()
# parser.add_argument("epoch", type=str, help="test epoch")
# args = parser.parse_args()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
Transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.5], std=[0.5]),
])
net = Net().to(device)
epoch = 32
net.load_state_dict(torch.load('./checkpoints/' + epoch + '.pkl'))
net.eval()
root = 'data/test/'
for item in tqdm(os.listdir(root)):
img = Image.open(root + item).convert('L')
x_data = Transform(img).float().unsqueeze(0).to(device)
outputs = net(x_data)
prediction = torch.max(F.softmax(outputs, dim=1),
dim=1)[1].cpu().numpy()[0]
age = prediction + 1
if len(str(age)) == 1:
result = '00' + str(age)
def __init__(self, num_states, num_actions, opt={}):
"""
in number of time steps, of temporal memory
the ACTUAL input to the net will be (x,a) temporal_window times, and followed by current x
so to have no information from previous time step going into value function, set to 0.
"""
self.temporal_window = getopt(opt, 'temporal_window', 1)
"""size of experience replay memory"""
self.experience_size = getopt(opt, 'experience_size', 30000)
"""number of examples in experience replay memory before we begin learning"""
self.start_learn_threshold = getopt(opt, 'start_learn_threshold',
int(min(self.experience_size * 0.1, 1000)))
"""gamma is a crucial parameter that controls how much plan-ahead the agent does. In [0,1]"""
self.gamma = getopt(opt, 'gamma', 0.8)
"""number of steps we will learn for"""
self.learning_steps_total = getopt(opt, 'learning_steps_total', 100000)
"""how many steps of the above to perform only random actions (in the beginning)?"""
self.learning_steps_burnin = getopt(opt, 'learning_steps_burnin', 3000)
"""what epsilon value do we bottom out on? 0.0 => purely deterministic policy at end"""
self.epsilon_min = getopt(opt, 'epsilon_min', 0.05)
"""what epsilon to use at test time? (i.e. when learning is disabled)"""
self.epsilon_test_time = getopt(opt, 'epsilon_test_time', 0.01)
"""
advanced feature. Sometimes a random action should be biased towards some values
for example in flappy bird, we may want to choose to not flap more often
"""
if 'random_action_distribution' in opt:
#this better sum to 1 by the way, and be of length this.num_actions
self.random_action_distribution = opt['random_action_distribution']
if len(self.random_action_distribution) != num_actions:
print 'TROUBLE. random_action_distribution should be same length as num_actions.'
a = self.random_action_distribution
s = sum(a)
if abs(s - 1.0) > 0.0001:
print 'TROUBLE. random_action_distribution should sum to 1!'
else:
self.random_action_distribution = []
"""
states that go into neural net to predict optimal action look as
x0,a0,x1,a1,x2,a2,...xt
this variable controls the size of that temporal window. Actions are
encoded as 1-of-k hot vectors
"""
self.net_inputs = num_states * self.temporal_window + num_actions * self.temporal_window + num_states
self.num_states = num_states
self.num_actions = num_actions
self.window_size = max(self.temporal_window, 2) #must be at least 2, but if we want more context even more
self.state_window = zeros(self.window_size)
self.action_window = zeros(self.window_size)
self.reward_window = zeros(self.window_size)
self.net_window = zeros(self.window_size)
#create [state -> value of all possible actions] modeling net for the value function
layers = []
if 'layers' in opt:
"""
this is an advanced usage feature, because size of the input to the network, and number of
actions must check out.
"""
layers = opt['layers']
if len(layers) < 2:
print 'TROUBLE! must have at least 2 layers'
if layers[0]['type'] != 'input':
print 'TROUBLE! first layer must be input layer!'
if layers[-1]['type'] != 'regression':
print 'TROUBLE! last layer must be input regression!'
if layers[0]['out_depth'] * layers[0]['out_sx'] * layers[0]['out_sy'] != self.net_inputs:
print 'TROUBLE! Number of inputs must be num_states * temporal_window + num_actions * temporal_window + num_states!'
if layers[-1]['num_neurons'] != self.num_actions:
print 'TROUBLE! Number of regression neurons should be num_actions!'
else:
#create a very simple neural net by default
layers.append({'type': 'input', 'out_sx': 1, 'out_sy': 1, 'out_depth': self.net_inputs})
if 'hidden_layer_sizes' in opt:
#allow user to specify this via the option, for convenience
for size in opt['hidden_layer_sizes']:
layers.append({'type': 'fc', 'num_neurons': size, 'activation': 'relu'})
layers.append({'type': 'regression', 'num_neurons': self.num_actions}) #value function output
self.value_net = Net(layers)
#and finally we need a Temporal Difference Learning trainer!
trainer_ops_default = {'learning_rate': 0.01, 'momentum': 0.0, 'batch_size': 64, 'l2_decay': 0.01}
tdtrainer_options = getopt(opt, 'tdtrainer_options', trainer_ops_default)
self.tdtrainer = Trainer(self.value_net, tdtrainer_options)
#experience replay
self.experience = []
#various housekeeping variables
self.age = 0 #incremented every backward()
self.forward_passes = 0 #incremented every forward()
self.epsilon = 1.0 #controls exploration exploitation tradeoff. Should be annealed over time
self.latest_reward = 0
self.last_input_array = []
self.average_reward_window = Window(1000, 10)
self.average_loss_window = Window(1000, 10)
self.learning = True
from net import Net
import visdom
from dataset import DataSet
from BP import BP
config = {
'lr': 0.0001,
'max_epoch': 500,
'vis': visdom.Visdom(env=u'plus_loss_test'),
'net': Net(2, [5, 3, 1], 0.0001, 'relu'),
'data': DataSet('x1+x2')
}
process = BP(config=config)
process.run()
f4.close()
print('SWA Finished!')
def get_test(df):
xs = []
for i in df:
img = i.reshape(28, 28)
img = img * 1. / 255.
xs.append(img)
xs = np.array(xs, dtype=np.float32).reshape(-1, height, width, 1)
return xs
get_new_weight()
model = Net((height, width, channels), numclass)
model.load_weights(new_weight_path, by_name=True)
df = pd.read_csv(TEST_CSV)
test = df.values
result = []
xs = get_test(test)
# print(xs.shape)
pre = model.predict(xs, batch_size=32)
# print(pre.shape)
pre = np.argmax(pre, axis=-1)
# print(pre.shape)
# result.append(pre)
def test_pdqn(args=get_args()):
env = gym.make(args.task)
args.state_shape = env.observation_space.shape or env.observation_space.n
args.action_shape = env.action_space.shape or env.action_space.n
# train_envs = gym.make(args.task)
# you can also use tianshou.env.SubprocVectorEnv
train_envs = VectorEnv(
[lambda: gym.make(args.task) for _ in range(args.training_num)])
# test_envs = gym.make(args.task)
test_envs = VectorEnv(
[lambda: gym.make(args.task) for _ in range(args.test_num)])
# seed
np.random.seed(args.seed)
torch.manual_seed(args.seed)
train_envs.seed(args.seed)
test_envs.seed(args.seed)
# model
net = Net(args.layer_num, args.state_shape, args.action_shape, args.device)
net = net.to(args.device)
optim = torch.optim.Adam(net.parameters(), lr=args.lr)
policy = DQNPolicy(net,
optim,
args.gamma,
args.n_step,
use_target_network=args.target_update_freq > 0,
target_update_freq=args.target_update_freq)
# collector
if args.prioritized_replay > 0:
buf = PrioritizedReplayBuffer(args.buffer_size,
alpha=args.alpha,
beta=args.alpha)
else:
buf = ReplayBuffer(args.buffer_size)
train_collector = Collector(policy, train_envs, buf)
test_collector = Collector(policy, test_envs)
# policy.set_eps(1)
train_collector.collect(n_step=args.batch_size)
# log
log_path = os.path.join(args.logdir, args.task, 'dqn')
writer = SummaryWriter(log_path)
def save_fn(policy):
torch.save(policy.state_dict(), os.path.join(log_path, 'policy.pth'))
def stop_fn(x):
return x >= env.spec.reward_threshold
def train_fn(x):
policy.set_eps(args.eps_train)
def test_fn(x):
policy.set_eps(args.eps_test)
# trainer
result = offpolicy_trainer(policy,
train_collector,
test_collector,
args.epoch,
args.step_per_epoch,
args.collect_per_step,
args.test_num,
args.batch_size,
train_fn=train_fn,
test_fn=test_fn,
stop_fn=stop_fn,
save_fn=save_fn,
writer=writer)
assert stop_fn(result['best_reward'])
train_collector.close()
test_collector.close()
if __name__ == '__main__':
pprint.pprint(result)
# Let's watch its performance!
env = gym.make(args.task)
collector = Collector(policy, env)
result = collector.collect(n_episode=1, render=args.render)
print(f'Final reward: {result["rew"]}, length: {result["len"]}')
collector.close()
success_place=True,
player_observable="attacker",
control="attacker",
visited=False,
)
places.update({"p2": p2})
def pick_first(list_of_enabled: List[Transition]):
return list_of_enabled[0]
n1 = Net(
transitions=transitions,
arcs=arcs,
places=places,
determine_transition_to_fire=pick_first,
des_tracking=DesTracking(),
)
enable_ts = n1.enabled_transitions()
new_net = n1.run_with_net_list()
print(len(new_net))
print(new_net[0].generate_list_of_places())
# new_net = new_net.step()
# new_net_enabled_ts = new_net.enabled_transitions()
# print(len(new_net_enabled_ts))
# print(len(new_net.marked_places()))
# print(enable_ts[0].name)
# print(len(n1.generate_list_of_places()))
# print(len(enable_ts))
def train(args, n_spk):
# load config
config = get_config(args.conf_path)
# logger
logger = Logger(args.log_name, 'train', 'val', 'dataset', 'decoder')
# training device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# hyper-set_parameters
pad_len = 2800
batch_len = 80
assert pad_len % batch_len == 0
# trainind settings and model
net = Net(config.model, n_spk, n_cyc=2, device=device)
net.to(device)
iter_count = 0
optim = Optimizers(config.optim)
optim.set_parameters(list(net.named_parameters()))
criteria_before = 10000
past_model = ''
# resume
if args.resume is not None:
dic = torch.load(args.resume)
net.load_state_dict(dic['model'])
iter_count = dic['iter_count']
optim = dic['optim']
criteria_before = dic['criteria']
past_model = dic['path']
# dataset
datasets = {
'train':
Dataset(args.train_dir,
args.stats_dir,
logger.dataset,
pad_len=pad_len,
batch_len=batch_len,
device=device),
'val':
Dataset(args.val_dir,
args.stats_dir,
logger.dataset,
pad_len=pad_len,
batch_len=batch_len,
device=device)
}
data_loaders = {
'train':
DataLoader(datasets['train'],
batch_size=config.train.batch_size,
shuffle=True),
'val':
DataLoader(datasets['val'],
batch_size=config.val.batch_size,
shuffle=False)
}
# logging about training data
logger.dataset.info('number of training samples: %d' %
len(datasets['train']))
logger.dataset.info('number of validation samples: %d' %
len(datasets['val']))
# loss function
loss_fn = Loss(device)
# log net
logger.train.info(net)
# training!
logger.train.info('Start training from iteration %d' % iter_count)
# Hypre-parameter required to compute loss
scale_var = torch.Tensor(
datasets['train'].scaler['mcep'].scale_).to(device)
# train
for e in range(config.train.epoch):
net.train()
losses = []
for batch in data_loaders['train']:
# iter for batch
iter_count += 1
# training data to device
inputs = {
'feat':
torch.cat((batch['uv'], batch['lcf0'], batch['codeap'],
batch['mcep']),
dim=-1).to(device),
'cv_stats':
torch.cat((batch['uv'], batch['lcf0'], batch['codeap']),
dim=-1).to(device),
'src_code':
batch['src_code'].to(device),
'trg_code':
batch['trg_code'].to(device),
'src_spk':
batch['src_id'].to(device),
'trg_spk':
batch['trg_id'].to(device),
'flen':
batch['flen'].to(device)
}
# forward propagation
out = net(inputs)
# compute loss
loss, loss_dic = loss_fn(out, inputs, scale_var)
# backward
loss.backward()
optim.step()
# log
losses.append(loss.cpu().detach().numpy())
if iter_count % config.train.log_every == 0:
logger.train.info('loss at iter %d : %s' %
(iter_count, loss.item()))
logger.train.figure('train', loss_dic, iter_count)
# log
logger.train.info('Loss for epoch %d : %.5f' % (e, np.mean(losses)))
# Validation
logger.val.info('Start validation at epoch %d' % e)
net.eval()
losses = []
criterias = []
with torch.no_grad():
for batch in data_loaders['val']:
# to device
inputs = {
'feat':
torch.cat((batch['uv'], batch['lcf0'], batch['codeap'],
batch['mcep']),
dim=-1).to(device),
'cv_stats':
torch.cat((batch['uv'], batch['lcf0'], batch['codeap']),
dim=-1).to(device),
'src_code':
batch['src_code'].to(device),
'trg_code':
batch['trg_code'].to(device),
'src_spk':
batch['src_id'].to(device),
'trg_spk':
batch['trg_id'].to(device),
'flen':
batch['flen'].to(device)
}
# forward propagation
out = net(inputs)
# compute loss
loss, loss_dic = loss_fn(out, inputs, scale_var)
criteria = loss_dic['mcd/1st']
# log
losses.append(loss.cpu().detach().numpy())
criterias.append(criteria)
# log
criteria = np.mean(criterias)
logger.val.info('Validation loss at epoch %d: %.5f' %
(e, np.mean(losses)))
logger.val.info('Validation criteria: %.5f' % criteria)
logger.val.figure('val', loss_dic, iter_count)
# save model with best criteria
if criteria < criteria_before:
logger.val.info('Passed criteria (%f < %f), saving best model...' \
% (criteria, criteria_before))
# remove the existing past model.
if not past_model == '':
os.remove(past_model)
logger.val.info(
'Found existing model at %s. Removed this file.' %
past_model)
# build dict
save_file = os.path.join(
args.model_dir, '%s.%d.pt' % (args.model_name, iter_count))
save_dic = {
'model': net.state_dict(),
'iter_count': iter_count,
'optim': optim,
'criteria': criteria,
'path': save_file
}
torch.save(save_dic, save_file)
criteria_before = criteria
past_model = save_file
# close SummaryWriter
logger.close()
