def test_memory(self):
# Set an environmental variable (local for this test)
os.environ['LOLOPY_JVM_MEMORY'] = '4g'
with self.assertLogs("py4j.java_gateway", level='DEBUG') as cm:
# Get a gateway
get_java_gateway(reuse=False)
# Make sure the memory amount appears in the logs
self.assertIn('Xmx4g', '\n'.join(cm.output))
def _call_lolo_merit(metric_name, y_true, y_pred, rng, y_std=None, *args):
"""Call a metric from lolopy
Args:
metric_name (str): Name of a Merit class (e.g., UncertaintyCorrelation)
y_true ([double]): True value
y_pred ([double]): Predicted values
y_uncert ([double]): Prediction uncertainties
*args (list): Any parameters to the constructor of the Metric
Returns:
(double): Metric score
"""
# If needed, set y_std to 1 for all entries
if y_std is None:
y_std = np.ones(len(y_true))
gateway = get_java_gateway()
# Get default rng
rng = rng if rng else gateway.jvm.scala.util.Random()
# Get the metric object
metric = getattr(gateway.jvm.io.citrine.lolo.validation, metric_name)
if len(args) > 0:
metric = metric(*args)
# Convert the data arrays to Java
y_true_java = send_1D_array(gateway, y_true, True)
y_pred_java = send_1D_array(gateway, y_pred, True)
y_std_java = send_1D_array(gateway, y_std, True)
# Make the prediction result
pred_result = gateway.jvm.io.citrine.lolo.util.LoloPyDataLoader.makeRegressionPredictionResult(y_pred_java, y_std_java)
# Run the prediction result through the metric
return metric.evaluate(pred_result, y_true_java, rng)
def __init__(self):
self.gateway = get_java_gateway()
# Create a placeholder for the model
self.model_ = None
self._compress_level = 9
self.feature_importances_ = None
def __setstate__(self, state):
# Unpickle the object
super(BaseLoloLearner, self).__setstate__(state)
# Get a pointer to the gateway
self.gateway = get_java_gateway()
# If needed, load the model into memory
if state['model_'] is not None:
bytes = state.pop('model_')
self.model_ = self.gateway.jvm.io.citrine.lolo.util.LoloPyDataLoader.deserializeObject(
bytes)
def test_launch(self):
# Launch the gateway
gate = get_java_gateway()
# Make sure it runs by making a random number
rnd = gate.jvm.java.util.Random()
self.assertIsInstance(rnd.nextInt(), int)
# Make sure importing Lolo works
java_import(gate.jvm, "io.citrine.lolo.learners.*")
self.assertIsInstance(gate.jvm.RandomForest, JavaClass)
# Make sure requsting a gateway againt returns the same gateway
gate2 = get_java_gateway()
self.assertIs(gate, gate2)
# Test getting a new gateway if needed
gate3 = get_java_gateway(reuse=False)
self.assertIsNot(gate, gate3)
# Make the server using the package version of lolo
gate4 = get_java_gateway(reuse=False, skip_devel_version=True)
java_import(gate4.jvm, "io.citrine.lolo.learners.*")
self.assertIsInstance(gate4.jvm.RandomForest, JavaClass)
def test_uncertainty_correlation(self):
seed(3893789455)
sample_size = 2 ** 15
gateway = get_java_gateway()
rng = gateway.jvm.scala.util.Random(783245)
for expected in [0, 0.75]:
# Make the error distribution
y_true = uniform(0, 1, sample_size)
# Make the errors and uncertainties
draw = multivariate_normal([0, 0], [[1, expected], [expected, 1]], sample_size)
# Add the errors, and separate out the standard deviations
y_pred = y_true + [d[0] * normal(0, 1) for d in draw]
y_std = [abs(d[1]) for d in draw]
# Test with a very large tolerance for now
measured_corr = uncertainty_correlation(y_true, y_pred, y_std, rng = rng)
corr_error = abs(measured_corr - expected)
self.assertLess(corr_error, 0.25, 'Error for {:.2f}: {:.2f}'.format(expected, corr_error))
def test_standard_confidene(self):
gateway = get_java_gateway()
rng = gateway.jvm.scala.util.Random(367894)
self.assertAlmostEqual(standard_confidence([1, 2], [2, 3], [1.5, 0.9]), 0.5, rng)
self.assertAlmostEqual(standard_confidence([1, 2], [2, 3], [1.5, 1.1]), 1, rng)
