def _update_light_curve_data_for_next_epoch(
light_curve_data: DataBase, next_day_data: DataBase,
canonical_data: DataBase, is_queryable: bool, strategy: str,
is_separate_files: bool) -> DataBase:
"""
Updates samples for next epoch
Parameters
----------
light_curve_data
light curve learning data
next_day_data
next day light curve data
canonical_data
canonical strategy light curve data
is_queryable
If True, allow queries only on objects flagged as queryable.
Default is True.
strategy
Query strategy. Options are (all can be run with budget):
"UncSampling", "UncSamplingEntropy", "UncSamplingLeastConfident",
"UncSamplingMargin", "QBDMI", "QBDEntropy", "RandomSampling",
is_separate_files
If True, consider samples separately read
from independent files. Default is False.
"""
light_curve_data.pool_metadata = next_day_data.pool_metadata
light_curve_data.pool_features = next_day_data.pool_features
light_curve_data.pool_labels = next_day_data.pool_labels
if not is_separate_files:
light_curve_data.test_metadata = next_day_data.test_metadata
light_curve_data.test_features = next_day_data.test_features
light_curve_data.test_labels = next_day_data.test_labels
light_curve_data.validation_metadata = next_day_data.validation_metadata
light_curve_data.validation_features = next_day_data.validation_features
light_curve_data.validation_labels = next_day_data.validation_labels
if strategy == 'canonical':
light_curve_data.queryable_ids = canonical_data.queryable_ids
if is_queryable:
queryable_flag = light_curve_data.pool_metadata['queryable'].values
light_curve_data.queryable_ids = light_curve_data.pool_metadata[
'id'].values[queryable_flag]
else:
light_curve_data.queryable_ids = light_curve_data.pool_metadata[
'id'].values
return light_curve_data
def _update_light_curve_data_val_and_test_data(
light_curve_data: DataBase, first_loop_data: DataBase,
is_separate_files: bool = False,
initial_training: Union[str, int] = 'original',
is_queryable: bool = False, number_of_classes: int = 2) -> DataBase:
"""
Updates initial light curve validation and test data
Parameters
----------
light_curve_data
initial light curve training data
first_loop_data
first loop light curve data
is_queryable
If True, allow queries only on objects flagged as queryable.
Default is True.
is_separate_files
If True, consider samples separately read
from independent files. Default is False.
initial_training
Choice of initial training sample.
If 'original': begin from the train sample flagged in the file
eilf 'previous': read training and queried from previous run.
If int: choose the required number of samples at random,
ensuring that at least half are SN Ia
Default is 'original'.
number_of_classes
Number of classes to consider in the classification
Currently only number_of_classes == 2 is implemented.
"""
if is_separate_files:
light_curve_data.build_samples(
nclass=number_of_classes, queryable=is_queryable,
sep_files=is_separate_files, initial_training=initial_training)
else:
light_curve_data.test_features = first_loop_data.pool_features
light_curve_data.test_metadata = first_loop_data.pool_metadata
light_curve_data.test_labels = first_loop_data.pool_labels
light_curve_data.validation_features = first_loop_data.pool_features
light_curve_data.validation_metadata = first_loop_data.pool_metadata
light_curve_data.validation_labels = first_loop_data.pool_labels
return light_curve_data
def _update_next_day_val_and_test_data(
next_day_data: DataBase, metadata_value: int,
id_key_name: str) -> DataBase:
"""
Removes metadata value data from next day validation and test samples
Parameters
----------
next_day_data
next day light curve data
metadata_value
metadata object value
id_key_name
object identification key name
"""
if (len(next_day_data.validation_metadata) > 0 and metadata_value
in next_day_data.validation_metadata[id_key_name].values):
val_indices = list(next_day_data.validation_metadata[
id_key_name].values).index(metadata_value)
next_day_data.validation_metadata = (
next_day_data.validation_metadata.drop(
next_day_data.validation_metadata.index[val_indices]))
next_day_data.validation_labels = np.delete(
next_day_data.validation_labels, val_indices, axis=0)
next_day_data.validation_features = np.delete(
next_day_data.validation_features, val_indices, axis=0)
if (len(next_day_data.test_metadata) > 0 and metadata_value
in next_day_data.test_metadata[id_key_name].values):
test_indices = list(next_day_data.test_metadata[
id_key_name].values).index(metadata_value)
next_day_data.test_metadata = (
next_day_data.test_metadata.drop(
next_day_data.test_metadata.index[test_indices]))
next_day_data.test_labels = np.delete(
next_day_data.test_labels, test_indices, axis=0)
next_day_data.test_features = np.delete(
next_day_data.test_features, test_indices, axis=0)
return next_day_data
def time_domain_loop(days: list, output_diag_file: str,
output_queried_file: str,
path_to_features_dir: str, strategy: str,
batch=1, canonical = False, classifier='RandomForest',
features_method='Bazin', path_to_canonical="",
path_to_full_lc_features="",
screen=True, training='original'):
"""Perform the active learning loop. All results are saved to file.
Parameters
----------
days: list
List of 2 elements. First and last day of observations since the
beginning of the survey.
output_diag_file: str
Full path to output file to store diagnostics of each loop.
output_queried_file: str
Full path to output file to store the queried sample.
path_to_features_dir: str
Complete path to directory holding features files for all days.
strategy: str
Query strategy. Options are 'UncSampling' and 'RandomSampling'.
batch: int (optional)
Size of batch to be queried in each loop. Default is 1.
canonical: bool (optional)
If True, restrict the search to the canonical sample.
classifier: str (optional)
Machine Learning algorithm.
Currently only 'RandomForest' is implemented.
features_method: str (optional)
Feature extraction method. Currently only 'Bazin' is implemented.
path_to_canonical: str (optional)
Path to canonical sample features files.
It is only used if "strategy==canonical".
path_to_full_lc_features: str (optional)
Path to full light curve features file.
Only used if training is a number.
screen: bool (optional)
If True, print on screen number of light curves processed.
training: str or int (optional)
Choice of initial training sample.
If 'original': begin from the train sample flagged in the file
If int: choose the required number of samples at random,
ensuring that at least half are SN Ia
Default is 'original'.
"""
## This will need to change for RESSPECT
# initiate object
data = DataBase()
# load features for the first day
path_to_features = path_to_features_dir + 'day_' + str(int(days[0])) + '.dat'
data.load_features(path_to_features, method=features_method,
screen=screen)
# change training
if training == 'original':
data.build_samples(initial_training='original')
full_lc_features = get_original_training(path_to_features=path_to_full_lc_features)
data.train_metadata = full_lc_features.train_metadata
data.train_labels = full_lc_features.train_labels
data.train_features = full_lc_features.train_features
else:
data.build_samples(initial_training=int(training))
# get list of canonical ids
if canonical:
canonical = DataBase()
canonical.load_features(path_to_file=path_to_canonical)
data.queryable_ids = canonical.queryable_ids
for night in range(int(days[0]), int(days[-1]) - 1):
if screen:
print('Processing night: ', night)
# cont loop
loop = night - int(days[0])
# classify
data.classify(method=classifier)
# calculate metrics
data.evaluate_classification()
# choose object to query
indx = data.make_query(strategy=strategy, batch=batch)
# update training and test samples
data.update_samples(indx, loop=loop)
# save diagnostics for current state
data.save_metrics(loop=loop, output_metrics_file=output_diag_file,
batch=batch, epoch=night)
# save query sample to file
data.save_queried_sample(output_queried_file, loop=loop,
full_sample=False)
# load features for next day
path_to_features2 = path_to_features_dir + 'day_' + str(night + 1) + '.dat'
data_tomorrow = DataBase()
data_tomorrow.load_features(path_to_features2, method=features_method,
screen=False)
# identify objects in the new day which must be in training
train_flag = np.array([item in data.train_metadata['id'].values
for item in data_tomorrow.metadata['id'].values])
# use new data
data.train_metadata = data_tomorrow.metadata[train_flag]
data.train_features = data_tomorrow.features.values[train_flag]
data.test_metadata = data_tomorrow.metadata[~train_flag]
data.test_features = data_tomorrow.features.values[~train_flag]
# new labels
data.train_labels = np.array([int(item == 'Ia') for item in
data.train_metadata['type'].values])
data.test_labels = np.array([int(item == 'Ia') for item in
data.test_metadata['type'].values])
if strategy == 'canonical':
data.queryable_ids = canonical.queryable_ids
if queryable:
queryable_flag = data_tomorrow.metadata['queryable'].values
queryable_test_flag = np.logical_and(~train_flag, queryable_flag)
data.queryable_ids = data_tomorrow.metadata['id'].values[queryable_test_flag]
else:
data.queryable_ids = data_tomorrow.metadata['id'].values[~train_flag]
if screen:
print('Training set size: ', data.train_metadata.shape[0])
print('Test set size: ', data.test_metadata.shape[0])
