def nn_plotter(): learning_rate_list = [0.5, 0.1, 0.01, 0.001] epochs_list = [500] regularisation_list = [0, 1, 2] reg_param_list = [0.0001, 0.001, 0.01, 0.1, 0.2, 0.5, 1.0] for i in epochs_list: for j in learning_rate_list: for l in regularisation_list: for m in reg_param_list: ds = hp.load_ds(hp.PATH, hp.FIXED) X, y = hp.split(ds) y_size = len(y) training_size = int((100 / 100) * y_size) train_X, train_y, test_X, test_y = hp.random_train_test(X, y, training_size) reg_str = "" if l != 0: reg_str = "Regularisation=L" + str(l) + ", Scale=" + str(m) print("\nStarting Neural Network, Epochs=" + str(i) + ", Learning Rate=" + str(j) + reg_str + "\n10-fold Cross Validation") x, y, tx, ty = nn.neural_network(train_X, train_y, test_X, test_y, i, j, [l, m], True, 0) filename = "../figs/RED_NN_E" + str(i) + "_LR" + str(j) + "_R" + str(l) + "_S" + str(m) + ".png" title = "Red Wine\nNeural Network 10-fold Cross Validation, Epochs=" + str(i) + ", Learning Rate=" + str(j) +"\n Hidden ReLU, Output ReLU\n" + reg_str hp.plotter(title, x, y, tx, ty, 90, filename, True) print("Finished Neural Network.\n")
def worker(line): try: result = execCommand(split(line), True) print '' if result is None else '%s\n' % str(result) except HandledException as e: err('%s\n' % e)
def reinit_chromecasts(self, update, context): found_chromecasts = self._cast.get_available_chromecasts() keyboard = helpers.split(found_chromecasts, 3) update.message.reply_text('Выбирай', reply_markup=ReplyKeyboardMarkup( keyboard, one_time_keyboard=True), parse_mode='Markdown') return self._choose_chromecast
def feature_loop_script(data,filter_feature,feature_value): #script for whole feature creating process feature_value = avg_by_feature(data,filter_feature,feature_value) date_features = make_date_features(feature_value) X_train,X_valid = helpers.split(feature_value,settings.train_size) X_historical,date_avg_features = average_date_features(X_train,X_valid,date_features) X_final,features_final = create_features(data,X_historical,date_avg_features) return X_final,features_final
def block_decryption(ct_block, key): # Generate keystream keystream = get_keystream(key) # w0-w4 according to document word_split = helpers.split(ct_block) # k0-k4 according to document key_split = helpers.split(key) # r0-r3 according to dcoument r = [0] * 4 # storage for undoing final swap y = [0] * 4 # storage for ciphertext after whitening c = [0] * 4 # Round counter - set to maximum round_number = 45 # Whiten input for n in range(4): r[n] = word_split[n] ^ key_split[n] # 16 round F() for round in range(constants.ROUNDS): f0, f1 = F(r[0], r[1], keystream[15 - round], round_number) tmp_r0 = r[0] tmp_r1 = r[1] r[0] = r[2] ^ f0 r[1] = r[3] ^ f1 r[2] = tmp_r0 r[3] = tmp_r1 round_number = round_number - 3 # Undo final swap y[0] = r[2] y[1] = r[3] y[2] = r[0] y[3] = r[1] # Whiten output for n in range(4): c[n] = y[n] ^ key_split[n] # Shift right to allow the bytes to be concatenated, reduce shift amount in increments of 16 c[n] = c[n] << (constants.KEYSIZE - (16 * (n + 1))) # Return encrypted blocks return c[0] | c[1] | c[2] | c[3]
def provide_names(self, update, context): self._current_watching = mal.get_current_watching() message = '' for some_anime in self._current_watching: message += f'[{some_anime["name"]}]({self.mal_prefix + some_anime["url"]}) - ' \ f'*{some_anime["num_watched_episodes"]}*/{some_anime["anime_num_episodes"]}\n' reply_keyboard = helpers.split( [i['name'] for i in self._current_watching], n=2) update.message.reply_text(message, reply_markup=ReplyKeyboardMarkup( reply_keyboard, one_time_keyboard=True), parse_mode='Markdown')
def linr_plotter(): learning_rate_list = [0.05] epochs_list = [500] cost_fn_list = [1, 2, 4, 5] # cost_fn_list = [3] regularisation_list = [3] # reg_param_list = [0.0001, 0.001, 0.01, 0.1] lamb = [0.001, 0.01, 0.1, 0.3, 0.5, 0.7, 1.0] alpha = [0.001, 0.01, 0.1, 0.3, 0.5, 0.7, 1.0] for i in epochs_list: for j in learning_rate_list: for k in cost_fn_list: for l in lamb: for m in alpha: ds = hp.load_ds(hp.PATH, hp.WHITEFIXED) X, y = hp.split(ds) y_size = len(y) training_size = int((100 / 100) * y_size) train_X, train_y, test_X, test_y = hp.random_train_test(X, y, training_size) loss_str = "L1" if k == 1: loss_str = "L1" elif k == 2: loss_str = "L2" elif k == 3: loss_str = "Elastic Net" elif k == 4: loss_str = "SVR" elif k == 5: loss_str = "Huber" reg_str = " Elastic Net: " + "α=" + str(m) + " λ=" + str(l) # if l != 0: # reg_str = ", Regularisation=L" + str(l) + ", Scale=" + str(m) el = [l, m] reg = [3,0.0] print("\nStarting Linear Regression, Epochs=" + str(i) + ", Learning Rate=" + str(j) + ", Loss Function=" + loss_str + reg_str + "\n10-fold Cross Validation") x, y, tx, ty = linr.linear_regression(train_X, train_y, test_X, test_y, i, j, k, reg, True, el) filename = "../figs/WHITE_ELASTIC_LINR_E" + str(i) + "_LR" + str(j) + "_LF" + str(k) + "_R" + str(l) + "_S" + str(m) + ".png" title = "White Wine\nLinear Regression, Epochs=" + str(i) + ", Learning Rate=" + str(j) +"\n Loss Function=" + loss_str + reg_str hp.plotter(title, x, y, tx, ty, 90, filename, True) print("Finished Linear Regression.\n")
def TestingModel_PlotGrid(model="linear_regression"): '''choose either `linear_regression` or `XGB` TODO: make more general ''' '''loop for the different values of a chosen feature, training, testing and plotting the results of each one in a nice grid''' sales = annotate.read() #get a list of the unique values for the feature feature = settings.filter_by_feature feature_list = list(sales[feature].unique()) fig, axs = plt.subplots(math.ceil(len(feature_list) / 2), 2, figsize=(15, 15), sharex='col', sharey='row') fig.autofmt_xdate() #plt.xticks(rotation=70) axs = axs.ravel() for i, item in enumerate(feature_list): print(item) X_final, features_final = annotate.feature_loop_script( sales, feature, item) X_train_final, X_valid_final = split(X_final, .7) if model == "linear_regression": X_LinRegOut, predictions, model_linreg, error = predict.train_test_LinearReg( X_train_final, X_valid_final, features_final) elif model == "XGB": X_out, gbm, predictions, error = predict.train_test_XGboost( X_train_final, X_valid_final, features_final, settings.XGBparams, settings.XGBnum_boost_round) save('feature_importance_' + str(item)) else: print("not a valid model") break axs[i].plot(X_train_final['sales'], label="train") axs[i].plot(X_valid_final['sales'], label="validate") axs[i].plot(predictions, label='predictions') axs[i].legend(loc='best') axs[i].set_title(item + " rmse: " + str(error)) fig.text(0.09, 0.55, 'Sales', fontsize=20, ha='center', va='center', rotation='vertical') save(feature + "_using_" + model + "_grid")
def induce_decision_tree(self, dataset): current_shares = hp.get_probabilities(hp.get_frequency(dataset), self.init_freq) max_share = max(current_shares.values()) best_split = hp.find_best_split(dataset) # no more info gain or hyperparameter is set to pre-prune the tree if (best_split.attribute == None or max_share < self.max_share_hyperparameter): node = nd.LeafNode(hp.get_frequency(dataset), self.init_freq) else: true_data, false_data = hp.split(dataset, best_split) child_true = self.induce_decision_tree(true_data) child_false = self.induce_decision_tree(false_data) node = nd.DecisionNode(best_split, child_true, child_false) return node
def init(): if Settings.get('helper_tasks', True): import helper_tasks helper_tasks.main() while True: try: line = raw_input('>') if line: result = execCommand(split(line), True) print '' if result is None else '%s\n' % str(result) except HandledException as e: err('%s\n' % e) except EOFError: # ^z (null character) was passed exit()
def _make_hints_text(digits, lookup): c = 0 for triplet in split(digits, 3): s = "".join(str(d) for d in triplet) try: hint = lookup[s] except: raise Exception("We don't have a hint for %s." % (s, )) line = "%s - %s" % (s, hint) yield line c = c + 1 if not c % 2: yield "" if not c % 10: yield "---" yield "" yield ""
def test_50_element_list(self): input_s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcedfghijklmnopqrstuvwx" expected = [input_s[:30], input_s[30:]] self.assertEqual(list(split(input_s, 30)), expected)
def print_digits(l): for r in split(l, 30): print(make_line(r))
X_project['predictions'] = model.predict(X_project[features]) #plot the results plt.figure(figsize=(20, 10)) plt.xticks(rotation=70) plt.plot(data.sales, label="historical sales data") plt.plot(X_project.predictions, label="future sales projections") plt.plot(40 * X_project.promo1 + 50, label="promo1 state") plt.plot(40 * X_project.promo2 + 50, label="promo2 state") plt.title("projected sales") plt.ylabel("Sales") plt.legend(loc='best') save("projections_" + str(settings.feature_value)) return X_project if __name__ == "__main__": sales, filtered_data, features = read(filename=str(settings.feature_value)) X_train, X_valid = split(filtered_data, settings.train_size) X_out, gbm, yhat_valid, error = train_test_XGboost( X_train, X_valid, features, settings.XGBparams, settings.XGBnum_boost_round, verbose=False) save('feature_importance_' + settings.feature_value) X_out, yhat, linreg, error = train_test_LinearReg(X_train, X_valid, features) X_project = forecast_future(filtered_data, gbm, features, use_XGBOOST=1)
# TensorFlow and tf.keras import tensorflow as tf from tensorflow import keras import numpy as np import matplotlib.pyplot as plt from helpers import split, fetch_data_set, shuffle_data save = True x, y, m = fetch_data_set(percent=100) x, y = shuffle_data(x, y) x, x_test = split(x, [80]) y, y_test = split(y, [80]) print(x.shape, y.shape, x_test.shape, y_test.shape) model = keras.Sequential([ keras.layers.Flatten(input_shape=(400, 1)), keras.layers.Dense(128, activation="relu"), keras.layers.Dense(10), ]) model.compile( optimizer="adam", loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=["accuracy"], )