def initial_population(population_size):
inlayer_size = env.observation_space.sample().shape[0] # 4 input nodes
outlayer_size = 1
hlayer_size = int(2 / 3 * inlayer_size + outlayer_size)
ann_population = [] # List for ANN population
for ann in range(population_size):
mlp = MLPClassifier(batch_size=1,
max_iter=1,
solver='sgd',
activation='relu',
learning_rate='invscaling',
hidden_layer_sizes=hlayer_size,
random_state=1)
mlp.partial_fit(np.array([env.observation_space.sample()],
dtype='int64'),
np.array([env.action_space.sample()], dtype='int64'),
classes=np.arange(env.action_space.n))
coef_init = np.array([[0.5, 0.5, 0.5], [0.5, 0.5, 0.5],
[0.8, 0.8, 0.8], [0.8, 0.8, 0.8]])
coef_hidden = np.array([[0.5], [0.5], [0.5]])
mlp.coefs_ = [coef_init, coef_hidden]
ann_population.append(mlp)
return ann_population
def fit(self, x, Y):
self.classes = np.sort(list(set(Y)))
x = np.array(x).copy()
y = np.array(Y).copy()
for f in range(len(self.classes)):
y[y == self.classes[f]] = f
clf = MLPClassifier(hidden_layer_sizes=self.shape,
alpha=self.beta,
learning_rate_init=self.eta0)
clf.partial_fit(x, Y, classes=self.classes)
coefs = clf.coefs_
intercepts = clf.intercepts_
coefs_tot = [np.zeros(np.shape(c)) for c in coefs]
intercepts_tot = [np.zeros(np.shape(c)) for c in intercepts]
for f in range(self.agg):
if self.verbose and (self.agg > 1):
print('Passage ' + str(f))
clfi = self.fit1(x, Y, clf, coefs, intercepts)
for i in range(len(coefs)):
coefs_tot[i] += clfi.coefs_[i]
intercepts_tot[i] += clfi.intercepts_[i]
coefs = [c / self.agg for c in coefs_tot]
intercepts = [c / self.agg for c in intercepts_tot]
clf.coefs_ = coefs
clf.intercepts_ = intercepts
self.clf = clf
def testData(solution):
model = MLPClassifier(hidden_layer_sizes=(8, 5))
model.fit(d, t)
coef = []
coef.append(np.asarray([solution[i:i + 8] for i in range(4)]))
coef.append(np.asarray([solution[32 + i:32 + i + 5] for i in range(8)]))
coef.append(np.asarray([solution[72 + i:72 + i + 3] for i in range(5)]))
model.coefs_ = coef
score = model.score(d[100:], t[100:])
return 1 - score
def generate_model(coefs_list=None,
bias_list=None,
hidden_layers=(15, 10),
input_nb=13):
model = MLPClassifier(hidden_layer_sizes=hidden_layers)
init_X = np.ones((4, input_nb))
init_y = [0, 1, 2, 3]
model.fit(init_X, init_y)
if coefs_list is None:
model.coefs_ = init_coefs(hidden_layers, input_nb)
coefs_list = coefs_to_list(model.coefs_)
else:
model.coefs_ = coefs_to_array(coefs_list, hidden_layers, input_nb)
if bias_list is None:
model.intercepts_ = init_bias(hidden_layers)
bias_list = bias_to_list(model.intercepts_)
else:
model.intercepts_ = bias_to_array(bias_list)
chromosome = (coefs_list, bias_list)
return (model, chromosome)
def trainNN(nn_structure):
data_set = load_digits()
X = data_set['data']
y = data_set['target']
X_train, X_test, y_train, y_test = train_test_split(X, y)
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
mlp = MLPClassifier(hidden_layer_sizes=hidden_layers_size)
mlp.fit(X_train, y_train)
mlp.coefs_ = nn_structure
mlp.intercepts_ = get_zeroes_biases_vectors()
predictions = mlp.predict(X_test)
return accuracy_score(y_test, predictions)
def deserialize_mlp(model_dict):
model = MLPClassifier(**model_dict['params'])
model.coefs_ = np.array(model_dict['coefs_'])
model.loss_ = model_dict['loss_']
model.intercepts_ = np.array(model_dict['intercepts_'])
model.n_iter_ = model_dict['n_iter_']
model.n_layers_ = model_dict['n_layers_']
model.n_outputs_ = model_dict['n_outputs_']
model.out_activation_ = model_dict['out_activation_']
model._label_binarizer = deserialize_label_binarizer(
model_dict['_label_binarizer'])
model.classes_ = np.array(model_dict['classes_'])
return model
def deserialize_model(path):
"""Deserialize JSON object storing the ml model.
Model (an MLPClassifier from sklearn) is re-instantiated
with proper values.
INPUT:
--path: filepath for loading the JSON object
OUTPUT:
--model: Returns an MLPClassifier (sklearn) object
"""
def deserialize_label_binarizer(label_binarizer_dict):
label_binarizer = LabelBinarizer()
label_binarizer.neg_label = label_binarizer_dict['neg_label']
label_binarizer.pos_label = label_binarizer_dict['pos_label']
label_binarizer.sparse_output = label_binarizer_dict[
'sparse_output']
label_binarizer.y_type_ = label_binarizer_dict['y_type_']
label_binarizer.sparse_input_ = label_binarizer_dict[
'sparse_input_']
label_binarizer.classes_ = np.array(
label_binarizer_dict['classes_'])
return label_binarizer
# Load (or deserialize) model from JSON
model_dict = {}
with open(path, 'r') as in_file:
model_dict = json.load(in_file)
model = MLPClassifier(**model_dict['params'])
model.coefs_ = np.array(model_dict['coefs_'], dtype=object)
model.loss_ = model_dict['loss_']
model.intercepts_ = np.array(model_dict['intercepts_'], dtype=object)
model.n_iter_ = model_dict['n_iter_']
model.n_layers_ = model_dict['n_layers_']
model.n_outputs_ = model_dict['n_outputs_']
model.out_activation_ = model_dict['out_activation_']
model._label_binarizer = deserialize_label_binarizer(
model_dict['_label_binarizer'])
model.features = list(model_dict['features'])
model.classes_ = np.array(model_dict['classes_'])
# Convert coeficients to numpy arrays to enable JSON deserialization
# This is a hack to compensate for a bug in sklearn_json
for i, x in enumerate(model.coefs_):
model.coefs_[i] = np.array(x)
return model
def cross(self, other):
"""Crossover Operator.
This operator is applied to each `n_layers` bipartite section of this
network and other - of same architecture - given `n_layers` cut points.
Returns
-------
A `TrainingCandidate` containing a new neural network with the same
architecture of its parents.
"""
W_c_ = []
b_c_ = []
for layer, (W_a, b_a, W_b, b_b) in enumerate(
zip(self.coefs_, self.intercepts_,
other.coefs_,
other.intercepts_)):
shape = W_a.shape
n_elements = shape[0] * shape[1]
cut = int(self.data.random_state.rand() * n_elements)
W_c = np.hstack((W_a.ravel()[:cut], W_b.ravel()[cut:]))
W_c.resize(shape)
W_c_.append(W_c)
cut = int(self.data.random_state.rand() * b_a.shape[1])
b_c = np.hstack((b_a[:, :cut], b_b[:, cut:]))
b_c_.append(b_c)
net = MLPClassifier(**World.params['nn_params'])
net.coefs_, net.intercepts_ = W_c_, b_c_
return TrainingCandidate(net)
def test_serialize_model():
instance = HostFootprint()
model = MLPClassifier()
label_binarizer = LabelBinarizer()
label_binarizer.neg_label = 0
label_binarizer.pos_label = 1
label_binarizer.sparse_output = False
label_binarizer.y_type_ = "binary"
label_binarizer.sparse_input_ = False
label_binarizer.classes_ = np.array([0])
parameters = {'hidden_layer_sizes': [(64, 32)]}
GridSearchCV(model, parameters, cv=5, n_jobs=-1, scoring='f1_weighted')
model.coefs_ = np.array([[1], [2]])
model.loss_ = 42
model.intercepts_ = np.array([[3], [4]])
model.classes_ = np.array([[5], [6]])
model.n_iter_ = 42
model.n_layers_ = 2
model.n_outputs_ = 1
model.out_activation_ = "logistic"
model._label_binarizer = label_binarizer
model.features = ['test_1', 'test_2', 'test_3']
with tempfile.TemporaryDirectory() as tmpdir:
model_file = os.path.join(tmpdir, 'host_footprint.json')
instance.serialize_model(model, model_file)
new_model = instance.deserialize_model(model_file)
assert model.features == new_model.features
print(f"model params: {model.get_params()}")
print(f"new_model params: {new_model.get_params()}")
assert len(model.get_params()['hidden_layer_sizes']) == len(
new_model.get_params()['hidden_layer_sizes'])
assert model._label_binarizer.y_type_ == new_model._label_binarizer.y_type_
assert len(model.coefs_) == len(new_model.coefs_)
assert len(model.intercepts_) == len(new_model.intercepts_)
def cross(self, other):
"""Crossover Operator.
This operator is applied to each `n_layers` bipartite section of this
network and other - of same architecture - given `n_layers` cut points.
Returns
-------
A `TrainingCandidate` containing a new neural network with the same
architecture of its parents.
"""
W_c_ = []
b_c_ = []
for layer, (W_a, b_a, W_b, b_b) in enumerate(
zip(self.coefs_, self.intercepts_, other.coefs_,
other.intercepts_)):
shape = W_a.shape
n_elements = shape[0] * shape[1]
cut = int(self.data.random_state.rand() * n_elements)
W_c = np.hstack((W_a.ravel()[:cut], W_b.ravel()[cut:]))
W_c.resize(shape)
W_c_.append(W_c)
cut = int(self.data.random_state.rand() * b_a.shape[1])
b_c = np.hstack((b_a[:, :cut], b_b[:, cut:]))
b_c_.append(b_c)
net = MLPClassifier(**World.params['nn_params'])
net.coefs_, net.intercepts_ = W_c_, b_c_
return TrainingCandidate(net)
def test_fit():
# Test that the algorithm solution is equal to a worked out example."""
X = np.array([[0.6, 0.8, 0.7]])
y = np.array([0])
mlp = MLPClassifier(algorithm='sgd',
learning_rate_init=0.1,
alpha=0.1,
activation='logistic',
random_state=1,
max_iter=1,
hidden_layer_sizes=2,
momentum=0)
# set weights
mlp.coefs_ = [0] * 2
mlp.intercepts_ = [0] * 2
mlp.classes_ = [0, 1]
mlp.n_outputs_ = 1
mlp.coefs_[0] = np.array([[0.1, 0.2], [0.3, 0.1], [0.5, 0]])
mlp.coefs_[1] = np.array([[0.1], [0.2]])
mlp.intercepts_[0] = np.array([0.1, 0.1])
mlp.intercepts_[1] = np.array([1.0])
mlp._coef_grads = [] * 2
mlp._intercept_grads = [] * 2
mlp.label_binarizer_.y_type_ = 'binary'
# Initialize parameters
mlp.n_iter_ = 0
mlp.learning_rate_ = 0.1
# Compute the number of layers
mlp.n_layers_ = 3
# Pre-allocate gradient matrices
mlp._coef_grads = [0] * (mlp.n_layers_ - 1)
mlp._intercept_grads = [0] * (mlp.n_layers_ - 1)
mlp.out_activation_ = 'logistic'
mlp.t_ = 0
mlp.best_loss_ = np.inf
mlp.loss_curve_ = []
mlp._no_improvement_count = 0
mlp._intercept_velocity = [
np.zeros_like(intercepts) for intercepts in mlp.intercepts_
]
mlp._coef_velocity = [np.zeros_like(coefs) for coefs in mlp.coefs_]
mlp.partial_fit(X, y, classes=[0, 1])
# Manually worked out example
# h1 = g(X1 * W_i1 + b11) = g(0.6 * 0.1 + 0.8 * 0.3 + 0.7 * 0.5 + 0.1)
# = 0.679178699175393
# h2 = g(X2 * W_i2 + b12) = g(0.6 * 0.2 + 0.8 * 0.1 + 0.7 * 0 + 0.1)
# = 0.574442516811659
# o1 = g(h * W2 + b21) = g(0.679 * 0.1 + 0.574 * 0.2 + 1)
# = 0.7654329236196236
# d21 = -(0 - 0.765) = 0.765
# d11 = (1 - 0.679) * 0.679 * 0.765 * 0.1 = 0.01667
# d12 = (1 - 0.574) * 0.574 * 0.765 * 0.2 = 0.0374
# W1grad11 = X1 * d11 + alpha * W11 = 0.6 * 0.01667 + 0.1 * 0.1 = 0.0200
# W1grad11 = X1 * d12 + alpha * W12 = 0.6 * 0.0374 + 0.1 * 0.2 = 0.04244
# W1grad21 = X2 * d11 + alpha * W13 = 0.8 * 0.01667 + 0.1 * 0.3 = 0.043336
# W1grad22 = X2 * d12 + alpha * W14 = 0.8 * 0.0374 + 0.1 * 0.1 = 0.03992
# W1grad31 = X3 * d11 + alpha * W15 = 0.6 * 0.01667 + 0.1 * 0.5 = 0.060002
# W1grad32 = X3 * d12 + alpha * W16 = 0.6 * 0.0374 + 0.1 * 0 = 0.02244
# W2grad1 = h1 * d21 + alpha * W21 = 0.679 * 0.765 + 0.1 * 0.1 = 0.5294
# W2grad2 = h2 * d21 + alpha * W22 = 0.574 * 0.765 + 0.1 * 0.2 = 0.45911
# b1grad1 = d11 = 0.01667
# b1grad2 = d12 = 0.0374
# b2grad = d21 = 0.765
# W1 = W1 - eta * [W1grad11, .., W1grad32] = [[0.1, 0.2], [0.3, 0.1],
# [0.5, 0]] - 0.1 * [[0.0200, 0.04244], [0.043336, 0.03992],
# [0.060002, 0.02244]] = [[0.098, 0.195756], [0.2956664,
# 0.096008], [0.4939998, -0.002244]]
# W2 = W2 - eta * [W2grad1, W2grad2] = [[0.1], [0.2]] - 0.1 *
# [[0.5294], [0.45911]] = [[0.04706], [0.154089]]
# b1 = b1 - eta * [b1grad1, b1grad2] = 0.1 - 0.1 * [0.01667, 0.0374]
# = [0.098333, 0.09626]
# b2 = b2 - eta * b2grad = 1.0 - 0.1 * 0.765 = 0.9235
assert_almost_equal(mlp.coefs_[0],
np.array([[0.098, 0.195756], [0.2956664, 0.096008],
[0.4939998, -0.002244]]),
decimal=3)
assert_almost_equal(mlp.coefs_[1],
np.array([[0.04706], [0.154089]]),
decimal=3)
assert_almost_equal(mlp.intercepts_[0],
np.array([0.098333, 0.09626]),
decimal=3)
assert_almost_equal(mlp.intercepts_[1], np.array(0.9235), decimal=3)
# Testing output
# h1 = g(X1 * W_i1 + b11) = g(0.6 * 0.098 + 0.8 * 0.2956664 +
# 0.7 * 0.4939998 + 0.098333) = 0.677
# h2 = g(X2 * W_i2 + b12) = g(0.6 * 0.195756 + 0.8 * 0.096008 +
# 0.7 * -0.002244 + 0.09626) = 0.572
# o1 = h * W2 + b21 = 0.677 * 0.04706 +
# 0.572 * 0.154089 + 0.9235 = 1.043
assert_almost_equal(mlp.decision_function(X), 1.043, decimal=3)
losses = np.empty(decay.size)
test_accs = np.empty(decay.size)
for idx, decay_rate in enumerate(decay):
np.random.seed(
7
) # seed NumPy's random number generator for reproducibility of results
# Initialize neural network
nn = MLPClassifier(hidden_layer_sizes=(5, 2),
random_state=7,
max_iter=1,
warm_start=True)
nn.fit(X_train, y_train)
# Initialize weights
nn.coefs_, nn.intercepts_ = init_weights(X_train.shape[1],
list(nn.hidden_layer_sizes))
loss_next = compute_loss(X_train, y_train, nn)
T = T_init
loss = []
start = time.time()
for i in range(num_iters):
# Save current parameters
coefs_prev = nn.coefs_
intercepts_prev = nn.intercepts_
loss_prev = loss_next
if debug:
print('Iteration # %d' % i)
print('Loss = ', loss_prev)
new_coefs.append(np.random.rand(100, 6))
if (cur_exp_param == 'hd'):
new_coefs.append(np.random.rand(100, 11))
if (cur_exp_param == 'gpu'):
new_coefs.append(np.random.rand(100, 8))
if (cur_exp_param == 'screen'):
new_coefs.append(np.random.rand(100, 9))
finetune_classifier = MLPClassifier(hidden_layer_sizes=(hidden_neurons,
hidden_neurons),
max_iter=1000,
alpha=0.001,
solver='adam',
verbose=1,
random_state=21)
finetune_classifier.coefs_ = new_coefs
finetune_classifier.fit(X_val_emb, y_val_categorical)
#-----give prediction on X_test_emb by review length and label frequency--------------------
model_name='./aug_models/'+cur_exp_param+'_'+cur_sent_embd_type+'_'\
+EDA_method+'_model.pkl'
joblib.dump(finetune_classifier, model_name)
print("now classifier is finutuned and ready to test")
print("use finetune_classifier and X_test_emb")
#sys.exit(0)
clf = NN(hid_layers, activation='relu')
features, encodings, ((x_train, y_train), (x_val, y_val),
(x_test, y_test)) = process(all_data,
train_frac,
val_frac,
test_frac,
modify=True)
print(x_train.shape, y_train.shape)
clf.fit(x_train, y_train)
print("Simulated annealing:")
acc_anneal = []
test_anneal = []
clf.coefs_ = []
clf.intercepts_ = []
#anneal(clf, hid_layers, x_train, y_train) #uses simulated annealing to find the optimal weights
anneal = NNAnneal(clf, hid_layers, x_train, y_train)
([clf.coefs_, clf.intercepts_]), e = anneal.anneal()
print(accuracy_score(clf.predict(x_train), y_train))
print(accuracy_score(clf.predict(x_val), y_val))
print(accuracy_score(clf.predict(x_test), y_test))
# acc_anneal.append(accuracy_score(clf.predict(x_val), y_val))
# test_anneal.append(accuracy_score(clf.predict(x_test), y_test))
# print(acc_anneal)
# print(test_anneal)
print("Hill climbing:")
def test_fit():
# Test that the algorithm solution is equal to a worked out example.
X = np.array([[0.6, 0.8, 0.7]])
y = np.array([0])
mlp = MLPClassifier(solver='sgd', learning_rate_init=0.1, alpha=0.1,
activation='logistic', random_state=1, max_iter=1,
hidden_layer_sizes=2, momentum=0)
# set weights
mlp.coefs_ = [0] * 2
mlp.intercepts_ = [0] * 2
mlp.n_outputs_ = 1
mlp.coefs_[0] = np.array([[0.1, 0.2], [0.3, 0.1], [0.5, 0]])
mlp.coefs_[1] = np.array([[0.1], [0.2]])
mlp.intercepts_[0] = np.array([0.1, 0.1])
mlp.intercepts_[1] = np.array([1.0])
mlp._coef_grads = [] * 2
mlp._intercept_grads = [] * 2
# Initialize parameters
mlp.n_iter_ = 0
mlp.learning_rate_ = 0.1
# Compute the number of layers
mlp.n_layers_ = 3
# Pre-allocate gradient matrices
mlp._coef_grads = [0] * (mlp.n_layers_ - 1)
mlp._intercept_grads = [0] * (mlp.n_layers_ - 1)
mlp.out_activation_ = 'logistic'
mlp.t_ = 0
mlp.best_loss_ = np.inf
mlp.loss_curve_ = []
mlp._no_improvement_count = 0
mlp._intercept_velocity = [np.zeros_like(intercepts) for
intercepts in
mlp.intercepts_]
mlp._coef_velocity = [np.zeros_like(coefs) for coefs in
mlp.coefs_]
mlp.partial_fit(X, y, classes=[0, 1])
# Manually worked out example
# h1 = g(X1 * W_i1 + b11) = g(0.6 * 0.1 + 0.8 * 0.3 + 0.7 * 0.5 + 0.1)
# = 0.679178699175393
# h2 = g(X2 * W_i2 + b12) = g(0.6 * 0.2 + 0.8 * 0.1 + 0.7 * 0 + 0.1)
# = 0.574442516811659
# o1 = g(h * W2 + b21) = g(0.679 * 0.1 + 0.574 * 0.2 + 1)
# = 0.7654329236196236
# d21 = -(0 - 0.765) = 0.765
# d11 = (1 - 0.679) * 0.679 * 0.765 * 0.1 = 0.01667
# d12 = (1 - 0.574) * 0.574 * 0.765 * 0.2 = 0.0374
# W1grad11 = X1 * d11 + alpha * W11 = 0.6 * 0.01667 + 0.1 * 0.1 = 0.0200
# W1grad11 = X1 * d12 + alpha * W12 = 0.6 * 0.0374 + 0.1 * 0.2 = 0.04244
# W1grad21 = X2 * d11 + alpha * W13 = 0.8 * 0.01667 + 0.1 * 0.3 = 0.043336
# W1grad22 = X2 * d12 + alpha * W14 = 0.8 * 0.0374 + 0.1 * 0.1 = 0.03992
# W1grad31 = X3 * d11 + alpha * W15 = 0.6 * 0.01667 + 0.1 * 0.5 = 0.060002
# W1grad32 = X3 * d12 + alpha * W16 = 0.6 * 0.0374 + 0.1 * 0 = 0.02244
# W2grad1 = h1 * d21 + alpha * W21 = 0.679 * 0.765 + 0.1 * 0.1 = 0.5294
# W2grad2 = h2 * d21 + alpha * W22 = 0.574 * 0.765 + 0.1 * 0.2 = 0.45911
# b1grad1 = d11 = 0.01667
# b1grad2 = d12 = 0.0374
# b2grad = d21 = 0.765
# W1 = W1 - eta * [W1grad11, .., W1grad32] = [[0.1, 0.2], [0.3, 0.1],
# [0.5, 0]] - 0.1 * [[0.0200, 0.04244], [0.043336, 0.03992],
# [0.060002, 0.02244]] = [[0.098, 0.195756], [0.2956664,
# 0.096008], [0.4939998, -0.002244]]
# W2 = W2 - eta * [W2grad1, W2grad2] = [[0.1], [0.2]] - 0.1 *
# [[0.5294], [0.45911]] = [[0.04706], [0.154089]]
# b1 = b1 - eta * [b1grad1, b1grad2] = 0.1 - 0.1 * [0.01667, 0.0374]
# = [0.098333, 0.09626]
# b2 = b2 - eta * b2grad = 1.0 - 0.1 * 0.765 = 0.9235
assert_almost_equal(mlp.coefs_[0], np.array([[0.098, 0.195756],
[0.2956664, 0.096008],
[0.4939998, -0.002244]]),
decimal=3)
assert_almost_equal(mlp.coefs_[1], np.array([[0.04706], [0.154089]]),
decimal=3)
assert_almost_equal(mlp.intercepts_[0],
np.array([0.098333, 0.09626]), decimal=3)
assert_almost_equal(mlp.intercepts_[1], np.array(0.9235), decimal=3)
# Testing output
# h1 = g(X1 * W_i1 + b11) = g(0.6 * 0.098 + 0.8 * 0.2956664 +
# 0.7 * 0.4939998 + 0.098333) = 0.677
# h2 = g(X2 * W_i2 + b12) = g(0.6 * 0.195756 + 0.8 * 0.096008 +
# 0.7 * -0.002244 + 0.09626) = 0.572
# o1 = h * W2 + b21 = 0.677 * 0.04706 +
# 0.572 * 0.154089 + 0.9235 = 1.043
# prob = sigmoid(o1) = 0.739
assert_almost_equal(mlp.predict_proba(X)[0, 1], 0.739, decimal=3)
def update(self):
if not World.executions:
raise RuntimeError('Cannot update. No executions left to work on.')
# Define workspace (data set of interest).
params = World.executions.pop(0)
World.params = params
t_time = time()
print('Data set %s %f' % (params['name'], t_time))
ds = params['dataset']()
X, y = ds.data, ds.target
if params['settings'].get('pc_decomposing', False):
X = decomposition.PCA(
whiten=params['settings'].get('whiten', False),
random_state=0).fit_transform(X)
if params['settings']['plotting']:
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)
plt.tight_layout()
plt.savefig('report/ds-%s.png' % params['name'])
plt.close()
# Separate train (80%) and test data (20%).
X, X_test, y, y_test = model_selection.train_test_split(
X, y, train_size=.8, random_state=random_state)
# Set class attributes. We need this for the genetic algorithm.
World.X, World.X_test, World.y, World.y_test = X, X_test, y, y_test
# Build a regularly trained Neural Network once.
# We'll use it as base for our benchmarks.
mpl = MLPClassifier(**params['nn_params'])
print('Regular training ongoing...')
t = time()
mpl.fit(X, y)
print('Training complete (elapsed: %f s)' % (time() - t))
self.evaluate(mpl, label='NN')
best_i, best_model, best_score = -1, None, -np.inf
for i, search_params in enumerate(params['searches']):
trainer = art.agents.ResponderAgent(
search=art.searches.genetic.GeneticAlgorithm,
environment=self,
search_params=search_params)
# Ask agent to find a trained net for us.
print('Genetic training has started. Parameters: \n%s'
% search_params)
t = time()
training = trainer.act()
print('Evolution complete (%i cycles, %f s elapsed, '
'candidate utility: %f)'
% (trainer.search.cycle_, time() - t,
trainer.utility(training)))
if (params['settings']['plotting'] and
search_params.get('debug', False)):
# Plotting generations' utilities.
plt.plot(trainer.search.lowest_utility_,
color='blue', linewidth=4, label='Lowest')
plt.plot(trainer.search.average_utility_,
color='orange', linewidth=4, label='Average')
plt.plot(trainer.search.highest_utility_,
color='red', linewidth=4, label='Highest')
plt.legend()
plt.xlabel('generation')
plt.ylabel('utility')
plt.tight_layout()
plt.savefig('report/ut-%s-%i.png' % (params['name'], i))
plt.close()
# Let's cross our fingers! Build a Neural Network with the
# parameters selected by the evolutionary process.
gmpl = MLPClassifier(**params['nn_params'])
gmpl.coefs_ = training.coefs_
gmpl.intercepts_ = training.intercepts_
score = self.evaluate(gmpl, label='GA')
if score > best_score:
best_i, best_model, best_score = i, gmpl, score
gmpl.fit(X, y)
self.evaluate(gmpl, label='trained-gnn')
print('%s\'s report:\n'
'\tBest estimator id: %i\n'
'Score: %.2f\n'
'Total time elapsed: %f s\n'
'---\n'
% (params['name'], best_i, best_score, (time() - t_time)))
import numpy as np
from sklearn.neural_network import MLPClassifier
os.chdir('../data')
# Load data
X = pd.read_csv('X.csv', header=None)
#with open('X.csv') as datafile:
# X = [[float(val) for val in line.split(',')] for line in datafile.read().split('\n') if line != '']
y = pd.read_csv('y.csv', header=None).transpose().values[0]
#with open('y.csv') as datafile:
# y = [float(line) for line in datafile.read().split('\n') if line != '']
Theta1 = pd.read_csv('Theta1.csv', header=None)
#with open('Theta1.csv') as datafile:
# Theta1 = [[float(val) for val in line.split(',')] for line in datafile.read().split('\n') if line != '']
Theta2 = pd.read_csv('Theta2.csv', header=None)
#with open('Theta2.csv') as datafile:
# Theta2 = [[float(val) for val in line.split(',')] for line in datafile.read().split('\n') if line != '']
clf = MLPClassifier(algorithm='l-bfgs', alpha=1e-5, hidden_layer_sizes=(25), random_state=1)
clf.fit(X, y)
#clf.n_outputs_ = 10
#clf.n_layers_ = 3
clf.out_activation_ = 'logistic'
clf.intercepts_ = [Theta1[0].values, Theta2[0].values]
clf.coefs_ = [Theta1.transpose()[1:].values, Theta2.transpose()[1:].values]
p = clf.predict(X)
diff = (p == y).mean()
print(diff)
memory[index % memory_size,
0], memory[index % memory_size,
1] = observation[0], observation[1]
memory[index % memory_size, 2], memory[index % memory_size, 3], memory[
index % memory_size,
4] = action_0, observation_1[0], observation_1[1]
index += 1
observation = observation_1
# choose minimum batch
batch_index = np.random.choice(memory_size, size=mini_batch)
batch_memory = memory[batch_index, :]
e_r_l_new = batch_memory[:, 0:3]
e_r_l_old = batch_memory[:, 3:5]
q_target = np.zeros((mini_batch, 1))
counter_2 = 0
for element in e_r_l_old:
q_target[counter_2] = r_ + GAMMA * max(old_nn.predict([np.append(element, 0)]), \
old_nn.predict([np.append(element, 1)]), \
old_nn.predict([np.append(element, 2)]))
counter_2 += 1
q_target = q_target.ravel()
new_nn.fit(e_r_l_new, q_target)
if step % learning_inter == 0:
old_nn.coefs_ = new_nn.coefs_
old_nn.intercepts_ = new_nn.intercepts_
# reach the right top
if observation[0] == env.observation_space.high[0]:
break
def update(self):
if not World.executions:
raise RuntimeError('Cannot update. No executions left to work on.')
# Define workspace (data set of interest).
params = World.executions.pop(0)
World.params = params
t_time = time()
print('Data set %s %f' % (params['name'], t_time))
ds = params['dataset']()
X, y = ds.data, ds.target
if params['settings'].get('pc_decomposing', False):
X = decomposition.PCA(whiten=params['settings'].get(
'whiten', False),
random_state=0).fit_transform(X)
if params['settings']['plotting']:
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)
plt.tight_layout()
plt.savefig('report/ds-%s.png' % params['name'])
plt.close()
# Separate train (80%) and test data (20%).
X, X_test, y, y_test = model_selection.train_test_split(
X, y, train_size=.8, random_state=random_state)
# Set class attributes. We need this for the genetic algorithm.
World.X, World.X_test, World.y, World.y_test = X, X_test, y, y_test
# Build a regularly trained Neural Network once.
# We'll use it as base for our benchmarks.
mpl = MLPClassifier(**params['nn_params'])
print('Regular training ongoing...')
t = time()
mpl.fit(X, y)
print('Training complete (elapsed: %f s)' % (time() - t))
self.evaluate(mpl, label='NN')
best_i, best_model, best_score = -1, None, -np.inf
for i, search_params in enumerate(params['searches']):
trainer = art.agents.ResponderAgent(
search=art.searches.genetic.GeneticAlgorithm,
environment=self,
search_params=search_params)
# Ask agent to find a trained net for us.
print('Genetic training has started. Parameters: \n%s' %
search_params)
t = time()
training = trainer.act()
print(
'Evolution complete (%i cycles, %f s elapsed, '
'candidate utility: %f)' %
(trainer.search.cycle_, time() - t, trainer.utility(training)))
if (params['settings']['plotting']
and search_params.get('debug', False)):
# Plotting generations' utilities.
plt.plot(trainer.search.lowest_utility_,
color='blue',
linewidth=4,
label='Lowest')
plt.plot(trainer.search.average_utility_,
color='orange',
linewidth=4,
label='Average')
plt.plot(trainer.search.highest_utility_,
color='red',
linewidth=4,
label='Highest')
plt.legend()
plt.xlabel('generation')
plt.ylabel('utility')
plt.tight_layout()
plt.savefig('report/ut-%s-%i.png' % (params['name'], i))
plt.close()
# Let's cross our fingers! Build a Neural Network with the
# parameters selected by the evolutionary process.
gmpl = MLPClassifier(**params['nn_params'])
gmpl.coefs_ = training.coefs_
gmpl.intercepts_ = training.intercepts_
score = self.evaluate(gmpl, label='GA')
if score > best_score:
best_i, best_model, best_score = i, gmpl, score
gmpl.fit(X, y)
self.evaluate(gmpl, label='trained-gnn')
print('%s\'s report:\n'
'\tBest estimator id: %i\n'
'Score: %.2f\n'
'Total time elapsed: %f s\n'
'---\n' % (params['name'], best_i, best_score,
(time() - t_time)))
