def check_model(monkeypatch=None,
use_granular=False,
log_file=h5_log_file,
continue_from_log=False,
mode="oracle",
**kwargs):
if not continue_from_log:
try:
if log_file is not None:
os.unlink(log_file)
except OSError:
pass
if monkeypatch is not None:
monkeypatch.setattr('builtins.input', lambda _: "0")
# start the review process.
reviewer = get_reviewer(data_fp,
mode=mode,
embedding_fp=embedding_fp,
prior_included=[1, 3],
prior_excluded=[2, 4],
log_file=log_file,
**kwargs)
if use_granular:
with open_logger(log_file) as logger:
# Two loops of training and classification.
reviewer.train()
reviewer.log_probabilities(logger)
query_idx = reviewer.query(1)
inclusions = reviewer._get_labels(query_idx)
reviewer.classify(query_idx, inclusions, logger)
reviewer.train()
reviewer.log_probabilities(logger)
query_idx = reviewer.query(1)
inclusions = reviewer._get_labels(query_idx)
reviewer.classify(query_idx, inclusions, logger)
else:
with open_logger(log_file) as logger:
if log_file is None:
logger.set_labels(reviewer.y)
init_idx, init_labels = reviewer._prior_knowledge()
reviewer.query_i = 0
reviewer.train_idx = np.array([], dtype=np.int)
reviewer.classify(init_idx,
init_labels,
logger,
method="initial")
reviewer._do_review(logger)
if log_file is None:
print(logger._log_dict)
check_log(logger)
if log_file is not None:
with open_logger(log_file, read_only=True) as logger:
check_log(logger)
def review(self, *args, **kwargs):
"""Do the systematic review, writing the results to the log file.
Arguments
---------
stop_after_class: bool
When to stop; if True stop after classification step, otherwise
stop after training step.
instant_save: bool
If True, save results after each single classification.
"""
with open_logger(self.log_file) as logger:
self._do_review(logger, *args, **kwargs)
def __init__(
self,
X,
y=None,
model=None,
query_model=None,
balance_model=None,
feature_model=None,
n_papers=None,
n_instances=DEFAULT_N_INSTANCES,
n_queries=None,
prior_included=[],
prior_excluded=[],
log_file=None,
final_labels=None,
verbose=1,
data_fp=None,
):
""" Initialize base class for systematic reviews.
Arguments
---------
X: np.array
The feature matrix for the current dataset.
y: np.array
Labels of each paper, 1 for included, 0 for excluded.
Can be set to None, to indicate inclusion data is not available.
model: BaseModel
Initialized model to fit the data during active learning.
See asreview.models.utils.py for possible models.
query_model: BaseQueryModel
Initialized model to query new instances for review, such as random
sampling or max sampling.
See asreview.query_strategies.utils.py for query models.
balance_model: BaseBalanceModel
Initialized model to redistribute the training data during the
active learning process. They might either resample or undersample
specific papers.
n_papers: int
Number of papers to review during the active learning process,
excluding the number of initial priors. To review all papers, set
n_papers to None.
n_instances: int
Number of papers to query at each step in the active learning
process.
n_queries: int
Number of steps/queries to perform. Set to None for no limit.
prior_included: list
List of papers (ids) that are included a priori.
prior_excluded: list
List of papers (ids) that are excluded a priori.
log_file: str
Path to log file.
final_labels: np.array
Final labels if we're using a two step inclusion process.
For example, if at one step a paper is considered after reading the
abstract and then at the second step, a final decision is made on
the basis of the full text.
"""
super(BaseReview, self).__init__()
self.X = X
self.y = y
if y is None:
self.y = np.full(X.shape[0], NOT_AVAILABLE)
self.y = np.array(self.y, dtype=np.int)
# Default to Naive Bayes model
if model is None:
model = NBModel()
if query_model is None:
query_model = MaxQuery()
if balance_model is None:
balance_model = SimpleBalance()
if feature_model is None:
raise ValueError("Supply feature model!")
self.model = model
self.balance_model = balance_model
self.query_model = query_model
self.feature_model = feature_model
self.shared = {"query_src": {}, "current_queries": {}}
self.model.shared = self.shared
self.query_model.shared = self.shared
self.balance_model.shared = self.shared
self.n_papers = n_papers
self.n_instances = n_instances
self.n_queries = n_queries
self.log_file = log_file
self.verbose = verbose
self.prior_included = prior_included
self.prior_excluded = prior_excluded
self.query_i = 0
self.train_idx = np.array([], dtype=np.int)
self.model_trained = False
self.data_fp = data_fp
with open_logger(log_file) as logger:
if not logger.is_empty():
y, train_idx, query_src, query_i = logger.review_state()
if X.shape[0] != len(y):
raise ValueError("The log file does not correspond to the "
"given data file, please use another log "
"file or dataset.")
self.y = y
self.train_idx = train_idx
self.shared["query_src"] = query_src
self.query_i = query_i
else:
if final_labels is not None:
logger.set_final_labels(final_labels)
logger.set_labels(self.y)
logger.add_settings(self.settings)
self._prior_knowledge(logger)
self.query_i = 0
def __init__(self,
X,
y=None,
model=None,
query_strategy=max_sampling,
train_data_fn=full_sample,
n_papers=None,
n_instances=DEFAULT_N_INSTANCES,
n_queries=None,
prior_included=[],
prior_excluded=[],
log_file=None,
fit_kwargs={},
balance_kwargs={},
query_kwargs={},
final_labels=None,
verbose=1):
super(BaseReview, self).__init__()
self.X = X
self.y = y
if y is None:
self.y = np.full(X.shape[0], NOT_AVAILABLE)
self.y = np.array(self.y, dtype=np.int)
# Default to Naive Bayes model
if model is None:
from asreview.models import create_nb_model
model = create_nb_model()
self.model = model
self.query_strategy = query_strategy
self.balance_strategy = train_data_fn
self.n_papers = n_papers
self.n_instances = n_instances
self.n_queries = n_queries
self.log_file = log_file
self.verbose = verbose
self.prior_included = prior_included
self.prior_excluded = prior_excluded
if prior_included is None:
self.prior_included = []
if prior_excluded is None:
self.prior_excluded = []
self.fit_kwargs = fit_kwargs
self.balance_kwargs = balance_kwargs
self.query_kwargs = query_kwargs
self.query_i = 0
self.train_idx = np.array([], dtype=np.int)
self.model_trained = False
self.query_kwargs["query_src"] = {}
self.query_kwargs["current_queries"] = {}
with open_logger(log_file) as logger:
if not logger.is_empty():
y, train_idx, query_src, query_i = logger.review_state()
self.y = y
self.train_idx = train_idx
self.query_kwargs["query_src"] = query_src
self.query_i = query_i
else:
if final_labels is not None:
logger.set_final_labels(final_labels)
logger.set_labels(self.y)
init_idx, init_labels = self._prior_knowledge()
self.query_i = 0
self.train_idx = np.array([], dtype=np.int)
self.classify(init_idx, init_labels, logger, method="initial")
# Initialize learner, but don't start training yet.
self.learner = ActiveLearner(
estimator=self.model,
query_strategy=self.query_strategy
)