def demo_sweep_intersections(n, out):
for i in range(n):
try:
print("{}{}{}{}".format(
Terminal.bold,
Terminal.blue,
i,
Terminal.end,
))
seed(i)
xs = random_segments(15)
(segments, points) = sweep_intersections(xs)
ax = init_plot()
plot_points(ax, points)
plot_segments(ax, segments)
export("{}/sweep_intersections_{}.png".format(out, i))
(brute_segments, brute_points) = brute_sweep_intersections(xs)
ax = init_plot()
plot_points(ax, brute_points)
plot_segments(ax, brute_segments)
export("{}/brute_sweep_intersections_{}.png".format(out, i))
equal = sorted(points) == sorted(brute_points)
print("same points : {}{}{}{}\n\n".format(
Terminal.bold,
Terminal.green if equal else Terminal.red,
equal,
Terminal.end,
))
except:
pass
def run(train_data, test_data):
batch_size = 10
n_samples = np.array(train_data).shape[0]
n_batches = int(np.ceil(float(n_samples) / batch_size))
batch_slices = list(
gen_even_slices(n_batches * batch_size, n_batches, n_samples))
nodes = [50, 75, 100, 150]
for item in nodes:
errors = []
model = BernoulliRBM(n_components=item,
learning_rate=0.1,
batch_size=10,
n_iter=1,
random_state=None,
verbose=1)
for _ in range(20):
for batch_slice in batch_slices:
model.partial_fit(train_data[batch_slice])
errors.append(percent_error(model.gibbs(test_data), test_data))
plot.plot_points(errors)
plot.plot_heatmap(reformat_data(test_data[0]))
plot.plot_heatmap(reformat_data(model.gibbs(test_data)[0]))
if item == 50 or item == 100:
plot.plot_heatmap(model.__dict__['components_'].reshape(item, 784))
def train_selected_model(activation,
learning_rate,
momentum,
n_points,
n_epochs,
batch_size,
plot_points=False):
train_data, test_data = data.generate_data(n_points)
model = train.build_model(activation)
optimizer = optim.SGD(model.parameters(),
lr=learning_rate,
momentum=momentum)
criterion = framework.MSELoss()
t0 = time.perf_counter()
history = train.train_model(model, optimizer, criterion, train_data,
test_data, n_epochs, batch_size)
t1 = time.perf_counter()
result = {
'train_loss': train.compute_loss(model, criterion, train_data,
batch_size),
'test_loss': train.compute_error(model, train_data, batch_size) * 100,
'train_err': train.compute_loss(model, criterion, test_data,
batch_size),
'test_err': train.compute_error(model, test_data, batch_size) * 100,
'time': t1 - t0
}
if plot_points:
plot.plot_points(test_data, train_data, model, plot_points)
return history, result
def main ():
# society = init ()
# # mutation occurs in genes only
# while 1:
# pass
plot.canvas ().ion ()
plot.canvas ().show ()
X = init (population,a=A,b=B) # random population here!!!
generation = 0
try:
while 1:
print(f'Generation {generation}')
plot.canvas().clf ()
plot.plot_function (line)
plot.plot_function (f)
plot.plot_points (X, [0 for i in X])
plot.plot_points (X, [f(i) for i in X])
plot.canvas ().pause (0.5)
X = thrive (X, birth_rate=0.4) # hybirding performs and returns new generation
X = ageing (X, death_rate=0.3)
generation+=1
pass
except Exception as e:
print (e)
pass
pass
def demo_convex_hull(n, out):
for i in range(n):
seed(i)
points = random_points(25)
ax = init_plot()
plot_points(ax, points)
plot_segments(ax, convex_hull(points))
export("{}/convex_hull_{}.png".format(out, i))
def demo_point_of_intersection(n, out):
for i in range(n):
seed(i)
segments = random_segments(2)
point = point_of_intersection(*segments)
ax = init_plot()
if point:
plot_points(ax, [point])
plot_segments(ax, segments)
export("{}/point_of_intersection_{}.png".format(out, i))
def noise(): data_array = pict_data() X0 = data_array[:3] W = hopfield.weights(X0) for x in X0: error = [] for i in range(0, 101, 10): choices = np.random.choice(len(x), size=int(i*len(x)/100), replace=False) x_noise = add_noise(x, choices) error.append(calculate_error(x, hopfield.recall_until_stable(W, x_noise))) print(error) plot.plot_points(error)
def train_selected_model(activation: ty.Union[framework.Tanh, framework.ReLU],
learning_rate: float,
momentum: float,
n_points: int,
n_epochs: int,
batch_size: int,
track_history: bool = False,
plot_points: bool = False):
"""
Train a miniproject model with a given activation using SGD and MSE loss.
:param activation: activation function
:param learning_rate: SGD learning rate
:param momentum: SGD momentum
:param n_points: number of points in training and test data
:param n_epochs: number of epochs
:param batch_size: batch size
:param trach_history: track training and test error and loss by epoch
:param plot_points: generate plots visualing model predictions of the training and test data
:returns: (history dictionary, final results)
"""
train_data, test_data = data.generate_data(n_points)
model = train.build_model(activation)
optimizer = framework.SGD(model, lr=learning_rate, momentum=momentum)
criterion = framework.MSELoss(model)
t0 = time.perf_counter()
history = train.train_model(model, optimizer, criterion, train_data,
test_data, n_epochs, batch_size, track_history)
t1 = time.perf_counter()
result = {
'train_loss': train.compute_loss(model, criterion, train_data,
batch_size),
'test_loss': train.compute_error(model, train_data, batch_size) * 100,
'train_err': train.compute_loss(model, criterion, test_data,
batch_size),
'test_err': train.compute_error(model, test_data, batch_size) * 100,
'time': t1 - t0
}
if plot_points:
plot.plot_points(test_data, train_data, model, plot_points)
return history, result
for item in nodes:
encoding_dim = item
# this is our input placeholder
input_img = Input(shape=(784, ))
encoded = Dense(encoding_dim, activation='relu')(input_img)
decoded = Dense(784, activation='sigmoid')(encoded)
autoencoder = Model(input_img, decoded)
autoencoder.compile(optimizer='SGD',
loss='binary_crossentropy',
metrics=['binary_accuracy'])
history = History()
autoencoder.fit(train_data,
train_data,
epochs=20,
batch_size=10,
shuffle=True,
verbose=0,
callbacks=[history],
validation_data=(test_data, test_data))
errors = [1 - x for x in history.history['val_binary_accuracy']]
plot.plot_points(errors)
plot.plot_heatmap(reformat_data(test_data[0]))
plot.plot_heatmap(reformat_data(autoencoder.predict(test_data)[0]))
if item == 50 or item == 100:
print(plot.plot_heatmap(autoencoder.layers[1].get_weights()[0].T))