def open(filename):
with configuration.ConfigurationContext("NetworkResistantImage"):
cumulative_wait_max = configuration.get("cumulative_wait_max",
2.0 * 60.0 * 60.0)
wait_interval_initial = configuration.get("wait_interval_initial",
0.5)
# Set initial state
wait_interval = wait_interval_initial
cumulative_wait = 0.0
last_exception = None
while cumulative_wait <= cumulative_wait_max:
try:
image = Image.open(filename)
return image
except Exception as ex:
print(
f"Cannot open {filename}: {ex}. Waiting {wait_interval} seconds."
)
last_exception = ex
time.sleep(wait_interval)
cumulative_wait += wait_interval
wait_interval *= 2.0
raise last_exception
def __init__(self, cls):
KerasIncrementalModel.__init__(self, cls)
with configuration.ConfigurationContext("DFNKerasIncrementalModel"):
self.exposure_coef = configuration.get("exposure_coef", 1.0)
self.always_rehearse = configuration.get("always_rehearse", False)
self.lambda_ = configuration.get("lambda", 0.5)
self.fixed_inner_steps = configuration.get("fixed_inner_steps",
None)
self.rehearsal_pool = []
def __init__(self, kb):
EmbeddingBasedKerasHC.__init__(self, kb)
# Configuration
with configuration.ConfigurationContext("IDKEmbeddingBasedKerasHC"):
self._l2_regularization_coefficient = configuration.get("l2", 5e-5)
self._mlnp = configuration.get("mlnp", True)
self._normalize_scores = configuration.get("normalize_scores", True)
self.fc_layer = None
self.uid_to_dimension = {}
self.graph = None
self.observed_uids = None
self.topo_sorted_uids = None
self.update_embedding()
def __init__(self, model, kb):
super().__init__(model, kb)
with configuration.ConfigurationContext(
"SemanticOneVsTwoActiveLearningMethod"):
self.semantic_measure_name = configuration.get(
"semantic_measure", "Rada1989")
self.semantic_measure = semanticmeasures.method(
self.semantic_measure_name, kb)
def __init__(self):
with configuration.ConfigurationContext("LNDWDataset"):
self.base_path = configuration.get_system("LNDWDataset.base_path")
self.side_length = configuration.get("side_length", 224)
self._viability_threshold = configuration.get(
"viability_threshold", 3.0)
self.all_classes_even_unviable = []
with open(os.path.join(self.base_path, "classes.csv")) as classes_file:
reader = csv.reader(classes_file, delimiter=";")
header = next(reader)
fields = {
"folder": "ID",
"class_name": "Class Name",
"individual_id": "No.",
"grade": "Grade",
"wordnet": "WordNet",
}
fields = {k: header.index(v) for k, v in fields.items()}
for line in reader:
self.all_classes_even_unviable += [{
k: line[v]
for k, v in fields.items()
}]
self.viable_classes = [
class_ for class_ in self.all_classes_even_unviable
if self._viable(class_)
]
self.wordnet_mapping = []
for class_ in self.viable_classes:
self.wordnet_mapping += [(
f"{_namespace_uid}::{class_['class_name']}" +
f"{int(class_['individual_id']):02d}",
f"WordNet3.0::{class_['wordnet']}",
)]
self.wordnet_mapping += [(
f"{_namespace_uid}::{class_['class_name']}",
f"WordNet3.0::{class_['wordnet']}",
)]
# Attributes are set in setup()
self.individuals = None
self.setup()
def __init__(self, cls):
KerasIncrementalModel.__init__(self, cls)
with configuration.ConfigurationContext(
"FastSingleShotKerasIncrementalModel"):
self._inner_steps = configuration.get("inner_steps",
no_default=True)
self._already_observed = False
def __init__(self):
with configuration.ConfigurationContext(self.__class__.__name__):
self.base_path = configuration.get_system(
"iNaturalist2018Dataset.base_path")
self.side_length = configuration.get("side_length", 224)
self._id_to_class = {}
with open(os.path.join(self.base_path,
"categories.json")) as json_file:
json_data = json.load(json_file)
for json_datum in json_data:
self._id_to_class[json_datum["id"]] = json_datum["name"]
def __init__(self, kb):
super().__init__(kb)
with configuration.ConfigurationContext(self.__class__.__name__):
self.noise_model = configuration.get("noise_model",
no_default=True)
if self.noise_model == "Deng2014":
self.relabel_fraction: float = configuration.get(
"relabel_fraction", no_default=True)
elif self.noise_model == "Poisson":
self.lambda_: float = configuration.get("lambda",
no_default=True)
elif self.noise_model == "Geometric":
self.q: float = configuration.get("q", no_default=True)
else:
raise ValueError(f"Unknown noise model: {self.noise_model}")
self.filter_imprecise = configuration.get("filter_imprecise",
False)
self.project_to_random_leaf = configuration.get(
"project_to_random_leaf", False)
self.last_concept_stamp = -1
self.graph: Optional[nx.DiGraph] = None
self.root = None
def __init__(self, prefix=""):
instrumentation.InstrumentationObserver.__init__(self, prefix)
# Configuration
with configuration.ConfigurationContext(self.__class__.__name__):
self._mongo_observer = sacred.observers.MongoObserver.create(
url=configuration.get(
"mongo_url",
next(
open(os.path.expanduser("~/work/experiments/sacred/mongourl"))
),
),
db_name=configuration.get("mongo_db_name", "sacred"),
)
self.sacred_experiment = None
self.sacred_run = None
self.done = None
self.run_object_available = None
self.sacred_thread = None
self.stored_result = None
self.stored_exception = None
def __init__(self, kb):
EmbeddingBasedKerasHC.__init__(self, kb)
# Configuration
with configuration.ConfigurationContext(self.__class__.__name__):
self._l2_regularization_coefficient = configuration.get("l2", 5e-5)
self.last_observed_concept_count = len(self.kb.get_observed_concepts())
self.fc_layer = None
self.uid_to_dimension = {}
self.dimension_to_uid = []
self.update_embedding()
def __init__(self):
with configuration.ConfigurationContext(self.__class__.__name__):
self.do_random_flip_horizontal = configuration.get(
"do_random_flip_horizontal", True)
self.do_random_flip_vertical = configuration.get(
"do_random_flip_vertical", True)
self.do_random_rotate = configuration.get("do_random_rotate", True)
self.do_random_crop = configuration.get("do_random_crop", True)
self.random_crop_factor = configuration.get(
"random_crop_factor", 0.2)
self.do_random_brightness_and_contrast = configuration.get(
"do_random_brightness_and_contrast", True)
self.random_brightness_factor = configuration.get(
"random_brightness_factor", 0.05)
self.random_contrast_factors = configuration.get(
"random_contrast_factors", (0.7, 1.3))
self.do_random_hue_and_saturation = configuration.get(
"do_random_hue_and_saturation", True)
self.random_hue_factor = configuration.get("random_hue_factor",
0.08)
self.random_saturation_factors = configuration.get(
"random_saturation_factors", (0.6, 1.6))
self.do_random_scale = configuration.get("do_random_scale", True)
self.random_scale_factors = configuration.get(
"random_scale_factors", (0.5, 2.0))
def __init__(
self,
cls: keras_hierarchicalclassification.KerasHierarchicalClassifier):
self.cls = cls
with configuration.ConfigurationContext("KerasIncrementalModel"):
# Preprocessing
self.random_crop_to_size = configuration.get(
"random_crop_to_size", None)
_channel_mean = configuration.get("channel_mean",
[127.5, 127.5, 127.5])
self.channel_mean_normalized = np.array(_channel_mean) / 255.0
_channel_stddev = configuration.get("channel_stddev",
[127.5, 127.5, 127.5])
self.channel_stddev_normalized = np.array(_channel_stddev) / 255.0
# Batch size
self.batchsize_max = configuration.get("batchsize_max", 256)
self.batchsize_min = configuration.get("batchsize_min", 1)
self.sequential_training_batches = configuration.get(
"sequential_training_batches", 1)
self.autobs_vram = configuration.get(
"autobs_vram", configuration.get_system("gpu0_vram"))
# Fine-tuning options
self.do_train_feature_extractor = configuration.get(
"train_feature_extractor", False)
self.use_pretrained_weights = configuration.get(
"use_pretrained_weights", "ILSVRC2012")
# Architecture
self.architecture = configuration.get("architecture",
"keras::ResNet50V2")
# Optimization and regularization
self.l2_regularization = configuration.get("l2_regularization",
5e-5)
self.optimizer_name = configuration.get("optimizer", "adam")
if self.optimizer_name == "sgd":
self.sgd_momentum = configuration.get("sgd_momentum", 0.9)
self.lr_schedule_cfg = configuration.get("lr_schedule", {
"name": "constant",
"config": {
"initial_lr": 0.003
}
})
self.lr_schedule = keras_learningrateschedule.get(
self.lr_schedule_cfg)
if self.architecture == "keras::ResNet50V2":
self.feature_extractor = resnet_v2.ResNet50V2(
include_top=False,
input_tensor=None,
input_shape=None,
pooling="avg",
weights="imagenet"
if self.use_pretrained_weights == "ILSVRC2012" else None,
)
self.pixels_per_gb = 1100000
self._add_regularizers()
elif self.architecture == "keras::InceptionResNetV2":
self.feature_extractor = inception_resnet_v2.InceptionResNetV2(
include_top=False,
input_tensor=None,
input_shape=None,
pooling="avg",
weights="imagenet"
if self.use_pretrained_weights == "ILSVRC2012" else None,
)
self.pixels_per_gb = 700000
self._add_regularizers()
elif self.architecture == "keras::MobileNetV2":
with configuration.ConfigurationContext("KerasIncrementalModel"):
self.side_length = configuration.get("side_length",
no_default=True)
self.feature_extractor = mobilenet_v2.MobileNetV2(
include_top=False,
input_tensor=None,
input_shape=(self.side_length, self.side_length, 3),
pooling="avg",
weights="imagenet"
if self.use_pretrained_weights == "ILSVRC2012" else None,
)
self.pixels_per_gb = 2000000
self._add_regularizers()
elif self.architecture == "keras::NASNetMobile":
with configuration.ConfigurationContext("KerasIncrementalModel"):
self.side_length = configuration.get("side_length",
no_default=True)
self.feature_extractor = nasnet.NASNetMobile(
include_top=False,
input_tensor=None,
input_shape=(self.side_length, self.side_length, 3),
pooling="avg",
weights="imagenet"
if self.use_pretrained_weights == "ILSVRC2012" else None,
)
self.pixels_per_gb = 1350000
self._add_regularizers()
elif self.architecture == "keras::CIFAR-ResNet56":
assert (self.do_train_feature_extractor
), "There are no pretrained weights for this architecture!"
assert (self.use_pretrained_weights is None
), "There are no pretrained weights for this architecture!"
from chia.methods.common import keras_cifar_resnet
self.feature_extractor = keras_cifar_resnet.feature_extractor(
version=2, n=6, l2_norm=self.l2_regularization)
self.pixels_per_gb = 200000
else:
raise ValueError(f'Unknown architecture "{self.architecture}"')
if self.optimizer_name == "adam":
self.optimizer = tf.keras.optimizers.Adam(self.lr_schedule(0))
else:
self.optimizer = tf.keras.optimizers.SGD(
learning_rate=self.lr_schedule(0), momentum=self.sgd_momentum)
self.augmentation = keras_dataaugmentation.KerasDataAugmentation()
if (self.use_pretrained_weights is not None
and self.use_pretrained_weights != "ILSVRC2012"):
print(
f"Loading alternative pretrained weights {self.use_pretrained_weights}"
)
self.feature_extractor.load_weights(self.use_pretrained_weights)
if not self.do_train_feature_extractor:
for layer in self.feature_extractor.layers:
layer.trainable = False
self.reported_auto_bs = False
# State here
self.current_step = 0
def main():
# Some constants
label_gt_resource_id = "label_ground_truth"
label_ann_resource_id = "label_annotated"
label_pred_resource_id = "label_predicted"
# General config
ilm_method = configuration.get("ilm_method", no_default=True)
cls_method = configuration.get("cls_method", no_default=True)
interaction_method = configuration.get("interaction_method",
no_default=True)
experiment_scale = configuration.get("experiment_scale", no_default=True)
dataset_name = configuration.get("dataset", no_default=True)
experiment_name = configuration.get("experiment_name", no_default=True)
report_interval = configuration.get("report_interval", no_default=True)
report_initially = configuration.get("report_initially", no_default=True)
validation_scale = configuration.get("validation_scale", no_default=True)
skip_reclassification = configuration.get("skip_reclassification",
no_default=True)
evaluators = configuration.get("evaluators", no_default=True)
# KB specific stuff
observe_gt_concepts = configuration.get("observe_gt_concepts",
no_default=True)
# Save and restore
restore_path = configuration.get("restore_path", no_default=True)
save_path = configuration.get("save_path", no_default=True)
save_path_append_run_number = configuration.get(
"save_path_append_run_number", no_default=True)
# Eval config
use_sacred_observer = configuration.get("use_sacred_observer",
no_default=True)
# Dataset specific setup stuff
if dataset_name == "CORe50":
core50_scenario = configuration.get("core50_scenario", no_default=True)
# Instantiate dataset
dataset = datasets.dataset(dataset_name)
# Get instrumentation going
instrumentation_observers = [
instrumentation.PrintObserver(experiment_name),
instrumentation.JSONResultObserver(experiment_name),
]
if use_sacred_observer:
from chia.framework.instrumentation import sacred_instrumentation
instrumentation_observers += [
sacred_instrumentation.SacredObserver(experiment_name)
]
with instrumentation.InstrumentationContext(
"run", observers=instrumentation_observers):
# Determine run count
if dataset_name == "CORe50":
run_count = dataset.get_run_count(core50_scenario)
else:
run_count = configuration.get("run_count", no_default=True)
run_count = max(1, int(math.ceil(run_count * experiment_scale)))
instrumentation.report("run_count", run_count)
results_across_runs = []
# Runs...
for run_id in range(run_count):
instrumentation.update_local_step(run_id)
# Dataset specific run init
if dataset_name == "CORe50":
dataset.setup(scenario=core50_scenario, run=run_id)
# Test datasets
test_pools = []
with instrumentation.InstrumentationContext("test_pools"):
for i in range(dataset.test_pool_count()):
instrumentation.update_local_step(i)
test_pool = dataset.test_pool(i, label_gt_resource_id)
if validation_scale < 1.0:
test_pool = test_pool[:min(
max(
1,
int(
math.
ceil(len(test_pool) * validation_scale))),
len(test_pool),
)]
instrumentation.report("size", len(test_pool))
test_pools += [test_pool]
# Build methods
kb = knowledge.KnowledgeBase()
if restore_path is not None:
kb.restore(restore_path)
else:
# Add hierarchy
wna = wordnet.WordNetAccess()
kb.add_relation(
"hypernymy",
is_symmetric=False,
is_transitive=True,
is_reflexive=False,
explore_left=False,
explore_right=True,
sources=[dataset.relation("hypernymy"), wna],
)
im = interaction.method(interaction_method, kb)
cls = hierarchicalclassification.method(cls_method, kb)
ilm = incrementallearning.method(ilm_method, cls)
# Restore
if restore_path is not None:
ilm.restore(restore_path)
# Evaluator
evaluator = evaluation.method(evaluators, kb)
train_pool_count = dataset.train_pool_count()
# Collect training data
train_pool = []
for train_pool_id in range(train_pool_count):
train_pool += pool.FixedPool(
dataset.train_pool(train_pool_id, label_gt_resource_id))
train_pool_size = len(train_pool)
instrumentation.report("train_pool_size", train_pool_size)
if observe_gt_concepts:
kb.observe_concepts([
sample.get_resource(label_gt_resource_id)
for sample in train_pool
])
# Run "interaction"
labeled_pool = im.query_annotations_for(train_pool,
label_gt_resource_id,
label_ann_resource_id)
labeled_pool_size = len(labeled_pool)
instrumentation.report("labeled_pool_size", labeled_pool_size)
if report_initially:
next_progress = 0.0
else:
next_progress = report_interval
def evaluate(progress=None):
nonlocal next_progress
if progress is not None:
if progress < next_progress:
return
else:
next_progress += report_interval
# Quick reclass accuracy
if not skip_reclassification:
with instrumentation.InstrumentationContext(
"reclassification", take_time=True):
instrumentation.update_local_step(0)
if validation_scale < 1.0:
reclass_pool = labeled_pool[:min(
max(
1,
int(
math.ceil(
len(labeled_pool) *
validation_scale)),
),
len(labeled_pool),
)]
else:
reclass_pool = labeled_pool
evaluator.update(
ilm.predict(reclass_pool, label_pred_resource_id),
label_ann_resource_id,
label_pred_resource_id,
)
instrumentation.report_dict(evaluator.result())
evaluator.reset()
# Validation
with instrumentation.InstrumentationContext("validation",
take_time=True):
results_across_test_pools = []
for test_pool_id in range(len(test_pools)):
instrumentation.update_local_step(test_pool_id)
evaluator.update(
ilm.predict(test_pools[test_pool_id],
label_pred_resource_id),
label_gt_resource_id,
label_pred_resource_id,
)
instrumentation.report_dict(evaluator.result())
results_across_test_pools += [evaluator.result()]
evaluator.reset()
return results_across_test_pools
with instrumentation.InstrumentationContext("training",
take_time=True):
# Learn the thing
if not observe_gt_concepts:
kb.observe_concepts([
sample.get_resource(label_ann_resource_id)
for sample in labeled_pool
])
ilm.observe(
labeled_pool,
label_ann_resource_id,
progress_callback=evaluate
if report_interval > 0 else None,
)
results_across_runs += [evaluate()]
if save_path is not None and save_path_append_run_number:
kb.save(f"{save_path}-{run_id}")
ilm.save(f"{save_path}-{run_id}")
instrumentation.store_result(results_across_runs)
# Save last model
if save_path is not None and not save_path_append_run_number:
kb.save(save_path)
ilm.save(save_path)
def __init__(self):
with configuration.ConfigurationContext(self.__class__.__name__):
self.base_path = configuration.get_system(
"NABirdsDataset.base_path")
self.side_length = configuration.get("side_length", 224)
self.use_lazy_mode = configuration.get("use_lazy_mode", True)
with open(os.path.join(self.base_path, "classes.txt")) as cls:
lines = [x.strip() for x in cls]
tuples = [x.split(sep=" ", maxsplit=1) for x in lines]
tuples = [(int(k), str(v)) for (k, v) in tuples]
self.uid_for_label_id = {
k: f"{_namespace_uid}::{int(k):03d}{v}"
for (k, v) in tuples
}
self.nabirds_ids = {k for (k, v) in tuples}
if len([k for (k, v) in tuples]) != len({k for (k, v) in tuples}):
print("Non-unique IDs found!")
quit(-1)
with open(os.path.join(self.base_path,
"image_class_labels.txt")) as lab:
with open(os.path.join(self.base_path,
"train_test_split.txt")) as tts:
with open(os.path.join(self.base_path, "images.txt")) as iid:
lablines = [x.strip() for x in lab]
labtuples = [
x.split(sep=" ", maxsplit=1) for x in lablines
]
labtuples = [(str(some_primary_key), int(label))
for (some_primary_key, label) in labtuples]
ttslines = [x.strip() for x in tts]
ttstuples = [
x.split(sep=" ", maxsplit=1) for x in ttslines
]
ttstuples = [(str(some_primary_key), int(is_train_or_test))
for (some_primary_key,
is_train_or_test) in ttstuples]
iidlines = [x.strip() for x in iid]
iidtuples = [
x.split(sep=" ", maxsplit=1) for x in iidlines
]
iidtuples = [(str(some_primary_key), str(image_path))
for (some_primary_key,
image_path) in iidtuples]
self.image_location_for_image_id = {
k: v
for (k, v) in iidtuples
}
combinedtuples = [
a + b for (a, b) in zip(labtuples, ttstuples)
]
mismatches = [a != c for (a, b, c, d) in combinedtuples]
if any(mismatches):
print("Mismatch between tts and label files!")
quit(-1)
combinedtuples = [(a, b, d)
for (a, b, c, d) in combinedtuples]
self._nabirds_training_tuples = [
(img, id) for (img, id, tt) in combinedtuples
if tt == 1
]
self._nabirds_validation_tuples = [
(img, id) for (img, id, tt) in combinedtuples
if tt == 0
]
with open(os.path.join(self.base_path, "hierarchy.txt")) as hie:
lines = [x.strip() for x in hie]
tuples = [x.split(sep=" ", maxsplit=1) for x in lines]
self.tuples = [(self.uid_for_label_id[int(k)],
self.uid_for_label_id[int(v)])
for (k, v) in tuples]
def main():
# Some constants
label_gt_resource_id = "label_ground_truth"
label_ann_resource_id = "label_annotated"
label_pred_resource_id = "label_predicted"
al_score_resource_id = "al_score"
# General config
ilm_method = configuration.get("ilm_method", no_default=True)
cls_method = configuration.get("cls_method", no_default=True)
interaction_method = configuration.get("interaction_method", no_default=True)
al_method = configuration.get("al_method", no_default=True)
experiment_scale = configuration.get("experiment_scale", no_default=True)
label_budget = configuration.get("label_budget", no_default=True)
dataset_name = configuration.get("dataset", no_default=True)
experiment_name = configuration.get("experiment_name", no_default=True)
validation_scale = configuration.get("validation_scale", no_default=True)
evaluators = configuration.get("evaluators", no_default=True)
al_score_fraction = configuration.get("al_score_fraction", no_default=True)
ll_cycle_mode = configuration.get("ll_cycle_mode", no_default=True)
if ll_cycle_mode:
ll_cycle_length = configuration.get("ll_cycle_length", no_default=True)
else:
ll_cycle_length = 0
# Eval config
use_sacred_observer = configuration.get("use_sacred_observer", no_default=True)
# Dataset specific setup stuff
if dataset_name == "CORe50":
core50_scenario = configuration.get("core50_scenario", no_default=True)
# Instantiate dataset
dataset = datasets.dataset(dataset_name)
# Get instrumentation going
instrumentation_observers = [
instrumentation.PrintObserver(experiment_name),
instrumentation.JSONResultObserver(experiment_name),
]
if use_sacred_observer:
from chia.framework.instrumentation import sacred_instrumentation
instrumentation_observers += [
sacred_instrumentation.SacredObserver(experiment_name)
]
with instrumentation.InstrumentationContext(
"run", observers=instrumentation_observers
):
# Determine run count
if dataset_name == "CORe50":
run_count = dataset.get_run_count(core50_scenario)
else:
run_count = configuration.get("run_count", no_default=True)
run_count = max(1, int(math.ceil(run_count * experiment_scale)))
instrumentation.report("run_count", run_count)
results_across_runs = []
# Runs...
for run_id in range(run_count):
instrumentation.update_local_step(run_id)
results_across_train_pools = []
# Dataset specific run init
if dataset_name == "CORe50":
dataset.setup(scenario=core50_scenario, run=run_id)
# Test datasets
test_pools = []
with instrumentation.InstrumentationContext("test_pools"):
for i in range(dataset.test_pool_count()):
instrumentation.update_local_step(i)
test_pool = dataset.test_pool(i, label_gt_resource_id)
if validation_scale < 1.0:
test_pool = test_pool[
: min(
max(
1, int(math.ceil(len(test_pool) * validation_scale))
),
len(test_pool),
)
]
instrumentation.report("size", len(test_pool))
test_pools += [test_pool]
# Build methods
kb = knowledge.KnowledgeBase()
# Add hierarchy
wna = wordnet.WordNetAccess()
kb.add_relation(
"hypernymy",
is_symmetric=False,
is_transitive=True,
is_reflexive=False,
explore_left=False,
explore_right=True,
sources=[dataset.relation("hypernymy"), wna],
)
im = interaction.method(interaction_method, kb)
cls = hierarchicalclassification.method(cls_method, kb)
ilm = incrementallearning.method(ilm_method, cls)
alm = activelearning.method(al_method, ilm, kb)
# Evaluator
evaluator = evaluation.method(evaluators, kb)
# Go over batches...
with instrumentation.InstrumentationContext("train_pool"):
train_pool_count = dataset.train_pool_count()
instrumentation.report("train_pool_count", train_pool_count)
for train_pool_id in range(train_pool_count):
instrumentation.update_local_step(train_pool_id)
with instrumentation.InstrumentationContext(
"train_pool", take_time=True
):
# Collect training data
train_pool = pool.FixedPool(
dataset.train_pool(train_pool_id, label_gt_resource_id)
)
train_pool_size = len(train_pool)
instrumentation.report("train_pool_size", train_pool_size)
train_pool_label_budget = max(
1, math.ceil(label_budget * train_pool_size)
)
instrumentation.report(
"train_pool_budget", train_pool_label_budget
)
# Start the cycle through the training data
with instrumentation.InstrumentationContext("llcycle"):
results_across_cycles = []
current_cycle = 0
while train_pool_label_budget > 0:
instrumentation.update_local_step(current_cycle)
assert train_pool_label_budget <= len(train_pool)
if ll_cycle_mode:
current_cycle_budget = min(
train_pool_label_budget, ll_cycle_length
)
else:
current_cycle_budget = train_pool_label_budget
instrumentation.report(
"current_cycle_budget", current_cycle_budget
)
instrumentation.report(
"train_pool_size", len(train_pool)
)
train_pool_label_budget -= current_cycle_budget
# Only do active learning if there is even a choice
if (len(train_pool) - current_cycle_budget) > 0:
# Run active learning method
if current_cycle > 0:
if al_score_fraction < 1.0:
# Don't look at whole training pool
fraction_train_pool = np.random.choice(
train_pool,
min(
len(train_pool),
max(
1,
math.ceil(
len(train_pool)
* al_score_fraction
),
),
),
replace=False,
)
scored_train_pool = alm.score(
fraction_train_pool,
al_score_resource_id,
)
else:
scored_train_pool = alm.score(
train_pool, al_score_resource_id
)
else:
scored_train_pool = [
sample.add_resource(
"llcycle",
al_score_resource_id,
random.uniform(0.0, 1.0),
)
for sample in train_pool
]
sorted_scored_train_pool = list(
sorted(
scored_train_pool,
key=lambda sample: sample.get_resource(
al_score_resource_id
),
reverse=True,
)
)
pool_to_be_labeled = sorted_scored_train_pool[
:current_cycle_budget
]
instrumentation.report(
"min_al_score",
sorted_scored_train_pool[-1].get_resource(
al_score_resource_id
),
)
instrumentation.report(
"cutoff_al_score",
pool_to_be_labeled[-1].get_resource(
al_score_resource_id
),
)
instrumentation.report(
"max_al_score",
pool_to_be_labeled[0].get_resource(
al_score_resource_id
),
)
else:
pool_to_be_labeled = train_pool
# Run "interaction"
labeled_pool = im.query_annotations_for(
pool_to_be_labeled,
label_gt_resource_id,
label_ann_resource_id,
)
# Learn the thing
kb.observe_concepts(
[
sample.get_resource(label_ann_resource_id)
for sample in labeled_pool
]
)
ilm.observe(labeled_pool, label_ann_resource_id)
# Remove the labeled samples from the pool
samples_before_removal = len(train_pool)
train_pool = train_pool.remove_multiple(labeled_pool)
assert (
len(train_pool)
== samples_before_removal - current_cycle_budget
)
current_cycle += 1
# Quick reclass accuracy
with instrumentation.InstrumentationContext(
"reclassification"
):
evaluator.update(
ilm.predict(
labeled_pool, label_pred_resource_id
),
label_ann_resource_id,
label_pred_resource_id,
)
instrumentation.report_dict(evaluator.result())
evaluator.reset()
# Validation
with instrumentation.InstrumentationContext(
"validation", take_time=True
):
results_across_test_pools = []
for test_pool_id in range(len(test_pools)):
instrumentation.update_local_step(test_pool_id)
evaluator.update(
ilm.predict(
test_pools[test_pool_id],
label_pred_resource_id,
),
label_gt_resource_id,
label_pred_resource_id,
)
instrumentation.report_dict(evaluator.result())
results_across_test_pools += [
evaluator.result()
]
evaluator.reset()
results_across_cycles += [results_across_test_pools]
results_across_train_pools += [results_across_cycles]
results_across_runs += [results_across_train_pools]
instrumentation.store_result(results_across_runs)
def __init__(self, kb):
with configuration.ConfigurationContext(self.__class__.__name__):
self.kmax = configuration.get("kmax", 5)
self.kb = kb
self.reset()