def model(GRU_size=5):
adam = optimizers.Adam()
model = Sequential()
model.add(GRU(GRU_size))
model.add(Dense(len(interested_words), activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer=adam)
return model
def create_classifier_model(
input_length, hidden_layer_sizes, regularization_beta):
layer_sizes = hidden_layer_sizes + [1]
num_layers = len(layer_sizes)
regularizer = keras.regularizers.l2(regularization_beta)
model = Sequential()
for i in range(num_layers):
kwargs = {
'activation': 'sigmoid' if i == num_layers - 1 else 'relu',
'kernel_regularizer': regularizer
}
if i == 0:
kwargs['input_dim'] = input_length
model.add(Dense(layer_sizes[i], **kwargs))
model.compile(
optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
return model
def fit_model(train_X, train_Y, window_size = 1):
EPOCHS=10
model = Sequential()
model.add(LSTM(4,
input_shape = (1, window_size)))
model.add(Dense(1))
model.compile(loss = "mean_squared_error",
optimizer = "adam")
model.fit(train_X,
train_Y,
epochs = EPOCHS,
batch_size = 1,
verbose = 2)
return(model)
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
], dtype='float32')
# this takes a looong time to index, and
# python may crash several times before indexing is complete
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Activation
model = Sequential()
model.add(Dense(8,
activation=keras.activations.sigmoid,
))
model.add(Dense(17,
activation=keras.activations.sigmoid,
))
model.compile(
optimizer=tf.train.AdamOptimizer(0.001),
loss=keras.losses.categorical_crossentropy,
# loss=keras.losses.mse,
metrics=[keras.metrics.binary_accuracy]
)
# This is the process I used to train my weights
# model.fit(votingrecords, votingtarget,epochs =2000)
# myWeights= model.get_weights()
# np.set_printoptions(suppress=True)
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,
shuffle=True)
'''
print(x_train)
print(x_train.shape)
print(x_test.shape)
print(y_train.shape)
print(y_test.shape)
'''
#2.모델 구성
model = Sequential()
model.add(Dense(5, input_dim=1))
model.add(Dense(1))
model.add(Dense(1))
#3.컴파일,훈련
model.compile(loss='mse', optimizer='adam', metrics=['mae'])
model.fit(x_train, y_train, epochs=100, validation_split=0.2)
#4.평가,예측
loss, mae = model.evaluate(x_test, y_test)
print('loss:', loss, 'mse:', mae)
y_predict = model.predict(x_test)
print(y_predict)
'''
#4.평가,예측
def create_model(self):
if LOAD_MODEL is not None:
model = load_model(LOAD_MODEL)
else:
model = Sequential()
model.add(Conv2D(128, (2, 2), input_shape=env.observation_space_values)) # OBSERVATION_SPACE_VALUES = (10, 10, 3) a 10x10 RGB image.
model.add(Activation('relu'))
model.add(Conv2D(128, (2, 2)))
model.add(Activation('relu'))
model.add(Flatten()) # this converts our 3D feature maps to 1D feature vectors
model.add(Dense(128))
model.add(Dense(len(env.actions), activation='linear')) # ACTION_SPACE_SIZE = how many choices (9)
model.compile(loss="mse", optimizer=Adam(lr=0.001))
return model
def init():
# [32C3-BN]*2-[32C5S2-BN]-0.4d-[64C3-BN]*2-[64C5S2-BN]-0.4d-F-256D-10D 20E
model = Sequential()
model.add(Conv2D(32, 3, padding='same', activation='relu', input_shape=(28, 28, 1)))
model.add(tf.keras.layers.BatchNormalization())
model.add(Conv2D(32, 3, padding='same', activation='relu', input_shape=(28, 28, 1)))
model.add(tf.keras.layers.BatchNormalization())
model.add(Conv2D(32, 5, padding='same',strides=2, activation='relu', input_shape=(28, 28, 1)))
model.add(tf.keras.layers.BatchNormalization())
model.add(Dropout(0.4))
model.add(Conv2D(64, 3, padding='same', activation='relu', input_shape=(28, 28, 1)))
model.add(tf.keras.layers.BatchNormalization())
model.add(Conv2D(64, 3, padding='same', activation='relu', input_shape=(28, 28, 1)))
model.add(tf.keras.layers.BatchNormalization())
model.add(Conv2D(64, 5, padding='same',strides=2, activation='relu', input_shape=(28, 28, 1)))
model.add(tf.keras.layers.BatchNormalization())
model.add(Dropout(0.4))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.4))
model.add(Dense(10, activation='softmax'))
model.load_weights("./models/model_weights.h5")
print("Loaded Model from disk")
optimizer = tf.keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)
model.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=optimizer, metrics=['accuracy'])
return model
image_size = x_train.shape[1]
input_size = image_size * image_size
# we train our network using float data
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255
# network parameters
batch_size = 128
hidden_units = 256
data_augmentation = True
epochs = 20
max_batches = len(x_train) / batch_size
# this is 3-layer MLP with ReLU after each layer
model = Sequential()
model.add(Dense(hidden_units, input_dim=input_size))
model.add(Activation('relu'))
model.add(Dense(hidden_units))
model.add(Activation('relu'))
model.add(Dense(num_labels))
# this is the output for one-hot vector
model.add(Activation('softmax'))
model.summary()
# loss function for one-hot vector
# use of sgd optimizer
# accuracy is good metric for classification tasks
model.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
def build_model(img_shape: Tuple[int, int, int],
num_classes: int) -> Sequential:
catdog_model = Sequential()
catdog_model.add(
Conv2D(filters=24,
kernel_size=3,
padding="same",
input_shape=img_shape))
catdog_model.add(Activation("relu"))
catdog_model.add(Conv2D(filters=24, kernel_size=3, padding="same"))
catdog_model.add(Activation("relu"))
catdog_model.add(MaxPool2D())
catdog_model.add(Conv2D(filters=48, kernel_size=3, padding="same"))
catdog_model.add(Activation("relu"))
catdog_model.add(Conv2D(filters=48, kernel_size=3, padding="same"))
catdog_model.add(Activation("relu"))
catdog_model.add(MaxPool2D())
catdog_model.add(Conv2D(filters=96, kernel_size=3, padding="same"))
catdog_model.add(Activation("relu"))
catdog_model.add(Conv2D(filters=96, kernel_size=3, padding="same"))
catdog_model.add(Activation("relu"))
catdog_model.add(MaxPool2D())
catdog_model.add(Conv2D(filters=128, kernel_size=3, padding="same"))
catdog_model.add(Activation("relu"))
catdog_model.add(Conv2D(filters=128, kernel_size=3, padding="same"))
catdog_model.add(Activation("relu"))
catdog_model.add(MaxPool2D())
catdog_model.add(Flatten())
catdog_model.add(Dense(128))
catdog_model.add(Dense(units=num_classes))
catdog_model.add(Activation("softmax"))
catdog_model.summary()
return catdog_model
from tensorflow.keras.callbacks import TensorBoard
(X_train,y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(60000,28,28,1).astype('float32')
X_test = X_test.reshape(10000,28,28,1).astype('float32')
X_train /= 255
X_test /= 255
n_classes = 10
y_train = keras.utils.to_categorical(y_train, n_classes)
y_test = keras.utils.to_categorical(y_test, n_classes)
model = Sequential()
model.add(Conv2D(32, kernel_size=(3,3), activation='relu', input_shape=(28,28,1)) )
model.add(Conv2D(64, kernel_size=(3,3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(n_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
tensor_board = TensorBoard('./logs/LeNet-MNIST-1')
model.fit(X_train, y_train, batch_size=128, epochs=15, verbose=1, validation_data=(X_test,y_test), callbacks=[tensor_board])
(image_width - wandb.config.window_width) / wandb.config.window_stride) + 1
if num_windows < output_length:
raise ValueError(
f'Window width/stride need to generate >= {output_length} windows (currently {num_windows})')
# Build windowing layer
image_reshaped = Reshape((image_height, image_width, 1))(image_input)
image_patches = Lambda(
slide_window,
arguments={'window_width': wandb.config.window_width,
'window_stride': wandb.config.window_stride}
)(image_reshaped)
# Build simple convnet
cnn = Sequential()
cnn.add(Conv2D(32, (3, 3), activation='relu'))
cnn.add(MaxPooling2D())
cnn.add(Dropout(0.4))
cnn.add(Conv2D(64, (3, 3), activation='relu'))
cnn.add(MaxPooling2D())
cnn.add(Dropout(0.4))
cnn.add(Flatten())
cnn.add(Dense(64, activation='relu'))
# TimeDistribute convnet output
cnn_out = TimeDistributed(cnn)(image_patches)
# Feed Time distributed into a GRU
gru_out = Bidirectional(gru_fn(128, return_sequences=True))(cnn_out)
gru2_out = gru_fn(128, return_sequences=True)(gru_out)
def build_ensemble_model(shape, NUM_CLASSES):
"""
This ensemble model is based on the Deep Fingerprinting Model's flatten and dense layers
before classification.
:param shape: The shape of the ensembled training data
:return: The ensemble model
"""
initializer = tf.keras.initializers.VarianceScaling(
scale=1.0, mode='fan_in', distribution='untruncated_normal')
model = Sequential()
model.add(Input(shape=shape))
model.add(
Dense(1024, kernel_initializer=glorot_uniform(seed=0), name='fc1'))
model.add(Activation('relu', name='fc1_act'))
model.add(Dropout(0.7, name='fc1_dropout'))
model.add(
Dense(1024, kernel_initializer=glorot_uniform(seed=0), name='fc2'))
model.add(Activation('relu', name='fc2_act'))
model.add(Dropout(0.7, name='fc2_dropout'))
model.add(
Dense(NUM_CLASSES,
kernel_initializer=glorot_uniform(seed=0),
name='fc3'))
model.add(Activation('softmax', name="softmax"))
sgd = SGD(lr=0.003, nesterov=True, momentum=0.5)
model.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])
return model
train_data_gen = train_image_generator.flow_from_directory(batch_size=batch_size,
directory=train_dir,
target_size=(IMG_HEIGHT, IMG_WIDTH),
class_mode='binary')
augmented_images = [train_data_gen[0][0][0] for i in range(5)]
plotImages(augmented_images)
"""In the cell below, create a model for the neural network that outputs class probabilities. It should use the Keras Sequential model. It will probably involve a stack of Conv2D and MaxPooling2D layers and then a fully connected layer on top that is activated by a ReLU activation function.
Compile the model passing the arguments to set the optimizer and loss. Also pass in `metrics=['accuracy']` to view training and validation accuracy for each training epoch.
"""
model = Sequential()
model.add(tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)))
model.add(tf.keras.layers.MaxPooling2D((2, 2)))
model.add(tf.keras.layers.Conv2D(64, (3, 3), activation='relu'))
model.add(tf.keras.layers.MaxPooling2D((2, 2)))
model.add(tf.keras.layers.Conv2D(64, (3, 3), activation='relu'))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dense(1, activation='sigmoid'))
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
model.summary()
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.regularizers import L2
(trainX, trainY), (testX, testY) = mnist.load_data()
import matplotlib.pyplot as plt
plt.imshow(trainX[0])
model = Sequential()
model.add(Flatten(input_shape=(28, 28)))
model.add(Dense(256, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(10, activation='softmax'))
model.summary()
model.compile(optimizer='sgd',
loss='sparse_categorical_crossentropy',
metrics=['acc'])
trainX = trainX / 255.0
testX = testX / 255.0
model.fit(trainX, trainY, epochs=10, verbose=1, validation_data=(testX, testY))
model2 = Sequential()
model2.add(Flatten(input_shape=(28, 28)))
model2.add(Dense(256, activation="relu", kernel_regularizer=L2(0.01)))
model2.add(Dense(128, activation='relu', kernel_regularizer=L2(0.01)))
speed = 10
count=0
car_shift=10
discount_factor =0.95
learning_rate =0.5
reward_val=10
crash_count =0
train_image_size = (right_max-left_max,int(H)-int(H//4),1)
X = []
y = []
model = Sequential()
model.add(Flatten())
model.add(Dense(256,activation='relu'))
model.add(Dense(126))
model.add(Dense(3))
#comment the below line if you want to train a model
model = load_model('Trained_models/model-v1.model')
model.compile(loss='mse',optimizer='adam',metrics=['accuracy'])
#print(model.summary())
l= len(get_state())
print(window_size)
def create_keras_model():
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
#model.add(keras.layers.Dropout(0.5))
#model.add(keras.layers.Flatten())
model.add(Dense(10, activation='softmax', name ='predictions'))
return model
# 그래프로 확인
sns.pairplot(df, hue='species');
plt.show()
# 데이터 분류
dataset = df.values
X = dataset[:,0:4].astype(float)
Y_obj = dataset[:,4]
# 문자열을 숫자로 변환
e = LabelEncoder()
e.fit(Y_obj)
Y = e.transform(Y_obj)
Y_encoded = tf.keras.utils.to_categorical(Y)
# 모델의 설정
model = Sequential()
model.add(Dense(16, input_dim=4, activation='relu'))
model.add(Dense(3, activation='softmax'))
# 모델 컴파일
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# 모델 실행
model.fit(X, Y_encoded, epochs=50, batch_size=1)
# 결과 출력
print("\n Accuracy: %.4f" % (model.evaluate(X, Y_encoded)[1]))
# split into train and validation
training_df = main_df[:last_10pct]
validation_df = main_df[last_10pct:last_5pct]
# preprocess the data
train_x, train_y = preprocess_df(training_df)
validation_x, validation_y = preprocess_df(validation_df)
# some statistics
print(f"train data: {len(train_x)} validation: {len(validation_x)}")
print(f"don't buys: {train_y.count(0)}, buys: {train_y.count(1)}")
print(f"VALIDATION don't buys: {validation_y.count(0)}, buys: {validation_y.count(1)}")
model = Sequential()
model.add(LSTM(128, activation='tanh', input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(128, activation='tanh', input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(128, activation='tanh', input_shape=(train_x.shape[1:])))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(2, activation="softmax"))
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.3,
random_state=101)
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
#model definition and compliation
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
model = Sequential()
model.add(Dense(19, activation='relu'))
model.add(Dense(19, activation='relu'))
model.add(Dense(19, activation='relu'))
model.add(Dense(19, activation='relu'))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')
model.fit(x=X_train,
y=y_train,
validation_data=(X_test, y_test),
batch_size=128,
epochs=400)
losses = pd.DataFrame(model.history.history)
losses.plot()
from sklearn.metrics import mean_absolute_error, mean_squared_error, explained_variance_score
# =============================================================================
X_train = np.load(os.path.join(os.getcwd(), 'data', 'LSTM_x_Train.npy'))
y_train = np.load(os.path.join(os.getcwd(), 'data', 'LSTM_y_Train.npy'))
X_test = np.load(os.path.join(os.getcwd(), 'data', 'LSTM_x_Test.npy'))
y_test = np.load(os.path.join(os.getcwd(), 'data', 'LSTM_y_Test.npy'))
#%%
# =============================================================================
# Build classification model - GRU
# =============================================================================
from tensorflow.keras.layers import GRU, Activation
model = Sequential()
model.add(
GRU(50,
input_shape=(X_train.shape[1], X_train.shape[2]),
return_sequences=True))
model.add(GRU(1, return_sequences=False))
model.add(Activation('sigmoid'))
model.summary()
adam = Adam(lr=learningRate)
model.compile(loss='binary_crossentropy', optimizer=adam, metrics=['accuracy'])
chk = ModelCheckpoint(os.path.join(os.getcwd(), 'data', 'best_model.hdf5'),
monitor='val_accuracy',
save_best_only=True,
mode='max',
verbose=1)
history = model.fit(X_train,
y_train,
epochs=150,
# функция нормализуем данные для работы
def normalize_data(data):
mean = data.mean(axis=0)
std = data.std(axis=0)
data -= mean
data /= std
return data
x_norm = normalize_data(x)
x_norm
x_train, x_test, y_train, y_test = train_test_split(x_norm, y, test_size=0.3, random_state = 2)
model = Sequential()
model.add(Dense(5059, activation="relu", input_shape=(x_train.shape[1],)))
model.add(Dropout(0.3))
model.add(Dense(1264, activation="relu"))
model.add(Dense(632, activation="relu"))
model.add(Dense(158, activation="relu"))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse', metrics=['mae'])
model.summary()
history = model.fit(x_train, y_train, epochs=150, batch_size=500, verbose=1, validation_split=0.3)
print(history)
history = history.history
print("[DEBUG-USER] nn finish")
def graphs(history):
print(y_test.shape) #(456,)
from sklearn.preprocessing import MinMaxScaler #preprocessing 전처리
scaler = MinMaxScaler()
scaler.fit(x)
x = scaler.transform(x)
x_train = scaler.transform(x_train)
x_test = scaler.transform(x_test)
print(np.max(x), np.min(x)) #395: 해당칼럼의 최대가 395
#2.모델링
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
model = Sequential()
model.add(Dense(100, activation='relu',
input_shape=(30, ))) #액티베이션 처음과 중간은 다른거 넣어도 마지막엔 시그모이드 함수 넣어야함
model.add(Dropout(0.2))
model.add(Dense(100, activation='relu'))
model.add(Dropout(0.2)) #이 레이어만 있는 경우도 상관없음, 히든이 없는 모델도 가능함
model.add(Dense(100, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(100, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(
1, activation='sigmoid')) #액티베이션이 디폴트값은 리니어,따라서 범위는 무한대~무한대, 나오는 값은
#시그모이드함수는 0과 1사이에 한정을 짓는 함수 0<n<1, 어떤 레이어도 0과 1사이에 수렴한다.
#렐루함수는 액티베이션에 대해서 가중치 연산을 제어한다, 값이 음수일 때 상쇄, 0이상의 값만 전달해줌.
#렐루함수는 0보다 같거나 크거나 =>렐루가 성능이 좋다, 평타 85%이상침(시그모이드는 그렇지 않음)
#max(0,x)
#최초에 나온 모델은 0과 1사이에 있는 시그모이드 함수
def test_rest(scan_object):
print('\n >>> start testing the rest... \n')
import talos
import random
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras import metrics, losses
deploy_filename = 'test' + str(random.randint(1, 20000000000))
print('\n ...Deploy()... \n')
talos.Deploy(scan_object, deploy_filename, 'val_acc')
print('\n ...Restore()... \n')
restored = talos.Restore(deploy_filename + '.zip')
x, y = talos.templates.datasets.breast_cancer()
x = x[:50]
y = y[:50]
x_train, y_train, x_val, y_val = talos.utils.val_split(x, y, .2)
x = talos.utils.rescale_meanzero(x)
callbacks = [
talos.utils.early_stopper(10),
talos.utils.ExperimentLogCallback('test', {})
]
metrics = [
metrics.MeanAbsolutePercentageError(),
metrics.MeanSquaredLogarithmicError(),
metrics.RootMeanSquaredError(),
metrics.Precision(),
metrics.Recall()
]
print('\n ...callbacks and metrics... \n')
model1 = Sequential()
model1.add(Dense(10, input_dim=x.shape[1]))
model1.add(Dense(1))
model1.compile('adam', metrics=metrics)
model1.fit(x, y, callbacks=callbacks)
print('\n ...generator... \n')
model2 = Sequential()
model2.add(Dense(10, input_dim=x.shape[1]))
model2.add(Dense(1))
model2.compile('adam')
model2.fit_generator(talos.utils.generator(x, y, 10), 5)
print('\n ...SequenceGenerator... \n')
model3 = Sequential()
model3.add(Dense(10, input_dim=x.shape[1]))
model3.add(Dense(1))
model3.compile('adam', 'logcosh')
model3.fit_generator(talos.utils.SequenceGenerator(x, y, 10))
# print('\n ...gpu_utils... \n')
# talos.utils.gpu_utils.force_cpu()
# talos.utils.gpu_utils.parallel_gpu_jobs()
# print('\n ...gpu_utils... \n')
from talos.utils.test_utils import create_param_space
create_param_space(restored.results, 5)
print('finished testing the rest \n')
def model_fit(x_train, y_train, x_test, y_test, x_valid, numclasses,
input_shape, saved_model_path):
'''
load data, compile and train CNN model, apply data shape trasformation for ANN inputs
Parameters
Input:
x_train, y_train - train data: qrs segments and labels
y_test, y_test - test data: qrs segments and labels
x_valid - validation data
numclasses - the number of classes (labels)
input_shape - the unput shape of the chosen ANN
Output:
model - sequential model
history - training history parameters
x_valid - reshaped validation data
'''
x_train, x_test, x_valid = map(lambda x: get_transformed_input(x),
[x_train, x_test, x_valid])
epochs = 100
model = Sequential()
# Convolutional layers
model.add(
Convolution1D(100,
4,
1,
activation='tanh',
input_shape=input_shape,
kernel_regularizer=regularizers.l2(0.001)))
model.add(MaxPooling1D(pool_size=2))
model.add(
Convolution1D(200,
2,
1,
activation='tanh',
kernel_regularizer=regularizers.l2(0.001)))
model.add(MaxPooling1D(pool_size=4))
model.add(
Convolution1D(300,
1,
1,
activation='tanh',
kernel_regularizer=regularizers.l2(0.001)))
model.add(MaxPooling1D(pool_size=2))
model.add(
Convolution1D(400,
1,
1,
activation='tanh',
kernel_regularizer=regularizers.l2(0.001)))
model.add(Flatten())
model.add(Dropout(0.9))
model.add(Dense(3000, activation='tanh'))
model.add(Dense(numclasses, activation='softmax'))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
reduce_lr = tensorflow.keras.callbacks.ReduceLROnPlateau(monitor='loss',
factor=0.5,
patience=50,
min_lr=0.0001)
callbacks = [
ModelCheckpoint(filepath=saved_model_path,
monitor='categorical_crossentropy'), reduce_lr
]
history = model.fit(x_train,
y_train,
validation_data=(x_test, y_test),
epochs=epochs,
verbose=1,
callbacks=callbacks)
return model, history, x_valid
axes.imshow(image, cmap=plt.cm.gray_r)
axes.set_xticks([])
axes.set_yticks([])
axes.set_tile(target)
plt.tight_layout()
#--------------------------------------------------------------------------------------------------#
#--------------------------------------------------------------------------------------------------#
# Creating the Neural Networks and adding Layers to the Networks.
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, Dense, Flatten, MaxPooling2D
NN = Sequential()
#--------------Then adding a convolution layer--------------------------------#
NN.add(
Conv2D(filters=64,
kernel_size=(3, 3),
activation='relu',
input_shape=(28, 28, 1)))
#--------------Then adding a pooling layer------------------------------------#
NN.add(MaxPooling2D(pool_size=(2, 2)))
#--------------Then adding flattening the results-----------------------------#
NN.add(Flatten())
#-------Then adding a dense layer to reduce the number of features-------#
NN.add(Dense(units=128, activation='relu'))
#-------Then adding a dense layer to produce the final output-----------#
NN.add(Dense(units=10, activation='softmax'))
#-------------------Printing the Model's Summary---------------------------#
print(NN.summary()) # show all data conclusion
#output: Model: "sequential_9"
# _________________________________________________________________
# Layer (type) Output Shape Param #
# pos_feature_mat_tau_lst = []
#
# pos_feature_mat_tau = np.vstack([np.hstack((np.zeros((model_def.list_size + 1, k1)),
# np.hstack((np.ones(k1), np.zeros(model_def.list_size - k1 + 1))).reshape(-1, 1),
# np.zeros((model_def.list_size + 1, model_def.list_size - k1)))).flatten()
# for k1 in range(1, model_def.list_size+1)])
pos_feature_gamma = np.eye(model_def.list_size)
var_dic = {'phi_A': item_feature_mat_A, 'gamma': pos_feature_gamma}
# Model:
model_phi_A = Sequential()
model_phi_A.add(
Dense(1,
input_dim=var_dic['phi_A'].shape[1],
activation='sigmoid',
use_bias=False))
model_phi_A.compile(loss=GCM.pos_log_loss, optimizer=RMSprop())
# Note the large output dimension and the softmax. We want multiple transition probabilities that sum up to 1
# Its the shape**2, as we flatten the square matrix.
model_gamma = Sequential()
model_gamma.add(SimpleDense(list_size + 1))
model_gamma.compile(loss=GCM.pos_log_loss, optimizer=RMSprop())
# model_tau = Sequential()
# model_tau.add(Dense(var_dic['tau'].shape[1], input_dim=var_dic['tau'].shape[1], activation=None, use_bias=False,
# kernel_initializer=Identity(), trainable=False))
# model_tau.compile('rmsprop', 'binary_crossentropy') # No trainable weights, so doesn't really matter
def _build_generator(self):
model = Sequential()
model.add(
Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim))
model.add(Reshape((7, 7, 128)))
model.add(UpSampling2D())
model.add(Conv2D(128, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(UpSampling2D())
model.add(Conv2D(64, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(Conv2D(self.channels, kernel_size=3, padding="same"))
model.add(Activation("tanh"))
noise = Input(shape=(self.latent_dim, ))
img = model(noise)
return Model(noise, img)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import numpy as np
import tensorflow as tf
np.random.seed(3)
tf.random.set_seed(3)
Data_set = np.loadtxt("C:/Users/HJ/Downloads/lung_cancer.csv", delimiter=",")
X = Data_set[:, 0:4]
Y = Data_set[:, 4]
model = Sequential()
model.add(Dense(30, input_dim=4, activation="relu"))
model.add(Dense(1, activation="sigmoid"))
model.compile(loss="mean_squared_error",
optimizer="adam",
metrics=["accuracy"])
model.fit(X, Y, epochs=100, batch_size=10)
def _build_discriminator(self):
model = Sequential()
model.add(
Conv2D(32,
kernel_size=3,
strides=2,
input_shape=self.img_shape,
padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
model.add(ZeroPadding2D(padding=((0, 1), (0, 1))))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(256, kernel_size=3, strides=1, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
img = Input(shape=self.img_shape)
validity = model(img)
return Model(img, validity)
def model_architecture(
self,
input_shape, # type: Tuple[int, int]
output_shape # type: Tuple[int, Optional[int]]
):
# type: (...) -> tf.keras.models.Sequential
"""Build a keras model and return a compiled model."""
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import \
Masking, LSTM, Dense, TimeDistributed, Activation
# Build Model
model = Sequential()
# the shape of the y vector of the labels,
# determines which output from rnn will be used
# to calculate the loss
if len(output_shape) == 1:
# y is (num examples, num features) so
# only the last output from the rnn is used to
# calculate the loss
model.add(Masking(mask_value=-1, input_shape=input_shape))
model.add(LSTM(self.rnn_size, dropout=0.2))
model.add(Dense(input_dim=self.rnn_size, units=output_shape[-1]))
elif len(output_shape) == 2:
# y is (num examples, max_dialogue_len, num features) so
# all the outputs from the rnn are used to
# calculate the loss, therefore a sequence is returned and
# time distributed layer is used
# the first value in input_shape is max dialogue_len,
# it is set to None, to allow dynamic_rnn creation
# during prediction
model.add(Masking(mask_value=-1,
input_shape=(None, input_shape[1])))
model.add(LSTM(self.rnn_size, return_sequences=True, dropout=0.2))
model.add(TimeDistributed(Dense(units=output_shape[-1])))
else:
raise ValueError("Cannot construct the model because"
"length of output_shape = {} "
"should be 1 or 2."
"".format(len(output_shape)))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
logger.debug(model.summary())
return model
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM, GRU
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
x = np.array([[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]]) #(4,3)
y = np.array([4, 5, 6, 7]) #(4,)
print("x.shape: ", x.shape)
x = x.reshape(4, 3, 1)
print("x.shape: ", x.shape)
#2. 모델 구성
model = Sequential()
model.add(GRU(16, activation='relu', input_shape=(3, 1)))
model.add(Dense(16))
model.add(Dense(1))
model.summary()
model.compile(loss='mse', metrics=['mse'], optimizer='adam')
model.fit(x, y, batch_size=1, verbose=1, epochs=100)
x_input = np.array([5, 6, 7])
x_input = x_input.reshape(1, 3, 1)
y_predict = model.predict(x_input)
print(y_predict)
#Build LSTM model on training data
#The model architecture used here is slightly more complex. Its elements are:
#LSTM input layer with 50 units.
#Dropout layer to prevent overfitting (see: http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf).
#A second LSTM layer with 256 units.
#A further Dropout layer.
#A Dense layer to produce a single output.
#Use MSE as loss function.
model2 = Sequential()
model2.add(LSTM(input_shape = (window_size, 1),
units = window_size,
return_sequences = True))
model2.add(Dropout(0.5))
model2.add(LSTM(256))
model2.add(Dropout(0.5))
model2.add(Dense(1))
model2.add(Activation("linear"))
model2.compile(loss = "mse",
optimizer = "adam")
print(model2.summary())
# Fit the model.
model2.fit(train_X,
train_Y,
batch_size = 512,
epochs = 3,
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# Convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
# BytePS: adjust learning rate based on number of GPUs.
opt = keras.optimizers.Adadelta(lr=1.0 * bps.size())
# BytePS: add BytePS Distributed Optimizer.
opt = bps.DistributedOptimizer(opt)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D
import pickle
pickle_in = open("X.pickle","rb")
X = pickle.load(pickle_in)
pickle_in = open("y.pickle","rb")
y = pickle.load(pickle_in)
X = X/255.0
model = Sequential()
model.add(Conv2D(256, (3, 3), input_shape=X.shape[1:]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(256, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten()) # this converts our 3D feature maps to 1D feature vectors
model.add(Dense(64))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy',
y_test = tf.keras.utils.to_categorical(y_test, num_classes=tag_size)
print("학습 샘플 시퀀스 형상 : ", x_train.shape)
print("학습 샘플 레이블 형상 : ", y_train.shape)
print("테스트 샘플 시퀀스 형상 : ", x_test.shape)
print("테스트 샘플 레이블 형상 : ", y_test.shape)
# 모델 정의 (Bi-LSTM)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Embedding, Dense, TimeDistributed, Dropout, Bidirectional
from tensorflow.keras.optimizers import Adam
model = Sequential()
model.add(
Embedding(input_dim=vocab_size,
output_dim=30,
input_length=max_len,
mask_zero=True))
model.add(
Bidirectional(
LSTM(200, return_sequences=True, dropout=0.50,
recurrent_dropout=0.25)))
model.add(TimeDistributed(Dense(tag_size, activation='softmax')))
model.compile(loss='categorical_crossentropy',
optimizer=Adam(0.01),
metrics=['accuracy'])
model.fit(x_train, y_train, batch_size=128, epochs=10)
print("평가 결과 : ", model.evaluate(x_test, y_test)[1])
model.save('ner_model.h5')
#https://www.youtube.com/watch?v=V23DmbdzMvg import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.utils import to_categorical from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split from sklearn import preprocessing iris = load_iris() X = preprocessing.scale(iris['data']) Y = to_categorical(iris['target']) #print(X) #print(Y) #training data and test data X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2) #model model = Sequential() model.add(Dense(10, input_dim=4, activation='relu')) model.add(Dense(10, activation='relu')) model.add(Dense(3, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) #fitting the model model.fit(X_train, Y_train, validation_data=(X_test, Y_test), epochs=200, batch_size=10)
def build_discriminator(width, height, depth, alpha=0.2):
# initialize the model along with the input shape to be
# "channels last"
model = Sequential()
inputShape = (height, width, depth)
# first set of CONV => RELU layers
model.add(Conv2D(32, (5, 5), padding="same", strides=(2, 2),
input_shape=inputShape))
model.add(LeakyReLU(alpha=alpha))
# second set of CONV => RELU layers
model.add(Conv2D(64, (5, 5), padding="same", strides=(2, 2)))
model.add(LeakyReLU(alpha=alpha))
# first (and only) set of FC => RELU layers
model.add(Flatten())
model.add(Dense(512))
model.add(LeakyReLU(alpha=alpha))
# sigmoid layer outputting a single value
model.add(Dense(1))
model.add(Activation("sigmoid"))
# return the discriminator model
return model
def build_generator(dim, depth, channels=1, inputDim=100,
outputDim=512):
# initialize the model along with the input shape to be
# "channels last" and the channels dimension itself
model = Sequential()
inputShape = (dim, dim, depth)
chanDim = -1
# first set of FC => RELU => BN layers
model.add(Dense(input_dim=inputDim, units=outputDim))
model.add(Activation("relu"))
model.add(BatchNormalization())
# second set of FC => RELU => BN layers, this time preparing
# the number of FC nodes to be reshaped into a volume
model.add(Dense(dim * dim * depth))
model.add(Activation("relu"))
model.add(BatchNormalization())
# reshape the output of the previous layer set, upsample +
# apply a transposed convolution, RELU, and BN
model.add(Reshape(inputShape))
model.add(Conv2DTranspose(32, (5, 5), strides=(2, 2),
padding="same"))
model.add(Activation("relu"))
model.add(BatchNormalization(axis=chanDim))
# apply another upsample and transposed convolution, but
# this time output the TANH activation
model.add(Conv2DTranspose(channels, (5, 5), strides=(2, 2),
padding="same"))
model.add(Activation("tanh"))
# return the generator model
return model
import numpy as np
import pickle
from scipy.stats import zscore
import datetime
import pytz
np.random.seed(seed=11)
with open('series_85177_500_stride50.pkl', 'rb') as f:
segments = pickle.load(f)
segments = zscore(segments).astype(np.float32) # standardize
deep_model = Sequential(name="LSTM-autoencoder")
deep_model.add(CuDNNGRU(20, input_shape=(500, 1), return_sequences=False))
#deep_model.add(CuDNNGRU(100, return_sequences=False))
deep_model.add(Dense(20, activation=None))
deep_model.add(RepeatVector(500))
#deep_model.add(CuDNNGRU(100, return_sequences=True))
deep_model.add(CuDNNGRU(20, return_sequences=True))
deep_model.add(TimeDistributed(Dense(1)))
deep_model.compile(optimizer=Adam(lr=5e-3, clipnorm=1.0), loss='mse')
#deep_model.load_weights("model_weights/lstm_autoencoder_2020-01-09_18-20-21.h5")
training_time_stamp = datetime.datetime.now(
tz=pytz.timezone('Europe/London')).strftime("%Y-%m-%d_%H-%M-%S")
CB = EarlyStopping(monitor='val_loss',
min_delta=1e-4,
[0, 0, 1],
[0, 0, 1],
])
# this takes a looong time to index, and
# python may crash several times before indexing is complete
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Activation
model = Sequential()
model.add(Dense(8,
activation=keras.activations.sigmoid,
))
model.add(Dense(3,
activation=keras.activations.sigmoid,
))
model.compile(
optimizer=tf.train.AdamOptimizer(0.001),
# loss=keras.losses.categorical_crossentropy,
loss=keras.losses.mse,
metrics=[keras.metrics.binary_accuracy]
)
# This is the process I used to train my weights
# model.fit(bin7, count3, epochs=2000)
# myWeights = model.get_weights()
def create_topology_mnist_conv_28_28_1():
seed(1)
tf.random.set_seed(1)
model = Sequential()
model.add(
Conv2D(filters=32,
kernel_size=(5, 5),
padding='Same',
activation='relu',
input_shape=(28, 28, 1)))
model.add(
Conv2D(filters=32,
kernel_size=(5, 5),
padding='Same',
activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(
Conv2D(filters=64,
kernel_size=(3, 3),
padding='Same',
activation='relu'))
model.add(
Conv2D(filters=64,
kernel_size=(3, 3),
padding='Same',
activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(256, activation="relu"))
model.add(Dropout(0.5))
model.add(Dense(10, activation="softmax"))
model.summary()
return model
# this takes a looong time to index, and
# python may crash several times before indexing is complete
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Activation
model = Sequential()
model.add(Dense(8,
activation=keras.activations.sigmoid,
))
model.add(Dense(3,
activation=keras.activations.sigmoid,
))
model.compile(
optimizer=tf.train.AdamOptimizer(0.001),
# loss=keras.losses.categorical_crossentropy,
loss=keras.losses.mse,
metrics=[keras.metrics.binary_accuracy]
)
# This is the process I used to train my weights
model.fit(x_train, y_train, epochs=2000)
myWeights = model.get_weights()
dense_layers = [0]
layer_sizes = [128]
conv_layers = [3]
for dense_layer in dense_layers:
for layer_size in layer_sizes:
for conv_layer in conv_layers:
NAME = "bz16-adam-c30-{}-conv-{}-nodes-{}-dense-{}".format(
conv_layer, layer_size, dense_layer, int(time.time()))
print(NAME)
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 _ in range(dense_layer):
model.add(Dense(layer_size))
model.add(Activation('relu'))
model.add(Dense(1))
