def main():
jt.seed(settings.SEED)
np.random.seed(settings.SEED)
model = get_model()
train_loader = TrainDataset(data_root=settings.DATA_ROOT,
split='train',
batch_size=settings.BATCH_SIZE,
shuffle=True)
val_loader = ValDataset(data_root=settings.DATA_ROOT,
split='val',
batch_size=1,
shuffle=False)
writer = SummaryWriter(settings.WRITER_PATH)
learning_rate = settings.LEARNING_RATE
momentum = settings.MOMENTUM
weight_decay = settings.WEIGHT_DECAY
model_backbone = []
model_backbone.append(model.get_backbone())
model_head = model.get_head()
params_list = []
for module in model_backbone:
params_list.append(dict(params=module.parameters(), lr=learning_rate))
for module in model_head:
for m in module.modules():
print(type(m).__name__, type(m))
params_list.append(
dict(params=module.parameters(), lr=learning_rate * 10))
optimizer = nn.SGD(params_list, learning_rate, momentum, weight_decay)
epochs = settings.EPOCHS
evaluator = Evaluator(settings.NCLASS)
for epoch in range(epochs):
#train(model, train_loader, optimizer, epoch, learning_rate, writer)
val(model, val_loader, epoch, evaluator, writer)
def hook_rand():
global rand_hooked
if rand_hooked: return
rand_hooked = True
np.random.seed(0)
if "torch" in sys.modules:
LOG.i("Hook torch.rand")
torch = sys.modules["torch"]
torch.rand = hook_pt_rand
torch.normal = hook_pt_normal
torch.manual_seed(0)
if "jittor" in sys.modules:
jittor = sys.modules["jittor"]
LOG.i("Hook jittor.random")
jittor.random = hook_jt_rand
jittor.seed(0)
def test_normalize_3d_tensor(self):
jt.seed(28)
n_channels = 3
img_size = 10
mean = jt.random((n_channels, )).data
std = jt.random((n_channels, )).data
img = jt.random((n_channels, img_size, img_size)).data
target = transform.image_normalize(img, mean, std)
mean_unsqueezed = mean.reshape(-1, 1, 1)
std_unsqueezed = std.reshape(-1, 1, 1)
result1 = transform.image_normalize(img, mean_unsqueezed,
std_unsqueezed)
result2 = transform.image_normalize(img, mean_unsqueezed,
std_unsqueezed)
assert_array_almost_equal(target, result1)
assert_array_almost_equal(target, result2)
def setup_seed(self, seed):
np.random.seed(seed)
random.seed(seed)
jt.seed(seed)
def setUpClass(self):
np.random.seed(0)
jt.seed(3)
def setUpClass(self):
jt.seed(0)
np.random.seed(0)
torch.manual_seed(0)
def init_seeds(seed=0):
# Initialize random number generator (RNG) seeds
random.seed(seed)
np.random.seed(seed)
jt.seed(seed)
# "policy.0.weight": init(256,4,),
# "policy.0.bias":np.zeros(256,).astype("float32"),
# "policy.2.weight": init(2,256,),
# "policy.2.bias":np.zeros(2,).astype("float32"),
# })
# print(model.parameters())
# vs = []
# for v in jt.find_vars():
# vs.append(v().flatten())
# vs = np.concatenate(vs)
# pl.plot(vs)
env.seed(seed)
np.random.seed(seed)
jt.seed(seed)
prev_time = time.time()
start_time = prev_time
for episode in range(max_episodes):
# print(np.random.rand(3))
state = env.reset()
done = False
tot_reward = 0
length = 0
entropy_term = jt.float32(0).stop_fuse()
num_step = num_steps // update_step
for steps in range(num_step):
