def ri2py_listvector(obj): if 'data.frame' in obj.rclass: items = zip(obj.do_slot('names'), (numpy2ri.ri2py(x) for x in obj)) res = PandasDataFrame.from_items(items) else: res = numpy2ri.ri2py(obj) return res
def ri2py_dataframe(obj): # use the numpy converter recarray = numpy2ri.ri2py(obj) try: idx = numpy2ri.ri2py(obj.do_slot('row.names')) except LookupError as le: idx = None res = PandasDataFrame.from_records(recarray, index=idx) return res
def pval_grenander_fit(pvals): fdrtool = importr('fdrtool') pval_vec = ro.FloatVector(pvals) pval_ecdf = ecdf_pkg.ecdf_pval(pval_vec) gre_fit = fdrtool.grenander(pval_ecdf, type='decreasing') x_knots = rpyn.ri2py(gre_fit.rx2('x.knots')) f_knots = rpyn.ri2py(gre_fit.rx2('f.knots')) if len(f_knots) == 0: x_knots = np.array([0, 1]) f_knots = np.array([1, 1]) assert len(f_knots) == len(x_knots) return x_knots, f_knots
def predict(self, X, eval_MSE=False): """ X should be a dataframe """ X = self._check_X(X) _ = self.pkg.predict_randomForest(self.rf, X, predict_all=eval_MSE) if eval_MSE: y_hat = numpy2ri.ri2py(_[0]) mse = std(numpy2ri.ri2py(_[1]), axis=1, ddof=1) ** 2. return y_hat, mse else: return numpy2ri.ri2py(_)
def r_spectrum(signal, r_periodogram): filtered_signal = detrend(signal, type='linear') filtered_signal = recursive_filter_function(filtered_signal) filtered_signal = demean(filtered_signal) res = r_periodogram(numpy2ri.numpy2ri(filtered_signal), pad=0.3, tap=0.3, span=2, plot=False, detrend=True, demean=True) freq = numpy2ri.ri2py(res.rx2('freq')) psd = numpy2ri.ri2py(res.rx2('spec')) return 1 / freq, psd
def _infer_network(self, data): """ Infer the network. Args: data (pd.DataFrame): data to be used for the inference. """ # activate implicit conversion from pandas to R objects pandas2ri.activate() genie3 = importr('GENIE3') importr('foreach') importr('doParallel') # transform pandas dataframe into GENIE3 input format globalenv['r_matrix'] = numpy2ri.py2ri(data.T.values) globalenv['r_rows'] = data.columns globalenv['r_cols'] = data.index r(''' rownames(r_matrix) <- c(r_rows) colnames(r_matrix) <- c(r_cols) ''') expr_matrix = globalenv['r_matrix'] # run GENIE3 values = numpy2ri.ri2py( genie3.GENIE3(expr_matrix, self.regulators, self.targets, self.tree_method, self.k, self.n_trees, self.n_cores, self.verbose)) weight_matrix = pd.DataFrame(values, columns=data.columns, index=data.columns) self.graph = Graph(adjacency=weight_matrix) logger.debug('inferred with {}'.format(self.method))
def _pr_rc_curve_r(observations, predictions, FDRth=0.05): """ :param observations: known truth set :param predictions: all data :param FDRth: :return: """ obs_rtbl = numpy2ri.py2ri(observations) prd_rtbl = numpy2ri.py2ri(predictions) curve_prm = {'scores.class0': prd_rtbl, 'weights.class0': obs_rtbl, 'curve': True, 'sorted': True} prc = PRROC.pr_curve(**curve_prm) auc = prc.rx2('auc.integral')[0] curve = numpy2ri.ri2py(prc.rx2('curve')) cols = ['recall', 'precision', 'threshold'] df = pd.DataFrame(curve, columns=cols) FDR5percTh = - (df[df.precision >= (1 - FDRth)])['threshold'].min() if not np.isnan(FDR5percTh): index_min = min(df[df.precision >= (1 - FDRth)].index.tolist()) else: index_min = 0 SENS = df.at[index_min, 'recall'] threshold = -FDR5percTh return df, auc, SENS, FDR5percTh
def _roc_curve_r(observations, predictions, FDRth=0.05): """ :param observations: known truth set :param predictions: all data :param FDRth: :return: """ obs_rtbl = numpy2ri.py2ri(observations) prd_rtbl = numpy2ri.py2ri(predictions) roc_prm = {'direction': '>'} RES = pROC.roc(obs_rtbl, prd_rtbl, **roc_prm) auc = pandas2ri.ri2py(RES.rx2('auc'))[0] columns = ['threshold', 'ppv', 'sensitivity', 'specificity'] coor_prm = {'ret': r.c('threshold', 'ppv', 'sensitivity', 'specificity')} COORS = pROC.coords(RES, 'all', **coor_prm) cords = numpy2ri.ri2py(COORS) df = pd.DataFrame(cords.T, columns=columns) FDR5percTh = (df[df.ppv >= (1 - FDRth)])['threshold'].max() if not np.isnan(FDR5percTh): index_min = min(df[df.threshold <= FDR5percTh].index.tolist()) else: index_min = 0 threshold = df.at[index_min, 'threshold'] SENS = df.at[index_min, 'sensitivity'] SPEC = df.at[index_min, 'specificity'] return df, auc, SENS, FDR5percTh
def _exec_r_module(self): try: import rpy2.robjects from rpy2.robjects import numpy2ri from rpy2.robjects import pandas2ri from rpy2.robjects.packages import importr except ImportError: raise ImportError('R module cannot be run, because ' '"rpy2" package is not installed.') module_name = os.path.splitext(os.path.basename(self.source_file))[0] logger.debug('import module "%s" from source file: %s', self.source_file) logger.debug('source module: "%s"', self.source_file) rpy2.robjects.r('source("{0}")'.format(self.source_file)) module = rpy2.robjects.r[module_name] version = module.get('VERSION')[0] if version != self.handles.version: raise PipelineRunError( 'Version of source and handles is not the same.') func = module.get('main') numpy2ri.activate() # enables use of numpy arrays pandas2ri.activate() # enable use of pandas data frames kwargs = self.keyword_arguments logger.debug('evaluate main() function with INPUTS: "%s"', '", "'.join(kwargs.keys())) # R doesn't have unsigned integer types for k, v in kwargs.iteritems(): if isinstance(v, np.ndarray): if v.dtype == np.uint16 or v.dtype == np.uint8: logging.debug( 'module "%s" input argument "%s": ' 'convert unsigned integer data type to integer', self.name, k) kwargs[k] = v.astype(int) elif isinstance(v, pd.DataFrame): # TODO: We may have to translate pandas data frames explicitly # into the R equivalent. # pandas2ri.py2ri(v) kwargs[k] = v args = rpy2.robjects.ListVector({k: v for k, v in kwargs.iteritems()}) base = importr('base') r_out = base.do_call(func, args) for handle in self.handles.output: # NOTE: R functions are supposed to return a list. Therefore # we can extract the output argument using rx2(). # The R equivalent would be indexing the list with "[[]]". if isinstance(r_out.rx2(handle.name), rpy2.robjects.vectors.DataFrame): handle.value = pandas2ri.ri2py(r_out.rx2(handle.name)) # handle.value = pd.DataFrame(r_out.rx2(handle.name)) else: # NOTE: R doesn't have an unsigned integer data type. # So we cast to uint16. handle.value = numpy2ri.ri2py(r_out.rx2(handle.name)).astype( np.uint16) # handle.value = np.array(r_out.rx2(handle.name), np.uint16) return self.handles.output
def ri2py_intvector(obj): # special case for factors if 'factor' in obj.rclass: res = pandas.Categorical.from_codes(numpy.asarray(obj) - 1, categories=obj.do_slot('levels'), ordered='ordered' in obj.rclass) else: res = numpy2ri.ri2py(obj) return res
def ri2py_intvector(obj): # special case for factors if 'factor' in obj.rclass: res = pandas.Categorical.from_codes(numpy.asarray(obj) - 1, categories = obj.do_slot('levels'), ordered = 'ordered' in obj.rclass) else: res = numpy2ri.ri2py(obj) return res
def fit(self, X, Y): numpy2ri.activate() rPMA = importr('PMA') typex, typez = _check_penalty_type(self.penalty) X, x_mean, x_std = _center_data(X) Y, y_mean, y_std = _center_data(Y) if self.n_component is None: self.n_component = np.min([X.shape[1], Y.shape[1]]) out = rPMA.CCA(x=X, z=Y, K=self.n_component, \ niter=self.n_iter, standardize=False, \ typex=typex, typez=typez, \ penaltyx=self.C[0], penaltyz=self.C[1], \ trace=False) self.u = numpy2ri.ri2py(out[0]) self.v = numpy2ri.ri2py(out[1]) self._x_score, self._y_score = self.transform(X, Y) self._cancorr = _cancorr(X, Y, self.u, self.v) numpy2ri.deactivate() return self
def get_distance(phyloseq_d, dist_method): R_phyloseq = importr('phyloseq') R_base = importr('base') distances = R_phyloseq.distance(phyloseq_d, method=dist_method) distance_mat = R_base.as_matrix(distances) distance_df = pd.DataFrame(numpy2ri.ri2py(distance_mat), index=pandas2ri.ri2py(R_phyloseq.sample_names(phyloseq_d)), columns=pandas2ri.ri2py(R_phyloseq.sample_names(phyloseq_d)) ) return distance_df
def get_wunifrac_distance(phyloseq_d): R_phyloseq = importr('phyloseq') R_base = importr('base') distances = R_phyloseq.UniFrac(phyloseq_d, weighted=True, normalized=True, fast=True, parallel=False) distance_mat = R_base.as_matrix(distances) distance_df = pd.DataFrame(numpy2ri.ri2py(distance_mat), index=pandas2ri.ri2py(R_phyloseq.sample_names(phyloseq_d)), columns=pandas2ri.ri2py(R_phyloseq.sample_names(phyloseq_d)) ) return distance_df
def processData(data,prompts): expandedMatrix = buildMatrices(data) competencies = {} eigenRatios = {} meanCompetencies = {} negativeCompetencies = {} for dataSet, matrix in expandedMatrix.items(): sys.err.println("Processing " + dataSet) prompt = prompts['Answer.prompt_' + dataSet.split('_')[1]] # Calculate competencies for this scale factors = CCT(matrix, prompt) competencies[dataSet] = np2ri.ri2py((factors.rx('loadings')[0])).flatten() eigen = np2ri.ri2py((factors.rx('values')[0])).flatten() eigenRatios[dataSet] = eigen[0]/eigen[1] meanCompetencies[dataSet] = competencies[dataSet].mean() negativeCompetencies[dataSet] = (competencies[dataSet] < 0).sum() * 1.0/len(competencies[dataSet]) return (competencies,eigenRatios,meanCompetencies,negativeCompetencies)
def fit(self, X, y): self.X = self._check_X(X) y = array(y).astype(float) self.columns = numpy2ri.ri2py(self.X.colnames) n_sample, self.n_feature = self.X.nrow, self.X.ncol if isinstance(self.param['mtry'], basestring): p = self.n_feature self.param['mtry'] = eval(self.param['mtry']) self.rf = self.pkg.randomForest(x=self.X, y=y, **self.param) return self
def processData(dataFrame): originalCompetencies = {} competencies = {} eigenRatios = {} matrices = buildMatrices(dataFrame) for dataSet, matrix in matrices.items(): factors = CCT(matrix) results = np2ri.ri2py((factors.rx('loadings')[0])).flatten() originalCompetencies[dataSet] = results matrix = reverseNegatives(matrix,results) factors = CCT(matrix) results = np2ri.ri2py((factors.rx('loadings')[0])).flatten() competencies[dataSet] = results eigen = np2ri.ri2py((factors.rx('values')[0])).flatten() eigenRatios[dataSet] = eigen return (competencies, eigenRatios, originalCompetencies)
def fit_betabinom_ab(n, k, weights=None): assert np.all((k >= 0) & (k <= n)) n_r = ro.FloatVector(n) k_r = ro.FloatVector(k) if weights is not None: assert len(weights) == len(k) assert len(weights) == len(n) weights_r = ro.FloatVector(weights) result_r = bbfit.fit_betabinom_w(n_r, k_r, weights_r) else: result_r = bbfit.fit_betabinom(n_r, k_r) result = rpyn.ri2py(result_r) log_a, log_b = result.flatten() return np.exp(log_a), np.exp(log_b)
def ri2py_floatvector(obj): # special case for POSIXct date objects if 'POSIXct' in obj.rclass: tzone_name = obj.do_slot('tzone')[0] if tzone_name == '': # R is implicitly using the local timezone, while Python time libraries # will assume UTC. tzone = get_timezone() else: tzone = pytz.timezone(tzone_name) foo = (tzone.localize(datetime.fromtimestamp(x)) for x in obj) res = pandas.to_datetime(tuple(foo)) else: res = numpy2ri.ri2py(obj) return res
def run_auto_arima(window, horizons, args): numpy2ri.activate() forecast = importr('forecast') _, y_train, _, _ = window extra_param = args['extras'] fit = forecast.auto_arima(y_train, stationary=extra_param.get('stationary', False), seasonal=extra_param.get('seasonal', True), stepwise=extra_param.get('stepwise', False)) order = list(fit[6]) arima_str = 'ARIMA({0},{5},{1}) ({2},{6},{3})_{4}' print arima_str.format(*order) result = forecast.forecast(fit, h=max_h, level=np.array([0.95])) y_pred = numpy2ri.ri2py(result[3]) y_arima = y_pred[np.array(horizons) - 1] return y_arima
def output_pheno_beta(self, meffil=False): """Get pheno and beta dataframe objects stored as attributes for input to MethylationArray object. Parameters ---------- meffil True if ran meffil pipeline.""" self.pheno_py=pandas2ri.ri2py(robjects.r['as'](self.pheno,'data.frame')) if not meffil: self.beta_py=pd.DataFrame(pandas2ri.ri2py(self.beta_final),index=numpy2ri.ri2py(robjects.r("featureNames")(self.RSet)),columns=numpy2ri.ri2py(robjects.r("sampleNames")(self.RSet))).transpose() self.pheno_py['Sample_Name']=np.vectorize(lambda x: x.split('/')[-1])(self.pheno_py['Basename']) self.pheno_py = self.pheno_py.set_index('Sample_Name').loc[self.beta_py.index,:] else: self.beta_py=pd.DataFrame(pandas2ri.ri2py(self.beta_final),index=robjects.r("rownames")(self.beta_final),columns=robjects.r("colnames")(self.beta_final)).transpose() print(self.beta_py) print(self.beta_py.index) print(self.pheno_py) self.pheno_py = self.pheno_py.set_index('Sample_Name').loc[self.beta_py.index,:]
def convert_r_response_to_python(response, convert_scalars=True, to_list=False, native_to_json=False): """Converts rpy2 types to Python objects. The output is either a Python built-in, NumPy or Pandas object. Note: Rpy2 returns scalars as vectors. These are converted back to scalars with this conversion, which may not be desirable. This behavior can be switched of. Args: response (rpy2 type): object from the R session to be converted convert_scalars (bool): convert vectors with length 1 to scalars Returns: Converted object """ original_response_type = type(response) new_res = response if issubclass(original_response_type, rpy2.robjects.vectors.Array): new_res = numpy2ri.ri2py(response) elif issubclass(original_response_type, rpy2.robjects.vectors.DataFrame): new_res = pandas2ri.ri2py(response) if native_to_json: json_res = new_res.to_json(orient='records') json_res = json_res.replace('-2147483648', 'null') new_res = json.loads(json_res) elif issubclass(original_response_type, rpy2.robjects.vectors.Vector): if convert_scalars and len(response) == 1: new_res = response[0] elif to_list: new_res = list(response) return new_res
def testAtomicVectorToNumpy(self): v = robjects.vectors.IntVector((1, 2, 3)) a = rpyn.ri2py(v) self.assertTrue(isinstance(a, numpy.ndarray)) self.assertEqual(1, v[0])
def ri2py_listvector(obj): if 'data.frame' in obj.rclass: res = ri2py.registry[DataFrame](obj) else: res = numpy2ri.ri2py(obj) return res
def ri2py_vector(obj): res = numpy2ri.ri2py(obj) return res
def testAtomicVectorToNumpy(self): v = robjects.vectors.IntVector((1,2,3)) a = rpyn.ri2py(v) self.assertTrue(isinstance(a, numpy.ndarray)) self.assertEqual(1, v[0])
from rpy2.robjects.numpy2ri import numpy2rpy as numpy2ri from rpy2.robjects.numpy2ri import rpy2py as ri2py #from rpy2.robjects.numpy2ri import numpy2ri, ri2py from rpy2.robjects.packages import importr, data import openturns as ot # Require stats = importr("stats") faraway = importr("faraway") savings_data = data(faraway).fetch("savings")["savings"] #data(faraway).fetch("savings")["savings"] # Model 1 : 2 param, non intercept sr = ri2py(savings_data)["sr"] r.assign('sr', numpy2ri(sr)) pop15 = ri2py(savings_data)["pop15"] r.assign('pop15', numpy2ri(pop15)) pop75 = ri2py(savings_data)["pop75"] r.assign('pop75', numpy2ri(pop75)) formula = Formula('sr ~ pop75 + pop15 - 1') fit = stats.lm(formula) summary = stats.summary_lm(fit) """ list(summary.names) provides ['call', 'terms', 'residuals', 'coefficients', 'aliased', 'sigma', 'df', 'r.squared', 'adj.r.squared', 'fstatistic', 'cov.unscaled'] """ r2 = summary[7][0] ar2 = summary[8][0]
def ri2py_dataframe(obj): # use the numpy converter recarray = numpy2ri.ri2py(obj) res = PandasDataFrame.from_records(recarray) return res
def risk_assessment_plot(X_binarized_norm, y, ROC_models): """ Function that generates risk assessment plot. Takes as the input matrix of metrics. :return: plot """ # for recurrence problem lr_probabilities, rf_probabilities, mlp_probabilities, xgb_probabilities = me.best_models_ROC_curves( X_binarized_norm, y, ROC_models, False) # for recurrence problem output_list1 = me.risk_assessment_data(lr_probabilities, rf_probabilities, y) output_list2 = me.risk_assessment_data(mlp_probabilities, xgb_probabilities, y) import rpy2.robjects.numpy2ri as rpyn rpyn.activate() [xrf_sens, yrf_sens, xrf_spec, yrf_spec, xlr_sens, ylr_sens, xlr_spec, ylr_spec] = rpyn.ri2py(output_list1) [xmlp_sens, ymlp_sens, xmlp_spec, ymlp_spec, xxgb_sens, yxgb_sens, xxgb_spec, yxgb_spec] = rpyn.ri2py( output_list2) plt.figure() plt.rcParams["figure.figsize"] = (10, 6) # for recurrence problem plt.plot(xlr_sens, ylr_sens, color='b', label='Events LR', lw=2, alpha=.8) plt.plot(xlr_spec, ylr_spec, color='b', linestyle='--', label='Non-events LR', lw=2, alpha=.8) plt.plot(xrf_sens, yrf_sens, color='g', label='Events RF', lw=2, alpha=.8) plt.plot(xrf_spec, yrf_spec, color='g', linestyle='--', label=r'Non-events RF', lw=2, alpha=.8) plt.plot(xmlp_sens, ymlp_sens, color='k', label=r'Events MLP', lw=2, alpha=.8) plt.plot(xmlp_spec, ymlp_spec, color='k', linestyle='--', label=r'Non-events MLP', lw=2, alpha=.8) plt.plot(xxgb_sens, yxgb_sens, color='magenta', label=r'Events XGBoost', lw=2, alpha=.8) plt.plot(xxgb_spec, yxgb_spec, color='magenta', linestyle='--', label=r'Non-events XGBoost', lw=2, alpha=.8) plt.xlabel('Calculated risk') plt.ylabel('Sensitivity, 1-Specificity') plt.legend(loc="best") plt.show()
def ri2py_vector(obj): # use the numpy converter first res = numpy2ri.ri2py(obj) if isinstance(res, recarray): res = PandasDataFrame.from_records(res) return res
def _exec_r_module(self): try: import rpy2.robjects from rpy2.robjects import numpy2ri from rpy2.robjects import pandas2ri from rpy2.robjects.packages import importr except ImportError: raise ImportError( 'R module cannot be run, because ' '"rpy2" package is not installed.' ) module_name = os.path.splitext(os.path.basename(self.source_file))[0] logger.debug( 'import module "%s" from source file: %s', self.source_file ) logger.debug('source module: "%s"', self.source_file) rpy2.robjects.r('source("{0}")'.format(self.source_file)) module = rpy2.robjects.r[module_name] version = module.get('VERSION')[0] if version != self.handles.version: raise PipelineRunError( 'Version of source and handles is not the same.' ) func = module.get('main') numpy2ri.activate() # enables use of numpy arrays pandas2ri.activate() # enable use of pandas data frames kwargs = self.keyword_arguments logger.debug( 'evaluate main() function with INPUTS: "%s"', '", "'.join(kwargs.keys()) ) # R doesn't have unsigned integer types for k, v in kwargs.iteritems(): if isinstance(v, np.ndarray): if v.dtype == np.uint16 or v.dtype == np.uint8: logging.debug( 'module "%s" input argument "%s": ' 'convert unsigned integer data type to integer', self.name, k ) kwargs[k] = v.astype(int) elif isinstance(v, pd.DataFrame): # TODO: We may have to translate pandas data frames explicitly # into the R equivalent. # pandas2ri.py2ri(v) kwargs[k] = v args = rpy2.robjects.ListVector({k: v for k, v in kwargs.iteritems()}) base = importr('base') r_out = base.do_call(func, args) for handle in self.handles.output: # NOTE: R functions are supposed to return a list. Therefore # we can extract the output argument using rx2(). # The R equivalent would be indexing the list with "[[]]". if isinstance(r_out.rx2(handle.name), rpy2.robjects.vectors.DataFrame): handle.value = pandas2ri.ri2py(r_out.rx2(handle.name)) # handle.value = pd.DataFrame(r_out.rx2(handle.name)) else: # NOTE: R doesn't have an unsigned integer data type. # So we cast to uint16. handle.value = numpy2ri.ri2py(r_out.rx2(handle.name)).astype( np.uint16 ) # handle.value = np.array(r_out.rx2(handle.name), np.uint16) return self.handles.output
def approx_qei(X, model, maxima, x_pending = None, num_sampled_points = 5, num_batches_eval = 400, strategy_batch_selection = 'random'): """ Use Mickael Binois approximation to qEI function This is used to calculate qEI score for batches Parameters ---------- * `X` [array-like, shape=(n_samples, n_features)]: Values where the acquisition function should be computed. * `model` [sklearn estimator that implements predict with ``return_std``]: The fit estimator that approximates the function through the method ``predict``. It should have a ``return_std`` parameter that returns the standard deviation. * `maxima`[float, default 0]: Previous minimum value which we would like to improve upon. * `num_sampled_points` [int, default 5]: Number of points to sample in parallel * `num_batches_eval`[int, default 400] Number of batches to evaluate * `strategy_batch_selection` [default 'random']: Strategy for selection of elements in batches Returns ------- * `values`: [array-like, shape=(len(num_batches_eval),)]: qEI values for each batch """ # Converting x_pending list to numpy array if x_pending is not None: x_pending = np.array(x_pending) batches = [] cc_vec = np.zeros(num_batches_eval) # Batch preparation for i in range(num_batches_eval): if strategy_batch_selection == 'random': rel_ind = np.random.choice(X.shape[0], num_sampled_points, replace=False) b = X[rel_ind,:] if x_pending is not None: b = np.vstack([x_pending, b]) else: raise ValueError ("No such sampling strategy exists ..") batches.append(b) mean, covar = model.predict(b, return_cov=True) #print ('covar') #print(np.isnan(covar).any()) cc = qEI.qEI_approx(mean, covar, maxima) cc_num = rpyn.ri2py(cc) cc_vec[i] = cc_num #print(cc_vec) max_qEI_val = np.nanmax(cc_vec) print('max') print(max_qEI_val) max_qEI_val_ind = np.argmax(cc_vec) best_batch = batches[max_qEI_val_ind] return best_batch, batches, cc_vec, max_qEI_val
################################################################################ ################################################################################ # code with sample from R objects : it is easier if we want to compare directly in R print('') print('-' * 10) print('') rnorm = r['rnorm'] set_seed = r['set.seed'] ## generate regressor and dependent variable set_seed(0) X1 = rnorm(n_points) X2 = rnorm(n_points) err1 = rnorm(n_points) output = numpy2ri(ri2py(X1) + ri2py(X1) - ri2py(X2) + ri2py(err1) + 1) r.assign('X1', X1) r.assign('X2', X2) r.assign('output', output) ## perform Durbin-Watson test formula = Formula('output ~ X1 + X2') dw_test_1 = lmtest.dwtest(formula, alternative=hypothesis['R'], exact=True) print('Result from R :') print('p-value :', dw_test_1[3][0]) print('Alternative hypothesis : ', dw_test_1[2][0]) print('dw stat : ', dw_test_1[0][0]) print('') # transformation into openturns objects firstSample = ot.Sample(np.column_stack((ri2py(X1), ri2py(X2))))