def main_():
if len(argv) < 2:
print 'The input format is\nmain train/test [tcp/b] [filename]'
return 0
t = argv[1]
mode = 'tcp'
data = []
if len(argv) == 4:
mode = argv[2]
if mode == 'tcp':
getdata = getdata_tcp
else:
getdata = getdata_b
if t == 'test':
if len(argv) == 2:
test()
else:
fname = argv[3]
data = getdata_file(fname)
data = filter_xyz(data)
data14 = cluster(data, 14)
simulate(data14)
elif t == 'train':
train()
else:
while (True):
data = getdata()
data = filter_xyz(data)
data14 = cluster(data, 14)
simulate(data14)
def main(P, mate, mutate):
"""Run this experiment"""
training_ints = initialize_instances('./../data/x_train_val.csv')
testing_ints = initialize_instances('./../data/x_test.csv')
factory = BackPropagationNetworkFactory()
measure = SumOfSquaresError()
data_set = DataSet(training_ints)
acti = HyperbolicTangentSigmoid()
rule = RPROPUpdateRule()
oa_name = "GA_{}_{}_{}".format(P, mate, mutate)
FILE = OUTFILE.replace('XXX', oa_name)
with open(FILE, 'w') as f:
f.write('{},{},{},{},{},{},{},{},{}\n'.format('iteration', 'MSE_trg',
'MSE_tst', 'acc_trg',
'acc_tst', 'f1_trg',
'f1_tst', 'train_time',
'pred_time'))
classification_network = factory.createClassificationNetwork([
INPUT_LAYER, HIDDEN_LAYER1, HIDDEN_LAYER2, HIDDEN_LAYER3,
HIDDEN_LAYER4, OUTPUT_LAYER
], acti)
nnop = NeuralNetworkOptimizationProblem(data_set, classification_network,
measure)
oa = StandardGeneticAlgorithm(P, mate, mutate, nnop)
train(oa, classification_network, oa_name, training_ints, testing_ints,
measure, TRAINING_ITERATIONS, FILE)
def main_(): if len(argv) < 2: print 'The input format is\nmain train/test [tcp/b] [filename]' return 0 t=argv[1] mode='tcp' data=[] if len(argv) == 4 : mode=argv[2] if mode == 'tcp': getdata = getdata_tcp else : getdata = getdata_b if t == 'test': if len(argv) == 2: test() else: fname=argv[3] data=getdata_file(fname) data=filter_xyz(data) data14=cluster(data,14); simulate(data14); elif t == 'train': train() else: while(True): data=getdata() data=filter_xyz(data) data14=cluster(data,14) simulate(data14)
def main():
"""Run this experiment"""
training_ints = initialize_instances('./../data/x_train_val.csv')
testing_ints = initialize_instances('./../data/x_test.csv')
factory = BackPropagationNetworkFactory()
measure = SumOfSquaresError()
data_set = DataSet(training_ints)
acti = HyperbolicTangentSigmoid()
rule = RPROPUpdateRule()
classification_network = factory.createClassificationNetwork([INPUT_LAYER, HIDDEN_LAYER1,HIDDEN_LAYER2,HIDDEN_LAYER3,HIDDEN_LAYER4, OUTPUT_LAYER],acti)
nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure)
oa = RandomizedHillClimbing(nnop)
train(oa, classification_network, 'RHC', training_ints, testing_ints, measure, TRAINING_ITERATIONS, OUTFILE)
def main():
"""Run this experiment"""
training_ints = initialize_instances('./../data/x_train_val.csv')
testing_ints = initialize_instances('./../data/x_test.csv')
factory = BackPropagationNetworkFactory()
measure = SumOfSquaresError()
data_set = DataSet(training_ints)
acti = HyperbolicTangentSigmoid()
rule = RPROPUpdateRule()
# oa_names = ["Backprop"]
classification_network = factory.createClassificationNetwork([
INPUT_LAYER, HIDDEN_LAYER1, HIDDEN_LAYER2, HIDDEN_LAYER3,
HIDDEN_LAYER4, OUTPUT_LAYER
], acti)
train(
BatchBackPropagationTrainer(data_set, classification_network, measure,
rule), classification_network, 'Backprop',
training_ints, testing_ints, measure, TRAINING_ITERATIONS, OUTFILE)
def train_from_rss(feeds):
parser = parse_old.Parser()
all_lines = []
for link, content in feeds:
text_clean = re.sub('<[^<]+?>', '', content)
raw = urllib2.urlopen(link).read()
encoding = chardet.detect(raw)['encoding']
raw_uni = raw.decode(encoding)
line_list = parser.parserByDensity(raw_uni)
line_list = [line[:4] for line in line_list]
line_list = [line + [(1 if line[0][:20] in text_clean else 0)] for line in line_list]
# 大于2行才有意义
# 获取最后一个是1的,这样所有判断的才是确定是正确的。
lines = []
start = 0
last = 0
for index, val in enumerate(line_list):
if val[-1]:
last = index
if val[-1] and not start:
start = index
# for index in range(last):
# print str(line_list[index][5]) + str(line_list[index][1])[:4] + line_list[index][0]
if len(line_list) > 2:
fake_line = ['', 0, 0, 0, 0]
line_list = [fake_line] + line_list + [fake_line]
lines = [[line_list[i][1], line_list[i - 1][1], line_list[i + 1][1], line_list[i][-1]] for i in range(1, len(line_list) - 1)]
all_lines += lines
# Balance positive samples and negative samples:
positive = [line for line in all_lines if line[-1] > 0]
negative = [line for line in all_lines if line[-1] <= 0]
random.shuffle(positive)
random.shuffle(negative)
min_len = min(len(positive), len(negative), 100) # Too many samples may not a good thing.
all_lines = positive[:min_len] + negative[:min_len]
random.shuffle(all_lines)
train(all_lines)
with open('train.csv', 'w') as f:
for line in all_lines:
print line
f.write(','.join(map(str, (line[0], line[-1]))) + '\n')
def train_bayes(params):
"""
Wrapper around train function to serve as objective function for Gaussian
optimization in scikit-optimize routine gp_minimize.
Arguments:
----------
params: list, shape=[nb_layers + 2,]
List of search space dimensions. Entries have to be tuples
(lower_bound, upper_bound) for Reals or Integers.
Returns:
--------
tbd
"""
# Create Hyperdash hd_experiment
hd_exp = Experiment(project_name)
# Translate params into format understood by train function
# n_layer = 4
# layer_sizes = hd_exp.param('layer_sizes', (2**np.array(params[:n_layer])).tolist())
# learning_rate = hd_exp.param('learning rate', 10**params[n_layer])
# mini_batch_size = hd_exp.param('mini batch size', int(2**params[n_layer + 1]))
# pkeep = hd_exp.param('dropout prob', 1)
# hyper_params = [layer_sizes, learning_rate, mini_batch_size, pkeep]
# hyper_param_str = make_hyper_param_str(hyper_params)
layer_sizes = [4096] * 4
learning_rate = hd_exp.param('learning rate', 10**params[0])
mini_batch_size = hd_exp.param('mini batch size', int(2**params[1]))
pkeep = hd_exp.param('dropout prob', 1)
hyper_params = [layer_sizes, learning_rate, mini_batch_size, pkeep]
hyper_param_str = make_hyper_param_str(hyper_params)
# Call train function
tic = time.time()
logger.info('Start training for ' + hyper_param_str)
log_df, best_error = train(train_tuple, validation_tuple, hyper_params,
nb_epochs, random_seed, hd_exp, project_dir)
elapsed_time = time.time() - tic
logger.info('Finished training in {} s.'.format(elapsed_time))
# Writing Pandas log file to csv file on disk.
logger.info('Writing pandas DF log to disk.')
log_df.to_csv(project_dir + '/' + hyper_param_str + '/data_df.csv')
# Finish Hyperdash Experiment
hd_exp.end()
return best_error
def my_solution(X_train, X_test, y_train, y_test):
# train with self
dimensions = [X_train.shape[1], 3, y_train.shape[1]]
params = ann.train(X_train,
y_train,
dimensions,
alpha=0.1,
batch_size=50,
epoch=3472,
momentum=0.04,
tol=1e-10)
y_pred = ann.predict(X_test, params, dimensions)
y_pred = y_pred.argmax(axis=1)
y_test = y_test.argmax(axis=1)
# evaluate
print('My implements1:')
print(classification_report(y_test, y_pred))
return params, y_pred, y_test
import ann ann.initialize() ann.restore() ann.train(0.015, 1000000, 10000)
validation_tuple = load_labeled_csv(validation_filename, feature_cols,
label_cols)
# Normalize training and validation data by training statistics
train_mean = np.mean(train_tuple.features, axis=0)
train_std = np.std(train_tuple.features, axis=0)
train_tuple.features -= train_mean
train_tuple.features /= train_std
validation_tuple.features -= train_mean
validation_tuple.features /= train_std
logger.info('Finished importing and normalization of input data.')
# ------------------------ Training --------------------------------------- #
hd_exp = Experiment(hyper_param_str)
# Run backpropagation training.
df, best_error = train(train_tuple, validation_tuple, hyper_params, nb_epochs,
random_seed, hd_exp, deep_cal_dir + '/code/')
logger.info('Writing log dataframe to csv on disk.')
df.to_csv(hyper_param_str + '/log_file.csv')
# Finish Hyperdash experiment.
hd_exp.end()
logger.info("PROGRAM END.")
#! /usr/bin/python
import ann
traindata = ann.read_dataset('train.list')
trainlabel = ann.read_label('trainlabel.list')
hidden = 100
nn = ann.create_neural_net(960, hidden, 20)
testdata = ann.read_dataset('test1.list')
testlabel = ann.read_label('testlabel1.list')
epoch = 1000
learningrate = 0.2
momentum = 0.75
ann.train(nn, traindata, trainlabel, testdata, testlabel, epoch, learningrate, momentum, 1, 'classified.txt', 'classified2.txt')
