learningRate = 0.001 decay = 1e-6 """# Preprocessing dividing all images by 255 """ xTrain = xTrain / 255.0 xTest = xTest / 255.0 """# Building model""" # Encoder encoderInput = Input(shape=(28, 28, 1)) # 784 features x = Flatten()(encoderInput) x = Dense(128, activation='relu')(x) # 128 features encoderOutput = Dense(64, activation='relu')(x) # 64 features encoder = keras.Model(encoderInput, encoderOutput, name="encoder") # encoder model # Decoder decoderInput = Dense(128, activation='relu')(encoderOutput) x = Dense(28*28*1, activation='relu')(decoderInput) decoderOutput = Reshape((28, 28, 1))(x) # Autoencoder autoencoder = keras.Model(encoderInput, decoderOutput, name="autoencoder") autoencoder.summary() """# Training model""" optimizer = Adam(learningRate, decay)
plt.figure(figsize=(10,8))
for i in range(25):
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(x_test[i], cmap=plt.cm.binary)
plt.xlabel(class_names[y_test[i].argmax()])
plt.show()
'''
input_layer = Input((28, 28))
x = Flatten()(input_layer)
x = Dense(128, activation='relu')(x)
output_layer = Dense(NUM_CLASSES, activation='softmax')(x)
#model = Model(input_layer, output_layer)
model = keras.Sequential([
keras.layers.Conv2D(32, (3, 3), activation='relu',
input_shape=(28, 28, 1)),
keras.layers.MaxPooling2D((2, 2)),
keras.layers.Conv2D(64, (3, 3), activation='relu'),
keras.layers.MaxPooling2D((2, 2)),
keras.layers.Conv2D(64, (3, 3), activation='relu'),
keras.layers.Flatten(),
keras.layers.Dense(64, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
activation='relu',
input_shape=x_train[0].shape))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu', padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(96, kernel_size=(3, 3), activation='relu', padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten()) # Flattening the 2D arrays for fully connected layers
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.4))
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(len(CATEGORIES), activation='softmax'))
opt = keras.optimizers.Adam(learning_rate=1e-4)
model.compile(optimizer=opt,
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Import the early stopping callback
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
# Define a callback to monitor val_acc
modelcnn.add(Conv1D(
128,
3,
padding='same',
))
modelcnn.add(Activation('tanh'))
modelcnn.add(Conv1D(
512,
3,
padding='same',
))
modelcnn.add(Dropout(0.5))
modelcnn.add(Activation('tanh'))
modelcnn.add(Flatten())
modelcnn.add(Dense(len(pd.unique(y))))
modelcnn.add(Activation('softmax'))
opt = tensorflow.keras.optimizers.Adam(lr=0.00001, decay=1e-6)
modelcnn.compile(loss='sparse_categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
cnnhistory = modelcnn.fit(X_trainn,
y_train,
batch_size=16,
epochs=50,
validation_data=(X_vall, y_val))
# Check out our train accuracy and validation accuracy over epochs.
train_accuracy = cnnhistory.history['accuracy']
from sklearn.preprocessing import OneHotEncoder y_train = y_train.reshape(-1,1) # reshape에서 -1은 재배열의 의미이다. y_test = y_test.reshape(-1,1) ohencoder = OneHotEncoder() ohencoder.fit(y_train) y_train = ohencoder.transform(y_train).toarray() y_test = ohencoder.transform(y_test).toarray() from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Dropout, LSTM model = Sequential() model.add(LSTM(50, input_shape=(28, 28))) model.add(Dense(40, activation='relu')) model.add(Dense(30, activation='relu')) model.add(Dense(10, activation='relu')) model.add(Dense(10, activation='softmax')) model.summary() # 3. 컴파일, 훈련 model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) from tensorflow.keras.callbacks import EarlyStopping early_stopping = EarlyStopping(monitor='loss', patience=10, mode='auto') model.fit(x_train, y_train, batch_size=128, epochs=70, validation_split=0.2, callbacks=[early_stopping]) # 4. 평가, 예측 loss, acc = model.evaluate(x_test, y_test, batch_size=128) y_pred = model.predict(x_test[:-10])
directory="../stanford_dataSet/data/test2/",
target_size=(input_size, input_size),
color_mode="rgb",
batch_size=batch_size,
class_mode="categorical",
shuffle=False,
seed=42)
y_train = train_generator.classes
y_valid = valid_generator.classes
y_train = np_utils.to_categorical(y_train)
y_valid = np_utils.to_categorical(y_valid)
model = Sequential()
model.add(GlobalAveragePooling2D(input_shape=train_inception_v3.shape[1:]))
model.add(Dense(256))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(120, activation='softmax'))
from keras.models import model_from_json
json_file = open('../stanford_dataSet/data/model_inception_v3.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
loaded_model.load_weights("../stanford_dataSet/data/model_inception_v3.h5")
print("Loaded model from disk")
optimizer = RMSprop(lr=0.0001, rho=0.99)
X = pickle.load(file)
with open("y.pickle", 'rb') as file:
y = pickle.load(file)
# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
lr = 4e-4
dense1 = 70
dense2 = 25
dropout1 = 0.15
dropout2 = 0.2
model = Sequential()
model.add(Dense(dense1, activation="relu"))
model.add(Dropout(dropout1))
model.add(Dense(dense2, activation="relu"))
model.add(Dropout(dropout2))
model.add(Dense(1, activation="sigmoid"))
model.compile(Adam(lr=lr), loss="binary_crossentropy", metrics=["accuracy"])
log_dir = "logs\\fit\\" + f"lr={lr} dense ({dense1}, {dense2}) drop ({dropout1}, {dropout2}) " + str(
int(time.time()))
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir)
model_saver = tf.keras.callbacks.ModelCheckpoint('saved_model',
monitor='accuracy',
verbose=1,
data = f.read()
words = set(text_to_word_sequence(data))
result = one_hot(data, round(len(words) * 1.3))
m.append(result)
m = pad_sequences(m, maxlen=2000)
return m
posarray = get_array_from_directory('D:/AI&ML/data/aclImdb_v1/aclImdb/train/pos')
negarray = get_array_from_directory('D:/AI&ML/data/aclImdb_v1/aclImdb/train/neg')
poslabelarr = np.zeros(len(posarray))
neglabelarr = np.ones(len(negarray))
x_train = np.concatenate((posarray, negarray))
y_train = np.concatenate((poslabelarr, neglabelarr))
y_train = keras.utils.to_categorical(y_train, 2)
model = Sequential()
model.add(Embedding(2000, 128))
model.add(LSTM(128, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(2, activation='sigmoid'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())
model.fit(x_train, y_train, epochs=25)
model.save('model.h5')
class_x_data = np.hstack((x1_data, x2_data))
class_y_data = class_idx * np.ones((n_data, 1))
x_data = np.vstack((x_data, class_x_data)).astype(np.float32)
y_data = np.vstack((y_data, class_y_data)).astype(np.int32)
print('x_data.shape: {}, y_data.shape: {}'.format(x_data.shape, y_data.shape))
#input_visualization()
#plt.show()
train_ds = tf.data.Dataset.from_tensor_slices((x_data, y_data))
train_ds = train_ds.shuffle(1000).batch(8)
# Model
model = Sequential()
model.add(Dense(n_class))
model.add(Activation('softmax'))
#model.summary()
loss_object = SparseCategoricalCrossentropy()
optimizer = Adam(learning_rate=0.01)
train_loss = Mean()
train_acc = SparseCategoricalAccuracy()
EPOCHS = 10
## Training
for epoch in range(EPOCHS):
trainer()
training_reporter()
scaled_train_samples = scaler.fit_transform(train_samples.reshape(-1, 1))
# for i in scaled_train_samples:
# print(i)
#%% Simple tf.keras Sequential Model
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Activation, Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.metrics import categorical_crossentropy
#%% Set up model
model = Sequential([
Dense(units=16, input_shape=(1, ), activation='relu'),
# Dense(units=8, activation='relu'),
Dense(units=32, activation='relu'),
# Dense(units=2048, activation='relu'),
Dense(units=2, activation='softmax')
])
model.summary()
model.compile(optimizer=Adam(learning_rate=0.0001),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
import datetime
import os
# log_dir = os.getcwd() + "\\logs\\fit\\"
def __init__(self):
super().__init__()
self.add(Flatten())
self.add(Dense(1, activation=sigmoid))
self.add(Reshape([1]))
# Building the Model
model = Sequential()
model.add(Conv2D(layer_size, (3, 3), input_shape=X.shape[1:]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
for l in range(conv_layer - 1):
model.add(Conv2D(layer_size, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
for l in range(dense_layer):
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(X,
y,
batch_size=32,
epochs=10,
validation_split=0.3,
# print('===================')
# print(x[:5])
# print(y[:10])
# print(np.max(x), np.min(x))
# print(dataset.feature_names)
# print(dataset.DESCR)
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.8, random_state= 104, shuffle=True)
#2 모델구성
from tensorflow.keras.models import Sequential,Model
from tensorflow.keras.layers import Input,Dense
input1 = Input(shape=(13,))
dense1 = Dense(120, activation='relu')(input1)
dense1 = Dense(80)(dense1)
dense1 = Dense(60)(dense1)
dense1 = Dense(30)(dense1)
dense1 = Dense(7)(dense1)
dense1 = Dense(7)(dense1)
dense1 = Dense(5)(dense1)
dense1 = Dense(4)(dense1)
output1 = Dense(1)(dense1)
model = Model(inputs = input1, outputs = output1)
#3 컴파일 훈련
model.compile(loss='mse', optimizer='adam', metrics=['mae'])
model.fit(x_train, y_train, epochs=1000, batch_size=4, validation_split=0.2, verbose=1)
#4평가 예측
(train_data, test_data, train_labels,
test_labels) = train_test_split(data, labels, test_size=0.2)
# train_data = data
# test_data = data
# train_labels = labels
# test_labels = labels
label_lb = LabelBinarizer()
label_lb.fit(tags)
train_labels = label_lb.transform(train_labels)
test_labels = label_lb.transform(test_labels)
model = Sequential([
Dense(128, input_shape=(len(train_data[0]), ), activation='relu'),
Dense(64, activation='relu'),
Dropout(0.5),
Dense(len(train_labels[0]), activation='softmax')
])
model.compile(optimizer='adam',
loss=CategoricalCrossentropy(),
metrics=['accuracy'])
time_start = time.time()
history = model.fit(train_data,
train_labels,
epochs=30,
batch_size=5,
validation_data=(test_data, test_labels),
eb_layer = Embedding(maxwords,
embed_dim,
embeddings_initializer=Constant(embedding_matrix),
input_length=maxseqlen,
mask_zero=True,
trainable=False)
model = Sequential()
model.add(eb_layer)
model.add(SpatialDropout1D(0.30))
model.add(
Bidirectional(
LSTM(lstm_out,
dropout=0.2,
recurrent_dropout=0.2,
return_sequences=True)))
model.add(TimeDistributed(Dense(2, activation="softmax")))
adam = optimizers.Adam(learning_rate=0.001)
model.compile(loss="binary_crossentropy",
optimizer=adam,
metrics=["acc"],
sample_weight_mode="temporal")
print(model.summary())
batch_size = 32
#class_weights = {0: 1., 1: 5.}
weighting = 4
model.fit(x_train,
y_train,
validation_split=0.1,
epochs=10,
x = Embedding(self.n_item, self.n_factors, embeddings_initializer='he_normal',
embeddings_regularizer=l2(1e-6))(x)
x = Reshape((self.n_factors,))(x)
return x
user = Input(shape=(1,))
u = EmbeddingLayer(n_users, n_factors)(user)
movie = Input(shape=(1,))
m = EmbeddingLayer(n_movies, n_factors)(movie)
x = Concatenate()([u, m])
x = Dropout(0.05)(x)
x = Dense(10, kernel_initializer='he_normal')(x)
x = Activation('relu')(x)
x = Dropout(0.5)(x)
x = Dense(1, kernel_initializer='he_normal')(x)
x = Activation('sigmoid')(x)
x = Lambda(lambda x: x * (max_rating - min_rating) + min_rating)(x)
model = Model(inputs=[user, movie], outputs=x)
opt = Adam(lr=0.001)
model.compile(loss='mean_squared_error', optimizer=opt)
print(model.summary())
history = model.fit(x=X_train_array, y=y_train, batch_size=64, epochs=5, verbose=1,
validation_data=(X_test_array, y_test))
Conv2D(16, 3, padding='same', activation='relu',
input_shape=(IMG_HEIGHT, IMG_WIDTH ,3)),
MaxPooling2D(),
Conv2D(32, 3, padding='same', activation='relu'),
MaxPooling2D(),
Conv2D(64, 3, padding='same', activation='relu'),
MaxPooling2D(),
Conv2D(128, 3, padding='same', activation='relu'),
MaxPooling2D(),
Flatten(),
Dense(256, activation='relu'),
Dropout(0.5),
Dense(512, activation='relu'),
Dropout(0.5),
Dense(1, activation='sigmoid')
])
op = Adam(lr=0.0003)
model.compile(optimizer=op,
loss='binary_crossentropy',
metrics=['accuracy'])
history = model.fit_generator(
train_data_gen,
steps_per_epoch=total_train // batch_size,
epochs=epochs,
validation_data=val_data_gen,
1))) #Usamos LSTM que é um tipo de camada de recorrencia
regressor.add(Dropout(0.3))
regressor.add(LSTM(units=50, return_sequences=True))
regressor.add(Dropout(0.3))
regressor.add(LSTM(units=50, return_sequences=True))
regressor.add(Dropout(0.3))
regressor.add(
LSTM(units=50)
) #Colocamos return_sequences =True quando vamos passar os dados de uma camada recorrente para outra recorrente, no caso a proxima é densa
regressor.add(Dropout(0.3))
regressor.add(
Dense(units=1, activation='linear')
) #Camada de saida com funçao linear, nao queremos fazer nenhuma transformaçao na saida
regressor.compile(
optimizer='rmsprop',
loss='mean_squared_error',
metrics=['mean_absolute_error'
]) #RMSprop é o optimizer mais recomendado para Redes Recorrentes
regressor.fit(previsores, preco_real, epochs=100, batch_size=32)
# ==== Estrutura dos dados de teste ====
base_teste = pd.read_csv('petr4_teste.csv')
preco_real_teste = base_teste.iloc[:, 1:
2].values #Pegamos somente a primeira coluna
base_completa = pd.concat(
(base['Open'], base_teste['Open']),
def __init__(self, num_class=2, weight_decay=0.005):
super(C3D_Model, self).__init__()
# 64, 128, 128, 256, 256
self.weight_decay = weight_decay
self.conv3d_1 = Conv3D(64, (3, 3, 3),
strides=(1, 1, 1),
padding='same',
activation='relu',
kernel_regularizer=l2(self.weight_decay))
self.maxpooling3d_1 = MaxPooling3D((2, 2, 1),
strides=(2, 2, 1),
padding='same')
self.conv3d_2 = Conv3D(128, (3, 3, 3),
strides=(1, 1, 1),
padding='same',
activation='relu',
kernel_regularizer=l2(self.weight_decay))
self.maxpooling3d_2 = MaxPooling3D((2, 2, 2),
strides=(2, 2, 2),
padding='same')
self.conv3d_3 = Conv3D(128, (3, 3, 3),
strides=(1, 1, 1),
padding='same',
activation='relu',
kernel_regularizer=l2(self.weight_decay))
self.maxpooling3d_3 = MaxPooling3D((2, 2, 2),
strides=(2, 2, 2),
padding='same')
self.conv3d_4 = Conv3D(256, (3, 3, 3),
strides=(1, 1, 1),
padding='same',
activation='relu',
kernel_regularizer=l2(self.weight_decay))
self.maxpooling3d_4 = MaxPooling3D((2, 2, 2),
strides=(2, 2, 2),
padding='same')
self.conv3d_5 = Conv3D(256, (3, 3, 3),
strides=(1, 1, 1),
padding='same',
activation='relu',
kernel_regularizer=l2(self.weight_decay))
self.maxpooling3d_5 = MaxPooling3D((2, 2, 2),
strides=(2, 2, 2),
padding='same')
self.flatten = Flatten()
self.dropout_0 = Dropout(0.5)
self.dense_1 = Dense(1024,
activation='relu',
kernel_regularizer=l2(self.weight_decay))
self.dropout_1 = Dropout(0.5)
self.dense_2 = Dense(512,
activation='relu',
kernel_regularizer=l2(self.weight_decay))
self.dropout_2 = Dropout(0.5)
self.output_tensor = Dense(num_class,
activation='softmax',
kernel_regularizer=l2(self.weight_decay))
def f(env_name):
import time
# importing frameworks/libraries
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Lambda
from tensorflow.keras.models import Model
import pandas as pd
import matplotlib.pyplot as plt
import gym
import numpy as np
from timeit import default_timer as timer
import pybulletgym
import pybullet_envs
'''gpus = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_virtual_device_configuration(
gpus[0],
[tf.config.experimental.VirtualDeviceConfiguration(memory_limit=1024)])'''
tf.keras.backend.set_floatx('float64')
# declaring constants
gamma = 0.99
upds = [64, 256, 1024]
lamb = 0.95
# max_episodes = 3000
tot_steps = 1000000
env = gym.make(env_name)
env.seed(15)
np.random.seed(24)
tf.random.set_seed(34)
node = 64
policy_learning_rates = [1e-1, 1e-2, 1e-3, 1e-4]
mult_lrs = [1, 2]
# getting the dimension of the environment
state_dim = env.observation_space.shape[0]
action_dim = env.action_space.shape[0]
action_bound = env.action_space.high[0]
# act_bound_low = env.action_space.low[0]
# print(act_bound, act_bound_low)
std_bound = [1e-2, 1.0]
for upd in upds:
for policy_lr in policy_learning_rates:
for mult_lr in mult_lrs:
# models
# policy model
state_input = Input((state_dim, ))
dense_1 = Dense(node, activation='relu')(state_input)
dense_2 = Dense(node, activation='relu')(dense_1)
out_mu = Dense(action_dim, activation='tanh')(dense_2)
mu_output = Lambda(lambda x: x * action_bound)(out_mu)
std_output = Dense(action_dim, activation='softplus')(dense_2)
policy_model = tf.keras.models.Model(state_input,
[mu_output, std_output])
policy_model_optimize = tf.keras.optimizers.Adam(policy_lr)
# value model
value_model = tf.keras.Sequential([
Input((state_dim, )),
Dense(node, activation='relu'),
Dense(node, activation='relu'),
Dense(1, activation='linear')
])
value_lr = mult_lr * policy_lr
value_model_optimizer = tf.keras.optimizers.Adam(value_lr)
ep_score = 0
ep_step = 0
episode = 0
scores = []
steps = []
state_batch = []
action_batch = []
td_target_batch = []
advantage_batch = []
done = False
state = env.reset()
print(
"Experiment is starting to learn {} using A2C with a policy learning rate {} and value learning rate {} and upd {}."
.format(env_name, policy_lr, value_lr, upd))
start = timer()
for step in range(tot_steps):
state = np.reshape(state, [1, state_dim])
mu, std = policy_model.predict(state)
action = np.random.normal(mu[0], std[0], size=action_dim)
action = np.clip(action, -action_bound, action_bound)
next_state, reward, done, _ = env.step(action)
state = np.reshape(state, [1, state_dim])
action = np.reshape(action, [1, action_dim])
next_state = np.reshape(next_state, [1, state_dim])
reward = np.reshape(reward, [1, 1])
if done:
td_target = reward
else:
v_value = value_model.predict(
(np.reshape(next_state, [1, state_dim])))
td_target = np.reshape(reward + gamma * v_value[0],
[1, 1])
advantage = td_target - value_model.predict(state)
state_batch.append(state)
action_batch.append(action)
td_target_batch.append(td_target)
advantage_batch.append(advantage)
if len(state_batch) >= upd or done:
states_arr = state_batch[0]
for elem in state_batch[1:]:
states_arr = np.append(states_arr, elem, axis=0)
actions_arr = action_batch[0]
for elem in action_batch[1:]:
actions_arr = np.append(actions_arr, elem, axis=0)
td_targets_arr = td_target_batch[0]
for elem in td_target_batch[1:]:
td_targets_arr = np.append(td_targets_arr,
elem,
axis=0)
advantages_arr = advantage_batch[0]
for elem in advantage_batch[1:]:
advantages_arr = np.append(advantages_arr,
elem,
axis=0)
# gradient and loss calculation
# policy
with tf.GradientTape() as policy_tape:
mus, stds = policy_model(states_arr, training=True)
stds = tf.clip_by_value(stds, std_bound[0],
std_bound[1])
vars = stds**2
log_policy_pdf = -0.5 * (actions_arr - mus) ** 2 / \
vars - 0.5 * tf.math.log(vars * 2 * np.pi)
log_policy_pdf = tf.reduce_sum(log_policy_pdf,
1,
keepdims=True)
policy_loss = log_policy_pdf * advantages_arr
policy_loss = tf.reduce_sum(-policy_loss)
policy_grads = policy_tape.gradient(
policy_loss, policy_model.trainable_variables)
policy_model_optimize.apply_gradients(
zip(policy_grads,
policy_model.trainable_variables))
# value
with tf.GradientTape() as value_tape:
v_pred = value_model(states_arr, training=True)
assert v_pred.shape == td_targets_arr.shape
mse = tf.keras.losses.MeanSquaredError()
value_loss = mse(v_pred,
tf.stop_gradient(td_targets_arr))
value_grads = value_tape.gradient(
value_loss, value_model.trainable_variables)
value_model_optimizer.apply_gradients(
zip(value_grads, value_model.trainable_variables))
state_batch = []
action_batch = []
td_target_batch = []
advantage_batch = []
ep_score += reward[0][0]
ep_step += 1
state = next_state[0]
if done:
scores.append(ep_score)
steps.append(ep_step)
episode += 1
print("Episode: {} Step: {} Reward: {}".format(
episode, step, ep_score))
ep_score = 0
ep_step = 0
state = env.reset()
end = timer()
print(
'Experiment is finished to learn {} using A2C with a policy learning rate {} and value learning rate {} and upd {} after {} hours.'
.format(env_name, policy_lr, value_lr, upd,
(end - start) / 3600.0))
dict = {'r': scores, 'l': steps}
df = pd.DataFrame(dict)
logdir = 'logs/a2c/envs/' + env_name + '/lrs/'
fname = 'plr=' + str(policy_lr) + 'mult=' + str(
mult_lr) + 'upd=' + str(upd) + '.csv'
os.makedirs(logdir, exist_ok=True)
df.to_csv(logdir + fname)
for upd in upds:
for policy_lr in policy_learning_rates:
for mult_lr in mult_lrs:
df = pd.read_csv('logs/a2c/envs/' + env_name + '/lrs/plr=' +
str(policy_lr) + 'mult=' + str(mult_lr) +
'upd=' + str(upd) + '.csv')
x = np.cumsum(df['l'])
plt.scatter(x,
df['r'],
s=5,
label='plr=' + str(policy_lr) + 'mult=' +
str(mult_lr),
alpha=0.4)
plt.legend()
plt.xlabel('Steps')
plt.ylabel('Episodic Score')
plt.title('Experiment on ' + env_name)
logdir = 'logs/a2c/envs/' + env_name + '/lrs/'
fname = env_name + '_opt.png'
plt.savefig(logdir + fname)
import tensorflow as tf from tensorflow.keras.layers import Input, Dense from tensorflow.keras.models import Model # this is the size of our encoded representations encoding_dim = 64 # 32 floats -> compression of factor 24.5, assuming the input is 784 floats # this is our input placeholder input_img = Input(shape=(784,)) # "encoded" is the encoded representation of the input encoded = Dense(encoding_dim, activation='relu')(input_img) # this model maps an input to its encoded representation encoder = Model(input_img, encoded) # "decoded" is the lossy reconstruction of the input decoded = Dense(784, activation='sigmoid')(encoded) # this model maps an input to its reconstruction autoencoder = Model(input_img, decoded) # create a placeholder for an encoded (32-dimensional) input encoded_input = Input(shape=(encoding_dim,)) # retrieve the last layer of the autoencoder model decoder_layer = autoencoder.layers[-1] # create the decoder model decoder = Model(encoded_input, decoder_layer(encoded_input)) autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy') from tensorflow.keras.datasets import mnist
def get_age_model(DATA):
feed_forward_size = 2048
max_seq_len = 150
model_dim = 256 + 256 + 64 + 32 + 8 + 16
input_creative_id = Input(shape=(max_seq_len, ), name='creative_id')
x1 = Embedding(
input_dim=NUM_creative_id + 1,
output_dim=256,
weights=[DATA['creative_id_emb']],
trainable=args.not_train_embedding,
# trainable=False,
input_length=150,
mask_zero=True)(input_creative_id)
# encodings = PositionEncoding(model_dim)(x1)
# encodings = Add()([embeddings, encodings])
input_ad_id = Input(shape=(max_seq_len, ), name='ad_id')
x2 = Embedding(
input_dim=NUM_ad_id + 1,
output_dim=256,
weights=[DATA['ad_id_emb']],
trainable=args.not_train_embedding,
# trainable=False,
input_length=150,
mask_zero=True)(input_ad_id)
input_product_id = Input(shape=(max_seq_len, ), name='product_id')
x3 = Embedding(
input_dim=NUM_product_id + 1,
output_dim=32,
weights=[DATA['product_id_emb']],
trainable=args.not_train_embedding, #
# trainable=False,
input_length=150,
mask_zero=True)(input_product_id)
input_advertiser_id = Input(shape=(max_seq_len, ), name='advertiser_id')
x4 = Embedding(
input_dim=NUM_advertiser_id + 1,
output_dim=64,
weights=[DATA['advertiser_id_emb']],
trainable=args.not_train_embedding, #
# trainable=False,
input_length=150,
mask_zero=True)(input_advertiser_id)
input_industry = Input(shape=(max_seq_len, ), name='industry')
x5 = Embedding(
input_dim=NUM_industry + 1,
output_dim=16,
weights=[DATA['industry_emb']],
trainable=args.not_train_embedding,
# trainable=False,
input_length=150,
mask_zero=True)(input_industry)
input_product_category = Input(shape=(max_seq_len, ),
name='product_category')
x6 = Embedding(
input_dim=NUM_product_category + 1,
output_dim=8,
weights=[DATA['product_category_emb']],
trainable=args.not_train_embedding,
# trainable=False,
input_length=150,
mask_zero=True)(input_product_category)
# (bs, 100, 128*2)
encodings = layers.Concatenate(axis=2)([x1, x2, x3, x4, x5, x6])
# (bs, 100)
masks = tf.equal(input_creative_id, 0)
# (bs, 100, 128*2)
attention_out = MultiHeadAttention(
8, 79)([encodings, encodings, encodings, masks])
# Add & Norm
attention_out += encodings
attention_out = LayerNormalization()(attention_out)
# Feed-Forward
ff = PositionWiseFeedForward(model_dim, feed_forward_size)
ff_out = ff(attention_out)
# Add & Norm
# ff_out (bs, 100, 128)，但是attention_out是(bs,100,256)
ff_out += attention_out
encodings = LayerNormalization()(ff_out)
encodings = GlobalMaxPooling1D()(encodings)
encodings = Dropout(0.2)(encodings)
# output_gender = Dense(2, activation='softmax', name='gender')(encodings)
output_age = Dense(10, activation='softmax', name='age')(encodings)
model = Model(inputs=[
input_creative_id, input_ad_id, input_product_id, input_advertiser_id,
input_industry, input_product_category
],
outputs=[output_age])
model.compile(
optimizer=optimizers.Adam(2.5e-4),
loss={
# 'gender': losses.CategoricalCrossentropy(from_logits=False),
'age': losses.CategoricalCrossentropy(from_logits=False) #
},
# loss_weights=[0.4, 0.6],
metrics=['accuracy'])
return model
x_train = x_train.reshape(x_train.shape[0], 30, 1) x_test = x_test.reshape(x_test.shape[0], 30, 1) # 2. 모델 구성 from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Conv1D, MaxPooling1D, Dense, Flatten, Dropout model = Sequential() model.add(Conv1D(400, 3, padding='same', input_shape=(30, 1))) model.add(Dropout(0.2)) model.add(MaxPooling1D(2)) model.add(Conv1D(300, 3)) model.add(Dropout(0.2)) model.add(Flatten()) model.add(Dense(200, activation='sigmoid')) model.add(Dropout(0.2)) model.add(Dense(120, activation='sigmoid')) model.add(Dense(60, activation='sigmoid')) model.add(Dense(30, activation='sigmoid')) model.add(Dense(1, activation='sigmoid')) # 3. 컴파일, 훈련 model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc']) from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint early_stopping = EarlyStopping(monitor='val_loss', patience=30, mode='auto') modelpath= '../data/modelcheckpoint/k54_conv1d_cancer_checkpoint.hdf5' cp = ModelCheckpoint(modelpath, monitor='val_loss', save_best_only=True, mode='auto') model.fit(x_train, y_train, epochs=400, validation_split=0.2, callbacks=[early_stopping, cp], batch_size=16) # 4. 평가, 예측
model.add(Dropout(0.2))
model.add(Conv2D(64, (3, 3), padding='same',
activation='relu')) #padding default=valid
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=2)) #pool_size default=2
model.add(Dropout(0.2))
model.add(Conv2D(128, (3, 3), padding='same',
activation='relu')) #padding default=valid
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=2)) #pool_size default=2
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax')) #ouput
#3. 컴파일, 훈련
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
es = EarlyStopping(monitor='loss', patience=10, mode='auto')
r_lr = ReduceLROnPlateau(monitor='val_loss', patience=3, factor=0.5, verbose=1)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#batch_size 무조건 32가 잘 먹히진 안음...
#특히 이미지 파일의 경우... 한번에 많이 줘야 학습을 잘하지 않을까...
def build_model(
img_shape: Tuple[int, int, int],
num_classes: int,
optimizer: tf.keras.optimizers.Optimizer,
learning_rate: float,
filter_block1: int,
kernel_size_block1: int,
filter_block2: int,
kernel_size_block2: int,
filter_block3: int,
kernel_size_block3: int,
dense_layer_size: int,
kernel_initializer: tf.keras.initializers.Initializer,
activation_cls: tf.keras.layers.Activation,
dropout_rate: float
) -> Model:
input_img = Input(shape=img_shape)
x = Conv2D(
filters=filter_block1,
kernel_size=kernel_size_block1,
padding="same",
kernel_initializer=kernel_initializer
)(input_img)
x = activation_cls(x)
x = Conv2D(
filters=filter_block1,
kernel_size=kernel_size_block1,
padding="same", kernel_initializer=kernel_initializer
)(x)
if dropout_rate:
x = Dropout(rate=dropout_rate)(x)
x = activation_cls(x)
x = MaxPool2D()(x)
x = Conv2D(
filters=filter_block2,
kernel_size=kernel_size_block2,
padding="same",
kernel_initializer=kernel_initializer
)(x)
x = activation_cls(x)
x = Conv2D(
filters=filter_block2,
kernel_size=kernel_size_block2,
padding="same",
kernel_initializer=kernel_initializer
)(x)
if dropout_rate:
x = Dropout(rate=dropout_rate)(x)
x = activation_cls(x)
x = MaxPool2D()(x)
x = Conv2D(
filters=filter_block3,
kernel_size=kernel_size_block3,
padding="same",
kernel_initializer=kernel_initializer
)(x)
x = activation_cls(x)
x = Conv2D(
filters=filter_block3,
kernel_size=kernel_size_block3,
padding="same",
kernel_initializer=kernel_initializer
)(x)
if dropout_rate:
x = Dropout(rate=dropout_rate)(x)
x = activation_cls(x)
x = MaxPool2D()(x)
x = Flatten()(x)
x = Dense(
units=dense_layer_size,
kernel_initializer=kernel_initializer
)(x)
x = activation_cls(x)
x = Dense(
units=num_classes,
kernel_initializer=kernel_initializer
)(x)
y_pred = Activation("softmax")(x)
model = Model(
inputs=[input_img],
outputs=[y_pred]
)
opt = optimizer(learning_rate=learning_rate)
model.compile(
loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"]
)
return model
def make_autoencoder_model(self, d):
#################################################
# Hyper-parameters
#################################################
encoding_dim = 2
hidden_dim = self.hidden_dim
architecture = self.architecture
#activation='elu'
activation='leaky_relu'
optimizer=self.optimizer
loss=self.loss
#optimizer=optimizers.Adam(lr=0.01)
#loss='mean_squared_error'
#################################################
out_activation = 'sigmoid' if loss=='binary_crossentropy' else 'linear'
activation = None if activation=='leaky_relu' else activation
#################################################
# Auto-encoder
#################################################
input_img = Input(shape=(d,))
####### Encoder #######
encoded = input_img
# Layer
if architecture >= 1:
encoded = Dense(hidden_dim, activation=activation)(encoded)
if activation is None: encoded = layers.LeakyReLU()(encoded)
# Layer
if architecture >= 2:
encoded = Dense(hidden_dim//2, activation=activation)(encoded)
if activation is None: encoded = layers.LeakyReLU()(encoded)
# Layer
if architecture >= 3:
encoded = Dense(hidden_dim//4, activation=activation)(encoded)
if activation is None: encoded = layers.LeakyReLU()(encoded)
# Layer
encoded = Dense(encoding_dim, activation=out_activation)(encoded)
####### Decoder #######
decoded = encoded
# Layer
if architecture >= 3:
decoded = Dense(hidden_dim//4, activation=activation)(decoded)
if activation is None: decoded = layers.LeakyReLU()(decoded)
# Layer
if architecture >= 2:
decoded = Dense(hidden_dim//2, activation=activation)(decoded)
if activation is None: decoded = layers.LeakyReLU()(decoded)
# Layer
if architecture >= 1:
decoded = Dense(hidden_dim, activation=activation)(decoded)
if activation is None: decoded = layers.LeakyReLU()(decoded)
# Layer
decoded = Dense(d, activation=out_activation)(decoded)
####### Make model #######
autoencoder = Model(input_img, decoded)
encoder = Model(input_img, encoded)
#decoder = Model(encoded, decoded)
autoencoder.compile(optimizer=optimizer, loss=loss)
return autoencoder, encoder, decoded
NAME = "Cats-vs-dogs-{}-CNN-layers-sized{}-and-Denselayer-sized-{}-{}".format(conv_layers,layer_sizes , dense_layers ,int(time.time())) #very important to choose the name correctly to use tensorboard
model = Sequential()
model.add(Conv2D(64, (3, 3), input_shape=X.shape[1:]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
model.add(Conv2D(128, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
model.add(Flatten()) # this converts our 3D feature maps to 1D feature vectors
model.add(Dense(256))
model.add(Activation('relu'))
model.add(Dropout(0.3))
model.add(Dense(1))
model.add(Activation('sigmoid'))
# tensorboard = TensorBoard(log_dir='log',
# batch_size=128,
# write_graph=True,
# write_grads=True,
# write_images=True,
# update_freq='batch')
# tensorboard not working properly
#%% defining our extra functions to help us improve our training
#mY = y_train.mean()
#sY = y_train.std()
#y_train = ( y_train - mY ) / sY
#y_test = ( y_test - mY ) / sY
#%% NN
mName = 'NN'
val_loss = []
model_rec = []
history_rec = []
for i in range(10):
model = Sequential()
model.add(Dense(units=3, activation='relu', input_dim=X.shape[1]))
#model.add(Dense(units=3, activation='relu', input_dim=X.shape[1]))
#model.add(Dense(units=3, activation='relu', input_dim=X.shape[1]))
#model.add(Dense(units=3, activation='relu', input_dim=X.shape[1]))
model.add(Dense(units=3, activation='relu'))
model.add(Dense(units=3, activation='relu'))
model.add(Dense(units=3, activation='relu'))
model.add(Dense(units=1))
model.summary()
model.compile(loss='mse', optimizer='adam', metrics=['mse'])
# model.save_weights('model.h5')
model_rec.append(model)
patience = 200
[20,30,40],[30,40,50],[40,50,60]])
y = np.array([4,5,6,7,8,9,10,11,12,13,50,60,70])
x_pred = np.array([50,60,70])
print("x.shape : ", x.shape) #(13, 3)
print("y.shape : ", y.shape) #(13,)
x = x.reshape(13, 3, 1)
#2. 모델구성
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense,GRU
model = Sequential()
model.add(GRU(10, activation='relu', input_shape=(3,1)))
model.add(Dense(30,activation='relu'))
model.add(Dense(20))
model.add(Dense(10))
model.add(Dense(1))
model.summary()
# 3. 컴파일, 훈련
model.compile(loss='mse', optimizer='adam')
model.fit(x,y, epochs=100, batch_size=1)
# 4. 평가, 예측
loss = model.evaluate(x, y)
print('loss : ',loss)
x_pred = x_pred.reshape(1, 3 , 1)
session = tf.Session(config=config)
model = Sequential()
model.add(Conv2D(512, (3, 3), input_shape=X.shape[1:]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(512, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
# Last dense layers must (not sure) have number of labels in data in parenthesis
model.add(Dense(32))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Dense(2))
model.add(Activation('softmax'))
model.compile(loss='sparse_categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# Visualizing model open cmd cd to folder where the script is saved
# and type "tensorboard --logdir=logs\"
tensorboard = TensorBoard(log_dir="logs/{}".format(NAME))
model.fit(X,
