def add_systems(args, config_dict, schema, debug=False):
"""
Params:
config_dict: A dictionary that maps the bot name to a dictionary containing configs for the bot. The
dictionary should contain the bot type (key 'type') and. for bots that use an underlying model for generation,
the path to the directory containing the parameters, vocab, etc. for the model.
Returns:
agents: A dict mapping from the bot name to the System object for that bot.
pairing_probabilities: A dict mapping from the bot name to the probability that a user is paired with that
bot. Also includes the pairing probability for humans (backend.Partner.Human)
"""
total_probs = 0.0
# systems = {HumanSystem.name(): HumanSystem()}
### changed parts from original craigslistbargain code
# get_system: in craigslistbargain/systems/__init__.py
systems = {HumanSystem.name(): HumanSystem(), RulebasedSystem.name(): get_system("rulebased", args)}
###
pairing_probabilities = {}
timed = False if debug else True
for (sys_name, info) in config_dict.iteritems():
if "active" not in info.keys():
warnings.warn("active status not specified for bot %s - assuming that bot is inactive." % sys_name)
if info["active"]:
name = info["type"]
try:
model = get_system(name, args, schema=schema, timed=timed, model_path=info.get('checkpoint'))
except ValueError:
warnings.warn(
'Unrecognized model type in {} for configuration '
'{}. Ignoring configuration.'.format(info, sys_name))
continue
systems[sys_name] = model
if 'prob' in info.keys():
prob = float(info['prob'])
pairing_probabilities[sys_name] = prob
total_probs += prob
print '{} systems loaded'.format(len(systems))
for name in systems:
print name
# TODO: clean up pairing probabilities (obsolete)
if total_probs > 1.0:
raise ValueError("Probabilities for active bots can't exceed 1.0.")
if len(pairing_probabilities.keys()) != 0 and len(pairing_probabilities.keys()) != len(systems.keys()):
remaining_prob = (1.0-total_probs)/(len(systems.keys()) - len(pairing_probabilities.keys()))
else:
remaining_prob = 1.0 / len(systems.keys())
inactive_bots = set()
for system_name in systems.keys():
if system_name not in pairing_probabilities.keys():
if remaining_prob == 0.0:
inactive_bots.add(system_name)
else:
pairing_probabilities[system_name] = remaining_prob
for sys_name in inactive_bots:
systems.pop(sys_name, None)
return systems, pairing_probabilities
def test_create_seed_nonperiodic():
system, pars = get_system('alanine')
configuration = Configuration(system, pars)
seed_covalent = configuration.create_seed(kind='covalent')
ff = yaff_generate(seed_covalent)
energy_covalent = ff.compute()
seed_dispersion = configuration.create_seed(kind='dispersion')
ff = yaff_generate(seed_dispersion)
energy_dispersion = ff.compute()
seed_electrostatic = configuration.create_seed(kind='electrostatic')
ff = yaff_generate(seed_electrostatic)
energy_electrostatic = ff.compute()
seed_nonbonded = configuration.create_seed(kind='nonbonded')
ff = yaff_generate(seed_nonbonded)
energy_nonbonded = ff.compute()
seed_full = configuration.create_seed(kind='all')
ff = yaff_generate(seed_full)
energy_full = ff.compute()
assert abs(energy_covalent) > 0.0
assert abs(energy_dispersion) > 0.0
assert abs(energy_electrostatic) > 0.0
np.testing.assert_almost_equal(
energy_nonbonded,
energy_dispersion + energy_electrostatic,
)
np.testing.assert_almost_equal(
energy_full,
energy_covalent + energy_nonbonded,
)
def test_create_openmm_topology():
system, _ = get_system('cau13')
with pytest.raises(AssertionError):
create_openmm_topology(system)
rvecs = system.cell._get_rvecs().copy()
transform_lower_triangular(system.pos, rvecs, reorder=True)
reduce_box_vectors(rvecs)
system.cell.update_rvecs(rvecs)
topology = create_openmm_topology(system)
# verify box vectors are correct
a, b, c = topology.getPeriodicBoxVectors()
assert np.allclose(
a.value_in_unit(unit.angstrom),
rvecs[0, :] / molmod.units.angstrom,
)
assert np.allclose(
b.value_in_unit(unit.angstrom),
rvecs[1, :] / molmod.units.angstrom,
)
assert np.allclose(
c.value_in_unit(unit.angstrom),
rvecs[2, :] / molmod.units.angstrom,
)
def test_short_simulation(tmp_path):
system, pars = get_system('uio66')
configuration = Configuration(system, pars)
# conversion
conversion = ExplicitConversion()
openmm_seed = conversion.apply(configuration)
system = openmm_seed.get_system() # necessary to create Simulation object
topology, positions = configuration.create_topology()
a, b, c = topology.getPeriodicBoxVectors()
# instantiate simulation for each platform
platforms = ['Reference', 'CPU', 'CUDA', 'OpenCL']
for name in platforms:
integrator = mm.LangevinMiddleIntegrator(
300 * unit.kelvin, # temperature
0.1 * unit.picosecond, # friction coefficient
0.5 * unit.femtosecond, # step size
)
try:
platform = mm.Platform.getPlatformByName(name)
except mm.OpenMMException:
continue
simulation = mm.app.Simulation(
topology,
system,
integrator,
platform,
)
simulation.context.setPositions(positions)
#simulation.context.setPeriodicBoxVectors(box[0], box[1], box[2])
simulation.context.setPeriodicBoxVectors(a, b, c)
simulation.step(20)
def test_ff_yaff_periodic():
ff = get_system('cau13', return_forcefield=True)
wrapper = YaffForceFieldWrapper(ff)
pos = ff.system.pos.copy()
rvecs = ff.system.cell._get_rvecs().copy()
nstates = 10
pos_ = np.zeros((nstates,) + pos.shape)
rvecs_ = np.zeros((nstates,) + (3, 3))
energy_ = np.zeros(10)
gpos_ = np.zeros(pos_.shape)
for i in range(10):
pos += np.random.uniform(-1, 1, size=pos.shape) / 5
rvecs += np.random.uniform(-0.5, 0.5, size=rvecs.shape) / 5
pos_[i, :] = pos[:] / molmod.units.angstrom
rvecs_[i, :] = rvecs[:] / molmod.units.angstrom
ff.update_pos(pos)
ff.update_rvecs(rvecs)
energy_[i] = ff.compute(gpos_[i, :], None)
energy_w, force_w = wrapper.evaluate(pos_, rvecs=rvecs_, do_forces=True)
np.testing.assert_almost_equal(
energy_ / molmod.units.kjmol,
energy_w,
)
np.testing.assert_almost_equal(
- gpos_ / molmod.units.kjmol * molmod.units.angstrom,
force_w,
)
def init_trainer(self, args):
if args.gpuid:
print('Running with GPU {}.'.format(args.gpuid[0]))
cuda.set_device(args.gpuid[0])
else:
print('Running with CPU.')
if args.random_seed:
random.seed(args.random_seed + os.getpid())
np.random.seed(args.random_seed + os.getpid())
schema = Schema(args.schema_path)
scenario_db = ScenarioDB.from_dict(schema,
read_json(args.scenarios_path),
Scenario)
valid_scenario_db = ScenarioDB.from_dict(
schema, read_json(args.valid_scenarios_path), Scenario)
# if len(args.agent_checkpoints) == 0
# assert len(args.agent_checkpoints) <= len(args.agents)
if len(args.agent_checkpoints) < len(args.agents):
ckpt = [None] * 2
else:
ckpt = args.agent_checkpoints
systems = [
get_system(name, args, schema, False, ckpt[i])
for i, name in enumerate(args.agents)
]
rl_agent = 0
system = systems[rl_agent]
model = system.env.model
loss = None
# optim = build_optim(args, [model, system.env.critic], None)
optim = {
'model': build_optim(args, model, None),
'critic': build_optim(args, system.env.critic, None)
}
optim['critic']._set_rate(0.05)
scenarios = {
'train': scenario_db.scenarios_list,
'dev': valid_scenario_db.scenarios_list
}
from neural.a2c_trainer import RLTrainer as A2CTrainer
trainer = A2CTrainer(systems,
scenarios,
loss,
optim,
rl_agent,
reward_func=args.reward,
cuda=(len(args.gpuid) > 0),
args=args)
self.args = args
self.trainer = trainer
self.systems = systems
def test_update_properties(tmp_path):
system, pars = get_system('mil53')
configuration = Configuration(system, pars)
config = configuration.write()
config['yaff']['rcut'] = 15.0
config['yaff']['interaction_radius'] = 15.0
configuration.update_properties(config)
assert configuration.rcut == 15.0
def test_wrap_coordinates():
for name in ['cau13', 'uio66', 'ppycof', 'mof5', 'mil53', 'cof5']:
ff = get_system(name, return_forcefield=True)
positions = ff.system.pos.copy()
rvecs = ff.system.cell._get_rvecs().copy()
rvecs_ = ff.system.cell._get_rvecs().copy()
ff.update_pos(positions)
ff.update_rvecs(rvecs)
e = ff.compute()
# make random periodic displacements
for i in range(100):
coefficients = np.random.randint(0, high=3, size=(3, 1))
atom = np.random.randint(0, high=ff.system.natom)
positions[atom, :] += np.sum(coefficients * rvecs, axis=0)
ff.update_pos(positions)
ff.update_rvecs(rvecs)
e0 = ff.compute()
assert np.allclose(e, e0)
wrap_coordinates(positions, rvecs, rectangular=False)
frac = np.dot(positions,
np.linalg.inv(rvecs)) # fractional coordinates
assert np.all(frac >= 0)
assert np.all(frac <= 1)
assert np.allclose(rvecs, rvecs_) # rvecs should not change
ff.update_pos(positions)
ff.update_rvecs(rvecs)
e1 = ff.compute()
assert np.allclose(e0, e1)
with pytest.raises(AssertionError):
wrap_coordinates(positions, rvecs, rectangular=True)
# transform rvecs
transform_lower_triangular(positions, rvecs, reorder=False)
reduce_box_vectors(rvecs)
wrap_coordinates(positions, rvecs, rectangular=True)
for i in range(positions.shape[0]):
assert np.all(np.abs(positions[i, :]) < np.diag(rvecs))
ff.update_pos(positions)
ff.update_rvecs(rvecs)
e2 = ff.compute()
assert np.allclose(e0, e2)
# reorder rvecs
transform_lower_triangular(positions, rvecs, reorder=True)
reduce_box_vectors(rvecs)
wrap_coordinates(positions, rvecs, rectangular=True)
for i in range(positions.shape[0]):
assert np.all(np.abs(positions[i, :]) < np.diag(rvecs))
ff.update_pos(positions)
ff.update_rvecs(rvecs)
e3 = ff.compute()
assert np.allclose(e0, e3)
def test_initialize_nonperiodic(tmp_path):
system, pars = get_system('alanine')
configuration = Configuration(system, pars)
configuration.log_system()
# write defaults
path_config = tmp_path / 'config.yml'
config = configuration.write(path_config)
with open(path_config, 'r') as f:
content = f.read()
assert content == """yaff: {}\n"""
def test_save_load_pdb(tmp_path):
system, pars = get_system('mil53')
configuration = Configuration(system, pars)
# YAFF and OpenMM use a different switching function. If it is disabled,
# the results between both are identical up to 6 decimals
configuration.switch_width = 0.0 # disable switching
configuration.rcut = 10.0 # request cutoff of 10 angstorm
configuration.interaction_radius = 11.0
#configuration.update_properties(configuration.write())
conversion = ExplicitConversion(pme_error_thres=5e-4)
seed_mm = conversion.apply(configuration, seed_kind='all')
seed_yaff = configuration.create_seed(kind='all')
topology, pos = configuration.create_topology()
box = seed_yaff.system.cell._get_rvecs() / molmod.units.angstrom
wrapper_mm = OpenMMForceFieldWrapper.from_seed(seed_mm, 'Reference')
wrapper_yaff = YaffForceFieldWrapper.from_seed(seed_yaff)
assert wrapper_yaff.periodic # system should not be considered periodic
assert wrapper_mm.periodic # system should not be considered periodic
#positions = seed_yaff.system.pos.copy() / molmod.units.angstrom
#rvecs = seed_yaff.system.cell._get_rvecs().copy() / molmod.units.angstrom
e0, f0 = wrapper_mm.evaluate(pos, box, do_forces=True)
e1, f1 = wrapper_yaff.evaluate(pos, box, do_forces=True)
assert np.allclose(e0, e1, rtol=1e-3)
path_pdb = tmp_path / 'top.pdb'
mm.app.PDBFile.writeFile(
topology,
pos * unit.angstrom,
open(path_pdb, 'w+'),
keepIds=True,
)
pdb = mm.app.PDBFile(str(path_pdb))
positions = pdb.getPositions(asNumpy=True).value_in_unit(unit.angstrom)
a, b, c = pdb.getTopology().getPeriodicBoxVectors()
rvecs = np.array([
a.value_in_unit(unit.angstrom),
b.value_in_unit(unit.angstrom),
c.value_in_unit(unit.angstrom)
])
e2, f2 = wrapper_mm.evaluate(positions, rvecs, do_forces=True)
e3, f3 = wrapper_yaff.evaluate(positions, rvecs, do_forces=True)
assert np.allclose(e2, e3, rtol=1e-3)
assert np.allclose(e1, e3, rtol=1e-4) # rounding errors during saving pdb
assert np.allclose(e0, e2, rtol=1e-4)
def test_get_prefixes():
system, pars = get_system('cau13')
configuration = Configuration(system, pars)
prefixes = configuration.get_prefixes('all')
covalent_prefixes = configuration.get_prefixes('covalent')
dispersion_prefixes = configuration.get_prefixes('dispersion')
electrostatic_prefixes = configuration.get_prefixes('electrostatic')
nonbonded_prefixes = configuration.get_prefixes('nonbonded')
_ = dispersion_prefixes + electrostatic_prefixes
assert tuple(sorted(_)) == tuple(sorted(nonbonded_prefixes))
__ = covalent_prefixes + nonbonded_prefixes
assert tuple(sorted(__)) == tuple(sorted(prefixes))
def test_lattice_reduction():
system, pars = get_system('cau13')
pos = system.pos.copy()
rvecs = system.cell._get_rvecs().copy()
# use reduction algorithm from Bekker, and transform to diagonal
reduced = do_gram_schmidt_reduction(rvecs)
reduced_LT = np.linalg.cholesky(reduced @ reduced.T)
assert np.allclose(reduced_LT, np.diag(np.diag(reduced_LT))) # diagonal
# transform to lower triangular
transform_lower_triangular(pos, rvecs, reorder=True)
reduce_box_vectors(rvecs)
# assert equality of diagonal elements from both methods
np.testing.assert_almost_equal(np.diag(rvecs), np.diag(reduced_LT))
def test_from_files(tmp_path):
system, pars = get_system('mil53')
configuration = Configuration(system, pars)
configuration.write(tmp_path / 'config.yml')
system.to_file(str(tmp_path / 'system.chk'))
with open(tmp_path / 'pars.txt', 'w+') as f:
f.write(pars)
path_system = tmp_path / 'system.chk'
path_pars = tmp_path / 'pars.txt'
path_config = tmp_path / 'config.yml'
configuration = Configuration.from_files(
chk=path_system,
txt=path_pars,
yml=path_config,
)
def __init__(self, options, models=None):
super(RuleBasedAgent, self).__init__(options, models=models)
args = argparse.Namespace(
random_seed=hash(self.options.random_seed),
schema_path='cocoa-negotiation/fb-negotiation/data/bookhatball-schema.json',
scenarios_path='cocoa-negotiation/fb-negotiation/data/toy-scenarios.json',
train_examples_paths='cocoa-negotiation/fb-negotiation/data/rulebased-transcripts.json',
train_max_examples=1,
test_max_examples=0,
max_turns=self.options.max_dialogue_len,
agents=['rulebased', 'rulebased'],
templates='cocoa-negotiation/fb-negotiation/templates.pkl',
policy='cocoa-negotiation/fb-negotiation/model.pkl',
)
self.schema = Schema(args.schema_path)
self.agent = get_system('rulebased', args, self.schema,
model_path='cocoa-negotiation/model.pkl')
def test_nonperiodic():
systems = ['alanine']
platforms = ['Reference']
seed_kinds = ['covalent', 'dispersion', 'electrostatic']
tolerance = {
('Reference', 'covalent'): 1e-6,
('Reference', 'dispersion'): 1e-6,
('Reference', 'electrostatic'): 1e-6,
#('Cuda', 'covalent'): 1e-5,
#('Cuda', 'dispersion'): 1e-5,
#('Cuda', 'electrostatic'): 1e-5,
}
nstates = 10
disp_ampl = 1.0
box_ampl = 1.0
for name in systems:
for platform in platforms:
for kind in seed_kinds:
system, pars = get_system(name)
configuration = Configuration(system, pars)
tol = tolerance[(platform, kind)]
conversion = ExplicitConversion()
seed_mm = conversion.apply(configuration, seed_kind=kind)
seed_yaff = configuration.create_seed(kind=kind)
wrapper_mm = OpenMMForceFieldWrapper.from_seed(
seed_mm, platform)
wrapper_yaff = YaffForceFieldWrapper.from_seed(seed_yaff)
assert not wrapper_yaff.periodic # system should not be considered periodic
assert not wrapper_mm.periodic # system should not be considered periodic
pos = seed_yaff.system.pos.copy()
for i in range(nstates):
dpos = np.random.uniform(-disp_ampl,
disp_ampl,
size=pos.shape)
energy_mm, forces_mm = wrapper_mm.evaluate(
(pos + dpos) / molmod.units.angstrom, )
energy, forces = wrapper_yaff.evaluate(
(pos + dpos) / molmod.units.angstrom, )
assert_tol(energy, energy_mm, tol)
assert_tol(forces, forces_mm, 10 * tol)
def test_ff_yaff_stress():
def energy_func(positions, rvecs):
ff.update_pos(positions)
ff.update_rvecs(rvecs)
return ff.compute()
ff = get_system('cau13', return_forcefield=True)
positions = ff.system.pos.copy()
rvecs = ff.system.cell._get_rvecs().copy()
vtens = np.zeros((3, 3))
ff.compute(None, vtens)
unit = molmod.units.pascal * 1e6
pressure = np.trace(vtens) / np.linalg.det(rvecs) / unit
dUdh = estimate_cell_derivative(positions, rvecs, energy_func, dh=1e-5)
vtens_numerical = rvecs.T @ dUdh
pressure_ = np.trace(vtens_numerical) / np.linalg.det(rvecs) / unit
assert abs(pressure - pressure_) < 1e-3 # require at least kPa accuracy
stress_ = vtens_numerical / np.linalg.det(rvecs)
stress_ /= (molmod.units.kjmol / molmod.units.angstrom ** 3)
wrapper = YaffForceFieldWrapper(ff)
stress_w = wrapper.compute_stress(
positions / molmod.units.angstrom,
rvecs / molmod.units.angstrom,
use_symmetric=False,
)
assert np.allclose(stress_w, stress_, atol=1e-5)
# compute vtens using symmetric box, and verify compute_stress symmetric
pos_tmp = positions.copy()
rvecs_tmp = rvecs.copy()
transform_symmetric(pos_tmp, rvecs_tmp)
ff.update_pos(pos_tmp)
ff.update_rvecs(rvecs_tmp)
vtens = np.zeros((3, 3))
ff.compute(None, vtens)
stress_vtens = vtens / np.linalg.det(rvecs)
stress_vtens /= (molmod.units.kjmol / molmod.units.angstrom ** 3)
stress_wrapper = wrapper.compute_stress(
positions / molmod.units.angstrom,
rvecs / molmod.units.angstrom,
use_symmetric=True,
)
assert np.allclose(stress_wrapper, stress_vtens, atol=1e-5)
def test_transform_symmetric():
system, pars = get_system('mil53')
pos = system.pos.copy()
rvecs = system.cell._get_rvecs().copy()
# transform to symmetric form
transform_symmetric(pos, rvecs)
assert np.allclose(rvecs, rvecs.T)
# transform to triangular, and back to symmetric
rvecs_ = rvecs.copy()
pos_ = pos.copy()
transform_lower_triangular(pos_, rvecs_, reorder=False)
transform_symmetric(pos_, rvecs_)
# assert equality
np.testing.assert_almost_equal(rvecs_, rvecs)
np.testing.assert_almost_equal(pos_, pos)
def test_create_seed_periodic():
system, pars = get_system('cau13')
configuration = Configuration(system, pars)
# change parameters randomly
with pytest.raises(ValueError): # cell is too small
configuration.supercell = [3, 1, 1]
configuration.rcut = 12.0
assert configuration.interaction_radius == 12.0 # should change too
configuration.switch_width = 5.0
configuration.tailcorrections = False
seed_covalent = configuration.create_seed(kind='covalent')
ff = yaff_generate(seed_covalent)
energy_covalent = ff.compute()
seed_dispersion = configuration.create_seed(kind='dispersion')
ff = yaff_generate(seed_dispersion)
energy_dispersion = ff.compute()
seed_electrostatic = configuration.create_seed(kind='electrostatic')
ff = yaff_generate(seed_electrostatic)
energy_electrostatic = ff.compute()
seed_nonbonded = configuration.create_seed(kind='nonbonded')
ff = yaff_generate(seed_nonbonded)
energy_nonbonded = ff.compute()
seed_full = configuration.create_seed(kind='all')
ff = yaff_generate(seed_full)
energy_full = ff.compute()
assert abs(energy_covalent) > 0.0
assert abs(energy_dispersion) > 0.0
assert abs(energy_electrostatic) > 0.0
np.testing.assert_almost_equal(
energy_nonbonded,
energy_dispersion + energy_electrostatic,
)
np.testing.assert_almost_equal(
energy_full,
energy_covalent + energy_nonbonded,
)
def test_wrapper_openmm_mic():
system, pars = get_system('mil53')
configuration = Configuration(system, pars)
kind = 'all'
# YAFF and OpenMM use a different switching function. If it is disabled,
# the results between both are identical up to 6 decimals
configuration.switch_width = 0.0 # disable switching
configuration.rcut = 10.0 # request cutoff of 10 angstorm
configuration.cell_interaction_radius = 10.0
configuration.supercell = [2, 3, 5]
configuration.update_properties(configuration.write())
conversion = ExplicitConversion(pme_error_thres=1e-5)
seed_mm = conversion.apply(configuration, seed_kind=kind)
wrapper = OpenMMForceFieldWrapper.from_seed(seed_mm, 'Reference')
u = molmod.units.angstrom
seed_yaff = configuration.create_seed(kind=kind)
positions = seed_yaff.system.pos.copy() / u
rvecs = seed_yaff.system.cell._get_rvecs().copy() / u
e, _ = wrapper.evaluate(positions, rvecs, do_forces=True)
# make random periodic displacements
for i in range(5):
coefficients = np.random.randint(-3, high=3, size=(3, 1))
atom = np.random.randint(0, high=seed_yaff.system.natom, size=(10,))
positions[atom, :] += np.sum(coefficients * rvecs, axis=0)
e_ = wrapper.evaluate(positions, rvecs, do_forces=False)
assert np.allclose(e, e_)
# make random periodic displacements and rewrap coordinates
for i in range(5):
coefficients = np.random.randint(-3, high=3, size=(3, 1))
atom = np.random.randint(0, high=seed_yaff.system.natom, size=(10,))
positions[atom, :] += np.sum(coefficients * rvecs, axis=0)
wrap_coordinates(positions, rvecs, rectangular=True)
e_ = wrapper.evaluate(positions, rvecs, do_forces=False)
assert np.allclose(e, e_)
def test_check_compatibility():
system, _ = get_system('lennardjones')
conversion = ExplicitConversion()
seed_kind = 'dispersion'
# generate pars with unsupported prefix
pars_unsupported = """
BLAAA:UNIT SIGMA angstrom
BLAAA:UNIT EPSILON kcalmol
BLAAA:SCALE 1 1.0
BLAAA:SCALE 2 1.0
BLAAA:SCALE 3 1.0
# ---------------------------------------------
# KEY ffatype SIGMA EPSILON ONLYPAULI
# ---------------------------------------------
BLAAA:PARS C 2.360 0.116 0"""
with pytest.raises(AssertionError):
configuration = Configuration(system, pars_unsupported)
# generate pars with unsupported scaling
pars_unsupported = """
LJ:UNIT SIGMA angstrom
LJ:UNIT EPSILON kcalmol
LJ:SCALE 1 0.5
LJ:SCALE 2 1.0
LJ:SCALE 3 1.0
# ---------------------------------------------
# KEY ffatype SIGMA EPSILON ONLYPAULI
# ---------------------------------------------
LJ:PARS C 2.360 0.116 0"""
configuration = Configuration(system, pars_unsupported)
with pytest.raises(AssertionError):
seed_mm = conversion.apply(configuration, seed_kind=seed_kind)
def test_transform_lower_triangular():
for i in range(100):
trial = np.random.uniform(-20, 20, size=(3, 3))
trial *= np.sign(np.linalg.det(trial))
assert np.linalg.det(trial) > 0
pos = np.random.uniform(-100, 100, size=(10, 3))
transform_lower_triangular(pos, trial) # in-place
# comparison with cholesky made inside transform_lower_triangular
for name in ['cau13', 'uio66']: # FAILS ON COBDP; ewald_reci changes
ff = get_system(name, return_forcefield=True) # nonrectangular system
gpos0 = np.zeros((ff.system.natom, 3))
energy0 = ff.compute(gpos0, None)
rvecs = ff.system.cell._get_rvecs().copy()
transform_lower_triangular(ff.system.pos, rvecs, reorder=True)
assert is_lower_triangular(rvecs)
ff.update_pos(ff.system.pos)
ff.update_rvecs(rvecs)
gpos1 = np.zeros((ff.system.natom, 3))
energy1 = ff.compute(gpos1, None)
np.testing.assert_almost_equal( # energy should remain the same
energy0,
energy1,
)
def add_systems(args, config_dict, schema):
"""
Args:
config_dict: A dictionary that maps the bot name to a dictionary containing configs for the bot. The
dictionary should contain the bot type (key 'type') and. for bots that use an underlying model for generation,
the path to the directory containing the parameters, vocab, etc. for the model.
Returns:
systems: A dict mapping from the bot name to the System object for that bot.
"""
total_probs = 0.0
systems = {HumanSystem.name(): HumanSystem()}
timed = False if params['debug'] else True
for (sys_name, info) in config_dict.iteritems():
if "active" not in info.keys():
warnings.warn(
"active status not specified for bot %s - assuming that bot is inactive."
% sys_name)
if info["active"]:
name = info["type"]
try:
model = get_system(name,
args,
schema=schema,
timed=timed,
model_path=args.checkpoint)
except ValueError:
warnings.warn(
'Unrecognized model type in {} for configuration '
'{}. Ignoring configuration.'.format(info, sys_name))
continue
systems[sys_name] = model
return systems
parser.add_argument('--agent-id',
default=0,
type=int,
help='Which agent to try')
add_scenario_arguments(parser)
add_system_arguments(parser)
args = parser.parse_args()
if args.random_seed:
random.seed(args.random_seed)
np.random.seed(args.random_seed)
schema = Schema(args.schema_path)
scenario_db = ScenarioDB.from_dict(schema, read_json(args.scenarios_path),
Scenario)
agents = [get_system('rulebased', args, schema) for _ in (0, 1)]
configs = random_configs(10)
scenarios = scenario_db.scenarios_list[:20]
#scenarios = [scenarios[0] for _ in xrange(10)]
max_turns = args.max_turns
success_rates = []
mean_margins = []
margin_stes = []
def eval_bot(params):
success = []
margins = []
agent_id = args.agent_id
baseline_agent_id = 1 - agent_id
config = Config(**params)
options.add_model_arguments(parser)
args = parser.parse_args()
if args.random_seed:
random.seed(args.random_seed)
np.random.seed(args.random_seed)
schema = Schema(args.schema_path)
scenario_db = ScenarioDB.from_dict(schema, read_json(args.scenarios_path),
Scenario)
valid_scenario_db = ScenarioDB.from_dict(
schema, read_json(args.valid_scenarios_path), Scenario)
assert len(args.agent_checkpoints) <= len(args.agents)
systems = [
get_system(name, args, schema, False, args.agent_checkpoints[i])
for i, name in enumerate(args.agents)
]
rl_agent = 0
system = systems[rl_agent]
model = system.env.model
loss = make_loss(args, model, system.mappings['tgt_vocab'])
optim = build_optim(args, model, None)
scenarios = {
'train': scenario_db.scenarios_list,
'dev': valid_scenario_db.scenarios_list
}
trainer = RLTrainer(systems,
scenarios,
register_failure_args(parser)
parser.add_argument(
"--benchmark_config",
default="",
help=
"A comma separated list of benchmark parameters, eg. rate=500,duration=10.",
)
parser.add_argument(
"-d",
action="store_true",
help="Debug mode, sets up mininet, then waits in Mininet.CLI",
)
args = parser.parse_args()
system = get_system(args)
topo = args.topology
topo_kwargs = (dict([arg.split("=") for arg in args.topo_args.split(",")])
if args.topo_args != "" else {})
print(topo, topo_kwargs)
topo_module = importlib.import_module("src.topologies." + topo)
failure_provider = get_failure_provider(args)
## A list of benchmark configs with defaults. Change values as appropriate when we have an
## idea of what values *are* appropriate.
bench_defs = {
"rate": 1, # upper bound on reqs/sec
"duration": 160, # duration of operation sending in seconds
"test_results_location": "test.res",
def test_periodic():
systems = ['uio66', 'cau13', 'mil53', 'ppycof', 'cof5', 'mof5']
platforms = ['Reference']
seed_kinds = ['covalent', 'dispersion', 'electrostatic']
# systematic constant offset in dispersion energy for COFs, unclear why
tolerance = {
('Reference', 'covalent'): 1e-6, # some MM3 terms have error 1e-7
('Reference', 'dispersion'): 1e-2, # some MM3 terms have error 1e-3
('Reference', 'electrostatic'): 1e-3,
#('CUDA', 'covalent'): 1e-3,
#('CUDA', 'dispersion'): 1e-3,
#('CUDA', 'electrostatic'): 1e-3,
}
nstates = 5
disp_ampl = 0.3
box_ampl = 0.3
for name in systems:
for platform in platforms:
for kind in seed_kinds:
system, pars = get_system(name)
configuration = Configuration(system, pars)
tol = tolerance[(platform, kind)]
# YAFF and OpenMM use a different switching function. If it is disabled,
# the results between both are identical up to 6 decimals
configuration.switch_width = 0.0 # disable switching
configuration.rcut = 13.0 # request cutoff of 13 angstorm
configuration.interaction_radius = 15.0
configuration.update_properties(configuration.write())
conversion = ExplicitConversion(pme_error_thres=5e-4)
seed_mm = conversion.apply(configuration, seed_kind=kind)
seed_yaff = configuration.create_seed(kind=kind)
wrapper_mm = OpenMMForceFieldWrapper.from_seed(
seed_mm, platform)
wrapper_yaff = YaffForceFieldWrapper.from_seed(seed_yaff)
assert wrapper_yaff.periodic # system should not be considered periodic
assert wrapper_mm.periodic # system should not be considered periodic
pos = seed_yaff.system.pos.copy()
rvecs = seed_yaff.system.cell._get_rvecs().copy()
for i in range(nstates):
dpos = np.random.uniform(-disp_ampl,
disp_ampl,
size=pos.shape)
drvecs = np.random.uniform(-box_ampl,
box_ampl,
size=rvecs.shape)
drvecs[0, 1] = 0
drvecs[0, 2] = 0
drvecs[1, 2] = 0
tmp = rvecs + drvecs
reduce_box_vectors(tmp)
energy_mm, forces_mm = wrapper_mm.evaluate(
(pos + dpos) / molmod.units.angstrom,
rvecs=tmp / molmod.units.angstrom,
)
energy, forces = wrapper_yaff.evaluate(
(pos + dpos) / molmod.units.angstrom,
rvecs=tmp / molmod.units.angstrom,
)
assert_tol(energy, energy_mm, tol)
assert_tol(forces, forces_mm, 10 * tol)
def test_implicit_nonperiodic():
system, pars = get_system('alanine')
configuration = Configuration(system, pars)
conversion = ImplicitConversion()
seed_mm = conversion.apply(configuration, seed_kind='all')
parser.add_argument('--agent-checkpoints', nargs='+', help='Directory to learned models')
parser.add_argument('--random-seed', help='Random seed', type=int, default=1)
parser.add_argument('--verbose', default=False, action='store_true', help='Whether or not to have verbose prints')
parser.add_argument('--valid-scenarios-path', help='Output path for the validation scenarios')
cocoa.options.add_scenario_arguments(parser)
options.add_system_arguments(parser)
options.add_rl_arguments(parser)
options.add_model_arguments(parser)
args = parser.parse_args()
if args.random_seed:
random.seed(args.random_seed)
np.random.seed(args.random_seed)
schema = Schema(args.schema_path)
scenario_db = ScenarioDB.from_dict(schema, read_json(args.scenarios_path), Scenario)
valid_scenario_db = ScenarioDB.from_dict(schema, read_json(args.valid_scenarios_path), Scenario)
assert len(args.agent_checkpoints) <= len(args.agents)
systems = [get_system(name, args, schema, False, args.agent_checkpoints[i]) for i, name in enumerate(args.agents)]
rl_agent = 0
system = systems[rl_agent]
model = system.env.model
loss = make_loss(args, model, system.mappings['tgt_vocab'])
optim = build_optim(args, model, None)
scenarios = {'train': scenario_db.scenarios_list, 'dev': valid_scenario_db.scenarios_list}
trainer = RLTrainer(systems, scenarios, loss, optim, rl_agent, reward_func=args.reward)
trainer.learn(args)
def add_systems(args, config_dict, schema, debug=False):
"""
Params:
config_dict: A dictionary that maps the bot name to a dictionary containing configs for the bot. The
dictionary should contain the bot type (key 'type') and. for bots that use an underlying model for generation,
the path to the directory containing the parameters, vocab, etc. for the model.
Returns:
agents: A dict mapping from the bot name to the System object for that bot.
pairing_probabilities: A dict mapping from the bot name to the probability that a user is paired with that
bot. Also includes the pairing probability for humans (backend.Partner.Human)
"""
total_probs = 0.0
systems = {HumanSystem.name(): HumanSystem()}
pairing_probabilities = {}
timed = False if debug else True
print 'timed:', timed
for (sys_name, info) in config_dict.iteritems():
if "active" not in info.keys():
warnings.warn(
"active status not specified for bot %s - assuming that bot is inactive."
% sys_name)
if info["active"]:
name = info["type"]
try:
# TODO: model related arguments should be in config_dict (read from params.json), instead of in command line args, currently we are assuming there is only one model that needs `checkpoint`
model = get_system(name,
args,
schema=schema,
timed=timed,
model_path=args.checkpoint)
except ValueError:
warnings.warn(
'Unrecognized model type in {} for configuration '
'{}. Ignoring configuration.'.format(info, sys_name))
continue
systems[sys_name] = model
if 'prob' in info.keys():
prob = float(info['prob'])
pairing_probabilities[sys_name] = prob
total_probs += prob
# TODO: clean up pairing probabilities (obsolete)
if total_probs > 1.0:
raise ValueError("Probabilities for active bots can't exceed 1.0.")
if len(pairing_probabilities.keys()) != 0 and len(
pairing_probabilities.keys()) != len(systems.keys()):
remaining_prob = (1.0 - total_probs) / (
len(systems.keys()) - len(pairing_probabilities.keys()))
else:
remaining_prob = 1.0 / len(systems.keys())
inactive_bots = set()
for system_name in systems.keys():
if system_name not in pairing_probabilities.keys():
if remaining_prob == 0.0:
inactive_bots.add(system_name)
else:
pairing_probabilities[system_name] = remaining_prob
for sys_name in inactive_bots:
systems.pop(sys_name, None)
return systems, pairing_probabilities
parser.add_argument('--max-examples',
default=20,
type=int,
help='Number of test examples to predict')
parser.add_argument('-v',
'--verbose',
default=False,
action='store_true',
help='whether or not to have verbose prints')
cocoa.options.add_scenario_arguments(parser)
cocoa.options.add_dataset_arguments(parser)
options.add_system_arguments(parser)
args = parser.parse_args()
if args.random_seed:
random.seed(args.random_seed)
np.random.seed(args.random_seed)
schema = Schema(args.schema_path)
scenario_db = ScenarioDB.from_dict(schema, read_json(args.scenarios_path),
Scenario)
assert len(args.agent_checkpoints) == len(args.agents)
agents = [
get_system(name, args, schema, model_path=model_path)
for name, model_path in zip(args.agents, args.agent_checkpoints)
]
num_examples = args.scenario_offset
generate_examples(num_examples, scenario_db, args.results_path,
args.max_examples, args.remove_fail, args.max_turns)
