# Model name model_name = '64_oscis_optim' save_name = os.path.join(save_dir, model_name) # Side of image img_side = 10 # Polyomino type n = 3 # Number of polyominoes num_polys = 2 # Batch Size batch_size = 64 # Data generator generator = polyomino_scenes(n, img_side, num_polys, batch_size) # Model parameters learning_rate = 1e-2 training_steps = 5000 # Dynamics duration episodes = 100 update_rate = .1 anneal = False # Loss is sum of frame potential and within-group synchrony loss_func = loss_func_ex.matt_loss_torch # How frequently to report results plot_when = 5
from make_data_new import polyomino_scenes
import numpy as np
import net
import matplotlib.pyplot as plt
saved = True
while saved:
generator = polyomino_scenes(n=3,
num_objects=2,
img_side=8,
batch_size=1,
rotation=True)
train_data = generator.generate_batch()
train_img = net.convert2twod(train_data[0])
train_mask = net.mask_pro(train_data[1][0])
if np.min(np.sum(train_mask, axis=2), axis=1) != 0:
np.savez('/media/data_cifs/yuwei/osci_save/data/train_data328.npz',
image=train_data[0],
mask=train_mask)
plt.imshow(train_data[0][0])
plt.savefig('/media/data_cifs/yuwei/osci_save/data/train_data328.png')
saved = False
def __init__(self,
n=1,
num=2,
lr=1e-2,
report=25,
batch_size=16,
train_step=100,
evolution_step=20,
img_side=2):
# omino type
self.n = n
# number of objects
self.num = num
# learning rate
self.lr = lr
# report steps
self.report = report
# batch size
self.batch = batch_size
# image size
self.img_side = img_side
# save dir
self.fig_dir = os.path.join(os.path.expanduser('~'), 'oscillators')
# model dir
self.data_dir = os.path.join(os.path.expanduser('~'), 'osc_models')
# Min and max number of groups
self.min_groups = 2
self.max_groups = self.num
for dr in [self.fig_dir, self.data_dir]:
if not os.path.exists(dr):
os.makedirs(dr)
# initialize a generator
if self.img_side > 2:
self.generator = polyomino_scenes(self.n, self.img_side, self.num,
self.batch, True)
self.types = len(self.generator.n_ominoes)
else:
self.types = 2
# training steps
self.steps = train_step
# iterate steps
self.episodes = evolution_step
# start to build the graph
# initialize a network
#self.network = small_net(5,16)
self.network = big_net(img_side, 3, 5, num_features=16)
self.network.apply(weights_init)
self.optimizer = torch.optim.Adam(self.network.parameters(),
lr=self.lr)
# if you want to see which param is gonna require grads print it with its value
# by uncommenting following
"""
for name, param in self.network.named_parameters():
if param.requires_grad:
print(name, param.data)
"""
# save map generated
self.couplings = []
# one test image could be used
if self.img_side > 2:
test_batch, test_mask = generate_test_img(n=self.n,
img_side=self.img_side,
num=self.num)
#self.test_img = self.convert2oned(test_data[0], test=True)
self.test_batch = torch.tensor(test_batch).unsqueeze(1).float()
self.test_mask = torch.tensor(list(map(self._mask_pro,
test_mask))).float()
else:
self.test_img = np.reshape(np.concatenate(
[np.zeros((1, 2)), np.ones((1, 2))], axis=0),
newshape=[1, 2, 2, 1])
self.test_img = self.convert2oned(self.test_img, test=True)
self.test_mask = np.reshape(
np.concatenate(
[np.array([[1, 1, 0, 0]]),
np.array([[0, 0, 1, 1]])]), [1, 2, 4])
self.test_mask = torch.tensor(self.test_mask).float()
self.loss_history = []
model_name = '64_oscis_optim'
save_name = os.path.join(save_dir, model_name)
# Side of image
img_side = 16
# Polyomino type
n = 4
# Number of polyominoes
num_polys = 2
# Batch Size
batch_size = 64
# Data generator
generator = polyomino_scenes(n,
img_side,
num_polys,
batch_size,
rotation=False,
noisy=False)
# Model parameters
learning_rate = 1e-3
training_steps = 5000
init_steps = 1600
kernel_size = 5
num_conv_features = 32
out_kernel_side = None
# Dynamics duration
episodes = 100
update_rate = 1.0
anneal = False
save_name = os.path.join(save_dir, model_name)
img_side = 16
learning_rate = 1e-4
training_steps = 5000
episodes = 100
loss_func1 = loss_func_ex.coh_btw_groups_torch
loss_func2 = loss_func_ex.coh_in_groups_torch
loss_func3 = loss_func_ex.exinp_btw_groups_torch
loss_func4 = loss_func_ex.fpt_btw_groups_torch
report = 100
effect = 2
batch_size = 32
#train_data = np.load('train_data.npz')
#train_img = train_data['image']
#train_mask = torch.tensor(train_data['mask']).float()
generator = polyomino_scenes(5, img_side, 4, batch_size)
#network = net.net2() # architecture
network = nets.big_net(img_side, 3)
#network.apply(net.weights_init) # network initialization
display = kv.displayer() # visualization
osci = km.kura_torch(img_side**2)
loss_history = []
train_op = torch.optim.Adam(network.parameters(), lr=learning_rate)
for step in range(training_steps):
train_op.zero_grad()
batch, sd = generator.generate_batch()
batch = torch.tensor(batch).unsqueeze(1).float()