def generator(num_exp, sky, read, sig):
#############################################
# Generator of Signal and Noise Distributions
# Parameters:
# num_exp = Number of exposures taken
# sky = photon rate of the sky-background
# read = photon rate of the read noise
# sig = photon rate of the signal
#############################################
num_meas = 1
# Calculate the total noise and signal rates
tot_rate = sky + sig + read * num_exp
tot_noise_rate = sky + read * num_exp
noise_array = []
signal_array = []
#Initialize random class
R = Random()
#Get the samples for the different distributions
noise = R.Poisson(lam=tot_noise_rate, size=(num_meas, num_exp))
signal = R.Poisson(lam=tot_rate, size=(num_meas, num_exp))
return (signal, noise)
def call_random(i,
x,
training_data,
testing_data,
fold,
goal="Max",
eval_time=3600,
lifes=5):
# test_data = testing_data.values
random_optimizer = Random(NP=10,
Goal=goal,
eval_time=eval_time,
num_lifes=lifes)
v, num_evals, tuning_time = random_optimizer.solve(
process, OrderedDict(param_grid[i]['learners_para_dic']),
param_grid[i]['learners_para_bounds'],
param_grid[i]['learners_para_categories'], param_grid[i]['model'], x,
training_data, fold)
params = v.ind.values()
start_time = time.time()
predicted_tune = param_grid[i]['model'](training_data.iloc[:, :-1],
training_data.iloc[:, -1],
testing_data.iloc[:, :-1], params)
predicted_default = param_grid[i]['model'](training_data.iloc[:, :-1],
training_data.iloc[:, -1],
testing_data.iloc[:, :-1], None)
val_tune = evaluation(x, predicted_tune, testing_data.iloc[:, -1],
testing_data.iloc[:, :-1])
val_predicted = evaluation(x, predicted_default, testing_data.iloc[:, -1],
testing_data.iloc[:, :-1])
print("For measure %s: default=%s, predicted=%s" %
(x, val_predicted, val_tune))
tuning_time += time.time() - start_time
# print(val_tune, params, num_evals, tuning_time)
return val_tune, params, num_evals, tuning_time
def test():
""" Testing stuff to see it works properly """
a = Random()
b = Sequential()
a.enter_name("Player Random")
b.enter_name("Player Sequential")
game = SingleGame(a, b)
game.perform_game()
game.show_result()
def Cookie_Derp(Seedd, Ratee, Nmeass, Nexpp, OutputFileNamee):
# default seed
Seed = 5555
# default rate parameter for cookie disappearance (rate =1, means a cookies per day)
Rate = 1
# default number of time measurements (time to next missing cookie) - per experiment
Nmeas = 1
# default number of experiments
Nexp = 1
# output file defaults
doOutputFile = False
# class instance of our Random class using seed
Seed = int(Seedd)
Rate = float(Ratee)
Nmeas = int(Nmeass)
Nexp = int(Nexpp)
random = Random(Seed)
doOutputFile = True
if doOutputFile == True:
OutputFileName = OutputFileNamee
else:
OutputFileName = "Cookie.txt"
if doOutputFile:
outfile = open(OutputFileName, 'w+')
outfile.write(str(Rate)+"\n")
for e in range(0,Nexp):
for t in range(0,Nmeas):
outfile.write(str(random.Exponential(Rate))+" ")
outfile.write(" \n")
outfile.close()
else:
print(Rate)
for e in range(0,Nexp):
for t in range(0,Nmeas):
print(random.Exponential(Rate), end=' ')
print(" ")
def choose_players():
""" Let user choose players and player names in textual interface"""
# Available picks
player_type_list = ["H", "MC", "S", "R"]
players = []
while len(players) < 2: # Until the player count is two
i = len(players) + 1 # Number of current player
while True:
player_type_input = input(f"Player {i}: ")
if player_type_input not in player_type_list:
print("Invalid input! Please try again.")
continue # Loop will continue until valid input
break
if player_type_input == "H":
while True:
try:
memo = int(input("What will memory of Historian be? "))
except:
continue
if 1 <= memo <= 20:
break
player = Historian(memo)
if player_type_input == "MC":
player = MostCommon()
if player_type_input == "S":
player = Sequential()
if player_type_input == "R":
player = Random()
player_name = input("Player name: ")
player.enter_name(player_name)
players.append(player)
i += 1
return players # List with players to enter tournament
def get_algorithm(algorithm_type, alpha, clusters):
if algorithm_type == AlgorithmType.Random:
return Random(alpha, clusters)
# elif algorithm_type == AlgorithmType.EFirst:
# return EFirst(alpha, clusters)
elif algorithm_type == AlgorithmType.EGreedy:
return EGreedy(alpha, clusters)
elif algorithm_type == AlgorithmType.EGreedy_Disjoint:
return EGreedy_Disjoint(alpha, clusters)
# elif algorithm_type == AlgorithmType.EGreedy_Hybrid:
# return EGreedy_Hybrid(alpha, clusters)
# elif algorithm_type == AlgorithmType.EGreedy_Seg:
# return Combo_Seg(alpha, AlgorithmType.EGreedy)
elif algorithm_type == AlgorithmType.LinUCB_Disjoint:
return LinUCB_Disjoint(alpha, clusters)
# elif algorithm_type == AlgorithmType.LinUCB_GP:
# return LinUCB_GP(alpha, clusters)
elif algorithm_type == AlgorithmType.LinUCB_GP_All:
return LinUCB_GP_All(alpha, clusters)
# elif algorithm_type == AlgorithmType.LinUCB_Hybrid:
# return LinUCB_Hybrid(alpha, clusters)
elif algorithm_type == AlgorithmType.UCB:
return UCB(alpha, clusters)
# elif algorithm_type == AlgorithmType.UCB_Seg:
# return Combo_Seg(alpha, AlgorithmType.UCB)
else:
raise NotImplementedError("Non-implemented algorithm." +
algorithm_type.name)
p = sys.argv.index('-Nmeas')
Nt = int(sys.argv[p + 1])
if Nt > 0:
Nmeas = Nt
if '-Nexp' in sys.argv:
p = sys.argv.index('-Nexp')
Ne = int(sys.argv[p + 1])
if Ne > 0:
Nexp = Ne
if '-output' in sys.argv:
p = sys.argv.index('-output')
OutputFileName = sys.argv[p + 1]
doOutputFile = True
# class instance of our Random class using seed
random = Random(seed)
if doOutputFile:
outfile = open(OutputFileName, 'w')
outfile.write(str(rate) + " \n")
for e in range(0, Nexp):
for t in range(0, Nmeas):
outfile.write(str(random.Exponential(rate)) + " ")
outfile.write(" \n")
outfile.close()
else:
print(rate)
for e in range(0, Nexp):
for t in range(0, Nmeas):
print(random.Exponential(rate), end=' ')
print(" ")
#! /usr/bin/env python
from Random import Random
import numpy as np
import matplotlib.pyplot as plt
if __name__ == "__main__":
i = 0
random = Random(66666)
valuelist = []
while i < 1000:
#print (random.Exponential(i),"exponential")
#print (random.Color_Baloon(),"my color")
#color = random.Color_Baloon()
x = random.parabolic_dist(10.)
#x = random.Exponential(10.)
#print (x)
#color =random.Bernoulli(0.5)
valuelist.append(x)
#print (color)
i = i + 1
n, bins, patches = plt.hist(valuelist,
20,
density=True,
facecolor='r',
alpha=0.75)
#print (n)
plt.xlabel('x')
plt.ylabel('Probability/20 bin')
plt.title('Generated Random Numbers with parabolic distribution ')
# Cole Le Mahieu Project 3
# import packages
import sys
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.mlab as mlab
from scipy.stats import norm
from math import *
from Random import Random
# instantiate Random class
random = Random()
# default number experiments, measurements
Nexp = 500
Nroll = 100
# default slices to pull out of neymann construction
probA = 0.3
probB = 0.6
# user can input value for experiment or measurement number
if "-Nexp" in sys.argv:
p = sys.argv.index("-Nexp")
Ne = int(sys.argv[p + 1])
if Ne > 0:
Nexp = Ne
if "-Nroll" in sys.argv:
p = sys.argv.index("-Nroll")
Nt = int(sys.argv[p + 1])
for rep in range(REP):
rand_state = np.random.randint(low = 1, high = 1000)
np.random.seed(rand_state)
divideFold = KFold(10, random_state = rand_state, shuffle = True)
reg_models = {}
reg_models["gradient_boosting"] = lambda: ensemble.GradientBoostingRegressor()
reg_models["neural_network"] = lambda: neural_network.MLPRegressor()
reg_models["ridge"] = lambda: linear_model.Ridge()
reg_models["gradient_descent"] = lambda: linear_model.SGDRegressor()
reg_models["svm"] = lambda: svm.SVR(gamma = "auto")
reg_models["knn"] = lambda: neighbors.KNeighborsRegressor(weights = "distance")
reg_models["random_forest"] = lambda: ensemble.RandomForestRegressor(random_state = rand_state)
reg_models["gaussian_process"] = lambda: gaussian_process.GaussianProcessRegressor()
reg_models["decision_tree"] = lambda: tree.DecisionTreeRegressor(random_state = rand_state)
reg_models["random"] = lambda: Random()
reg_models["default"] = lambda: Default()
results = {}
for baseline in ["default", "random"]:
results[baseline] = {}
# Loop through all regressors, except the baseline
for regressor_type in filter(lambda reg: not reg in ["random", "default"], constants.REGRESSORS):
# results[baseline][regressor_type] = {}
kfold = 0
results[baseline][regressor_type] = []
# Divide datasets in train and test
for train_indx, test_indx in divideFold.split(datasets):
# results[baseline][regressor_type][kfold] = []
# Only get pymfe calculated features for train datasets
targets = data[data.name.isin(list(datasets.iloc[train_indx]))]
users_to_update = list()
clicks_to_update = list()
user_recommendation_size = int(len(user_ids) * part)
print("Starting evaluation of {0} with recommendation of size: {1}".format(
algoName, part))
input = open(
"{0}//{1}//Processed//sorted_time_impressions.csv".format(path, name),
"r")
input.readline() # get rid of header
line = input.readline()
hour_begin_timestamp = datetime.datetime.fromtimestamp(
int(line.split(",")[2]) / 1000)
warmup = True
algo = Random(alpha, user_embeddings, user_ids)
recommended_users = list()
for line in input:
total_impressions += 1
parts = line.split(",")
user_id = int(parts[0])
click = int(parts[1])
timestamp = datetime.datetime.fromtimestamp(int(parts[2]) / 1000)
if warmup and (timestamp - hour_begin_timestamp
).seconds < time_between_updates_in_seconds:
users_to_update.append(user_id)
clicks_to_update.append(click)
continue
if (timestamp - hour_begin_timestamp
def __init__(self, seed=5555):
self.m_random = Random(seed)
#! /usr/bin/env python
from Random import Random
import numpy as np
import matplotlib.pyplot as plt
random_number = Random(77777777)
myx = []
for x in range(1, 10000):
faces = random_number.Category6()
myx.append(faces)
# create histogram of our data
plt.figure()
plt.hist(myx,
6,
density=True,
facecolor='green',
histtype="barstacked",
alpha=0.75)
# plot formating options
plt.xlabel('Dice faces')
plt.ylabel('Probability', fontweight="bold", fontsize="17")
plt.title('Categorical Distribution', fontweight="bold", fontsize="17")
plt.grid(True, color='r')
# save and show figure
plt.savefig("Dice.png")
#plt.show()
reg_models[
"gradient_boosting"] = lambda: ensemble.GradientBoostingRegressor()
reg_models["neural_network"] = lambda: neural_network.MLPRegressor()
reg_models["ridge"] = lambda: linear_model.Ridge()
reg_models["gradient_descent"] = lambda: linear_model.SGDRegressor()
reg_models["svm"] = lambda: svm.SVR(gamma="auto")
reg_models["knn"] = lambda: neighbors.KNeighborsRegressor(weights=
"distance")
reg_models["random_forest"] = lambda: ensemble.RandomForestRegressor(
random_state=rand_state)
reg_models[
"gaussian_process"] = lambda: gaussian_process.GaussianProcessRegressor(
)
reg_models["decision_tree"] = lambda: tree.DecisionTreeRegressor(
random_state=rand_state)
reg_models["random"] = lambda: Random(random_seed=rand_state)
reg_models["default"] = lambda: Default()
predictions = []
# Divide datasets in train and test
for train_indx, test_indx in divideFold.split(datasets):
models = {}
# Selecting only data for test
tests = meta_base[meta_base.name.isin(list(datasets.iloc[test_indx]))]
# Selecting only data from train
train_data = meta_base[meta_base.name.isin(
list(datasets.iloc[train_indx]))]
targets = train_data.drop(combinations_strings + ["name"],
axis=1).values
# Training block
for comb in combinations_strings:
def generator_Of_Random_Coin(Seedd, Probb, Ntosss, Nexpp, Outputt):
#Assignments of defaults
Seed = 53422
# Single coin-toss probability for "1"
Prob = 0.3
# number of coin tosses (per experiment)
Ntoss = 10
# number of experiments
Nexp = 10
# output file defaults
doOutputFile = False
# read the user-provided seed from the command line (if there)
if '-seed' in sys.argv:
p = sys.argv.index('-seed')
seed = sys.argv[p+1]
if '-prob' in sys.argv:
p = sys.argv.index('-prob')
ptemp = float(sys.argv[p+1])
if ptemp >= 0 and ptemp <= 1:
prob = ptemp
if '-Ntoss' in sys.argv:
p = sys.argv.index('-Ntoss')
Nt = int(sys.argv[p+1])
if Nt > 0:
Ntoss = Nt
if '-Nexp' in sys.argv:
p = sys.argv.index('-Nexp')
Ne = int(sys.argv[p+1])
if Ne > 0:
Nexp = Ne
if '-output' in sys.argv:
p = sys.argv.index('-output')
OutputFileName = sys.argv[p+1]
doOutputFile = True
# class instance of our Random class using seed
Seed = int(Seedd)
Prob = float(Probb)
Ntoss = int(Ntosss)
Nexp = int(Nexpp)
random = Random(Seed)
doOutputFile = True
if doOutputFile == True:
outfile = Outputt
else:
outfile = "Flips.txt"
if doOutputFile: #flag to check if there is file
outfile = open(outfile, 'w+')
for e in range(0,Nexp):
for t in range(0,Ntoss):
outfile.write(str(random.Geometric(Prob))+" ")
outfile.write(" \n")
outfile.close()
else:
for e in range(0,Nexp):
for t in range(0,Ntoss):
print(random.Geometric(Prob), end=' ')
print(" ")
return (outfile)
# default seed
seed = 5555
# default type of dice roll
type = "nb"
# default number of coin tosses (per experiment)
Ntoss = 1
# default number of experiments
Nexp = 1
# output file defaults
doOutputFile = False
random_number = Random(seed)
# read the user-provided seed from the command line (if there)
if '-seed' in sys.argv:
p = sys.argv.index('-seed')
seed = sys.argv[p + 1]
if '-type' in sys.argv:
p = sys.argv.index('-type')
ptemp = sys.argv[p + 1]
type = ptemp
if '-Ntoss' in sys.argv:
p = sys.argv.index('-Ntoss')
Nt = int(sys.argv[p + 1])
if Nt > 0:
Ntoss = Nt
def get_algorithm(algorithm_type, alpha):
if algorithm_type == AlgorithmType.Random:
return Random(alpha)
elif algorithm_type == AlgorithmType.EFirst:
return EFirst(alpha)
elif algorithm_type == AlgorithmType.EGreedy:
return EGreedy(alpha)
elif algorithm_type == AlgorithmType.EGreedy_Disjoint:
return EGreedy_Disjoint(alpha)
elif algorithm_type == AlgorithmType.EGreedy_Hybrid:
return EGreedy_Hybrid(alpha)
elif algorithm_type == AlgorithmType.EGreedy_Seg:
return Combo_Seg(alpha, AlgorithmType.EGreedy)
elif algorithm_type == AlgorithmType.LinUCB_Disjoint:
return LinUCB_Disjoint(alpha)
elif algorithm_type == AlgorithmType.LinUCB_GP:
return LinUCB_GP(alpha)
elif algorithm_type == AlgorithmType.LinUCB_GP_All:
return LinUCB_GP_All(alpha)
elif algorithm_type == AlgorithmType.LinUCB_Hybrid:
return LinUCB_Hybrid(alpha)
elif algorithm_type == AlgorithmType.UCB:
return UCB(alpha)
elif algorithm_type == AlgorithmType.UCB_Seg:
return Combo_Seg(alpha, AlgorithmType.UCB)
elif algorithm_type == AlgorithmType.EGreedy_Lin:
return EGreedy_Lin(alpha)
elif algorithm_type == AlgorithmType.EGreedy_Seg_Lin:
return Combo_Seg(alpha, AlgorithmType.EGreedy_Lin)
elif algorithm_type == AlgorithmType.EGreedy_Lin_Hybrid:
return EGreedy_Lin_Hybrid(alpha)
elif algorithm_type == AlgorithmType.TS:
return TS(alpha)
elif algorithm_type == AlgorithmType.TS_Bootstrap:
return TS_Bootstrap(alpha)
elif algorithm_type == AlgorithmType.TS_Lin:
return TS_Lin(alpha)
elif algorithm_type == AlgorithmType.TS_Seg:
return Combo_Seg(alpha, AlgorithmType.TS)
elif algorithm_type == AlgorithmType.TS_Disjoint:
return TS_Disjoint(alpha)
elif algorithm_type == AlgorithmType.TS_Hybrid:
return TS_Hybrid(alpha)
elif algorithm_type == AlgorithmType.TS_Truncated:
return TS_Truncated(alpha)
elif algorithm_type == AlgorithmType.EGreedy_TS:
return EGreedy_TS(alpha)
elif algorithm_type == AlgorithmType.TS_Gibbs:
return TS_Gibbs(alpha)
elif algorithm_type == AlgorithmType.TS_Laplace:
return TS_Laplace(alpha)
elif algorithm_type == AlgorithmType.EGreedy_Annealing:
return EGreedy_Annealing(alpha)
elif algorithm_type == AlgorithmType.NN:
return NN(alpha)
elif algorithm_type == AlgorithmType.Ensemble:
return Ensemble(alpha)
elif algorithm_type == AlgorithmType.TS_RLR:
return TS_RLR(alpha)
else:
raise NotImplementedError("Non-implemented algorithm." +
algorithm_type.name)
