def linear_regression(a=1.0, b=0.0):
X = np.linspace(-100, 100, 200)
X = X.reshape((-1, 1))
[train_x, test_x] = split_data(X, ratio=0.8, random=True)
train_y = a * train_x + b
test_y = a * test_x + b
i = Input(1)
x = Dense(1)(i)
# define trainer
trainer = Trainer(loss='mse',
optimizer=Adam(learning_rate=0.2),
batch_size=50,
epochs=50)
# create model
model = Sequential(i, x, trainer)
model.summary()
# training process
model.fit(train_x, train_y)
# predict
y_hat = model.predict(test_x)
plt.plot(test_x, test_y, 'b')
plt.plot(test_x, y_hat, 'r')
plt.show()
def main():
(x_train, y_train), (x_test, y_test) = mnist.load_data()
print 'Imported MNIST data: training input %s and training labels %s.' % (
x_train.shape, y_train.shape)
print 'Imported MNIST data: test input %s and test labels %s.' % (
x_test.shape, y_test.shape)
N, H, W = x_train.shape
x = x_train.reshape((N, H * W)).astype('float') / 255
y = to_categorical(y_train, num_classes=10)
model = Sequential()
model.add(Dense(), ReLU(), layer_dim=(28 * 28, 300), weight_scale=1e-2)
model.add(Dense(), ReLU(), layer_dim=(300, 100), weight_scale=1e-2)
model.add(Dense(), Softmax(), layer_dim=(100, 10), weight_scale=1e-2)
model.compile(optimizer=GradientDescent(learning_rate=1e-2),
loss_func=categorical_cross_entropy)
model.fit(x, y, epochs=10, batch_size=50, verbose=False)
N, H, W = x_test.shape
x = x_test.reshape((N, H * W)).astype('float') / 255
y = to_categorical(y_test, num_classes=10)
model.evaluate(x, y)
def linear_classification(a=1.0, b=0.0, graph=False):
# prepare data
x = np.linspace(-100, 100, 200)
y = a * x + b
X = np.array(list(zip(x, y))) + np.random.randn(200, 2) * 100
Y = to_one_hot(np.where(a * X[:, 0] + b > X[:, 1], 1, 0))
(train_x, train_y), (test_x, test_y) = split_data(X,
Y,
ratio=0.8,
random=True)
# build simple FNN
i = Input(2)
x = Dense(2, activation='softmax')(i)
# define trainer
trainer = Trainer(loss='cross_entropy',
optimizer=Adam(learning_rate=0.05),
batch_size=50,
epochs=50,
metrics=['accuracy'])
# create model
model = Sequential(i, x, trainer)
model.summary()
# training process
model.fit(train_x, train_y)
print(model.evaluate(test_x, test_y))
if graph:
plt.plot(model.history['loss'])
plt.show()
# predict
y_hat = model.predict(test_x)
y_hat = np.argmax(y_hat, axis=1)
simple_plot(test_x, y_hat, a, b)
def binary_classification():
def separate_label(data):
X = normalize(data[:, :2].astype('float32'))
Y = np.where(data[:, 2] == b'black', 0, 1)
return X, Y
# prepare train data
data_dir = "data/examples/binary_classification"
train_data_path = os.path.join(data_dir, 'training.arff')
train_data = load_arff(train_data_path)
train_x, train_y = separate_label(train_data)
train_y = to_one_hot(train_y)
# build simple FNN
i = Input(2)
x = Dense(30, activation='relu')(i)
x = Dense(30, activation='relu')(x)
x = Dense(2, activation='softmax')(x)
# define trainer
trainer = Trainer(loss='cross_entropy', optimizer=Adam(clipvalue=1.0), batch_size=256, epochs=500, metrics=['accuracy'])
# create model
model = Sequential(i, x, trainer)
model.summary()
# training process
model.fit(train_x, train_y)
plt.plot(range(len(model.history['loss'])), model.history['loss'])
plt.show()
# predict
test_data_path = os.path.join(data_dir, 'test.arff')
test_data = load_arff(test_data_path)
test_x, _ = separate_label(test_data)
y_hat = model.predict(test_x)
simple_plot(test_x, y_hat)
def universal_approximation(f, x):
[train_x, test_x] = split_data(x, ratio=0.8, random=True)
train_y = f(train_x)
test_x = np.sort(test_x, axis=0)
test_y = f(test_x)
# build simple FNN
i = Input(1)
x = Dense(50, activation='relu')(i)
x = Dense(1)(x)
# define trainer
schedule = ExponentialDecay(initial_learning_rate=0.01, decay_rate=0.75)
trainer = Trainer(loss='mse',
optimizer=Adam(learning_rate=schedule),
batch_size=50,
epochs=750)
# create model
model = Sequential(i, x, trainer)
model.summary()
# training process
start = time.time()
model.fit(train_x, train_y)
print(time.time() - start)
plt.plot(range(len(model.history['loss'])), model.history['loss'])
plt.show()
# predict
y_hat = model.predict(test_x)
plt.plot(test_x, test_y, 'b-', label='original')
plt.plot(test_x, y_hat, 'r-', label='predicted')
plt.legend()
plt.show()
model.add(RepeatVector(DIGITS + 1))
# The decoder RNN could be multiple layers stacked or a single keras_layer
for _ in range(LAYERS):
model.add(RNN(HIDDEN_SIZE, return_sequences=True))
# For each of step of the output sequence, decide which character should be chosen
model.add(TimeDistributedDense(convertor.get_dim()))
model.add(Activation("softmax"))
model.compile(loss="categorical_crossentropy", optimizer="adam")
# Train the model each generation and show predictions against the validation dataset
for iteration in range(1, 200):
print()
print("-" * 50)
print("Iteration", iteration)
model.fit(X_train, y_train, batch_size=BATCH_SIZE, nb_epoch=1, validation_data=(X_val, y_val), show_accuracy=True)
###
# Select 10 samples from the validation set at random so we can visualize errors
for i in range(10):
ind = np.random.randint(0, len(X_val))
rowX, rowy = X_val[np.array([ind])], y_val[np.array([ind])]
preds = model.predict_classes(rowX, verbose=0)
q = convertor.decode(rowX[0], invert=True)
correct = convertor.decode(rowy[0])
guess = convertor.decode(preds[0], calc_argmax=False)
print("Q", q)
print("T", correct)
print(colors.ok + "☑" + colors.close if correct == guess else colors.fail + "☒" + colors.close, guess)
print("---")
train_y = convert_to_one_hot(train_y, num_classes)
test_x = np.reshape(test_x, (len(test_x), 1, img_rows, img_cols)).astype(skml_config.config.i_type)
test_y = convert_to_one_hot(test_y, num_classes)
train_x, valid_x, train_y, valid_y = train_test_split(train_x, train_y)
filters = 64
model = Sequential()
model.add(Convolution(filters, 3, input_shape=input_shape))
model.add(BatchNormalization())
model.add(ReLU())
model.add(MaxPooling(2))
model.add(Convolution(filters, 3))
model.add(BatchNormalization())
model.add(ReLU())
model.add(GlobalAveragePooling())
model.add(Affine(num_classes))
model.compile(SoftmaxCrossEntropy(), Adam())
train_batch_size = 100
valid_batch_size = 1
print("訓練開始: {}".format(datetime.now().strftime("%Y/%m/%d %H:%M")))
model.fit(train_x, train_y, train_batch_size, 20, validation_data=(valid_batch_size, valid_x, valid_y), validation_steps=1)
print("訓練終了: {}".format(datetime.now().strftime("%Y/%m/%d %H:%M")))
model.save(save_path)
loss, acc = model.evaluate(test_x, test_y)
print("Test loss: {}".format(loss))
print("Test acc: {}".format(acc))
with gzip.open(PATH.as_posix(), "rb") as f:
((x_train, y_train), (x_test, y_test), _) = pickle.load(f,
encoding="latin-1")
im_size = (28, 28)
input_dim = np.prod(im_size)
# %% Auto Encoder
autoencoder = Sequential(input_dim,
30,
10,
30,
input_dim,
activation='logistic')
autoencoder.fit(x_train, x_train, epochs=10)
x_sample = x_test[np.random.randint(1000, size=8)]
output = autoencoder.forward(x_sample)
for i in range(8):
# plot original image
ax = plt.subplot(8, 2, 2 * i + 1)
ax.axis('off')
ax.imshow(x_sample[i].reshape(im_size), cmap='gray')
# plot reconstructed image
ax = plt.subplot(8, 2, 2 * i + 2)
ax.axis('off')
ax.imshow(output[i].reshape(im_size), cmap='gray')
y = np.array([[1],
[0],
[0],
[1]])
print("Prediction")
p = model.predict(X)
print(p)
print("Error")
print(p-y)
loss_function = SquaredError()
custom_loss = CustomLoss()
print("Training")
loss_history = model.fit(X, y, epochs=100, batch_size=4, steps_per_epoch=1000, halt=False, loss=custom_loss)
print("Prediction")
p = model.predict(X)
print(p)
print("Error")
print(p-y)
print("Weights in first dense layer")
print(model.layers[0].weights)
print("Weights in second dense layer")
print(model.layers[2].weights)
plt.plot(np.arange(0, 100), loss_history[:, 0])
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.show()
[1, 0],
[1, 1]])
y = np.array([[0, 1],
[1, 0],
[1, 0],
[1, 0]])
print("Prediction")
p = model.predict(X)
print(p)
print("Error")
print(p-y)
loss_function = SquaredError()
print("Training")
loss_history = model.fit(X, y, epochs=100, batch_size=2, steps_per_epoch=1000, halt=False, loss=loss_function)
print("Prediction")
p = model.predict(X)
print(p)
print("Error")
print(p-y)
print("Weights")
print(model.layers[0].weights)
plt.plot(np.arange(0, 100), loss_history[:, 0])
plt.plot(np.arange(0, 100), loss_history[:, 1])
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.show()
#%%
import init
from models import Sequential, Dense
from utils import *
xtr, ytr = np.loadtxt('data/xt'), np.loadtxt('data/yt')
nn = Sequential(2, Dense(8, dropout=0.01), 1, activation='tanh')
#%%
nn.fit(xtr, ytr, lr=5e-3, epochs=50, callbacks=[train_anim(xtr, ytr)])
"""
mndata = MNIST('./samples')
images, labels = mndata.load_training()
vocab = set()
for label in labels:
vocab.add(label)
vocab = sorted(vocab)
Y = []
for label in labels:
one_hot = [0] * len(vocab)
one_hot[label] = 1
Y.append(one_hot)
X = np.array(images).T / 255
Y = np.array(Y).T
return (X, Y)
X, Y = parse_data()
model = Sequential()
model.add(Dense(1024, n_inputs=X.shape[0]))
model.add(Dense(1024))
model.add(Dense(1024))
model.add(Dense(Y.shape[0], activation='sigmoid'))
model.compile()
# model = pickle.load(open('model.p', 'rb'))
model.fit(X, Y, 1, learning_rate=0.003)
import init
from models import Sequential
from layers import Dense
from utils import onehot
import numpy as np
from tensorflow.keras.datasets import mnist
(x_tr, y_tr), (x_ts, y_ts) = mnist.load_data()
im_shape = x_tr[0].shape
im_size = np.prod(im_shape)
def accuracy(model):
return np.mean(np.argmax((model(x_ts)), axis=(-1)) == y_ts)
nn = Sequential(im_size, Dense(30, activation='tanh'), Dense(10, activation='logistic'))
x_tr = x_tr.reshape(-1, im_size)
x_ts = x_ts.reshape(-1, im_size)
nn.fit(x_tr, (onehot(y_tr, 10)), epochs=10)
print(accuracy(nn))
test_labels_one_hot = data[5]
model = Sequential()
model.add(
Dense(16, 784, kernel_initializer=truncated_normal,
bias_initializer=zeros))
model.add(Sigmoid())
model.add(
Dense(10, 16, kernel_initializer=truncated_normal, bias_initializer=zeros))
model.add(Sigmoid())
loss = SquaredError()
loss_history = model.fit(train_imgs,
train_labels_one_hot,
batch_size=32,
epochs=10,
loss=loss,
halt=False)
pred = model.predict(test_imgs)
pred_labels = pred.argmax(1)
print("MSE", loss.evaluate(pred, test_labels_one_hot).mean(0))
print("Percentage correct", np.mean(pred_labels == test_labels) * 100)
print("Prediction for first 5 images")
print(pred[0:5, :].argmax(1))
print("True labels")
print(test_labels[0:5])
plt.plot(np.arange(0, 10), loss_history.mean(1))
plt.title("Graph of mean loss over all one-hot outputs")
plt.xlabel("Epoch")
plt.ylabel("Mean loss")
x, inputs_shape, t, outputs_shape = create_data_numeric(3)
loss = "mean_squared_error"
metric = "rmse"
last_layer_activation = "identify"
seed = 15
model = Sequential(seed=seed)
model.add(Dense(10, activation="relu", inputs_shape=inputs_shape))
model.add(Dense(10, activation="relu"))
model.add(Dense(outputs_shape, activation=last_layer_activation))
model.compile(loss=loss, optimizer=Adam(), metric=metric)
train_x, test_x, train_t, test_t = train_test_split(x,
t,
test_size=0.3,
random_state=seed)
model.fit(train_x, train_t, test_x, test_t, epochs=1000, batch_size=50)
#誤差をプロット
import matplotlib.pyplot as plt
plt.plot(model.history_train[0])
plt.plot(model.history_test[0])
plt.title("loss")
plt.legend(["train", "test"])
plt.plot(model.history_train[1])
plt.plot(model.history_test[1])
plt.title(model.metric_name)
plt.legend(["train", "test"])
model.add(Conv2D(32, (5, 5), activation="relu",
inputs_shape=x_train.shape[1:]))
model.add(Pooling((2, 2)))
model.add(Conv2D(16, (3, 3), activation="relu"))
model.add(Pooling((2, 2)))
model.add(Dense(10, activation="relu"))
model.add(Dropout(0.5))
model.add(Dense(10, activation="softmax"))
model.compile(loss="categorical_crossentropy",
optimizer=Adam(),
metric="accuracy")
model.fit(x_train=x_train,
t_train=y_train,
x_test=x_test,
t_test=y_test,
batch_size=128,
epochs=10,
output_num=1)
#誤差をプロット
plt.plot(model.history_train[0])
plt.plot(model.history_test[0])
plt.title("loss")
plt.legend(["train", "test"])
plt.show()
plt.plot(model.history_train[1])
plt.plot(model.history_test[1])
plt.title(model.metric_name)
plt.legend(["train", "test"])