def run(self, data, coefficients, resources=None): """ Like linear_utilities, but in addition it runs linear utilities for modified data and stores utilities when each variable is set to its 5%, 95% quantiles, keeping the other variables at their median. Last row in the resulting file is the difference in utilities between these two. The file name can be passed in resources - entry 'utilities_diagnose_file'. """ if data.ndim < 3: raise StandardError, "Argument 'data' must be a 3D numpy array." if not isinstance(resources, Resources): resources= Resources(resources) nobs, neqs, nvar = data.shape medians = zeros(nvar, dtype=float32) quant = zeros((2,nvar), dtype=float32) data_with_medians = array(data[0,:,:]) for ivar in range(nvar): # compute medain and quantiles for each variable medians[ivar], quant[0,ivar], quant[1,ivar] = quantile(data[:,:,ivar].ravel(), array([0.5, 0.05, 0.95])) data_with_medians[:,ivar] = medians[ivar] file_name = resources.get("utilities_diagnose_file", "util") if resources.get("submodel", None) is not None: file_name = "%s_submodel_%s" % (file_name, resources.get("submodel", 1)) diagnose_utilities = zeros((3, nvar), dtype=float32) argcor = () for ivar in range(nvar): # iterate over variables for iquant in [0,1]: # 0 for 5% quantile, 1 for 95% quantile mod_data = array(data_with_medians).reshape(1,neqs, nvar) # copy original data mod_data[0,:,ivar] = quant[iquant, ivar] utility = linear_utilities.run(self, mod_data, coefficients, resources) diagnose_utilities[iquant, ivar] = utility[0,0] argcor = argcor + (data[:,:,ivar].ravel(),) diagnose_utilities[2,:] = diagnose_utilities[1,:] - diagnose_utilities[0,:] coef_names = resources.get("coefficient_names", map(lambda x: 'x%s' % x, arange(nvar)+1)) #write_to_text_file(file_name, coef_names, delimiter=' ') #write_table_to_text_file( file_name, diagnose_utilities, mode='ab') logger.log_status("Diagnosed utilities written into %s." % file_name) return linear_utilities.run(self, data, coefficients, resources)
def run(self, data, coefficients, resources=None): """ 'data' is a 4D numpy array (nobservations x nequations x ncoefficients x number of nests) and it can be created by InteractionDataset.create_logit_data(...). 'coefficients' is either a 1D array (ncoefficients + number of nests) used for estimating, or a 3D array (nequations x nvariables x number of nests) used for simulating. In the former case, the additional elements (number of nests) contain additional parameters (not used in the utility computation, such as scaling parameters). In the latter case, the additional parameters are extracted from the array. They correspond to variables called '__logsum'. The method returns a tuple (u, mu) where u is a 2D array of utilities (nobservations x number of elemental alternatives). mu is an array of additional parameters from the coefficient arrays not used in the utility computation. The method calls its parent's run method (class lineear_utilities) for each nest. The class can be paired with the probabilities class opus_core.nl_probabilities. """ nobs, nalts, nvars, M = data.shape result = zeros((nobs, nalts)) addpar = zeros(M) if coefficients.ndim > 2: coef_object = resources.get('specified_coefficients', None) for nest in range(M): d = data[:, :, :, nest] if coefficients.ndim == 1: coef = coefficients[0:nvars] addpar[nest] = coefficients[nvars + nest] elif coefficients.ndim == 3: idx_logsum = where( array(coef_object.get_variable_names()) == '__logsum')[0] coef = coefficients[:, :, nest] filter = ones(coef.shape[1], dtype='bool8') filter[idx_logsum] = False coef = coef.compress(filter, axis=1) d = d.compress(filter, axis=2) addpar[nest] = coefficients[:, idx_logsum, nest].sum() else: raise StandardError, "Coefficients have wrong dimension." u = linear_utilities.run(self, d, coef, resources) result = result + u return (result, addpar)
def run(self, data, coefficients, resources=None): """ 'data' is a 4D numpy array (nobservations x nequations x ncoefficients x number of nests) and it can be created by InteractionDataset.create_logit_data(...). 'coefficients' is either a 1D array (ncoefficients + number of nests) used for estimating, or a 3D array (nequations x nvariables x number of nests) used for simulating. In the former case, the additional elements (number of nests) contain additional parameters (not used in the utility computation, such as scaling parameters). In the latter case, the additional parameters are extracted from the array. They correspond to variables called '__logsum'. The method returns a tuple (u, mu) where u is a 2D array of utilities (nobservations x number of elemental alternatives). mu is an array of additional parameters from the coefficient arrays not used in the utility computation. The method calls its parent's run method (class lineear_utilities) for each nest. The class can be paired with the probabilities class opus_core.nl_probabilities. """ nobs, nalts, nvars, M = data.shape result = zeros((nobs, nalts)) addpar = zeros(M) if coefficients.ndim > 2: coef_object = resources.get('specified_coefficients', None) for nest in range(M): d=data[:,:,:,nest] if coefficients.ndim == 1: coef = coefficients[0:nvars] addpar[nest] = coefficients[nvars+nest] elif coefficients.ndim == 3: idx_logsum = where(array(coef_object.get_variable_names()) == '__logsum')[0] coef = coefficients[:,:,nest] filter = ones(coef.shape[1], dtype='bool8') filter[idx_logsum]= False coef = coef.compress(filter, axis=1) d = d.compress(filter, axis=2) addpar[nest] = coefficients[:,idx_logsum, nest].sum() else: raise StandardError, "Coefficients have wrong dimension." u = linear_utilities.run(self, d, coef, resources) result = result+u return (result, addpar)