proso.models package

Submodules

proso.models.environment module

class proso.models.environment.CommonEnvironment

Bases: proso.models.environment.Environment

add_write_hook(write_hook)

call_write_hooks(key, value, user, item, item_secondary, time, previous_value, answer)

confusing_factor(item, item_secondary, user=None)

confusing_factor_more_items(item, items, user=None)

last_answer_time(user=None, item=None, context=None)

last_answer_time_more_items(items, user=None)

number_of_answers(user=None, item=None, context=None)

number_of_answers_more_items(items, user=None)

number_of_correct_answers(user=None, item=None, context=None)

number_of_correct_answers_more_items(user=None, item=None)

number_of_first_answers(user=None, item=None, context=None)

number_of_first_answers_more_items(items, user=None)

rolling_success(user, window_size=10)

class proso.models.environment.Environment

Bases: object

This class encapsulates environment for the purpose of modelling.

add_write_hook(write_hook)

audit(key, user=None, item=None, item_secondary=None, limit=None, symmetric=True)

delete(key, user=None, item=None, item_secondary=None, symmetric=True)

export_audit()

export_values()

flush()

This method is called to enforce persistence of the data. This is useful mainly for interaction with database where it is not efficient to touch database for each answer. When your environment is only an in memery implementation, you can leave this method as it is.

get_items_with_values(key, item, user=None)

get_items_with_values_more_items(key, items, user=None)

process_answer(user, item, asked, answered, time, answer, response_time, guess, **kwargs)

This method is used during the answer streaming and is called after the predictive model for each answer.

Parameters:

• user (int) – identifier of ther user answering the question
• asked (int) – identifier of the asked item
• answered (int) – identifier of the answered item or None if the user answered “I don’t know”
• response_time (int) – time the answer took in milliseconds
• time (datetime.datetime) – time when the user answered the question
• guess (float) – probability of correct response in case of random answer

read(key, user=None, item=None, item_secondary=None, default=None, symmetric=True)

read_all_with_key(key)

read_more_items(key, items, user=None, item=None, default=None, symmetric=True)

read_more_keys(keys, user=None, item=None, item_secondary=None, default=None, symmetric=True)

time(key, user=None, item=None, item_secondary=None, symmetric=True)

time_more_items(key, items, user=None, item=None, symmetric=True)

update(key, init_value, update_fun, user=None, item=None, item_secondary=None, time=None, audit=True, symmetric=True, answer=None)

write(key, value, user=None, item=None, item_secondary=None, time=None, audit=True, symmetric=True, permanent=True, answer=None)

class proso.models.environment.EnvironmentWriteHook

Bases: object

event(key, value, user, item, item_secondary, time, previous_value, answer)

class proso.models.environment.InMemoryEnvironment(audit_enabled=True)

Bases: proso.models.environment.CommonEnvironment

CONFUSING_FACTOR = 'confusing_factor'

LAST_CORRECTNESS = 'last_correctness'

NUMBER_OF_ANSWERS = 'number_of_answers'

NUMBER_OF_CORRECT_ANSWERS = 'number_of_correct_answers'

NUMBER_OF_FIRST_ANSWERS = 'number_of_first_answers'

audit(key, user=None, item=None, item_secondary=None, limit=None, symmetric=True)

confusing_factor(item, item_secondary, user=None)

confusing_factor_more_items(item, items, user=None)

delete(key, user=None, item=None, item_secondary=None, symmetric=True)

export_audit()

export_values()

get_items_with_values(key, item, user=None)

get_items_with_values_more_items(key, items, user=None)

last_answer_time(user=None, item=None, context=None)

last_answer_time_more_items(items, user=None)

number_of_answers(user=None, item=None, context=None)

number_of_answers_more_items(items, user=None)

number_of_correct_answers(user=None, item=None, context=None)

number_of_correct_answers_more_items(items, user=None)

number_of_first_answers(user=None, item=None, context=None)

number_of_first_answers_more_items(items, user=None)

process_answer(user, item, asked, answered, time, answer, response_time, guess, **kwargs)

read(key, user=None, item=None, item_secondary=None, default=None, symmetric=True)

read_all_with_key(key)

read_more_items(key, items, user=None, item=None, default=None, symmetric=True)

read_more_keys(keys, user=None, item=None, item_secondary=None, default=None, symmetric=True)

rolling_success(user, window_size=10, context=None)

time(key, user=None, item=None, item_secondary=None, symmetric=True)

time_more_items(key, items, user=None, item=None, symmetric=True)

write(key, value, user=None, item=None, item_secondary=None, time=None, audit=True, symmetric=True, permanent=False, answer=None)

class proso.models.environment.TestCommonEnvironment(methodName='runTest')

Bases: proso.models.environment.TestEnvironment

test_confusing_factor()

test_get_items_with_values()

test_get_items_with_values_more_items()

test_last_answer_time()

test_number_of_answers()

test_number_of_correct_answers()

test_number_of_first_answers()

test_rolling_success()

test_symmetry()

test_time()

class proso.models.environment.TestEnvironment(methodName='runTest')

Bases: unittest.case.TestCase

generate_answer_id()

generate_environment()

generate_item()

generate_user()

test_audit()

test_permanent()

test_read_all_with_key()

test_read_more_items()

test_read_more_keys()

test_write_and_read()

test_write_hook()

proso.models.item_selection module

class proso.models.item_selection.ItemSelection(predictive_model, target_probability=0.65, history_adjustment=True)

Bases: object

get_predictions(environment, user=None, items=None, time=None)

get_rolling_success(environment, user, practice_context=None)

get_target_probability(environment, user, practice_context=None)

history_adjustment()

select(environment, user, items, time, practice_context, n, **kwargs)

Returns a list of items chosen to practice and a list of JSONs (or Nones) providing meta info about the selection.

class proso.models.item_selection.RandomItemSelection(predictive_model, target_probability=0.65, history_adjustment=True)

Bases: proso.models.item_selection.ItemSelection

select(environment, user, items, time, practice_context, n, **kwargs)

class proso.models.item_selection.ScoreItemSelection(predictive_model, weight_probability=10.0, weight_number_of_answers=5.0, weight_time_ago=5, weight_parent_time_ago=5.0, weight_parent_number_of_answers=2.5, target_probability=0.65, time_ago_max=120, recompute_parent_score=True, history_adjustment=True, estimate_parent_factors=True)

Bases: proso.models.item_selection.ItemSelection

select(environment, user, items, time, practice_context, n, **kwargs)

class proso.models.item_selection.TestWrapperItemSelection(item_selector, nth=10)

Bases: proso.models.item_selection.ItemSelection

get_predictions(environment, user=None, items=None, time=None)

get_rolling_success(environment, user, practice_context=None)

get_target_probability(environment, user, practice_context=None)

history_adjustment()

select(environment, user, items, time, practice_context, n, **kwargs)

proso.models.item_selection.adjust_target_probability(target_probability, rolling_success)

proso.models.option_selection module

class proso.models.option_selection.AdjustedOptionSelection(item_selector, options_number, **kwargs)

Bases: proso.models.option_selection.OptionSelection

adjust_to_level(level, x, op, median)

compute_options(target_probability, prediction, number_of_options, confusing_factors)

class proso.models.option_selection.AdjustedOptionsNumber(max_options=6, allow_zero_options_restriction=True)

Bases: proso.models.option_selection.OptionsNumber

compute_number_of_options(target_probability, prediction)

class proso.models.option_selection.CompetitiveOptionSelection(item_selector, options_number, **kwargs)

Bases: proso.models.option_selection.OptionSelection

compute_options(target_probability, prediction, number_of_options, confusing_factors)

class proso.models.option_selection.ConstantOptionsNumber(number_of_options, max_options=6, allow_zero_options_restriction=True)

Bases: proso.models.option_selection.OptionsNumber

compute_number_of_options(target_probability, prediction)

class proso.models.option_selection.FullyRandomOptionsNumber(max_options=6, allow_zero_options_restriction=True)

Bases: proso.models.option_selection.OptionsNumber

compute_number_of_options(target_probability, prediction)

class proso.models.option_selection.OptionSelection(item_selector, options_number, **kwargs)

Bases: object

compute_options(target_probability, prediction, number_of_options, confusing_factors)

item_selector()

options_number()

select_options(environment, user, item, time, options, allow_zero_options=True, **kwargs)

select_options_more_items(environment, user, items, time, options, allow_zero_options=None, **kwargs)

class proso.models.option_selection.OptionsNumber(max_options=6, allow_zero_options_restriction=True)

Bases: object

compute_number_of_options(target_probability, prediction)

get_max_options()

get_number_of_options(target_probability, prediction, allow_zero_options, options_available)

is_zero_options_restriction_allowed()

class proso.models.option_selection.PartiallyConstantOptionsNumber(number_of_options, max_options=6, allow_zero_options_restriction=True)

Bases: proso.models.option_selection.OptionsNumber

compute_number_of_options(target_probability, prediction)

class proso.models.option_selection.PartiallyRandomOptionsNumber(max_options=6, allow_zero_options_restriction=True)

Bases: proso.models.option_selection.OptionsNumber

compute_number_of_options(target_probability, prediction)

class proso.models.option_selection.RandomOptionSelection(item_selector, options_number, **kwargs)

Bases: proso.models.option_selection.OptionSelection

compute_options(target_probability, prediction, number_of_options, confusing_factors)

class proso.models.option_selection.TestOptionSelection(methodName='runTest')

Bases: unittest.case.TestCase

get_item_selector(target_probability)

get_option_selector(item_selector, options_number)

test_compute_options()

class proso.models.option_selection.TestOptionsNumber(methodName='runTest')

Bases: unittest.case.TestCase

get_options_number(max_options, allow_zero_options_restriction)

test_number_of_options()

class proso.models.option_selection.UniformlyAdjustedOptionsNumber(max_options=6, allow_zero_options_restriction=True)

Bases: proso.models.option_selection.OptionsNumber

compute_number_of_options(target_probability, prediction)

class proso.models.option_selection.ZeroOptionsNumber(max_options=6, allow_zero_options_restriction=True)

Bases: proso.models.option_selection.OptionsNumber

compute_number_of_options(target_probability, prediction)

proso.models.prediction module

class proso.models.prediction.AlwaysLearningPredictiveModel(pfae_good=1.0, pfae_bad=0.5, elo_alpha=0.8, elo_dynamic_alpha=0.05)

Bases: proso.models.prediction.PredictiveModel

predict_phase(data, user, item, time, **kwargs)

predict_phase_more_items(data, user, items, time, **kwargs)

prepare_phase(environment, user, item, time, **kwargs)

prepare_phase_more_items(environment, user, items, time, **kwargs)

update_phase(environment, data, prediction, user, item, correct, time, answer_id, **kwargs)

class proso.models.prediction.AveragePredictiveModel

Bases: proso.models.prediction.PredictiveModel

predict_phase(data, user, item, time, **kwargs)

predict_phase_more_items(data, user, items, time, **kwargs)

prepare_phase(environment, user, item, time, **kwargs)

prepare_phase_more_items(environment, user, items, time, **kwargs)

update_phase(environment, data, prediction, user, item, correct, time, answer_id, **kwargs)

class proso.models.prediction.PFAEStaircase(pfae_good=1.8, pfae_bad=0.8, elo_alpha=0.8, elo_dynamic_alpha=0.05, staircase_size=20, staircase_base=60)

Bases: proso.models.prediction.PredictiveModel

predict_phase(data, user, item, time, **kwargs)

predict_phase_more_items(data, user, items, time, **kwargs)

prepare_phase(environment, user, item, time, **kwargs)

prepare_phase_more_items(environment, user, items, time, **kwargs)

update_phase(environment, data, prediction, user, item, correct, time, answer_id, **kwargs)

class proso.models.prediction.PredictiveModel

Bases: object

This class handles the logic behind the predictive models, which is divided into 3 phases:

• prepare: the model loads the necessary data from the environment
• predict: the model uses the loaded data to predict the correctness of the answer
• update: the model updates environment to persist it for the future prediction

predict(environment, user, item, time, **kwargs)

predict_and_update(environment, user, item, correct, time, answer_id, **kwargs)

predict_more_items(environment, user, items, time, **kwargs)

predict_phase(data, user, item, time, **kwargs)

Uses the data from prepare phase and tries to predict the probability of the correct answer. That means the prediction for the user and the asked item before the given answer is processed.

Parameters:

• data (object) – data from the prepare phase
• user (int) – identifier of the user answering the question
• item (int) – identifier of the question item
• time (datetime.datetime) – datetime when the question is asked
• kwargs – used for other information about the question

Returns:

the number from [0, 1] representing the probability of the correct answer

Return type:

float

predict_phase_more_items(data, user, items, time, **kwargs)

prepare_phase(environment, user, item, time, **kwargs)

In this phase, the predictive model touches the environment, loads all necessary data and returns it.

Parameters:

• environment (proso.models.environment.Environment) – environment where all the important data are persist
• user (int) – identifier of the user answering the question
• item (int) – identifier of the question item
• time (datetime.datetime) – datetime when the question is asked
• kwargs – used for other information about the question

Returns:

object

prepare_phase_more_items(environment, user, items, time, **kwargs)

update_phase(environment, data, prediction, user, item, correct, time, answer_id, **kwargs)

After the prediction update the environment and persist some information for the predictive model.

Parameters:

• environment (proso.models.environment.Environment) – environment where all the important data are persist
• data (object) – data from the prepare phase
• user (int) – identifier of the user answering the question
• item (int) – identifier of the question item
• correct (bool) – corretness of the answer

class proso.models.prediction.PriorCurrentPredictiveModel(time_shift=80.0, pfae_good=3.4, pfae_bad=0.3, elo_alpha=0.8, elo_dynamic_alpha=0.05)

Bases: proso.models.prediction.PredictiveModel

predict_phase(data, user, item, time, **kwargs)

predict_phase_more_items(data, user, items, time, **kwargs)

prepare_phase(environment, user, item, time, **kwargs)

prepare_phase_more_items(environment, user, items, time, **kwargs)

update_phase(environment, data, prediction, user, item, correct, time, answer_id, **kwargs)

class proso.models.prediction.ShiftedPredictiveModel(predictive_model, prediction_shift)

Bases: proso.models.prediction.PredictiveModel

predict(environment, user, item, time, **kwargs)

predict_and_update(environment, user, item, correct, time, **kwargs)

predict_more_items(environment, user, items, time, **kwargs)

predict_phase(data, user, item, time, **kwargs)

predict_phase_more_items(data, user, items, time, **kwargs)

prepare_phase(environment, user, item, time, **kwargs)

prepare_phase_more_items(environment, user, items, time, **kwargs)

update_phase(environment, data, prediction, user, item, correct, time, answer_id, **kwargs)

class proso.models.prediction.SimplePredictiveModel

Bases: proso.models.prediction.PredictiveModel

Predictive model which doesn’t force you to use environment.

predict_phase(data, user, item, time, **kwargs)

predict_phase_more_items(data, user, items, time, **kwargs)

prepare_phase(environment, user, item, time, **kwargs)

prepare_phase_more_items(environment, user, items, time, **kwargs)

simple_predict(user, item, time, **kwargs)

simple_update(prediction, user, item, correct, time, **kwargs)

update_phase(environment, data, prediction, user, item, correct, time, answer_id, **kwargs)

proso.models.prediction.predict(skill_asked, option_skills)

Returns the probability of correct answer.

Parameters:

• skill_asked (float) – number representing a knowledge of the given user for the asked item
• option_skills ([float]) – list of numbers representing a knowledge for the options

Returns:

probability of the correct answer for the asked item and the probabilities for the options they will be answered instead of the asked item

Return type:

(float, [float])

proso.models.prediction.predict_simple(skill_asked, number_of_options=None, guess=None)

Module contents