def produce(self,
*,
inputs: Inputs,
timeout: float = None,
iterations: int = None) -> CallResult[Outputs]:
if (timeout is None):
big_table = self._core(inputs)
self._has_finished = True
self._iterations_done = True
return CallResult(big_table, self._has_finished,
self._iterations_done)
else:
# setup the timeout
with stopit.ThreadingTimeout(timeout) as to_ctx_mrg:
assert to_ctx_mrg.state == to_ctx_mrg.EXECUTING
# core computations
big_table = self._core(inputs)
if to_ctx_mrg.state == to_ctx_mrg.EXECUTED:
self._has_finished = True
self._iterations_done = True
return CallResult(big_table, self._has_finished,
self._iterations_done)
elif to_ctx_mrg.state == to_ctx_mrg.TIMED_OUT:
self._has_finished = False
self._iterations_done = False
return CallResult(None, self._has_finished,
self._iterations_done)
def fit(self, *, timeout: float = None, iterations: int = None) -> CallResult[None]:
if self._fitted:
return CallResult(None)
if self._training_inputs is None or self._training_outputs is None:
raise ValueError("Missing training data.")
self._clf.fit(self._training_inputs, self._training_outputs)
self._fitted = True
return CallResult(None)
def produce(self, *, inputs: Inputs, timeout: float = None, iterations: int = None) -> CallResult[Outputs]:
if self.hyperparams['preprocess'] == 'YES':
inputs = tm_preprocess(inputs, colnorms=self._norms)
pred_test = tm_predict(self._weights, inputs, self.hyperparams['q'],
self.hyperparams['r'], 'bc')
return CallResult(sign(pred_test.flatten()).astype(int))
def fit(self, *, timeout: float = None, iterations: int = None) -> CallResult[None]:
if self._fitted:
return CallResult(None)
if self._training_inputs is None or self._training_outputs is None:
raise ValueError("Missing training data.")
if len(self._training_outputs.shape) == 1:
self._training_outputs = np.expand_dims(self._training_outputs, axis=1)
(self._weights, _) = tm_fit(self._training_inputs, self._training_outputs, 'bc', self.hyperparams['r'],
self.hyperparams['q'], self.hyperparams['gamma'], self.hyperparams['solver'],
self.hyperparams['epochs'], self.hyperparams['alpha'], seed=self._seed)
self._fitted = True
return CallResult(None)
def produce(self, *, inputs: Inputs, timeout: float = None, iterations: int = None) -> CallResult[Outputs]:
"""
Predict the value for each sample in X
Inputs:
X: array of shape [n_samples, n_features]
Outputs:
y: array of shape [n_samples, n_targets]
"""
return CallResult(GaussianKernel(inputs, self._Xtrain, self.hyperparams['sigma']).dot(self._coeffs).flatten())
def fit(self, *, timeout: float = None, iterations: int = None) -> CallResult[None]:
"""
Learns the kernel regression coefficients alpha given training pairs (X,y)
"""
if self._fitted:
return CallResult(None)
if self._Xtrain is None or self._ytrain is None:
raise ValueError("Missing training data.")
self._U = generateGaussianPreconditioner(self._Xtrain, self.hyperparams['sigma'],
self.hyperparams['lparam'])
def mykernel(X, Y):
return GaussianKernel(X, Y, self.hyperparams['sigma'])
self._coeffs = PCGfit(self._Xtrain, self._ytrain, mykernel, self._U, self.hyperparams['lparam'],
self.hyperparams['eps'], self.hyperparams['maxIters'])
self._fitted = True
return CallResult(None)
def fit(self,
*,
timeout: float = None,
iterations: int = None) -> CallResult[None]:
if self._fitted:
return CallResult(None)
if self._training_inputs is None or self._training_outputs is None:
raise ValueError("Missing training data.")
(self._weights, _) = tm_fit(self._training_inputs,
self._training_outputs,
'regression',
self.hyperparams['r'],
self.hyperparams['q'],
self.hyperparams['gamma'],
self.hyperparams['solver'],
self.hyperparams['epochs'],
self.hyperparams['alpha'],
seed=self._seed)
self._fitted = True
return CallResult(None)
def produce(self,
*,
inputs: Inputs,
timeout: float = None,
iterations: int = None) -> CallResult[Outputs]:
"""Apply neural network-based feature extraction to image_tensor"""
image_tensor = inputs
# preprocess() modifies the data. For now just copy the data.
if not len(image_tensor.shape) == 4:
raise ValueError('Expect shape to have 4 dimension')
resized = False
if self._resize_data:
if not (image_tensor.shape[1] == 244
and image_tensor.shape[2] == 244):
resized = True
y = np.empty((image_tensor.shape[0], 224, 224, 3))
for index in range(image_tensor.shape[0]):
y[index] = imresize(image_tensor[index], (224, 224))
image_tensor = y
# preprocess() modifies the data. For now just copy the data.
if self._preprocess_data:
if resized:
# Okay to modify image_tensor, since its not input
data = image_tensor
else:
data = image_tensor.copy()
self._preprocess(data)
else:
data = image_tensor
result = self._model.predict(data)
self._has_finished = True
self._iterations_done = True
return CallResult(result.reshape(result.shape[0], -1),
self._has_finished, self._iterations_done)
def produce(self,
*,
inputs: Inputs,
timeout: float = None,
iterations: int = None) -> CallResult[Outputs]:
"""
Produce primitive's best choice of the output for each of the inputs.
The output value should be wrapped inside ``CallResult`` object before returning.
In many cases producing an output is a quick operation in comparison with ``fit``, but not
all cases are like that. For example, a primitive can start a potentially long optimization
process to compute outputs. ``timeout`` and ``iterations`` can serve as a way for a caller
to guide the length of this process.
Ideally, a primitive should adapt its call to try to produce the best outputs possible
inside the time allocated. If this is not possible and the primitive reaches the timeout
before producing outputs, it should raise a ``TimeoutError`` exception to signal that the
call was unsuccessful in the given time. The state of the primitive after the exception
should be as the method call has never happened and primitive should continue to operate
normally. The purpose of ``timeout`` is to give opportunity to a primitive to cleanly
manage its state instead of interrupting execution from outside. Maintaining stable internal
state should have precedence over respecting the ``timeout`` (caller can terminate the
misbehaving primitive from outside anyway). If a longer ``timeout`` would produce
different outputs, then ``CallResult``'s ``has_finished`` should be set to ``False``.
Some primitives have internal iterations (for example, optimization iterations).
For those, caller can provide how many of primitive's internal iterations
should a primitive do before returning outputs. Primitives should make iterations as
small as reasonable. If ``iterations`` is ``None``, then there is no limit on
how many iterations the primitive should do and primitive should choose the best amount
of iterations on its own (potentially controlled through hyper-parameters).
If ``iterations`` is a number, a primitive has to do those number of iterations,
if possible. ``timeout`` should still be respected and potentially less iterations
can be done because of that. Primitives with internal iterations should make
``CallResult`` contain correct values.
For primitives which do not have internal iterations, any value of ``iterations``
means that they should run fully, respecting only ``timeout``.
Parameters
----------
inputs : Inputs
The inputs of shape [num_inputs, ...].
timeout : float
A maximum time this primitive should take to produce outputs during this method call, in seconds.
iterations : int
How many of internal iterations should the primitive do.
Returns
-------
CallResult[Outputs]
The outputs of shape [num_inputs, ...] wrapped inside ``CallResult``.
"""
if not isinstance(inputs, d3m_metadata.container.pandas.DataFrame):
raise ValueError(
"inputs must be an instance of 'd3m_metadata.container.pandas.DataFrame'"
)
if "target" not in inputs.columns:
raise ValueError(
"inputs must contain single-class classification targets in a column labeled 'target'"
)
simple_metafeatures = SimpleMetafeatures().compute(inputs)
statistical_metafeatures = StatisticalMetafeatures().compute(inputs)
information_thoeretic_metafeatures = InformationTheoreticMetafeatures(
).compute(inputs)
landmarking_metafeatures = LandmarkingMetafeatures().compute(inputs)
metafeatures_df = d3m_metadata.container.pandas.DataFrame(
pd.concat([
simple_metafeatures, statistical_metafeatures,
information_thoeretic_metafeatures, landmarking_metafeatures
],
axis=1))
return CallResult(metafeatures_df)
def produce_log_proba(self, *, inputs: Inputs, timeout: float = None, iterations: int = None) -> CallResult[Outputs]:
return CallResult(self._clf.predict_log_proba(inputs))
def produce(self, *, inputs: Inputs, timeout: float = None, iterations: int = None) -> CallResult[Outputs]:
res = self._extract_feats(inputs,
fext_pipeline = self._fexture_pipeline,
resampling_rate = self._resampling_rate)
return CallResult(res, True, 1)