def test_condition_polytomous_response(self):
"""Testing polytomous response conditioning."""
dataset = np.random.randint(1, 6, (15, 100))
dataset[7] = np.random.randint(1, 3, (1, 100))
output = condition_polytomous_response(dataset, trim_ends=False)
self.assertTupleEqual(output[0].shape, dataset.shape)
row_max_start = np.cumsum(dataset.max(axis=1))
row_max_end = row_max_start.copy() - 1
row_max_start = np.roll(row_max_start, 1)
row_max_start[0] = 0
for ndx in range(dataset.shape[0]):
otpts = np.unique(dataset[ndx])
otpts2 = np.unique(output[0][ndx])
self.assertEqual(otpts.size, output[1][ndx])
self.assertTrue(otpts2.min() == row_max_start[ndx])
self.assertTrue(otpts2.max() == row_max_end[ndx])
# Trim First Column but not last
dataset[:, 0] = 1
output = condition_polytomous_response(dataset, trim_ends=True)
self.assertTupleEqual(
output[0].shape, (dataset.shape[0], dataset.shape[1]-1))
self.assertTrue(output[0].std(axis=0)[0] != 0)
# Trim First/Last Column but not last
dataset[:, -1] = 1
output = condition_polytomous_response(dataset, trim_ends=True)
self.assertTupleEqual(
output[0].shape, (dataset.shape[0], dataset.shape[1]-2))
self.assertTrue(output[0].std(axis=0)[0] != 0)
self.assertTrue(output[0].std(axis=0)[-1] != 0)
def grm_mml_eap(dataset, options=None):
"""Estimate parameters for graded response model.
Estimate the discrimination and difficulty parameters for
a graded response model using a mixed Bayesian / Marginal Maximum
Likelihood algorithm, good for small sample sizes
Args:
dataset: [n_items, n_participants] 2d array of measured responses
options: dictionary with updates to default options
Returns:
results_dictionary:
* Discrimination: (1d array) estimate of item discriminations
* Difficulty: (2d array) estimates of item difficulties by item thresholds
* LatentPDF: (object) contains information about the pdf
* Rayleigh_Scale: (int) Rayleigh scale value of the discrimination prior
* AIC: (dictionary) null model and final model AIC value
* BIC: (dictionary) null model and final model BIC value
Options:
* estimate_distribution: Boolean
* number_of_samples: int >= 5
* max_iteration: int
* distribution: callable
* quadrature_bounds: (float, float)
* quadrature_n: int
* hyper_quadrature_n: int
"""
options = validate_estimation_options(options)
cpr_result = condition_polytomous_response(dataset, trim_ends=False)
responses, item_counts, valid_response_mask = cpr_result
invalid_response_mask = ~valid_response_mask
n_items = responses.shape[0]
# Only use LUT
_integral_func = _solve_integral_equations_LUT
_interp_func = create_beta_LUT((.15, 5.05, 500), (-6, 6, 500), options)
# Quadrature Locations
latent_pdf = LatentPDF(options)
theta = latent_pdf.quadrature_locations
# Compute the values needed for integral equations
integral_counts = list()
for ndx in range(n_items):
temp_output = _solve_for_constants(responses[ndx,
valid_response_mask[ndx]])
integral_counts.append(temp_output)
# Initialize difficulty parameters for estimation
betas = np.full((item_counts.sum(), ), -10000.0)
discrimination = np.ones_like(betas)
cumulative_item_counts = item_counts.cumsum()
start_indices = np.roll(cumulative_item_counts, 1)
start_indices[0] = 0
for ndx in range(n_items):
end_ndx = cumulative_item_counts[ndx]
start_ndx = start_indices[ndx] + 1
betas[start_ndx:end_ndx] = np.linspace(-1, 1, item_counts[ndx] - 1)
betas_roll = np.roll(betas, -1)
betas_roll[cumulative_item_counts - 1] = 10000
# Set invalid index to zero, this allows minimal
# changes for invalid data and it is corrected
# during integration
responses[invalid_response_mask] = 0
# Prior Parameters
ray_scale = 1.0
eap_options = {
'distribution': stats.rayleigh(loc=.25, scale=ray_scale).pdf,
'quadrature_n': options['hyper_quadrature_n'],
'quadrature_bounds': (0.25, 5)
}
prior_pdf = LatentPDF(eap_options)
alpha_evaluation = np.zeros((eap_options['quadrature_n'], ))
# Meta-Prior Parameter
hyper_options = {
'distribution': stats.lognorm(loc=0, s=0.25).pdf,
'quadrature_n': options['hyper_quadrature_n'],
'quadrature_bounds': (0.1, 5)
}
hyper_pdf = LatentPDF(hyper_options)
hyper_evaluation = np.zeros((hyper_options['quadrature_n'], ))
base_hyper = (hyper_pdf.weights *
hyper_pdf.null_distribution).astype('float128')
linear_hyper = base_hyper * hyper_pdf.quadrature_locations
for iteration in range(options['max_iteration']):
previous_discrimination = discrimination.copy()
previous_betas = betas.copy()
previous_betas_roll = betas_roll.copy()
# Quadrature evaluation for values that do not change
# This is done during the outer loop to address rounding errors
partial_int = np.ones((responses.shape[1], theta.size))
for item_ndx in range(n_items):
partial_int *= _graded_partial_integral(
theta, betas, betas_roll, discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
# Estimate the distribution if requested
distribution_x_weight = latent_pdf(partial_int, iteration)
partial_int *= distribution_x_weight
# Update the lookup table if necessary
if (options['estimate_distribution'] and iteration > 0):
new_options = dict(options)
new_options.update({'distribution': latent_pdf.cubic_splines[-1]})
_interp_func = create_beta_LUT((.15, 5.05, 500), (-6, 6, 500),
new_options)
# EAP Discrimination Parameter
discrimination_pdf = stats.rayleigh(loc=0.25, scale=ray_scale).pdf
base_alpha = (prior_pdf.weights * discrimination_pdf(
prior_pdf.quadrature_locations)).astype('float128')
linear_alpha = (base_alpha *
prior_pdf.quadrature_locations).astype('float128')
for item_ndx in range(n_items):
# pylint: disable=cell-var-from-loop
# Indices into linearized difficulty parameters
start_ndx = start_indices[item_ndx]
end_ndx = cumulative_item_counts[item_ndx]
old_values = _graded_partial_integral(
theta, previous_betas, previous_betas_roll,
previous_discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
partial_int /= old_values
def _local_min_func(estimate):
# Solve integrals for diffiulty estimates
new_betas = _integral_func(estimate, integral_counts[item_ndx],
distribution_x_weight, theta,
_interp_func)
betas[start_ndx + 1:end_ndx] = new_betas
betas_roll[start_ndx:end_ndx - 1] = new_betas
discrimination[start_ndx:end_ndx] = estimate
new_values = _graded_partial_integral(
theta, betas, betas_roll, discrimination,
responses[item_ndx], invalid_response_mask[item_ndx])
new_values *= partial_int
otpt = np.sum(new_values, axis=1)
return np.log(otpt.clip(1e-313, np.inf)).sum()
# Mean Discrimination Value
for ndx, disc_location in enumerate(
prior_pdf.quadrature_locations):
alpha_evaluation[ndx] = _local_min_func(disc_location)
alpha_evaluation -= alpha_evaluation.max()
total_probability = np.exp(alpha_evaluation.astype('float128'))
numerator = np.sum(total_probability * linear_alpha)
denominator = np.sum(total_probability * base_alpha)
alpha_eap = numerator / denominator
# Reset the Value the updated discrimination estimation
_local_min_func(alpha_eap.astype('float64'))
new_values = _graded_partial_integral(
theta, betas, betas_roll, discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
partial_int *= new_values
# Compute the Hyper prior mean value
for ndx, scale_value in enumerate(hyper_pdf.quadrature_locations):
temp_distribution = stats.rayleigh(loc=0.25, scale=scale_value).pdf
hyper_evaluation[ndx] = np.log(
temp_distribution(discrimination) + 1e-313).sum()
hyper_evaluation -= hyper_evaluation.max()
hyper_evaluation = np.exp(hyper_evaluation.astype('float128'))
ray_scale = (np.sum(hyper_evaluation * linear_hyper) /
np.sum(hyper_evaluation * base_hyper)).astype('float64')
# Check Termination Criterion
if np.abs(previous_discrimination - discrimination).max() < 1e-3:
break
# Recompute partial int for later calculations
partial_int = np.ones((responses.shape[1], theta.size))
for item_ndx in range(n_items):
partial_int *= _graded_partial_integral(
theta, betas, betas_roll, discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
# Trim difficulties to conform to standard output
# TODO: look where missing values are and place NAN there instead
# of appending them to the end
output_betas = np.full((n_items, item_counts.max() - 1), np.nan)
for ndx, (start_ndx,
end_ndx) in enumerate(zip(start_indices,
cumulative_item_counts)):
output_betas[ndx, :end_ndx - start_ndx - 1] = betas[start_ndx +
1:end_ndx]
# Compute statistics for final iteration
null_metrics = latent_pdf.compute_metrics(
partial_int, latent_pdf.null_distribution * latent_pdf.weights, 0)
full_metrics = latent_pdf.compute_metrics(partial_int,
distribution_x_weight,
latent_pdf.n_points - 3)
# Ability estimates
eap_abilities = _ability_eap_abstract(partial_int, distribution_x_weight,
theta)
return {
'Discrimination': discrimination[start_indices],
'Difficulty': output_betas,
'Ability': eap_abilities,
'LatentPDF': latent_pdf,
'Rayleigh_Scale': ray_scale,
'AIC': {
'final': full_metrics[0],
'null': null_metrics[0],
'delta': null_metrics[0] - full_metrics[0]
},
'BIC': {
'final': full_metrics[1],
'null': null_metrics[1],
'delta': null_metrics[1] - full_metrics[1]
}
}
def grm_mml(dataset, options=None):
"""Estimate parameters for graded response model.
Estimate the discrimination and difficulty parameters for
a graded response model using marginal maximum likelihood.
Args:
dataset: [n_items, n_participants] 2d array of measured responses
options: dictionary with updates to default options
Returns:
discrimination: (1d array) estimate of item discriminations
difficulty: (2d array) estimates of item diffiulties by item thresholds
Options:
* max_iteration: int
* distribution: callable
* quadrature_bounds: (float, float)
* quadrature_n: int
"""
options = validate_estimation_options(options)
quad_start, quad_stop = options['quadrature_bounds']
quad_n = options['quadrature_n']
responses, item_counts = condition_polytomous_response(dataset, trim_ends=False)
n_items = responses.shape[0]
# Interpolation Locations
theta = _get_quadrature_points(quad_n, quad_start, quad_stop)
distribution = options['distribution'](theta)
# Compute the values needed for integral equations
integral_counts = list()
for ndx in range(n_items):
temp_output = _solve_for_constants(responses[ndx])
integral_counts.append(temp_output)
# Initialize difficulty parameters for estimation
betas = np.full((item_counts.sum(),), -10000.0)
discrimination = np.ones_like(betas)
cumulative_item_counts = item_counts.cumsum()
start_indices = np.roll(cumulative_item_counts, 1)
start_indices[0] = 0
for ndx in range(n_items):
end_ndx = cumulative_item_counts[ndx]
start_ndx = start_indices[ndx] + 1
betas[start_ndx:end_ndx] = np.linspace(-1, 1,
item_counts[ndx] - 1)
betas_roll = np.roll(betas, -1)
betas_roll[cumulative_item_counts-1] = 10000
#############
# 1. Start the iteration loop
# 2. estimate discrimination
# 3. solve for difficulties
# 4. minimize and repeat
#############
for iteration in range(options['max_iteration']):
previous_discrimination = discrimination.copy()
previous_betas = betas.copy()
previous_betas_roll = betas_roll.copy()
# Quadrature evaluation for values that do not change
# This is done during the outer loop to address rounding errors
partial_int = _graded_partial_integral(theta, betas, betas_roll,
discrimination, responses)
partial_int *= distribution
for item_ndx in range(n_items):
# pylint: disable=cell-var-from-loop
# Indices into linearized difficulty parameters
start_ndx = start_indices[item_ndx]
end_ndx = cumulative_item_counts[item_ndx]
old_values = _graded_partial_integral(theta, previous_betas,
previous_betas_roll,
previous_discrimination,
responses[item_ndx][None, :])
partial_int /= old_values
def _local_min_func(estimate):
# Solve integrals for diffiulty estimates
new_betas = _solve_integral_equations(estimate,
integral_counts[item_ndx],
distribution,
theta)
betas[start_ndx+1:end_ndx] = new_betas
betas_roll[start_ndx:end_ndx-1] = new_betas
discrimination[start_ndx:end_ndx] = estimate
new_values = _graded_partial_integral(theta, betas, betas_roll,
discrimination,
responses[item_ndx][None, :])
new_values *= partial_int
otpt = integrate.fixed_quad(
lambda x: new_values, quad_start, quad_stop, n=quad_n)[0]
return -np.log(otpt).sum()
# Univariate minimization for discrimination parameter
fminbound(_local_min_func, 0.2, 5.0)
new_values = _graded_partial_integral(theta, betas, betas_roll,
discrimination,
responses[item_ndx][None, :])
partial_int *= new_values
if np.abs(previous_discrimination - discrimination).max() < 1e-3:
break
# Trim difficulties to conform to standard output
# TODO: look where missing values are and place NAN there instead
# of appending them to the end
output_betas = np.full((n_items, item_counts.max()-1), np.nan)
for ndx, (start_ndx, end_ndx) in enumerate(zip(start_indices, cumulative_item_counts)):
output_betas[ndx, :end_ndx-start_ndx-1] = betas[start_ndx+1:end_ndx]
return discrimination[start_indices], output_betas
def pcm_jml(dataset, options=None):
"""Estimate parameters for partial credit model.
Estimate the discrimination and difficulty parameters for
the partial credit model using joint maximum likelihood.
Args:
dataset: [n_items, n_participants] 2d array of measured responses
options: dictionary with updates to default options
Returns:
discrimination: (1d array) estimates of item discrimination
difficulty: (2d array) estimates of item difficulties x item thresholds
Options:
* max_iteration: int
"""
options = validate_estimation_options(options)
cpr_result = condition_polytomous_response(dataset, _reference=0.0)
responses, item_counts, valid_response_mask = cpr_result
invalid_response_mask = ~valid_response_mask
n_items, n_takers = responses.shape
# Set initial parameter estimates to default
thetas = np.zeros((n_takers, ))
# Initialize item parameters for iterations
discrimination = np.ones((n_items, ))
betas = np.full((n_items, item_counts.max() - 1), np.nan)
scratch = np.zeros((n_items, betas.shape[1] + 1))
for ndx in range(n_items):
item_length = item_counts[ndx] - 1
betas[ndx, :item_length] = np.linspace(-1, 1, item_length)
# Set invalid index to zero, this allows minimal
# changes for invalid data and it is corrected
# during integration
responses[invalid_response_mask] = 0
for iteration in range(options['max_iteration']):
previous_discrimination = discrimination.copy()
#####################
# STEP 1
# Estimate theta, given betas / alpha
# Loops over all persons
#####################
for ndx in range(n_takers):
# pylint: disable=cell-var-from-loop
response_set = responses[:, ndx]
def _theta_min(theta, scratch):
# Solves for ability parameters (theta)
# Graded PCM Model
scratch *= 0.
scratch[:, 1:] = theta - betas
scratch *= discrimination[:, None]
np.cumsum(scratch, axis=1, out=scratch)
np.exp(scratch, out=scratch)
scratch /= np.nansum(scratch, axis=1)[:, None]
# Probability associated with response
values = np.take_along_axis(scratch,
response_set[:, None],
axis=1).squeeze()
return -np.log(values[valid_response_mask[:, ndx]] +
1e-313).sum()
thetas[ndx] = fminbound(_theta_min, -6, 6, args=(scratch, ))
# Recenter theta to identify model
thetas -= thetas.mean()
thetas /= thetas.std(ddof=1)
#####################
# STEP 2
# Estimate Betas / alpha, given Theta
# Loops over all items
#####################
for ndx in range(n_items):
# pylint: disable=cell-var-from-loop
# Compute ML for static items
response_set = responses[ndx]
def _alpha_beta_min(estimates):
# PCM_Model
kernel = thetas[:, None] - estimates[None, :]
kernel *= estimates[0]
kernel[:, 0] = 0
np.cumsum(kernel, axis=1, out=kernel)
np.exp(kernel, out=kernel)
kernel /= np.nansum(kernel, axis=1)[:, None]
# Probability associated with response
values = np.take_along_axis(kernel,
response_set[:, None],
axis=1).squeeze()
return -np.log(values[valid_response_mask[ndx]]).sum()
# Solves jointly for parameters using numerical derivatives
initial_guess = np.concatenate(
([discrimination[ndx]], betas[ndx, :item_counts[ndx] - 1]))
otpt = fmin_slsqp(_alpha_beta_min,
initial_guess,
disp=False,
bounds=[(.25, 4)] + [(-6, 6)] *
(item_counts[ndx] - 1))
discrimination[ndx] = otpt[0]
betas[ndx, :item_counts[ndx] - 1] = otpt[1:]
# Check termination criterion
if (np.abs(previous_discrimination - discrimination).max() < 1e-3):
break
return {'Discrimination': discrimination, 'Difficulty': betas}
def grm_jml(dataset, options=None):
"""Estimate parameters for graded response model.
Estimate the discrimination and difficulty parameters for
a graded response model using joint maximum likelihood.
Args:
dataset: [n_items, n_participants] 2d array of measured responses
options: dictionary with updates to default options
Returns:
discrimination: (1d array) estimate of item discriminations
difficulty: (2d array) estimates of item diffiulties by item thresholds
Options:
* max_iteration: int
"""
options = validate_estimation_options(options)
cpr_result = condition_polytomous_response(dataset)
responses, item_counts, valid_response_mask = cpr_result
invalid_response_mask = ~valid_response_mask
n_items, n_takers = responses.shape
# Set initial parameter estimates to default
thetas = np.zeros((n_takers, ))
# Initialize difficulty parameters for iterations
betas = np.full((item_counts.sum(), ), -10000.0)
discrimination = np.ones_like(betas)
cumulative_item_counts = item_counts.cumsum()
start_indices = np.roll(cumulative_item_counts, 1)
start_indices[0] = 0
for ndx in range(n_items):
end_ndx = cumulative_item_counts[ndx]
start_ndx = start_indices[ndx] + 1
betas[start_ndx:end_ndx] = np.linspace(-1, 1, item_counts[ndx] - 1)
betas_roll = np.roll(betas, -1)
betas_roll[cumulative_item_counts - 1] = 10000
# Set invalid index to zero, this allows minimal
# changes for invalid data and it is corrected
# during integration
responses[invalid_response_mask] = 0
for iteration in range(options['max_iteration']):
previous_betas = betas.copy()
#####################
# STEP 1
# Estimate theta, given betas / alpha
# Loops over all persons
#####################
for ndx in range(n_takers):
def _theta_min(theta):
# Solves for ability parameters (theta)
graded_prob = (
irt_evaluation(betas, discrimination, theta) -
irt_evaluation(betas_roll, discrimination, theta))
values = graded_prob[responses[:, ndx]]
return -np.log(values[valid_response_mask[:, ndx]] +
1e-313).sum()
thetas[ndx] = fminbound(_theta_min, -6, 6)
# Recenter theta to identify model
thetas -= thetas.mean()
thetas /= thetas.std(ddof=1)
#####################
# STEP 2
# Estimate Betas / alpha, given Theta
# Loops over all items
#####################
for ndx in range(n_items):
# pylint: disable=cell-var-from-loop
# Compute ML for static items
start_ndx = start_indices[ndx]
end_ndx = cumulative_item_counts[ndx]
def _alpha_beta_min(estimates):
# Set the estimates int
discrimination[start_ndx:end_ndx] = estimates[0]
betas[start_ndx + 1:end_ndx] = estimates[1:]
betas_roll[start_ndx:end_ndx - 1] = estimates[1:]
graded_prob = (
irt_evaluation(betas, discrimination, thetas) -
irt_evaluation(betas_roll, discrimination, thetas))
values = np.take_along_axis(graded_prob,
responses[None, ndx],
axis=0).squeeze()
np.clip(values, 1e-23, np.inf, out=values)
return -np.log(values[valid_response_mask[ndx]]).sum()
# Solves jointly for parameters using numerical derivatives
initial_guess = np.concatenate(
([discrimination[start_ndx]], betas[start_ndx + 1:end_ndx]))
otpt = fmin_slsqp(_alpha_beta_min,
initial_guess,
disp=False,
f_ieqcons=_jml_inequality,
bounds=[(.25, 4)] + [(-6, 6)] *
(item_counts[ndx] - 1))
discrimination[start_ndx:end_ndx] = otpt[0]
betas[start_ndx + 1:end_ndx] = otpt[1:]
betas_roll[start_ndx:end_ndx - 1] = otpt[1:]
# Check termination criterion
if (np.abs(previous_betas - betas).max() < 1e-3):
break
# Trim difficulties to conform to standard output
# TODO: look where missing values are and place NAN there instead
# of appending them to the end
output_betas = np.full((n_items, item_counts.max() - 1), np.nan)
for ndx, (start_ndx,
end_ndx) in enumerate(zip(start_indices,
cumulative_item_counts)):
output_betas[ndx, :end_ndx - start_ndx - 1] = betas[start_ndx +
1:end_ndx]
return {
'Discrimination': discrimination[start_indices],
'Difficulty': output_betas
}
def grm_mml(dataset, options=None):
"""Estimate parameters for graded response model.
Estimate the discrimination and difficulty parameters for
a graded response model using marginal maximum likelihood.
Args:
dataset: [n_items, n_participants] 2d array of measured responses
options: dictionary with updates to default options
Returns:
results_dictionary:
* Discrimination: (1d array) estimate of item discriminations
* Difficulty: (2d array) estimates of item diffiulties by item thresholds
* LatentPDF: (object) contains information about the pdf
* AIC: (dictionary) null model and final model AIC value
* BIC: (dictionary) null model and final model BIC value
Options:
* estimate_distribution: Boolean
* number_of_samples: int >= 5
* use_LUT: boolean
* max_iteration: int
* distribution: callable
* quadrature_bounds: (float, float)
* quadrature_n: int
"""
options = validate_estimation_options(options)
cpr_result = condition_polytomous_response(dataset, trim_ends=False)
responses, item_counts, valid_response_mask = cpr_result
invalid_response_mask = ~valid_response_mask
n_items = responses.shape[0]
# Should we use the LUT
_integral_func = _solve_integral_equations
_interp_func = None
if options['use_LUT']:
_integral_func = _solve_integral_equations_LUT
_interp_func = create_beta_LUT((.15, 5.05, 500), (-6, 6, 500), options)
# Quadrature Locations
latent_pdf = LatentPDF(options)
theta = latent_pdf.quadrature_locations
# Compute the values needed for integral equations
integral_counts = list()
for ndx in range(n_items):
temp_output = _solve_for_constants(responses[ndx,
valid_response_mask[ndx]])
integral_counts.append(temp_output)
# Initialize difficulty parameters for estimation
betas = np.full((item_counts.sum(), ), -10000.0)
discrimination = np.ones_like(betas)
cumulative_item_counts = item_counts.cumsum()
start_indices = np.roll(cumulative_item_counts, 1)
start_indices[0] = 0
for ndx in range(n_items):
end_ndx = cumulative_item_counts[ndx]
start_ndx = start_indices[ndx] + 1
betas[start_ndx:end_ndx] = np.linspace(-1, 1, item_counts[ndx] - 1)
betas_roll = np.roll(betas, -1)
betas_roll[cumulative_item_counts - 1] = 10000
# Set invalid index to zero, this allows minimal
# changes for invalid data and it is corrected
# during integration
responses[invalid_response_mask] = 0
#############
# 1. Start the iteration loop
# 2. estimate discrimination
# 3. solve for difficulties
# 4. minimize and repeat
#############
for iteration in range(options['max_iteration']):
previous_discrimination = discrimination.copy()
previous_betas = betas.copy()
previous_betas_roll = betas_roll.copy()
# Quadrature evaluation for values that do not change
# This is done during the outer loop to address rounding errors
partial_int = np.ones((responses.shape[1], theta.size))
for item_ndx in range(n_items):
partial_int *= _graded_partial_integral(
theta, betas, betas_roll, discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
# Estimate the distribution if requested
distribution_x_weight = latent_pdf(partial_int, iteration)
partial_int *= distribution_x_weight
# Update the lookup table if necessary
if (options['use_LUT'] and options['estimate_distribution']
and iteration > 0):
new_options = dict(options)
new_options.update({'distribution': latent_pdf.cubic_splines[-1]})
_interp_func = create_beta_LUT((.15, 5.05, 500), (-6, 6, 500),
new_options)
for item_ndx in range(n_items):
# pylint: disable=cell-var-from-loop
# Indices into linearized difficulty parameters
start_ndx = start_indices[item_ndx]
end_ndx = cumulative_item_counts[item_ndx]
old_values = _graded_partial_integral(
theta, previous_betas, previous_betas_roll,
previous_discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
partial_int /= old_values
def _local_min_func(estimate):
# Solve integrals for diffiulty estimates
new_betas = _integral_func(estimate, integral_counts[item_ndx],
distribution_x_weight, theta,
_interp_func)
betas[start_ndx + 1:end_ndx] = new_betas
betas_roll[start_ndx:end_ndx - 1] = new_betas
discrimination[start_ndx:end_ndx] = estimate
new_values = _graded_partial_integral(
theta, betas, betas_roll, discrimination,
responses[item_ndx], invalid_response_mask[item_ndx])
new_values *= partial_int
otpt = np.sum(new_values, axis=1)
return -np.log(otpt).sum()
# Univariate minimization for discrimination parameter
fminbound(_local_min_func, 0.2, 5.0)
new_values = _graded_partial_integral(
theta, betas, betas_roll, discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
partial_int *= new_values
if np.abs(previous_discrimination - discrimination).max() < 1e-3:
break
# Recompute partial int for later calculations
partial_int = np.ones((responses.shape[1], theta.size))
for item_ndx in range(n_items):
partial_int *= _graded_partial_integral(
theta, betas, betas_roll, discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
# Trim difficulties to conform to standard output
# TODO: look where missing values are and place NAN there instead
# of appending them to the end
output_betas = np.full((n_items, item_counts.max() - 1), np.nan)
for ndx, (start_ndx,
end_ndx) in enumerate(zip(start_indices,
cumulative_item_counts)):
output_betas[ndx, :end_ndx - start_ndx - 1] = betas[start_ndx +
1:end_ndx]
# Compute statistics for final iteration
null_metrics = latent_pdf.compute_metrics(
partial_int, latent_pdf.null_distribution * latent_pdf.weights, 0)
full_metrics = latent_pdf.compute_metrics(partial_int,
distribution_x_weight,
latent_pdf.n_points - 3)
# Ability estimates
eap_abilities = _ability_eap_abstract(partial_int, distribution_x_weight,
theta)
return {
'Discrimination': discrimination[start_indices],
'Difficulty': output_betas,
'Ability': eap_abilities,
'LatentPDF': latent_pdf,
'AIC': {
'final': full_metrics[0],
'null': null_metrics[0],
'delta': null_metrics[0] - full_metrics[0]
},
'BIC': {
'final': full_metrics[1],
'null': null_metrics[1],
'delta': null_metrics[1] - full_metrics[1]
}
}