def init_database(conn): """ Passing in a connection, initialize the database with somewhat randomized data. Arguments: - conn - postgres connection object """ schema = input("Input a schema name to be created: ") create_schema(conn, schema) create_tables(conn, schema) generate_data(conn, schema)
def train(path,BATCH_SIZE,IMG_SIZE,n_classes,save_path): datagenerator = helpers.generate_data(BATCH_SIZE,IMG_SIZE,preprocess_input,path) base_model = NASNetLarge(input_shape=(IMG_SIZE, IMG_SIZE,3), include_top=False, weights='imagenet') compiled_model = helpers.transfer_learning(base_model,n_classes) helpers.fit_model(compiled_model,datagenerator,save_path)
def squared_sin_data_set(): def f(x): return math.sin(x)**2 return PreloadSource( helpers.generate_data(f=f, start_value=0, end_value=3.14, step_value=0.1))
def update_data(attrname, old, new): x = covariance.value n1 = n1_variance.value n2 = n2_variance.value u11 = n1_u1.value u12 = n1_u2.value u21 = n2_u1.value u22 = n2_u2.value # update stim1 u = [u11, u21] cov = np.array([[n1, x], [x, n2]]) data1 = help.generate_data(u, cov) source_s1.data = dict(x=data1[:, 0], y=data1[:, 1]) # update stim2 u = [u12, u22] cov = cov data2 = help.generate_data(u, cov) source_s2.data = dict(x=data2[:, 0], y=data2[:, 1]) update_axes(data1, data2) update_table(data1, data2)
def test_gives_correct_output_for_unseen_data(self): nnet = NetFactory.create_neural_net(sizes=[1, 10, 1]) cost_func = QuadraticCost(neural_net=nnet) gd = GradientDescent(neural_net=nnet, cost_function=cost_func) def parabola(x): return x**2 examples = helpers.generate_data(f=parabola, start_value=-0.6, end_value=-0.4, step_value=0.005) gd.train(data_src=PreloadSource(examples), nepochs=10) xval = -0.5000125 yval = parabola(xval) net_input = np.array([xval], float) output = nnet.feed(net_input) self.assertAlmostEqual(output[0], yval, places=1)
from helpers import generate_data, progress # ---lOAD MODELS--- face_model = load_model('./models/facenet_keras.h5') # ---GENERATING DATA--- data_folder = './data/' # Paths to training images image_paths = [data_folder + file for file in os.listdir(data_folder)] print("Generating Dataset...") # Generate data from paths dataset = [generate_data(face_model, path) for path in image_paths] X = np.array([x[0] for x in dataset]) y = np.array([x[1] for x in dataset]) # ---TRAINING--- print("Dataset generated. Start training...") # Encode labels encoder = LabelEncoder() y = encoder.fit_transform(y) # SVM Classifer classify_model = SVC(kernel='linear', probability=True) classify_model.fit(X, y)
import numpy as np import matplotlib.pyplot as plt from helpers import generate_data, LinearRegression, calculate_rmse # data range and number of points l_bound = 0 r_bound = 100 n = 1000 data = generate_data(l_bound, r_bound, n) linreg = LinearRegression() linreg.fit(data) # Find regression line xx = np.linspace(l_bound, r_bound, n) yy = np.array(linreg.b[0] + linreg.b[1] * xx) # Check predictions check_data = generate_data(l_bound, r_bound, n // 10) pred_x = [[x] for x in check_data[:, 0]] actual_y = check_data[:, 1] pred_y = linreg.predict(pred_x) rmse = calculate_rmse(actual_y, pred_y) print('rmse:', rmse) plt.figure(1) plt.plot(xx, yy.T, color='tab:blue') plt.scatter(data[:, 0], data[:, 1], color='c') plt.scatter(check_data[:, 0], check_data[:, 1], color='r') plt.scatter(pred_x, pred_y, color='m')
from bokeh.layouts import column, grid, row from bokeh.models import Button from bokeh.palettes import RdYlBu3 from bokeh.plotting import figure, curdoc from bokeh.models import Button, ColumnDataSource, ColorBar from bokeh.models.glyphs import Line from bokeh.models.widgets import Slider, TextInput, DataTable, TableColumn import helpers as help import numpy as np # generate initial data set u1 = [2, 2] u2 = [4, 4] cov = np.array([[1, 0], [0, 1]]) x = help.generate_data(u1, cov) y = help.generate_data(u2, cov) # get the decoding axes and dprime values for this starting point values = np.round(help.get_table_values(x, y), 3) metrics = ['dprime_pop_LDA', 'dprime_pop_NULL', 'dprime_ind', 'ratio_LDA', 'ratio_NULL', 'cos(NULL, Noise)', 'cos(LDA, Noise)', 'rsc'] decoding_metrics = dict(metrics=metrics, values=values) source = ColumnDataSource(decoding_metrics) columns = [ TableColumn(field="metrics", title="Metric"), TableColumn(field="values", title="Value"), ] data_table = DataTable(source=source, columns=columns, width=400, height=280) # set the date source for two stimuli/signals that are trying to be discriminated
def main(): X, Y, true_f = h.generate_data(30) # individual elements over entire matrix kf_poly = lambda x, z, d: (1 + x * z)**d kf_rbf = lambda x, z, gamma: np.exp(-gamma * ((x - z)**2)) if to_run["abc"]: """ part (a) """ k_poly = Kernel(X, Y, kf_poly) k_rbf = Kernel(X, Y, kf_rbf) """ part (b) """ true_data = [true_f(x_val) for x_val in c.x_list] poly_pred_data = k_poly.get_fhat_data(X, Y) rbf_pred_data = k_rbf.get_fhat_data(X, Y) poly_list = [true_data, poly_pred_data] rbf_list = [true_data, rbf_pred_data] h.plot_multiple("poly", "a3_bi", X, Y, poly_list, c.pred_labels, c.a3b_ylimits) h.plot_multiple("rbf", "a3_bii", X, Y, rbf_list, c.pred_labels, c.a3b_ylimits) """ part (c) """ poly_5, poly_95 = k_poly.bootstrap(c.B) rbf_5, rbf_95 = k_rbf.bootstrap(c.B) poly_list = [true_data, poly_pred_data, poly_5, poly_95] rbf_list = [true_data, rbf_pred_data, rbf_5, rbf_95] h.plot_multiple("poly", "a3_ci", X, Y, poly_list, c.pct_labels, c.a3b_ylimits) h.plot_multiple("rbf", "a3_cii", X, Y, rbf_list, c.pct_labels, c.a3b_ylimits) if to_run["de"]: """ part (d) """ # repeated a X, Y, true_f = h.generate_data(300) k_poly = Kernel(X, Y, kf_poly, kfold=True) k_rbf = Kernel(X, Y, kf_rbf, kfold=True) # repeated b true_data = [true_f(x_val) for x_val in c.x_list] poly_pred_data = k_poly.get_fhat_data(X, Y) rbf_pred_data = k_rbf.get_fhat_data(X, Y) poly_list = [true_data, poly_pred_data] rbf_list = [true_data, rbf_pred_data] h.plot_multiple("poly", "a3_d.bi", X, Y, poly_list, c.pred_labels, c.a3b_ylimits) h.plot_multiple("rbf", "a3_d.bii", X, Y, rbf_list, c.pred_labels, c.a3b_ylimits) # repeated c poly_5, poly_95 = k_poly.bootstrap(c.B) rbf_5, rbf_95 = k_rbf.bootstrap(c.B) poly_list = [true_data, poly_pred_data, poly_5, poly_95] rbf_list = [true_data, rbf_pred_data, rbf_5, rbf_95] h.plot_multiple("poly", "a3_d.ci", X, Y, poly_list, c.pct_labels, c.a3b_ylimits) h.plot_multiple("rbf", "a3_d.cii", X, Y, rbf_list, c.pct_labels, c.a3b_ylimits) """ part (e) """ X, Y, true_f = h.generate_data(c.m) poly_pred = k_poly.kernel_rr(X, Y, k_poly.hp, k_poly.lamb) rbf_pred = k_rbf.kernel_rr(X, Y, k_rbf.hp, k_rbf.lamb) bs_5, bs_95 = get_bootstrap_values(X, Y, poly_pred, rbf_pred) print(bs_5) print(bs_95)