def LUTE_train(confEcalc,
emat,
pmat,
maxRMSE=0.1,
maxOverfittingScore=1.5,
randomSeed=12345,
confDBPath=None):
'''
Trains a LUTE model
For examples using LUTE, see examples/python.GMEC/LUTE.*.py and examples/python.KStar/LUTE.*.py in your Osprey distribution.
:param confEcalc: The conformation energy calculator
:type confEcalc: :java:ref:`.energy.ConfEnergyCalculator`
:param emat: An energy matrix
:type emat: :java:ref:`.ematrix.EnergyMatrix`
:param pmat: A pruning matrix, resulting from DEE
:type pmat: :java:ref:`.pruning.PruningMatrix`
:param float maxRMSE: The maximum tolerable fit RMS error
:param float maxOverfittingScore: The maximum tolerable amount of overfitting (score = training set RMSE / test set RMSE)
:param int randomSeed: Random seed to use for conformation sampling
:param str confDBPath: Path to write/read confDB file, or None to omit saving the confDB to disk
:returns: The LUTE model
:rtype: :java:ref:`.lute.LUTEState`
'''
confSpace = confEcalc.confSpace
# make a conf DB, saved to a file if needed
if confDBPath is None:
confDB = c.confspace.ConfDB(confSpace)
else:
confDB = c.confspace.ConfDB(confSpace, jvm.toFile(confDBPath))
try:
# make a conf table for LUTE
confTable = jvm.getInnerClass(c.confspace.ConfDB, 'ConfTable')(confDB,
'LUTE')
# use the OLSCG fitter for LUTE (it's a little faster than LASSO in practice)
fitter = jvm.getInnerClass(c.lute.LUTE, 'Fitter').OLSCG
# train LUTE
lute = c.lute.LUTE(confSpace)
sampler = c.lute.UniformConfSampler(confSpace, pmat, randomSeed)
lute.sampleTuplesAndFit(confEcalc, emat, pmat, confTable, sampler,
fitter, maxOverfittingScore, maxRMSE)
lute.reportConfSpaceSize(pmat)
# return the LUTE fit
return c.lute.LUTEState(lute.getTrainingSystem())
finally:
confDB.close()
def MSKStar_LMFE(weightsByState,
offset=useJavaDefault,
constrainLessThan=None):
'''
:java:classdoc:`.kstar.MSKStar$LMFE`
:param weightsByState: map from states to weights
:type weightsByState: map from :java:ref:`.kstar.MSKStar$State` to float
:builder_option offset .kstar.MSKStar$LMFE$Builder#offset:
:param float constrainLessThan: :java:methoddoc:`.kstar.MSKStar$LMFE$Builder#constrainLessThan`
:builder_return .kstar.MSKStar$LMFE$Builder:
'''
builder = _get_builder(jvm.getInnerClass(c.kstar.MSKStar, 'LMFE'))()
if offset is not useJavaDefault:
builder.setOffset(offset)
for (state, weight) in weightsByState.items():
builder.addState(state, weight)
if constrainLessThan is not None:
builder.constrainLessThan(constrainLessThan)
return builder.build()
def wrapStrandBuilder(c):
jtype = jvm.getInnerClass(c.confspace.Strand, 'Builder')
# public Builder setResidues(int firstResNum, int lastResNum) {
def newSetResidues(old, self, start, stop):
# TEMP: check for integer-valued residue numbers, which are now deprecated
checkDeprecatedResNumbers([start, stop], ['checkDeprecatedResNumbers', 'newSetResidues', 'curried', 'Strand'])
old(self, start, stop)
wrapMethod(jtype, 'setResidues', newSetResidues)
def KStar(proteinConfSpace,
ligandConfSpace,
complexConfSpace,
epsilon=useJavaDefault,
stabilityThreshold=useJavaDefault,
maxSimultaneousMutations=useJavaDefault,
writeSequencesToConsole=False,
writeSequencesToFile=None,
useExternalMemory=useJavaDefault,
showPfuncProgress=useJavaDefault):
'''
:java:classdoc:`.kstar.KStar`
For examples using K*, see the examples/python.KStar directory in your Osprey distribution.
:param proteinConfSpace: :java:fielddoc:`.kstar.KStar#protein`
:type proteinConfSpace: :java:ref:`.confspace.SimpleConfSpace`
:param ligandConfSpace: :java:fielddoc:`.kstar.KStar#ligand`
:type ligandConfSpace: :java:ref:`.confspace.SimpleConfSpace`
:param complexConfSpace: :java:fielddoc:`.kstar.KStar#complex`
:type complexConfSpace: :java:ref:`.confspace.SimpleConfSpace`
:builder_option epsilon .kstar.KStar$Settings$Builder#epsilon:
:builder_option stabilityThreshold .kstar.KStar$Settings$Builder#stabilityThreshold:
:builder_option maxSimultaneousMutations .kstar.KStar$Settings$Builder#maxSimultaneousMutations:
:builder_option useExternalMemory .kstar.KStar$Settings$Builder#useExternalMemory:
:builder_option showPfuncProgress .kstar.KStar$Settings$Builder#showPfuncProgress:
:param bool writeSequencesToConsole: True to write sequences and scores to the console
:param str writeSequencesToFile: Path to the log file to write sequences scores (in TSV format), or None to skip logging
:rtype: :java:ref:`.kstar.KStar`
'''
# build settings
settingsBuilder = _get_builder(jvm.getInnerClass(c.kstar.KStar,
'Settings'))()
if epsilon is not useJavaDefault:
settingsBuilder.setEpsilon(epsilon)
if stabilityThreshold is not useJavaDefault:
settingsBuilder.setStabilityThreshold(
jvm.boxDouble(stabilityThreshold))
if maxSimultaneousMutations is not useJavaDefault:
settingsBuilder.setMaxSimultaneousMutations(maxSimultaneousMutations)
if writeSequencesToConsole:
settingsBuilder.addScoreConsoleWriter()
if writeSequencesToFile is not None:
settingsBuilder.addScoreFileWriter(jvm.toFile(writeSequencesToFile))
if useExternalMemory is not useJavaDefault:
settingsBuilder.setExternalMemory(useExternalMemory)
if showPfuncProgress is not useJavaDefault:
settingsBuilder.setShowPfuncProgress(showPfuncProgress)
settings = settingsBuilder.build()
return c.kstar.KStar(proteinConfSpace, ligandConfSpace, complexConfSpace,
settings)
def wrapStrandFlex(c): jtype = jvm.getInnerClass(c.confspace.Strand, 'Flexibility') # use array access to call get() def getItem(self, key): # TEMP: check for integer-valued residue numbers, which are now deprecated checkDeprecatedResNumbers([key], ['checkDeprecatedResNumbers', 'getItem']) return self.get(key) jtype.__getitem__ = getItem
def COMETS_State(name, confSpace):
'''
:java:classdoc:`.gmec.Comets$State`
:param str name: :java:fielddoc:`.gmec.Comets$State#name`
:param confSpace: :java:fielddoc:`.gmec.Comets$State#confSpace`
:type confSpace: :java:ref:`.confspace.SimpleConfSpace`
:rtype: :java:ref:`.gmec.Comets$State`
'''
return jvm.getInnerClass(c.gmec.Comets, 'State')(name, confSpace)
def MSKStar_State(name, confSpace):
'''
:java:classdoc:`.kstar.MSKStar$State`
:param str name: :java:fielddoc:`.kstar.MSKStar$State#name`
:param confSpace: :java:fielddoc:`.kstar.MSKStar$State#confSpace`
:type confSpace: :java:ref:`.confspace.SimpleConfSpace`
:rtype: :java:ref:`.kstar.MSKStar$State`
'''
return jvm.getInnerClass(c.kstar.MSKStar, 'State')(name, confSpace)
def wrapStrandFlex(c):
jtype = jvm.getInnerClass(c.confspace.Strand, 'Flexibility')
# use array access to call get()
def getItem(self, key):
# TEMP: check for integer-valued residue numbers, which are now deprecated
checkDeprecatedResNumbers([key],
['checkDeprecatedResNumbers', 'getItem'])
return self.get(key)
jtype.__getitem__ = getItem
def wrapStrandBuilder(c):
jtype = jvm.getInnerClass(c.confspace.Strand, 'Builder')
# public Builder setResidues(int firstResNum, int lastResNum) {
def newSetResidues(old, self, start, stop):
# TEMP: check for integer-valued residue numbers, which are now deprecated
checkDeprecatedResNumbers([start, stop], [
'checkDeprecatedResNumbers', 'newSetResidues', 'curried', 'Strand'
])
old(self, start, stop)
wrapMethod(jtype, 'setResidues', newSetResidues)
def wrapResidueFlex(c): jtype = jvm.getInnerClass(c.confspace.Strand, 'ResidueFlex') # wrap setLibraryRotamers() to accept varargs def newSetLibraryRotamers(old, self, *mutations): return old(self, mutations) wrapMethod(jtype, 'setLibraryRotamers', newSetLibraryRotamers) # autocast setContinuous() to float def newSetContinuous(old, self, angle=None): if angle is None: return old(self) else: return old(self, float(angle)) wrapMethod(jtype, 'setContinuous', newSetContinuous)
def SharedEnergyCalculator(ecalc, isMinimizing=None):
'''
:java:classdoc:`.energy.EnergyCalculator$SharedBuilder`
:param ecalc: The existing energy calculator with which to share resources
:type ecalc: :java:ref:`.energy.EnergyCalculator`
:builder_option isMinimizing .energy.EnergyCalculator$Builder#isMinimizing:
:builder_return .energy.EnergyCalculator$SharedBuilder:
'''
builder = jvm.getInnerClass(c.energy.EnergyCalculator,
'SharedBuilder')(ecalc)
if isMinimizing is not None:
builder.setIsMinimizing(isMinimizing)
return builder.build()
def wrapResidueFlex(c):
jtype = jvm.getInnerClass(c.confspace.Strand, 'ResidueFlex')
# wrap setLibraryRotamers() to accept varargs
def newSetLibraryRotamers(old, self, *mutations):
return old(self, mutations)
wrapMethod(jtype, 'setLibraryRotamers', newSetLibraryRotamers)
# autocast setContinuous() to float
def newSetContinuous(old, self, angle=None):
if angle is None:
return old(self)
else:
return old(self, float(angle))
wrapMethod(jtype, 'setContinuous', newSetContinuous)
def writePdb(mol, path, comment=None):
'''
save a molecule to a PDB file
:param mol: the molecule to save
:type mol: :java:ref:`.structure.Molecule`
:param str path: path of the PDB file
:param str comment: Optional comment to add to the PDB file headers
'''
# deal with different molecule types
if isinstance(
mol,
jvm.getInnerClass(c.energy.EnergyCalculator,
'EnergiedParametricMolecule')):
c.structure.PDBIO.writeFile(mol, comment, path)
elif isinstance(mol, c.confspace.ParametricMolecule):
c.structure.PDBIO.writeFile(mol.mol, comment, None, path)
else:
c.structure.PDBIO.writeFile(mol, path)
print('write PDB file to file: %s' % path)
def _KStarConfSearchFactory(func):
# convert the python lambda to a JVM interface implementation
return jpype.JProxy(jvm.getInnerClass(c.kstar.KStar, 'ConfSearchFactory'),
dict={'make': func})
def start(heapSizeMiB=1024,
enableAssertions=False,
stackSizeMiB=16,
garbageSizeMiB=128):
'''
Starts the Java Virtual Machine (JVM) that runs Osprey's computation libraries.
Call :meth:`start` before using any of Osprey's other functions.
:param int heapSizeMiB: Size of the JVM heap in megabytes. This is essentially the amount of memory
Osprey will have to do computations. 1024 MiB is 1 GiB, but for larger designs,
you may want to use 2048 MiB (2 GiB), 4096 MiB (4 GiB), or even more memory.
:param bool enableAssertions: pass ``True`` to enable JVM assertions. Only useful for debugging.
:param int stackSizeMiB: Size of the JVM stack portion of the heap in megabytes.
Generally leave this at the default value, unless Osprey crashes because it's too small. Then try increasing it.
:param int garbageSizeMiB: Size of the garbage portion of the JVM heap that is reserved for temporary objects.
This default value is appropriate for the default heap size, but if using larger heap sizes, then increasing
the garbage size to 256, 512, or even 1024 MiB can give a modest improvement in performance.
'''
# disable buffered output on stdout, so python log messages line up with java log messages
sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
# setup a global exception handler to show java exception info
sys.excepthook = _java_aware_excepthook
# is this the real life, or is this just fantasy?
lib_dir = os.path.join(os.path.dirname(__file__), 'lib')
no_escape_from_reality = os.path.exists(lib_dir)
# build jvm classpath
if no_escape_from_reality:
# release environment: use jars in lib folder
for file in os.listdir(lib_dir):
jvm.addClasspath(os.path.join(lib_dir, file))
else:
# development environment: use the gradle-defined classpath
osprey_dir = os.path.join(os.path.dirname(__file__), '../../')
classpath_path = os.path.join(osprey_dir, 'build/python/classpath.txt')
if not os.path.isfile(classpath_path):
raise Exception(
'dev classpath for python not generated yet. run ./gradlew pythonDevelop'
)
for path in open(classpath_path, 'r').readlines():
jvm.addClasspath(path.strip())
# start the jvm
jvm.start(heapSizeMiB, enableAssertions, stackSizeMiB, garbageSizeMiB)
# set up class factories
global c
c = jpype.JPackage('edu.duke.cs.osprey')
wraps.init(c)
# init other globals
global WILD_TYPE
WILD_TYPE = c.confspace.Strand.WildType
global Forcefield
Forcefield = jvm.getInnerClass(c.energy.forcefield.ForcefieldParams,
'Forcefield')
global SolvationForcefield
SolvationForcefield = jvm.getInnerClass(
c.energy.forcefield.ForcefieldParams, 'SolvationForcefield')
global EnergyPartition
EnergyPartition = c.energy.EnergyPartition
global ExternalMemory
ExternalMemory = c.externalMemory.ExternalMemory
global ConfSpaceType
ConfSpaceType = jvm.getInnerClass(c.kstar.KStar, 'ConfSpaceType')
global BreakdownType
BreakdownType = jvm.getInnerClass(c.energy.ResidueForcefieldBreakdown,
'Type')
# expose static builder methods too
Parallelism.makeCpu = c.parallelism.Parallelism.makeCpu
Parallelism.make = c.parallelism.Parallelism.make
# print the preamble
print("OSPREY %s" % c.control.Main.Version)
def _get_builder(jclass, builder_name='Builder'):
return jvm.getInnerClass(jclass, builder_name)
def EwakstarDoer_State(name, confSpace):
return jvm.getInnerClass(c.ewakstar.EwakstarDoer, 'State')(name, confSpace)
