def get_suggested_lrs(self: Learner, num_it):
'compute Suggested LRs'
lrs, losses = tensor(self.recorder.lrs[num_it // 10:-5]), tensor(
self.recorder.losses[num_it // 10:-5])
if len(losses) == 0: return
lr_min = lrs[losses.argmin()].item()
grads = (losses[1:] - losses[:-1]) / (lrs[1:].log() - lrs[:-1].log())
lr_steep = lrs[grads.argmin()].item()
return SuggestedLRs(lr_min / 10., lr_steep)
def normalize_triplet_funcs(mean: FloatTensor,
std: FloatTensor,
do_x: bool = True,
do_y: bool = False) -> Tuple[Callable, Callable]:
"Create normalize/denormalize func using `mean` and `std`, can specify `do_y` and `device`."
mean, std = tensor(mean), tensor(std)
return (
partial(_normalize_triplet_batch,
mean=mean,
std=std,
do_x=do_x,
do_y=do_y),
partial(denormalize_triplet, mean=mean, std=std, do_x=do_x),
)
def __init__(self, n_in: int, ks=1, sym=False): # , n_out:int):
super().__init__()
self.conv = conv1d(n_in, n_in, ks, padding=ks // 2, bias=False)
self.gamma = nn.Parameter(tensor([0.]))
self.sym = sym
self.n_in = n_in
def neighbor_gen(at,
distance_expansion=None,
cutoff=5.0,
n_gaussians=25,
trainable_gaussians=False,
environment_provider=ASEEnvironmentProvider(5.0),
collect_triples=False,
pair_provider=None,
center_positions=True):
properties = {}
properties[Structure.Z] = tensor(at.numbers.astype(np.int)).unsqueeze(0)
positions = at.positions.astype(np.float32)
if center_positions:
positions -= at.get_center_of_mass()
properties[Structure.R] = tensor(positions).unsqueeze(0)
properties[Structure.cell] = tensor(at.cell.astype(
np.float32)).unsqueeze(0)
# get atom environment
idx = 0
nbh_idx, offsets = environment_provider.get_environment(idx, at)
properties[Structure.neighbors] = tensor(nbh_idx.astype(
np.int)).unsqueeze(0)
properties[Structure.cell_offset] = tensor(offsets.astype(
np.float32)).unsqueeze(0)
properties[Structure.neighbor_mask] = None
properties['_idx'] = tensor(np.array([idx], dtype=np.int)).unsqueeze(0)
if collect_triples:
nbh_idx_j, nbh_idx_k = collect_atom_triples(nbh_idx)
properties[Structure.neighbor_pairs_j] = tensor(
nbh_idx_j.astype(np.int))
properties[Structure.neighbor_pairs_k] = tensor(
nbh_idx_k.astype(np.int))
model = spk.custom.representation.RBF(
distance_expansion=distance_expansion,
cutoff=cutoff,
n_gaussians=n_gaussians,
trainable_gaussians=trainable_gaussians)
model = to_device(model)
r, f = model.forward(properties)
return to_np(r.squeeze()), to_np(f.squeeze())
def test_torch_tensor(self):
a = tensor([1, 2, 3])
b = torch.tensor([1, 2, 3])
self.assertTrue(torch.all(a == b))
def test_torch_tensor(self):
a = tensor([1, 2, 3])
b = torch.tensor([1, 2, 3])
self.assertTrue(torch.all(a == b))