def deserialize_ridge_regressor(model_dict): model = Ridge(model_dict["params"]) model.coef_ = np.array(model_dict["coef_"]) if "n_iter_" in model_dict: model.n_iter_ = np.array(model_dict["n_iter_"]) if isinstance(model_dict["intercept_"], list): model.intercept_ = np.array(model_dict["intercept_"]) else: model.intercept_ = float(model_dict["intercept_"]) return model
def get_Ridge(train_df, train_y, test_df): #train_df = train_df.applymap(lambda x:np.log(x+1)) #test_df = test_df.applymap(lambda x:np.log(x+1)) clf = Ridge(alpha=0.001) clf.fit(train_df, train_y) a = clf.coef_ for i in range(len(a)): if a[i] < 0: a[i] = 0 clf.coef_ = a #print (clf.coef_) return clf.predict(train_df), clf.predict(test_df)
def fit_learner(x, y, gamma, ridge=None): """ Returns an trained model that works exactly the same as Ridge, but fit optimally """ if ridge is None: ridge = Ridge() x_new, y_new = to_standard_form(x, y, gamma) ta_est_standard = ridge.fit(x_new, y_new).coef_ ta_est = to_general_form(ta_est_standard, x, y, gamma) ridge.coef_ = ta_est return ridge
def deserialize_ridge_regressor(model_dict): model = Ridge(model_dict['params']) model.coef_ = np.array(model_dict['coef_']) if 'n_iter_' in model_dict: model.n_iter_ = np.array(model_dict['n_iter_']) if isinstance(model_dict['intercept_'], list): model.intercept_ = np.array(model_dict['intercept_']) else: model.intercept_ = float(model_dict['intercept_']) return model
def sensitivity_ridge(data, runs): output_var = 'INCWAGE' lamb = 0.01 train, test = train_test_split(data, test_size=0.2) # global_delta = (12 * (1./(lamb**0.5)) + 8) / (len(train) * lamb) global_delta = ((1. / (lamb**0.5)) + 1) * (5. / (len(train) * lamb)) xtrain, ytrain = np.array( train.loc[:, train.columns != output_var]), np.array(train[output_var]) xtest, ytest = np.array(test.loc[:, test.columns != output_var]), np.array( test[output_var]) xtrain, xtest = normalize(xtrain), normalize(xtest) model = Ridge(alpha=2 * lamb) model.fit(xtrain, ytrain) orig_coef = model.coef_ non_private_accuracy = (sum( (model.predict(xtest) - ytest)**2) / len(test))**0.5 print("Ridge fit: ", non_private_accuracy) confidence = [] utility_global = defaultdict(list) epsilons = np.linspace(0.1, 0.99, 10) for e in epsilons: confidence.append(bound(e, 1.0, 1)) for _ in range(runs): model.coef_ = orig_coef + np.random.laplace( 0, (global_delta / e), orig_coef.shape) utility_global[e].append((sum( (model.predict(xtest) - ytest)**2) / len(xtest))**0.5) result = { "confidence": confidence, "utility_global": utility_global, "utility": non_private_accuracy } pickle.dump(result, open("new_ridge_utility.pickle", "wb"))
def pca_regress_pipeline_log(features, grades, groups, n_components=0.9, solver='full', whitening=True, standard=False, seed=42, mod_coefs=True, alpha=0.1, grade_name='', savepath=None): feature_names = ['Center +', 'Center -', 'Large U-1', 'Large U-2', 'Large U-3', 'Large U-4', 'Large U-5', 'Large U-6', 'Large U-7', 'Large N-U', 'Small U-1', 'Small U-2', 'Small U-3', 'Small U-4', 'Small U-5', 'Small U-6', 'Small U-7', 'Small N-U', 'Radial U-0', 'Radial U-1', 'Radial U-2', 'Radial U-3', 'Radial U-4', 'Radial U-5', 'Radial U-6', 'Radial U-7', 'Radial U-8', 'Radial N-U'] grades_log = grades # Fit PCA to full data pca = PCA(n_components=n_components, svd_solver=solver, whiten=whitening, random_state=seed) pca.fit(features) # Leave one out split logo = LeaveOneGroupOut() logo.get_n_splits(features, grades_log, groups) logo.get_n_splits(groups=groups) # 'groups' is always required all_shap_values, all_shap_values_lin = [], [] for train_idx, test_idx in logo.split(features, grades_log, groups): # Indices x_train, x_test = features[train_idx], features[test_idx] y_train, y_test = grades_log[train_idx], grades_log[test_idx] # Normalize with mean and std if standard: x_test -= x_train.mean(0) x_train -= x_train.mean(0) # Logistic regression model = LogisticRegression(solver='newton-cg', max_iter=1000, random_state=seed, fit_intercept=False) model.fit(pca.transform(x_train), y_train > 1) model_lin = Ridge(alpha=alpha, normalize=True, random_state=seed, fit_intercept=True) model_lin.fit(pca.transform(x_train), y_train) # Predicted score (for logistic regression) p = model.predict_proba(pca.transform(x_test)) p_lin = model_lin.predict(pca.transform(x_test)) # Merge PCA into the linear model if mod_coefs: coef = (pca.components_.T / pca.singular_values_) @ model.coef_.T * np.sqrt(pca.n_samples_ - 1) coef_lin = (pca.components_.T / pca.singular_values_) @ model_lin.coef_.T * np.sqrt(pca.n_samples_ - 1) # Update models model.coef_ = coef.T model_lin.coef_ = coef_lin.T p2_lin = model_lin.predict(x_test) p2 = model.predict_proba(x_test) # Inference p_inf = (x_test @ coef).squeeze() p_inf = (1 + np.exp(-p_inf)) ** -1 eps = 1.0e-10 assert np.sum(np.abs(p - p2)) < eps, 'LOGReg results are not equal' assert np.sum(np.abs(p_inf - p[:, 1])) < eps, 'LOGReg results are not equal' assert np.sum(np.abs(p_lin - p2_lin)) < eps, 'LINReg results are not equal' else: # Otherwise run PCA x_train = pca.transform(x_train) x_test = pca.transform(x_test) # Interpretability # Logistic regression explainer = shap.LinearExplainer(model, x_train, feature_dependence='correlation', nsamples=x_train.shape[0]) shap_values = explainer.shap_values(x_test) # Linear regression explainer_lin = shap.LinearExplainer(model_lin, x_train, feature_dependence='correlation', nsamples=x_train.shape[0]) shap_values_lin = explainer_lin.shap_values(x_test) # Append prediction all_shap_values.append(shap_values) all_shap_values_lin.append(shap_values_lin) # Combine shap values and plot the summary all_shap_values = np.vstack(all_shap_values) all_shap_values_lin = np.vstack(all_shap_values_lin) # Inverse PCA for the model without PCA if not mod_coefs: all_shap_values = pca.inverse_transform(all_shap_values) all_shap_values_lin = pca.inverse_transform(all_shap_values_lin) # Force plot # shap.force_plot(explainer.expected_value, all_shap_values, features) # plt.show() # Summary plots shap.summary_plot(all_shap_values, features, show=False, feature_names=feature_names) # plt.title(f'Logistic Regression ({grade_name})') if savepath is not None: plt.savefig(f'{savepath}{grade_name}_logistic_cov.png', transparent=False, bbox_inches='tight') plt.show() else: plt.show() shap.summary_plot(all_shap_values_lin, features, show=False, feature_names=feature_names) # plt.title(f'Linear Ridge Regression ({grade_name})') if savepath is not None: plt.savefig(f'{savepath}{grade_name}_linear_cov.png', transparent=False, bbox_inches='tight') plt.show() else: plt.show()
model.addLayer(DenseLayer(95, activation())) model.addLayer(DenseLayer(7, LinearActivation())) model.initialize(QuadraticCost()) ridge = Ridge(alpha=0.1) # load model parameters path1 = './model/my_model_W_{}.dat' path2 = './model/my_model_b_{}.dat' path3 = './model/my_model_ridge_W.dat' path4 = './model/my_model_ridge_intercept.dat' model_W, model_b, model_ridge_W, model_ridge_intercept = load_model( 4, path1, path2, path3, path4) # update the model for i in range(len(model.layers)): model.layers[i].W = model_W[i] model.layers[i].b = model_b[i] ridge.coef_ = model_ridge_W ridge.intercept_ = model_ridge_intercept[0] # get the data point inputlist = ball_tracking() # predict the configuration tar_position_in_list = list(ridge.predict(model.predict(inputlist))) for i in range(len(joint_names)): tar_position[joint_names[i]] = tar_position_in_list[i] while True: cur_pos = limb.joint_angles() for key, value in tar_position.iteritems(): error_new[key] = tar_position[key] - cur_pos[key]