def __init__(self): observations = [get_random_state().data.reshape(-1) for _ in range(10000)] self.scaler = sklearn.preprocessing.StandardScaler() self.scaler.fit(observations) self.featurizer = sklearn.pipeline.FeatureUnion([ ("rbf1", RBFSampler(gamma=5.0, n_components=150)), ("rbf2", RBFSampler(gamma=2.0, n_components=150)), ("rbf3", RBFSampler(gamma=1.0, n_components=150)), ("rbf4", RBFSampler(gamma=0.5, n_components=150)) ], n_jobs=1) # self.featurizer.fit(observations) self.featurizer.fit(self.scaler.transform(observations)) self.models = dict() for i in range(BOARD_ROWS): for j in range(BOARD_COLS): model = SGDRegressor(learning_rate="constant") model.partial_fit([self.featurize_state(State())], [0]) self.models[(i,j)] = model
def login(): """ View function to render the default page to the user. Enables the user to login using Google or Facebook OAuth provider. :return: """ state = utils.get_random_state() login_session['state'] = state # Get all categories and their item count all_categories = _get_categories() # Get most recently added items latest_items = _get_latest_category_items() return render_template('index.html', GOOGLE_CLIENT_ID=GOOGLE_CLIENT_ID, FB_APP_ID=FB_APP_ID, STATE=login_session['state'], LOGIN_SESSION=login_session, ACTIVE_CATEGORY=LATEST_CATEGORY, ALL_CATEGORIES=all_categories, CATEGORY_ITEMS=latest_items)
n_images = 25 plt.figure(figsize=(10, 10)) for i in range(n_images): plt.subplot(5, 5, i + 1) plt.xticks([]) plt.yticks([]) plt.grid(False) plt.imshow(digits.images[i], cmap=plt.cm.binary) plt.xlabel("Value: %d" % digits.target_names[digits.target[i]], fontsize=12) plt.suptitle('Example of the training data', fontsize=30) plt.show() # setup random state seed = 687 random_state = uls.get_random_state(seed) # split data X_train, X_test, y_train, y_test = train_test_split(flat_images, digits.target, test_size=0.33, random_state=random_state) # ++++++++++++++++++++++++++ # THE ANN # restrictions: # - 2 h.l. with sigmoid a.f. # - softmax a.f. at output # - 20% for validation # ++++++++++++++++++++++++++ # ann's ingridients
from utils import get_random_state from utils import compare if __name__ == "__main__": # (Question 1) dt.py: Decision tree SAMPLE_NUMBER = 2000 TRAIN_SET_SAMPLE_NUM = 150 X, y = get_dataset(SAMPLE_NUMBER) X_train, y_train = X[:TRAIN_SET_SAMPLE_NUM], y[:TRAIN_SET_SAMPLE_NUM] X_test, y_test = X[TRAIN_SET_SAMPLE_NUM:], y[TRAIN_SET_SAMPLE_NUM:] # 1. decisionTreeClassifier = DecisionTreeClassifier(random_state=get_random_state()) decisionTreeClassifier.fit(X_train, y_train) y_dtc = decisionTreeClassifier.predict(X_test) # Plot plot_boundary("1-1-Ground-Truth", decisionTreeClassifier, X_test, y_test, title="Ground Truth data") plot_boundary("1-1-Prediction", decisionTreeClassifier, X_test, y_dtc, title="Prediction data") # 2. max_depths = [i for i in range(1, 20)] training_scores = [] for max_depth in max_depths: decisionTreeClassifier = DecisionTreeClassifier(random_state=get_random_state(), max_depth=max_depth) decisionTreeClassifier.fit(X_train, y_train) y_dtc = decisionTreeClassifier.predict(X_test)
# -*- coding: utf-8 -*- """ Created on Fri Nov 6 14:07:50 2015 """ import numpy as np from matplotlib import pyplot as plt from utils import get_random_state from sklearn.linear_model import LinearRegression from sklearn.neighbors import KNeighborsRegressor from sklearn.linear_model import Ridge random_state = get_random_state() ''' This function is used to create a sample of data thanks to the given function Input : - x : The input value - n_samples : number of samples made with this input Output : - y : The data ''' def make_data(x,n_samples = 1, noise = 1): y = np.zeros(n_samples) for i in range(n_samples):
def main(): idw = arcpy.env.workspace + "\\Idw_Projected_30" noise_map = arcpy.env.workspace + "\\Transportation_Noise" line_for_initialization = arcpy.env.workspace + "\\example_route" geofences_restricted_airspace = arcpy.env.workspace + "\\Restricted_Airspace" geofence_point_boundary = arcpy.env.workspace + "\\Restricted_Airspace_Point_Boundary" output_new_line = r'threedline' #set up flight constraints # legal constraints parameters maximum_speed_legal = 27.7777777778 # in m/s. 100 in km/h # air taxi specific parameters #for Lilium Jet flight characteristics: aircraft = "Lilium". for Ehang aircraft ="EHANG" aircraft = "Lilium" type_aircraft, weight_aircraft, wing_area, CD_from_drag_polar, maximum_speed_air_taxi, acceleration_speed, acceleration_energy, deceleration_speed, deceleration_energy, minimal_cruise_energy, take_off_and_landing_energy, hover_energy, noise_pressure_acceleration, noise_pressure_deceleration, noise_at_cruise, noise_at_hover = init.aircraft_specs( aircraft) # flight comfort constraint maximum_angular_speed = 1 # (in radian/second) #environmental depending settings air_density = 1.225 #(in kg/m³) standard air pressure speed_of_sound = 343 # in m/s, at 20 Degrees Celsius gravity = 9.81 # in m/s² flight_constraints = flight_Constraints( type_aircraft, weight_aircraft, wing_area, CD_from_drag_polar, maximum_speed_legal, maximum_speed_air_taxi, acceleration_speed, acceleration_energy, deceleration_speed, deceleration_energy, minimal_cruise_energy, take_off_and_landing_energy, hover_energy, noise_pressure_acceleration, noise_pressure_deceleration, noise_at_cruise, noise_at_hover, maximum_angular_speed, air_density, speed_of_sound, gravity) #if feature classes from previous runs shall not be deleted, uncomment #uls.delete_old_objects_from_gdb("threed") # setup problem hypercube = [(-5, 5), (-5, 5)] rs = uls.get_random_state(1) problem_instance = ThreeDSpace( search_space=hypercube, fitness_function=uls.multi_objective_NSGA_fitness_evaluation(), IDW=idw, noisemap=noise_map, x_y_limits=900, z_sigma=5, work_space=env.workspace, random_state=rs, init_network=line_for_initialization, sample_point_distance="400 Meters", restricted_airspace=geofences_restricted_airspace, flight_constraints=flight_constraints, geofence_point_boundary=geofence_point_boundary) #evalluate least cost path # from solutions import solution # import utils # # linefc = "least_cost_path_3d" # pointfc = "least_cost_path_3d_p" # zpointfc = "least_cost_path_3d_p_z" # #utils.lineToPoints(linefc, pointfc, 10) # #utils.extractValuesRaster(pointfc, idw, zpointfc) # # repr = utils.point3d_fc_to_np_array(zpointfc, additional_fields = None) # # least_cost_path_solution = solution.Solution(repr) # least_cost_path_solution.PointFCName = pointfc # least_cost_path_solution.LineFCName = linefc # problem_instance.evaluate(least_cost_path_solution) # setup Genetic Algorithm p_c = 0.9 p_m = 0.5 n_iterations = 25 population_size = 16 n_crossover_points = 4 selection_pressure = 0.4 #params mutation percentage_disturbed_chromosomes = 0.2 max_disturbance_distance = 200 percentage_inserted_and_deleted_chromosomes = 0.25 mutation_group_size = 3 for seed in range(1): # setup random state random_state = uls.get_random_state(seed) # execute Genetic Algorithm ga1 = GeneticAlgorithm( problem_instance=problem_instance, random_state=random_state, population_size=population_size, selection=uls.nsga_parametrized_tournament_selection( selection_pressure), crossover=uls.n_point_crossover(n_crossover_points), p_c=p_c, mutation=uls.parametrized_point_mutation( percentage_disturbed_chromosomes= percentage_disturbed_chromosomes, max_disturbance_distance=max_disturbance_distance, percentage_inserted_and_deleted_chromosomes= percentage_inserted_and_deleted_chromosomes, group_size=mutation_group_size), p_m=p_m, aimed_point_amount_factor=2) ga1.initialize() #setting up the logging t = strftime("%Y-%m-%d_%H_%M_%S", gmtime()) lgr = logging.getLogger(t) lgr.setLevel(logging.DEBUG) # log all escalated at and above DEBUG # add a file handler fh = logging.FileHandler(r'baseline_routing/log_files/' + t + '_new.csv') fh.setLevel(logging.DEBUG) frmt = logging.Formatter( '%(asctime)s,%(name)s,%(levelname)s,%(message)s') fh.setFormatter(frmt) lgr.addHandler(fh) log_event = [ "rs", id(seed), __name__, "population_size", population_size, "x_y_limits", problem_instance.x_y_limits, "z_sigma", problem_instance.z_sigma, "sample_point_distance", problem_instance.sample_point_distance, "selection_pressure", selection_pressure, "pc", p_c, "pm", p_m, "aimed_point_factor", ga1.aimed_point_amount_factor, "n_crossover", n_crossover_points, "mutation_max_disturbance_distance", max_disturbance_distance, "mutation_group_size", mutation_group_size, "percentage_inserted_and_deleted", percentage_inserted_and_deleted_chromosomes, "percentage_disturbed", percentage_disturbed_chromosomes ] lgr.info(','.join(list(map(str, log_event)))) ga1.search(n_iterations=n_iterations, lgr=lgr, report=True, log=True, dplot=None)
import os import datetime import logging import numpy as np import matplotlib.pyplot as plt from sklearn import datasets from sklearn.metrics import accuracy_score from sklearn.model_selection import train_test_split import utils as uls from problems.ANNOP import ANNOP from ANN.ANN import ANN, softmax, sigmoid from algorithms.genetic_algorithm_Elitism import GeneticAlgorithm # setup logger file_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "LogFiles/" + (str(datetime.datetime.now().date()) + "-" + str(datetime.datetime.now().hour) + \ "_" + str(datetime.datetime.now().minute) + "_log.csv")) logging.basicConfig(filename=file_path, level=logging.DEBUG, format='%(name)s,%(message)s') #++++++++++++++++++++++++++ # THE DATA # restrictions: # - MNIST digits (8*8) # - 33% for testing # - flattened input images #++++++++++++++++++++++++++ # import data digits = datasets.load_digits() flat_images = np.array([image.flatten() for image in digits.images]) print(flat_images.shape) print(digits.target_names)
######################### Script DICTIONARY_FILE = '../WataProject/sentiment-dict.txt' TWEETS_LABELLED_FILE = '../WataProject/training_data_file.csv' N_FOLDS = 10 words_from_dict = read_dictionary(DICTIONARY_FILE) tweets, classes = read_tweets_labelled(TWEETS_LABELLED_FILE) vectorizer = CountVectorizer(min_df=1, vocabulary=set(words_from_dict).union(words_from_tweets(tweets)), lowercase=True) # Select classifier clf = svm.LinearSVC(random_state=get_random_state()) parameters = {'C': np.arange(0.01, 1.05, 0.05), 'loss': ['hinge', 'squared_hinge']} # clf = tree.DecisionTreeClassifier(random_state=get_random_state()) # parameters = {'max_depth': np.arange(1, 2000, 50)} # clf = svm.SVC(random_state=get_random_state()) # parameters = {'C': np.arange(0.1, 1.1, 0.1), 'kernel': ['poly', 'rbf'], 'gamma': np.arange(0.00005, 0.00006, 0.000001)} # clf = ensemble.ExtraTreesClassifier(random_state=get_random_state()) # parameters = {'criterion': ['gini']} new_tweets = ["New episode is awesome #GoTSeason6", "Best show ever #GoTSeason6 #ValarMorghulis", "Not that bad #GoTSeason6", "So disappointed, so slow #GoTSeason6", "Stopping watching the show, nothing like the books #GoTSeason6"] ############ Model evaluation