def load_model(model_name: str) -> GraphModel:
"""
load the model by user friendly name as in megnet.utils.models.AVAILABEL_MODELS
Args:
model_name: str model name string
Returns: GraphModel
"""
if model_name in AVAILABLE_MODELS:
mvl_path = os.path.join(MODEL_PATH, MODEL_MAPPING[model_name])
if os.path.isfile(mvl_path):
return MEGNetModel.from_file(mvl_path)
logger.info(
"Package-level mvl_models not included, trying temperary mvl_models downloads.."
)
local_mvl_path = os.path.join(LOCAL_MODEL_PATH,
MODEL_MAPPING[model_name])
if os.path.isfile(local_mvl_path):
logger.info("Model found in local mvl_models path")
return MEGNetModel.from_file(local_mvl_path)
_download_models()
return load_model(model_name)
else:
raise ValueError('model name %s not in available model list %s' %
(model_name, AVAILABLE_MODELS))
def test_check_dimension(self):
gc = CrystalGraph(bond_converter=GaussianDistance(np.linspace(0, 5, 20), 0.5))
s = Structure(Lattice.cubic(3), ['Si'], [[0, 0, 0]])
graph = gc.convert(s)
model = MEGNetModel(10, 2, nblocks=1, lr=1e-2,
n1=4, n2=4, n3=4, npass=1, ntarget=1,
graph_converter=CrystalGraph(bond_converter=gc),
)
with self.assertRaises(Exception) as context:
model.check_dimension(graph)
self.assertTrue('The data dimension for bond' in str(context.exception))
def __init__(self, target_name):
self.model = MEGNetModel.from_file(
pjoin(QM9_MODELDIR, target_name + ".hdf5"))
self.model.graph_convertor.atom_convertor = AtomNumberToTypeConvertor()
self.scaler = Scaler(SCALER[target_name]['mean'],
SCALER[target_name]['std'],
SCALER[target_name]['is_per_atom'])
def test_from_mvl_models(self):
with ScratchDir("."):
model = MEGNetModel.from_mvl_models("Eform_MP_2019")
li2o = self.get_structure("Li2O")
self.assertAlmostEqual(float(model.predict_structure(li2o)),
-2.0152957439422607,
places=4)
def test_from_url(self):
with ScratchDir("."):
model = MEGNetModel.from_url(
"https://github.com/materialsvirtuallab/megnet/raw/master/mvl_models/mp-2019.4.1/formation_energy.hdf5"
)
li2o = self.get_structure("Li2O")
self.assertAlmostEqual(float(model.predict_structure(li2o)),
-2.0152957439422607)
def setUpClass(cls):
cls.n_feature = 3
cls.n_bond_features = 10
cls.n_global_features = 2
class Generator(Sequence):
def __init__(self, x, y):
self.x = x
self.y = y
def __len__(self):
return 10
def __getitem__(self, index):
return self.x, self.y
x_crystal = [np.array([1, 2, 3, 4]).reshape((1, -1)),
np.random.normal(size=(1, 6, cls.n_bond_features)),
np.random.normal(size=(1, 2, cls.n_global_features)),
np.array([[0, 0, 1, 1, 2, 3]]),
np.array([[1, 1, 0, 0, 3, 2]]),
np.array([[0, 0, 1, 1]]),
np.array([[0, 0, 0, 0, 1, 1]]),
]
y = np.random.normal(size=(1, 2, 1))
cls.train_gen_crystal = Generator(x_crystal, y)
x_mol = [np.random.normal(size=(1, 4, cls.n_feature)),
np.random.normal(size=(1, 6, cls.n_bond_features)),
np.random.normal(size=(1, 2, cls.n_global_features)),
np.array([[0, 0, 1, 1, 2, 3]]),
np.array([[1, 1, 0, 0, 3, 2]]),
np.array([[0, 0, 1, 1]]),
np.array([[0, 0, 0, 0, 1, 1]]),
]
y = np.random.normal(size=(1, 2, 1))
cls.train_gen_mol = Generator(x_mol, y)
cls.model = MEGNetModel(10, 2, nblocks=1, lr=1e-2,
n1=4, n2=4, n3=4, npass=1, ntarget=1,
graph_converter=CrystalGraph(bond_converter=GaussianDistance(np.linspace(0, 5, 10), 0.5)),
)
cls.model2 = MEGNetModel(10, 2, nblocks=1, lr=1e-2,
n1=4, n2=4, n3=4, npass=1, ntarget=2,
graph_converter=CrystalGraph(bond_converter=GaussianDistance(np.linspace(0, 5, 10), 0.5)),
)
def test_crystal_model_v2(self):
cg = CrystalGraph()
s = Structure(Lattice.cubic(3), ['Si'], [[0, 0, 0]])
with ScratchDir('.'):
model = MEGNetModel(nfeat_edge=None,
nfeat_global=2,
nblocks=1,
lr=1e-2,
n1=4,
n2=4,
n3=4,
npass=1,
ntarget=1,
graph_converter=cg,
centers=np.linspace(0, 4, 10),
width=0.5)
model = model.train([s, s], [0.1, 0.1], epochs=2)
t = model.predict_structure(s)
self.assertTrue(t.shape == (1, ))
def setUpClass(cls):
cls.s = Structure.from_spacegroup('Fm-3m', Lattice.cubic(5.69169),
['Na', 'Cl'],
[[0, 0, 0], [0, 0, 0.5]])
cls.dummy_model = MEGNetModel(100,
2,
nblocks=1,
n1=4,
n2=2,
n3=2,
npass=1)
def __init__(self,
model_name: Union[str, GraphModel,
MEGNetModel] = DEFAULT_MODEL,
use_cache: bool = True):
"""
Args:
model_name (str or MEGNetModel): trained model. If it is
str, then only models in mvl_models are used.
use_cache (bool): whether to use cache for structure
graph calculations
"""
if isinstance(model_name, str):
model = MEGNetModel.from_file(model_name)
elif isinstance(model_name, GraphModel):
model = model_name
else:
raise ValueError('model_name only support str '
'or GraphModel object')
layers = model.layers
important_prefix = ['meg', 'set', 'concatenate']
all_names = [
i.name for i in layers
if any([i.name.startswith(j) for j in important_prefix])
]
if any([i.startswith('megnet') for i in all_names]):
self.version = 'v2'
else:
self.version = 'v1'
valid_outputs = [
i.output for i in layers
if any([i.name.startswith(j) for j in important_prefix])
]
outputs = []
valid_names = []
for i, j in zip(all_names, valid_outputs):
if isinstance(j, list):
for k, l in enumerate(j):
valid_names.append(i + '_%d' % k)
outputs.append(l)
else:
valid_names.append(i)
outputs.append(j)
full_model = Model(inputs=model.inputs, outputs=outputs)
model.model = full_model
self.model = model
self.valid_names = valid_names
self._cache: Dict[str, float] = {}
self.use_cache = use_cache
def random_structure_on_substrate(symbols,
amin,
amax,
dmin,
model_file,
Natt=RANDOM_ATTEMPTS):
# returns random structure (ase Atoms) on substrate with lowest e_tot according to Megnet model
substrate = read_vasp("POSCAR.substrate")
adapt = AseAtomsAdaptor()
model = MEGNetModel.from_file(model_file)
e_tot_min = 1000.
for i in range(Natt):
s = surface(substrate, (0, 0, 1), 1, vacuum=0., tol=1e-10)
cell = s.get_cell()
cell[2][2] = CELL_Z
s.set_cell(cell)
amin = cell[0][0]
amax = cell[0][0]
struct = random_structure(symbols, amin, amax, dmin, iwrite=0)
j = 0
atoms = struct.get_chemical_symbols()
positions = struct.get_positions()
for atom in atoms:
at = Atom(atom)
positions[j][2] = positions[j][2] + SURF_DIST
pos = positions[j]
at.position = pos
s.append(at)
j = j + 1
struct_pymatgen = adapt.get_structure(s)
try:
e_tot = model.predict_structure(struct_pymatgen)
# print(e_tot)
except:
e_tot = 0.
print("isolated molecule exception handled")
if e_tot < e_tot_min:
struct_out = s
e_tot_min = e_tot
print("e_tot min: ", e_tot_min)
write(filename='best.in', images=struct_out, format="espresso-in")
del model
return struct_out
def random_structure_group(symbols,
composition,
thickness,
tol_factor,
model_file,
dmin=2.0,
Natt=RANDOM_ATTEMPTS):
# returns pyxtal generated structure (ase Atoms) with lowest e_tot according to megnet model
tol_m_1 = Tol_matrix(prototype="atomic", factor=tol_factor)
adapt = AseAtomsAdaptor()
model = MEGNetModel.from_file(model_file)
e_tot_min = 0.
for i in range(Natt):
group_id = randrange(80) + 1
my_crystal = random_crystal_2D(group_id,
symbols,
composition,
1.0,
thickness=thickness,
tm=tol_m_1)
flag = 0
if my_crystal.valid == True:
struct = crystal_to_atoms(my_crystal)
Nat = len(struct.get_chemical_symbols())
struct_pymatgen = adapt.get_structure(struct)
try:
e_tot = model.predict_structure(struct_pymatgen)
except:
e_tot = 0.
print("isolated molecule exception handled")
struct2x2x1 = struct * (2, 2, 1)
positions = struct2x2x1.get_positions()
# positions = struct.get_positions()
# print(struct)
flag = check_dist(Nat * 2 * 2, positions, dmin)
# print(flag)
if (e_tot < e_tot_min) and flag == 1:
struct_out = struct
e_tot_min = e_tot
print("e_tot/atom: " + str(e_tot_min))
# write(filename="POSCAR.best.in", images=struct_out, format="espresso-in")
# write(filename="POSCAR.best", images=struct_out, format="vasp")
del model
return struct_out
def load_model(model_name):
"""
load the model by user friendly name as in megnet.utils.models.AVAILABEL_MODELS
Args:
model_name: str model name string
Returns: GraphModel
"""
if model_name in AVAILABLE_MODELS:
return MEGNetModel.from_file(MODEL_MAPPING[model_name])
else:
raise ValueError('model name %s not in available model list %s' % (model_name, AVAILABLE_MODELS))
def show_layers(model_file):
"""
show_layers(model_file)
Displays information on layers of a pre-trained
MEGNet model.
Inputs:
model_file- A pre-trained MEGNet model file.
Outputs:
1- Layers in the model file.
"""
pretrained_model = MEGNetModel.from_file(model_file)
print(pretrained_model.summary())
def setUpClass(cls):
cls.n_feature = 3
cls.n_bond_features = 10
cls.n_global_features = 2
def generator(x, y):
while True:
yield x, y
x_crystal = [
np.array([1, 2, 3, 4]).reshape((1, -1)),
np.random.normal(size=(1, 6, cls.n_bond_features)),
np.random.normal(size=(1, 2, cls.n_global_features)),
np.array([[0, 0, 1, 1, 2, 3]]),
np.array([[1, 1, 0, 0, 3, 2]]),
np.array([[0, 0, 1, 1]]),
np.array([[0, 0, 0, 0, 1, 1]]),
]
y = np.random.normal(size=(1, 2, 1))
cls.train_gen_crystal = generator(x_crystal, y)
x_mol = [
np.random.normal(size=(1, 4, cls.n_feature)),
np.random.normal(size=(1, 6, cls.n_bond_features)),
np.random.normal(size=(1, 2, cls.n_global_features)),
np.array([[0, 0, 1, 1, 2, 3]]),
np.array([[1, 1, 0, 0, 3, 2]]),
np.array([[0, 0, 1, 1]]),
np.array([[0, 0, 0, 0, 1, 1]]),
]
y = np.random.normal(size=(1, 2, 1))
cls.train_gen_mol = generator(x_mol, y)
cls.model = MEGNetModel(
10,
2,
nblocks=1,
lr=1e-2,
n1=4,
n2=4,
n3=4,
npass=1,
ntarget=1,
graph_convertor=CrystalGraph(
bond_convertor=GaussianDistance(np.linspace(0, 5, 10), 0.5)),
)
def find_sub_tree(cur_tag, input_history_tag):
###### load model #######
father_model_name = dump_model_name + '_' + input_history_tag + '.hdf5'
#########################
for db_str in cur_tag:
history_tag = input_history_tag
history_tag += '_'
history_tag += db_str
if special_path != '' and history_tag not in special_path:
continue
else:
pass
cur_model_name = dump_model_name + '_' + history_tag + '.hdf5'
cur_model = MEGNetModel.from_file(father_model_name)
###### get dataset ######
s, t = construct_dataset_from_str(db_str)
l = len(s)
###### train ############
try:
cur_model.train(s[:int(0.8*l)], t[:int(0.8*l)],
validation_structures=s[int(0.8*l):],
validation_targets=t[int(0.8*l):],
callbacks=[callback],
save_checkpoint=False,
automatic_correction=False,
batch_size = 256,
epochs=ep)
except TypeError:
logging.info('MAE of {tag} is: {mae}'.format(tag=history_tag, mae='nan'))
else:
mae = prediction(cur_model)
logging.info('MAE of {tag} is: {mae}'.format(tag=history_tag, mae=mae))
cur_model.save_model(cur_model_name)
del s, t, l
gc.collect()
###### next level #######
if len(cur_tag) > 1:
tmp_tag = cur_tag
next_tag = tmp_tag.replace(db_str, '')
find_sub_tree(next_tag, history_tag)
else:
pass
def __init__(self,
model_name: Union[str, GraphModel,
MEGNetModel] = DEFAULT_MODEL,
use_cache: bool = True):
if isinstance(model_name, str):
model = MEGNetModel.from_file(model_name)
elif isinstance(model_name, GraphModel):
model = model_name
else:
raise ValueError('model_name only support str '
'or GraphModel object')
layers = model.layers
important_prefix = ['meg', 'set', 'concatenate']
all_names = [
i.name for i in layers
if any([i.name.startswith(j) for j in important_prefix])
]
valid_outputs = [
i.output for i in layers
if any([i.name.startswith(j) for j in important_prefix])
]
outputs = []
valid_names = []
for i, j in zip(all_names, valid_outputs):
if isinstance(j, list):
for k, l in enumerate(j):
valid_names.append(i + '_%d' % k)
outputs.append(l)
else:
valid_names.append(i)
outputs.append(j)
full_model = Model(inputs=model.inputs, outputs=outputs)
model.model = full_model
self.model = model
self.valid_names = valid_names
self._cache = {}
self.use_cache = use_cache
def random_structure_model(stoichio,
amin,
amax,
dmin,
model_file,
Natt=RANDOM_ATTEMPTS):
# returns random structure (ase Atoms) with lowest e_tot according to megnet model
adapt = AseAtomsAdaptor()
model = MEGNetModel.from_file(model_file)
e_tot_min = 0.
flag = 0
for i in range(Natt):
struct = random_structure(stoichio, amin, amax, dmin)
# Nat = len(struct.get_chemical_symbols())
struct_pymatgen = adapt.get_structure(struct)
try:
e_tot = model.predict_structure(struct_pymatgen)
except:
e_tot = 0.
print("isolated molecule exception handled")
if e_tot < e_tot_min:
struct_out = struct
e_tot_min = e_tot
flag = 1
if flag == 0:
print("Warning: structure not generated!")
struct_out = Atoms(stoichio)
if flag == 1:
print("e_tot/atom: " + str(e_tot_min))
write(filename='POSCAR_' + random_str(5) + '.in',
images=struct_out,
format="espresso-in")
del model
return struct_out
def __init__(self, model_name=DEFAULT_MODEL, use_cache=True):
model = MEGNetModel.from_file(model_name)
layers = model.layers
important_prefix = ['meg', 'set', 'concatenate']
all_names = [i.name for i in layers if any([i.name.startswith(j) for j in important_prefix])]
valid_outputs = [i.output for i in layers if any([i.name.startswith(j) for j in important_prefix])]
outputs = []
valid_names = []
for i, j in zip(all_names, valid_outputs):
if isinstance(j, list):
for k, l in enumerate(j):
valid_names.append(i + '_%d' % k)
outputs.append(l)
else:
valid_names.append(i)
outputs.append(j)
full_model = Model(inputs=model.inputs, outputs=outputs)
model.model = full_model
self.model = model
self.valid_names = valid_names
self._cache = {}
self.use_cache = use_cache
def load(cls: "MEGNetProbModel",
save_path: PathLike,
load_ckpt: bool = True) -> "MEGNetProbModel":
"""Load a MEGNetProbModel from disk.
Args:
save_path: The path to the model's save directory.
load_ckpt: Whether to load the best checkpoint's weights, instead
of those saved at the time of the last :meth:`save`.
Returns:
The loaded model.
Raises:
FileNotFoundError: If the ``save_path`` or any components do not exist.
"""
paths = _get_save_paths(save_path)
try:
meg_model = MEGNetModel.from_file(str(paths["meg_path"]))
except OSError:
raise FileNotFoundError(
f"No saved MEGNetModel at `{paths['meg_path']}`.")
return super().load(save_path, load_ckpt, meg_model=meg_model)
def prepare_model_megnet(individuals, epochs, outfile, excl=[]):
# prepares model file
# prepares Megnet model based on list of individuals
# uses total energy per atom
# excl - excluding particular stoichiometry - important for network learning
structures = []
energies = []
adapt = AseAtomsAdaptor()
empty = 0
if not excl:
empty = 1
i = 0
for ind in individuals:
struct_ase = ind.get_init_structure()
chem_sym = struct_ase.get_chemical_symbols()
e_tot = ind.e_tot
struct_pymatgen = adapt.get_structure(struct_ase)
flag = 1
if empty == 0 and chem_sym == excl:
flag = 0
if flag == 1:
structures.append(struct_pymatgen)
energies.append(e_tot)
i = i + 1
print("read data of " + str(i) + " structures total")
# standard vales as taken from Megnet manual
nfeat_bond = 100
nfeat_global = 2
r_cutoff = 5
gaussian_centers = np.linspace(0, r_cutoff + 1, nfeat_bond)
gaussian_width = 0.5
distance_converter = GaussianDistance(gaussian_centers, gaussian_width)
graph_converter = CrystalGraph(bond_converter=distance_converter, cutoff=r_cutoff)
model = MEGNetModel(nfeat_bond, nfeat_global, graph_converter=graph_converter)
# model training
model.train(structures, energies, epochs=epochs)
model.save_model(outfile)
from megnet.models import MEGNetModel
model_form = MEGNetModel.from_file(
'/home/vol00/scarf690/src/megnet/mvl_models/mp-2018.6.1/band_gap_regression.hdf5'
)
## Set GPU
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
# 2. Model construction
## Graph converter
crystal_graph = CrystalGraph(bond_converter=GaussianDistance(
centers=np.linspace(0, 6, 100), width=0.5),
cutoff=5.0)
## model setup
model = MEGNetModel(
nfeat_edge=100,
nfeat_global=None,
ngvocal=len(TRAIN_FIDELITIES),
global_embedding_dim=16,
nblocks=3,
nvocal=95,
npass=2,
graph_converter=crystal_graph,
lr=1e-3,
)
# 3. Data loading and processing
## load data
## Structure data for all materials project materials
if not os.path.isfile("mp.2019.04.01.json"):
raise RuntimeError(
"Please download the data first! Use runall.sh in this directory if needed."
)
return result
# === megnet start === #
from megnet.models import MEGNetModel
from megnet.data.graph import GaussianDistance
from megnet.data.crystal import CrystalGraph
from megnet.utils.preprocessing import StandardScaler
from megnet.callbacks import ReduceLRUponNan, ManualStop, XiaotongCB
import numpy as np
gc = CrystalGraph(bond_converter=GaussianDistance(
np.linspace(0, 5, 100), 0.5), cutoff=4)
model = MEGNetModel(100, 2, graph_converter=gc, lr=1e-4, loss=examine_loss) # , metrics=[examine_loss])
INTENSIVE = False # U0 is an extensive quantity
scaler = StandardScaler.from_training_data(structures, targets, is_intensive=INTENSIVE)
model.target_scaler = scaler
# callbacks = [ReduceLRUponNan(patience=500), ManualStop(), XiaotongCB()]
# change structures to megnet predictable structures
mp_strs = []
train_graphs, train_targets = model.get_all_graphs_targets(structures, targets)
train_nb_atoms = [len(i['atom']) for i in train_graphs]
train_targets = [model.target_scaler.transform(i, j) for i, j in zip(train_targets, train_nb_atoms)]
for s in structures:
Xtrain = inputs.iloc[0:boundary]['structure']
ytrain = inputs.iloc[0:boundary]['band_gap']
Xtest = inputs.iloc[boundary:]['structure']
ytest = inputs.iloc[boundary:]['band_gap']
nfeat_bond = 10
nfeat_global = 2
r_cutoff = 5
gaussian_centers = np.linspace(0, 5, 10)
gaussian_width = 0.5
distance_convertor = GaussianDistance(gaussian_centers, gaussian_width)
bond_convertor = CrystalGraph(bond_convertor=distance_convertor,
cutoff=r_cutoff)
graph_convertor = CrystalGraph(
bond_convertor=GaussianDistance(np.linspace(0, 5, 10), 0.5))
model = MEGNetModel(nfeat_bond, nfeat_global, graph_convertor=graph_convertor)
model.from_file('fitted_gap_model.hdf5')
model.train(Xtrain,
ytrain,
epochs=epochs,
batch_size=batch_size,
validation_structures=Xtest,
validation_targets=ytest,
scrub_failed_structures=True)
model.save_model('fitted_gap_model.hdf5')
MAE = 0
test_size = len(test_structures)
for i in range(test_size):
MAE += abs(model.predict_structure(test_structures[i]).ravel() - test_targets[i])
MAE /= test_size
print('MAE is:', MAE)
training_mode = int(sys.argv[1])
# data preprocess part
if True:
import pickle
# load the past if needed
model = MEGNetModel.from_file('6a34b94_9_2.hdf5')
idx = 0
for sz in data_size[:-1]:
ME = 0
error_lst = []
for i in range(idx, idx + sz):
e = (model.predict_structure(structures[i]).ravel() - targets[i])
ME += e
error_lst.append(e)
if abs(e) > 0.5:
targets[i] = model.predict_structure(structures[i]).ravel()
# targets[i] = (model.predict_structure(structures[i]).ravel() + targets[i])/2
ME /= sz
f = open(str(sz) + 'txt', 'wb')
pickle.dump(error_lst, f)
f.close()
# Data preprocessing:
# Load binary compounds' formation energies example data,
# then split into training and validation subsets.
full_df = load_data("binary_e_form")
num_training = int(TRAINING_RATIO * len(full_df.index))
train_df = full_df[:num_training]
val_df = full_df[num_training:]
# 4217 training samples, 1055 validation samples.
train_structs = train_df["structure"]
val_structs = val_df["structure"]
train_targets = train_df["formation_energy_per_atom"]
val_targets = val_df["formation_energy_per_atom"]
# 1. Load MEGNetModel
meg_model = MEGNetModel.from_mvl_models("Eform_MP_2019")
# 2. Make probabilistic model
# Specify Kullback-Leibler divergence weighting in loss function:
kl_weight = BATCH_SIZE / num_training
# Then make the model:
prob_model = MEGNetProbModel(
meg_model=meg_model,
num_inducing_points=NUM_INDUCING_POINTS,
kl_weight=kl_weight,
)
def train_model():
"""Train and save the probabilistic model."""
prob_model.train(
###### megnet example hyper-parameters
from megnet.models import MEGNetModel
from megnet.data.graph import GaussianDistance
from megnet.data.crystal import CrystalGraph
import numpy as np
nfeat_bond = 100
nfeat_global = 2
r_cutoff = 5
gaussian_centers = np.linspace(0, r_cutoff + 1, nfeat_bond)
gaussian_width = 0.5
distance_converter = GaussianDistance(gaussian_centers, gaussian_width)
graph_converter = CrystalGraph(bond_converter=distance_converter,
cutoff=r_cutoff)
model = MEGNetModel(nfeat_bond, nfeat_global, graph_converter=graph_converter)
#########################################
def cvt_fmt_graph(rows):
structures = []
props = []
for row in rows:
structures.append(
pymatgen_io_ase.AseAtomsAdaptor.get_structure(row.toatoms()))
props.append(row.data[predict_item] / 100)
# props.append(abs(row.data[predict_item]/10))
graphs_valid = []
targets_valid = []
structures_invalid = []
if swap_E1_test:
structures['E1'], test_structures = test_structures, structures['E1']
targets['E1'], test_targets = test_targets, targets['E1']
logging.info('dataset EXP, element dict: {d}'.format(item=it, d=Counter(sp_lst)))
logging.info(str(structures.keys()) + str(targets.keys()))
for k in structures.keys():
logging.info(str(len(structures[k])) + str(len(targets[k])))
# data preprocess part
if load_old_model_enable:
import pickle
# load the past if needed
model = MEGNetModel.from_file(old_model_name)
if predict_before_dataclean:
prediction(model)
diff_lst = []
for i in range(len(s_exp)):
diff_lst.append(model.predict_structure(s_exp[i]).ravel() - t_exp[i])
logging.info('Std of the list(model output - exp data) is: {std}, \
mean is: {mean}'.format(std=np.std(diff_lst),
mean=np.mean(diff_lst)))
for it in items:
error_lst = []
prediction_lst = []
targets_lst = []
for i in range(len(structures[it])):
prdc = model.predict_structure(structures[it][i]).ravel()
import pandas as pd
import json
from tqdm import tqdm
from sklearn.metrics import mean_absolute_error
inputs = pd.read_pickle('./band_gap_data.pkl')
boundary = int(len(inputs)*0.75)
epochs = 5
batch_size=56
Xtrain = inputs.iloc[0:boundary]['structure']
ytrain = inputs.iloc[0:boundary]['band_gap']
Xtest = inputs.iloc[boundary:]['structure']
ytest = inputs.iloc[boundary:]['band_gap']
for j in range(5):
model = MEGNetModel.from_file('../entropy/0%s_model/fitted_band_gap_model.hdf5' % j)
model.load_weights('../entropy/0%s_model/model-best-new-band_gap.h5' % j)
preds = []
vals = []
for i in tqdm(range(len(Xtrain[-1000:]))):
if ytrain[i] > 0:
bg = model.predict_structure(Xtrain[i])
preds.append(bg)
vals.append(ytrain[i])
print(mean_absolute_error(preds, vals))
def setUpClass(cls):
cls.molecule = Molecule(["C", "O", "O"],
[[0, 0, 0], [-1, 0, 0], [1, 0, 0]])
cls.model = MEGNetModel.from_file(
os.path.join(
CWD, "../../../mvl_models/mp-2019.4.1/formation_energy.hdf5"))
