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 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 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
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)
plt.tight_layout()
plt.show()
model = Sequential([
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(),
Flatten(),
Dense(512, activation='relu'),
Dense(1)
])
model.compile(optimizer='adam',
loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
metrics=['accuracy'])
model.summary()
history = model.fit_generator(
train_data_gen,
steps_per_epoch=total_train // batch_size,
epochs=epochs,
validation_data=val_data_gen,
validation_steps=total_val // batch_size
)
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss=history.history['loss']
val_loss=history.history['val_loss']
for layer in baseModel.layers:
layer.trainable = False
for layer in baseModel.layers[-22:]:
layer.trainable = True
model.summary()
# optimizer = Adam(lr=0.001, beta_1=0.9, beta_2=0.999,
# epsilon=None, decay=1e-6, amsgrad=False)
optimizer = SGD(learning_rate=0.001)
model.compile(optimizer=optimizer,
loss="categorical_crossentropy",
metrics=['accuracy', utils.CalculateF1Score])
# Set a learning rate reductor
cb_early_stopper = EarlyStopping(monitor='val_loss', patience=4)
# Set a learning rate reductor
learningRateReduction = ReduceLROnPlateau(
monitor='val_accuracy', patience=3, verbose=1, factor=0.5, min_lr=0.00001)
# Fit the model
epochs = 30
batchSize = 10
history = model.fit(train_datagen.flow(xTrain, yTrain, batch_size=batchSize),
epochs=epochs, validation_data=(xValidate, yValidate),
def get_model(input_shape=(256, 256, 3), logits=5):
model = Sequential()
# 1st Convolutional Layer
model.add(
Conv2D(filters=96,
input_shape=input_shape,
kernel_size=(11, 11),
strides=(4, 4),
padding="valid",
activation="relu"))
# Max Pooling
model.add(MaxPool2D(pool_size=(3, 3), strides=(2, 2), padding="valid"))
# 2nd Convolutional Layer
model.add(
Conv2D(filters=256,
kernel_size=(5, 5),
strides=(1, 1),
padding="same",
activation="relu"))
# Max Pooling
model.add(MaxPool2D(pool_size=(3, 3), strides=(2, 2), padding="valid"))
# 3rd Convolutional Layer
model.add(
Conv2D(filters=384,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
activation="relu"))
# 4th Convolutional Layer
model.add(
Conv2D(filters=384,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
activation="relu"))
# 5th Convolutional Layer
model.add(
Conv2D(filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding="same",
activation="relu"))
# Max Pooling
model.add(MaxPool2D(pool_size=(3, 3), strides=(2, 2), padding="valid"))
# Passing it to a Fully Connected layer
model.add(Flatten())
# 1st Fully Connected Layer
model.add(Dense(units=9216, activation="relu"))
# 2nd Fully Connected Layer
model.add(Dense(units=4096, activation="relu"))
# 3rd Fully Connected Layer
model.add(Dense(4096, activation="relu"))
# Output Layer
model.add(Dense(logits, activation="softmax"))
opt = Adam(lr=0.001)
model.compile(optimizer=opt,
loss=sparse_categorical_crossentropy,
metrics=['sparse_categorical_accuracy'])
return model
# print type of model
print('type(vgg16_model): ', type(vgg16_model))
# Create empty Sequentail model
model = Sequential()
# Add layer by layer from the vgg16_model to our Sequential model
# Skip the last layer (index = -1) pf vgg16_model.
for layer in vgg16_model.layers[:-1]:
model.add(layer)
# print our new Sequential Model (witout the last layer)
model.summary()
# Check the model summary, we see the trainable parameters is 134260544
params = count_params(model)
assert params['non_trainable_params'] == 0
assert params['trainable_params'] == 134260544
# Set the layer to non-trainable
for layer in model.layers:
layer.trainable = False
# Add the Dense layer to the last output layer
model.add(Dense(units=2, activation='softmax'))
model.summary()
# Compiled the fine-tuned vgg16_model
model.compile(optimizer=Adam(learning_rate=0.0001), \
loss='categorical_crossentropy', metrics=['accuracy'])
# model fit
model.fit(x=train_batches, steps_per_epoch=4, \
validation_data=valid_batches, validation_steps=4, epochs=10, verbose=2)
# 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),
verbose=2)
time_end = time.time()
print('Training time:', time_end - time_start)
test_loss, test_acc = model.evaluate(test_data, test_labels, verbose=2)
print(test_acc, test_loss)
model = Sequential()
model.add(Dense(3, input_dim=5))
model.add(Dense(7))
model.add(Dense(4))
model.add(Dense(3))
model.summary()
input1 = Input(shape=(5, ))
dense1 = Dense(3)(input1)
dense1_1 = Dense(7)(dense1)
dense2 = Dense(4)(dense1_1)
output1 = Dense(3)(dense2)
model = Model(inputs=input1, outputs=output1)
model.summary()
'''
#3. Compile, Train
model.compile(optimizer='adam', loss='mse')
model.fit(x_train, y_train, batch_size=1, epochs=64,
validation_data=(x_test, y_test),verbose=2)
#4. Evaluate, Predict
from sklearn.metrics import mean_squared_error
from sklearn.metrics import r2_score
def RMSE(y_test, y_predict):
return np.sqrt(mean_squared_error(y_test, y_predict))
import tensorflow as tf
y_predict = model.predict(x_test)
loss = model.evaluate(x_test, y_test)
print('MSE :', mean_squared_error(y_test, y_predict))
data_augmentation,
layers.experimental.preprocessing.Rescaling(1. / 255),
layers.Conv2D(16, 3, padding='same', activation='relu'),
layers.MaxPooling2D(),
layers.Conv2D(32, 3, padding='same', activation='relu'),
layers.MaxPooling2D(),
layers.Conv2D(64, 3, padding='same', activation='relu'),
layers.MaxPooling2D(),
layers.Dropout(0.2),
layers.Flatten(),
layers.Dense(128, activation='relu'),
layers.Dense(num_classes)
])
model_v2.compile(
optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
epochs = 15
history = model_v2.fit(train_ds, validation_data=val_ds, epochs=epochs)
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs_range = range(epochs)
plt.figure(figsize=(8, 8))
plt.subplot(1, 2, 1)
X.append(features)
y.append(label)
X = np.array(X).reshape(-1, IMG_SIZE, IMG_SIZE, 1)
X = X / 255.0
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(Conv2D(64, (3, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(64))
model.add(Activation("relu"))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss="binary_crossentropy",
optimizer="adam",
metrics=['accuracy'])
model.fit(X, y, batch_size=2, epochs=20, validation_split=0.1)
model.save("trained.model")
# to all nodes #%% # below is another way to build the model model = Sequential() model.add(Dense(4, activation="relu")) model.add(Dense(2, activation="relu")) model.add(Dense(1)) #%% model = Sequential() model.add(Dense(4, activation="relu")) model.add(Dense(4, activation="relu")) model.add(Dense(4, activation="relu")) model.add(Dense(1)) model.compile(optimizer="rmsprop", loss="mse") #%% model.fit(x=X_train, y=y_train, epochs=250) #%% df_loss = pd.DataFrame(model.history.history) df_loss.plot() #%% # the last layer will determine what type of # model will be produced # in a regression problema we leave the # last layer with a identity activation function # if the problema was a classifcation problem # we shoul use more final neurons and with # a different activation function like
from tensorflow.examples.tutorials.mnist import input_data
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
# create model
model = Sequential()
model.add(Dense(128, input_dim=784, activation='sigmoid'))
model.add(Dense(10, activation='sigmoid'))
#compile model
model.compile(loss='mean_squared_error', optimizer='sgd', metrics=['accuracy'])
mnist = input_data.read_data_sets("/tf/data/mnist/", one_hot=True)
X = mnist.train.images
Y = mnist.train.labels
# Fit the model
model.fit(X, Y, epochs=1, batch_size=10)
# evaluate the model
scores = model.evaluate(X, Y)
print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1] * 100))
def train_nn(d, x, f, num_nodes, weights_init=None, summary=False, plot=False):
# set hyperparameters
lr_start = 1e-03
lr_decay = .99954
learning_rate = LearningRateScheduler(
lambda epoch: lr_start * lr_decay**epoch)
epochs = 10000
batch_size = x.shape[0] if weights_init is not None else np.ceil(
x.shape[0] / 100).astype(int)
# initialize weights if A,B,C are provided
if weights_init is not None:
def A_init(shape, dtype=None):
return weights_init[0].T
def B_init(shape, dtype=None):
return weights_init[1].reshape(-1)
def C_init(shape, dtype=None):
return weights_init[2]
# define the model
model = Sequential()
if weights_init:
model.add(Dense(num_nodes, input_shape=(d,), \
kernel_initializer=A_init, bias_initializer=B_init))
model.add(Activation('relu'))
model.add(Dense(1, \
kernel_initializer=C_init))
else:
model.add(Dense(num_nodes, input_shape=(d,), \
kernel_initializer=tf.keras.initializers.TruncatedNormal(), \
bias_initializer=tf.keras.initializers.Zeros()))
model.add(Activation('relu'))
model.add(Dense(1, \
kernel_initializer=tf.keras.initializers.TruncatedNormal(), \
bias_initializer=tf.keras.initializers.Zeros()))
# compile the model
model.compile(loss='mean_squared_error', \
optimizer=tf.keras.optimizers.Adam(lr=lr_start))
# display the model
if summary:
print()
model.summary()
# display network parameters
if weights_init:
label = 'GSN loss'
print('\ntraining network using GSN initialization...')
else:
label = 'random loss'
print('\ntraining network using random initialization...')
print('network parameters: epochs = {:d}, batch size = {:d}'.format(
epochs, batch_size))
# train the model
history = model.fit(x, f, batch_size=batch_size, epochs=epochs, \
verbose=0, callbacks=[learning_rate])
# save and plot the training process
fig = plt.figure(figsize=(8, 3))
plt.semilogy(history.history['loss'], label=label)
plt.legend(loc='upper right')
# save the figure
name = time.strftime('%Y-%m-%d %H.%M.%S', time.localtime())
#plt.savefig('./images/{:s}.png'.format(name), format='png')
#plt.savefig('./images/{:s}.pdf'.format(name), format='pdf')
# plot the figure
if plot:
plt.show()
else:
plt.close()
# return trained weights
A = model.layers[0].get_weights()[0].T
B = model.layers[0].get_weights()[1].reshape((-1, 1))
C = model.layers[-1].get_weights()[0].reshape((-1, 1))
c = model.layers[-1].get_weights()[1]
# evaluate the model
model.evaluate(x, f, batch_size=x.shape[0])
return A, B, C, c
print('x_test.reshape:', x_test.shape)
# 3. 모델
model = Sequential()
model.add(LSTM(1, input_shape=(10, 1)))
model.add(Dense(200))
model.add(Dense(300))
model.add(Dense(500))
model.add(Dense(200))
model.add(Dense(10, activation='softmax'))
model.summary()
# 4. 훈련
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc'])
model.fit(x_train,
y_train,
epochs=100,
batch_size=5,
verbose=1,
validation_split=0.5)
# 5. 평가, 예측
loss, acc = model.evaluate(x_test, y_test, batch_size=32)
print("loss : ", loss)
print("acc : ", acc)
y_predict = model.predict(x_test) # 평가 데이터 다시 넣어 예측값 만들기
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'))
# Horovod: adjust learning rate based on number of GPUs.
opt = tf.keras.optimizers.Adadelta(1.0 * hvd.size())
# Horovod: add Horovod Distributed Optimizer.
opt = hvd.DistributedOptimizer(opt)
model.compile(loss=tf.keras.losses.categorical_crossentropy,
optimizer=opt,
metrics=['accuracy'])
callbacks = [
# Horovod: broadcast initial variable states from rank 0 to all other processes.
# This is necessary to ensure consistent initialization of all workers when
# training is started with random weights or restored from a checkpoint.
hvd.callbacks.BroadcastGlobalVariablesCallback(0),
]
# Horovod: save checkpoints only on worker 0 to prevent other workers from corrupting them.
if hvd.rank() == 0:
callbacks.append(tf.keras.callbacks.ModelCheckpoint('./checkpoint-{epoch}.h5'))
model.fit(x_train, y_train,
batch_size=batch_size,
print(y_test.shape) #(89,)
'''
#2.모델구성
from tensorflow.keras.models import Sequential
#함수를 불러올때는 텐서플로우,케라스에서 '모델스'로 불러온다.
from tensorflow.keras.layers import Dense
#층을 불러올때는 텐서플로우,케라스에서 '레이어스'로 불러온다.
model = Sequential()
#model.add(Dense(10,input_dim=10,activation='relu'))
model.add(Dense(10, input_shape=(10, ), activation='relu'))
model.add(Dense(1))
#3.컴파일,훈련
model.compile(loss='mse', optimizer='adam')
model.fit(x_train, y_train, epochs=100, batch_size=10, validation_split=0.2)
#4.평가,예측:모델에 대한 평가,예측을 여러가지 지표로 확인
#1) 로스값 구하기
loss = model.evaluate(x_test, y_test, batch_size=10)
print('loss : ', loss)
#2) y예측값 구하기
y_predict = model.predict(x_test) #테스트한 x값을 통해 y값을 예측함
#3) y예측값을 통한 RMSE와 2R2 구하기
#RMSE(루트평균제곱오차): def함수를 통해 RMSE 선언 후 RMSE값 구하기
from sklearn.metrics import mean_squared_error #사이킷런 중 메트릭스에 있음
print(model.summary())
#Parâmetros:
#kernel_size: indica o tamanho da matriz de detector de características (feature detector)
#input_shape: indica o tamanho da imagem a ser utilizada no treinamento
#data_format='channels_last': parâmetro padrão que indica que será adicionada mais uma dimensão da imagem no final da matriz
#kernel_regularizer: indica que irá adicionar uma penalidade quando o erro tiver um determinado valo
"""## Etapa 8 - Compilando o modelo
* Parâmetros Adam: https://arxiv.org/abs/1412.6980
* Artigo sobre parâmetros Adam: https://machinelearningmastery.com/adam-optimization-algorithm-for-deep-learning/
* Parâmetros beta: representam a taxa de decaimento exponencial (por exemplo, 0.9) que está relacionado com a taxa de aprendizagem (learning rate - lr)
"""
#Compilando o modelo
model.compile(loss=categorical_crossentropy,
optimizer=Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-7),
metrics=['accuracy'])
arquivo_modelo = 'modelo_02_expressoes.h5'
arquivo_modelo_json = 'modelo_02_expressoes.json'
lr_reducer = ReduceLROnPlateau(monitor='val_loss',
factor=0.9,
patience=3,
verbose=1)
early_stopper = EarlyStopping(monitor='val_loss',
min_delta=0,
patience=8,
verbose=1,
mode='auto')
checkpointer = ModelCheckpoint(arquivo_modelo,
monitor='val_loss',
verbose=1,
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']),
axis=0) #Aqui concatenamos a base teste com a de treinamento
entradas = base_completa[
len(base_completa) - len(base_teste) -
90:].values #Precisamos somente da base de teste e os 90 dias anteriores ao primeiro dia de teste
entradas = entradas.reshape(
activation='relu'))
model.add(
Dense(75,
kernel_initializer='normal',
activation='relu'))
model.add(
Dense(100,
kernel_initializer='normal',
activation='relu'))
model.add(
Dense(1,
kernel_initializer='normal',
activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(Xcl_train,
ycl_train,
epochs=10,
batch_size=10,
verbose=0)
##################################################
##################################################
cluster_models[cl] = model
tn, fp, fn, tp = 0, 0, 0, 0
def train(self):
train_img_list = []
train_label_list = []
for file in os.listdir(self.train_folder):
files_img_in_array = self.read_train_images(filename=file)
train_img_list.append(files_img_in_array) #Image list add up
train_label_list.append(int(file.split('_')[0]))
print(train_label_list) #lable list addup
train_label_list = to_categorical(train_label_list, 4)
train_img_list = np.array(train_img_list)
train_label_list = np.array(train_label_list)
print(train_label_list)
#train_label_list = to_categorical(train_label_list,4) #format into binary [0,0,0,0,1,0,0]
train_img_list = train_img_list.astype('float32')
train_img_list /= 255
#-- setup Neural network CNN
model = Sequential()
#CNN Layer - 1
model.add(
Convolution2D(
filters=32, #Output for next later layer output (100,100,32)
kernel_size=(5, 5), #size of each filter in pixel
padding='same', #边距处理方法 padding method
input_shape=(100, 100,
3), #input shape ** channel last(TensorFlow)
))
model.add(Activation('relu'))
model.add(
MaxPooling2D(
pool_size=(2, 2), #Output for next layer (50,50,32)
strides=(2, 2),
padding='same',
))
#CNN Layer - 2
model.add(
Convolution2D(
filters=64, #Output for next layer (50,50,64)
kernel_size=(2, 2),
padding='same',
))
model.add(Activation('relu'))
model.add(
MaxPooling2D( #Output for next layer (25,25,64)
pool_size=(2, 2),
strides=(2, 2),
padding='same',
))
#Fully connected Layer -1
model.add(Flatten())
model.add(Dense(1024))
model.add(Activation('relu'))
# Fully connected Layer -2
model.add(Dense(512))
model.add(Activation('relu'))
# Fully connected Layer -3
model.add(Dense(256))
model.add(Activation('relu'))
# Fully connected Layer -4
model.add(Dense(self.categories))
model.add(Activation('softmax'))
# Define Optimizer
adam = Adam(lr=0.0001)
#Compile the model
model.compile(optimizer=adam,
loss="categorical_crossentropy",
metrics=['accuracy'])
# Fire up the network
model.fit(
train_img_list,
train_label_list,
epochs=self.number_batch,
batch_size=self.batch_size,
verbose=1,
)
#SAVE your work -model
model.save('./cellfinder.h5')
test_size=0.3,
random_state=101)
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
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)
predictions = model.predict(X_test)
# np.sqrt(mean_squared_error(y_test, predictions))
mae = mean_absolute_error(y_test, predictions)
# print(mae)
explained_variance_score(y_test, predictions)
def predict(figi: str):
interval = request.args.get('interval')
end_date = request.args.get('to')
client = ti.SyncClient(SANDBOX_TOKEN, use_sandbox=True)
print(datetime.now())
# get candles for last year
response = client.get_market_candles(figi=figi,
from_=datetime.now() -
timedelta(days=365),
to=datetime.now(),
interval=ti.CandleResolution.day)
candles_data = response.payload.candles
close_full_y = [float(x.c.real) for x in candles_data]
time_full_x = [x.time for x in candles_data]
num_shape = math.ceil(0.9 * len(close_full_y))
df = pd.DataFrame(list(zip(close_full_y, time_full_x)),
columns=['Close', 'Date'])
train = df.iloc[:num_shape, 0:1].values
test = df.iloc[num_shape:, 0:1].values
sc = MinMaxScaler(feature_range=(0, 1))
train_scaled = sc.fit_transform(train)
X_train = []
# Price on next day
y_train = []
window = 30
for i in range(window, num_shape):
X_train_ = np.reshape(train_scaled[i - window:i, 0], (window, 1))
X_train.append(X_train_)
y_train.append(train_scaled[i, 0])
X_train = np.stack(X_train)
y_train = np.stack(y_train)
model = Sequential()
model.add(
LSTM(units=50,
return_sequences=True,
input_shape=(X_train.shape[1], 1)))
model.add(Dropout(0.2))
model.add(LSTM(units=50, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(units=50, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(units=50))
model.add(Dropout(0.2))
model.add(Dense(units=1))
model.compile(optimizer='adam', loss='mean_squared_error')
model.fit(X_train, y_train, epochs=30, batch_size=24, verbose=0)
df_volume = np.vstack((train, test))
num_2 = df_volume.shape[0] - num_shape + window
pred_ = df['Close'].iloc[-1].copy()
prediction_full = []
df_copy = df.iloc[:, 0:1][1:].values
for j in range(20):
df_ = np.vstack((df_copy, pred_))
train_ = df_[:num_shape]
test_ = df_[num_shape:]
df_volume_ = np.vstack((train_, test_))
inputs_ = df_volume_[df_volume_.shape[0] - test_.shape[0] - window:]
inputs_ = inputs_.reshape(-1, 1)
inputs_ = sc.transform(inputs_)
X_test_2 = []
for k in range(window, num_2):
X_test_3 = np.reshape(inputs_[k - window:k, 0], (window, 1))
X_test_2.append(X_test_3)
X_test_ = np.stack(X_test_2)
predict_ = model.predict(X_test_)
pred_ = sc.inverse_transform(predict_)
prediction_full.append(pred_[-1][0])
df_copy = df_[j:]
df_date = df[['Date']]
for h in range(20):
df_date_add = pd.to_datetime(
df_date['Date'].iloc[-1]) + pd.DateOffset(days=1)
df_date_add = pd.DataFrame([df_date_add.strftime("%Y-%m-%d")],
columns=['Date'])
df_date = df_date.append(df_date_add)
df_date = df_date.reset_index(drop=True)
result = []
for ind, val in zip(df_date['Date'][len(close_full_y):], prediction_full):
mda = dict({"pred_close": float(val), "time": ind})
result.append(mda)
return jsonify(result)
model.add(BatchNormalization())
model.add(LSTM(128))
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'))
opt = tf.keras.optimizers.Adam(lr=0.001, decay=1e-6)
# Compile model
model.compile(loss='sparse_categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
tensorboard = TensorBoard(log_dir="logs/{}".format(NAME))
# unique file name that will include the epoch and the validation acc for that epoch
filepath = "RNN_Final-{epoch:02d}-{val_acc:.3f}"
checkpoint = ModelCheckpoint(
"models/{}.model".format(filepath,
monitor='val_acc',
verbose=1,
save_best_only=True,
mode='max')) # saves only the best ones
# Train model
history = model.fit(
train_x,
image=np.array(image)
resized = cv2.resize(image, dim, interpolation = cv2.INTER_AREA)
## define one constants, for mouth aspect ratio to indicate open mouth
MOUTH_AR_THRESH = 0.5
## initialize dlib's face detector (HOG-based) and then create
## the facial landmark predictor
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")
## grab the indexes of the facial landmarks for the mouth
(mStart, mEnd) = (49, 68)
if mode == "train":
model.compile(loss='categorical_crossentropy',optimizer=Adam(lr=0.0001, decay=1e-6),metrics=['accuracy'])
model_info = model.fit_generator(
train_generator,
steps_per_epoch=num_train // batch_size,
epochs=num_epoch,
validation_data=validation_generator,
validation_steps=num_val // batch_size)
model.save_weights('model.h5')
# emotions will be displayed on your face from the webcam feed
elif mode == "display":
model.load_weights('model.h5')
# prevents openCL usage and unnecessary logging messages
cv2.ocl.setUseOpenCL(False)
input_shape=(SIZE, SIZE, 3)))
model.add(MaxPooling2D((2, 2), padding='same'))
model.add(Conv2D(8, (3, 3), activation='relu', padding='same'))
model.add(MaxPooling2D((1, 1), padding='same'))
model.add(MaxPooling2D((2, 2), padding='same'))
#Decoder
model.add(UpSampling2D((1, 1)))
model.add(Conv2D(8, (3, 3), activation='relu', padding='same'))
model.add(UpSampling2D((2, 2)))
model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
model.add(UpSampling2D((2, 2)))
model.add(Conv2D(3, (3, 3), activation='relu', padding='same'))
model.compile(optimizer='adam',
loss='mean_squared_error',
metrics=['accuracy'])
model.summary()
model.fit(
img_array,
img_array,
epochs=1000, #1000s of epochs needed for good results. Use GPU.
shuffle=True) #Shuffle data for each epoch
print("Output")
pred = model.predict(img_array) #Predict model on the same input array.
#In reality, train on 1000s of input images and predict on images that the training
#algorithm never saw.
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,
sample_weight=sw_train * weighting + 1,
batch_size=batch_size,
verbose=1)
model.save("./data/models/nb_stream_10_fasttext.h5")
def cnn_classifer():
classifer = Sequential() #모델 생성
#해야 할 일: 모델을 chalkpoint를 정하여 저장하기, 가능하다면 병목특징 만들기, 학습률 높이는 알고리즘 찾아서 적용하기
#1
classifer.add(
Conv2D(filters=20,
kernel_size=(3, 3),
activation='relu',
input_shape=(64, 64, 1),
padding='same',
strides=(2, 2),
kernel_initializer='he_normal'))
classifer.add(BatchNormalization())
classifer.add(Activation('relu'))
classifer.add(AveragePooling2D(
pool_size=(2, 2))) #globalmaxpooling으로 고침(원래는 maxpooling)
#classifer.add(BatchNormalization())
classifer.add(
Conv2D(filters=20,
kernel_size=(3, 3),
activation='relu',
padding='same',
strides=(2, 2),
kernel_initializer='he_normal'))
#classifer.add(BatchNormalization())
classifer.add(MaxPooling2D(pool_size=(2, 2)))
#classifer.add(BatchNormalization())
classifer.add(Dropout(0.25))
classifer.add(Flatten()) #2차원으로 변환(항상 맨 아래에 있어야 함)
#세번째. Flatten층 추가하기=>1D로 변환
#네번째, Dense층 추가하기
classifer.add(
Dense(units=32, activation='relu', kernel_initializer='he_normal'))
classifer.add(Dropout(0.5))
classifer.add(
Dense(units=1,
activation='hard_sigmoid',
kernel_initializer='he_normal')) #시그모이드 함수는 바꾸지 말것
#이진분류 필요
classifer.summary()
optimizer = keras.optimizers.Adadelta(
rho=0.95, lr=1.0, decay=0.0) #학습의 단계가 진행될 수록 계수의 값이 작아지는 문제를 해결
#모든 경사의 제곱합을 평균 감쇄하여 재곱식으로 계산
sgd = optimizers.SGD(lr=0.1, decay=1e-6, momentum=0.9,
nesterov=True) #학습률을 처음에는 크게하였다 점점 줄임
#다섯번째, 모델 컴파일하기
optimizer = tf.keras.optimizers.RMSprop(lr=0.001,
rho=0.9,
epsilon=None,
decay=0.0)
# optimizer에 adagrad를 넣는다면 적응형 함수
#classifer.compile(loss="mse",metrics=["mae"])
classifer.compile(
optimizer=tf.keras.optimizers.Adadelta(rho=0.95, lr=1.0, decay=0.0),
loss='mse',
metrics=['accuracy'
]) #loss를 binary_crossentropy로 쓰기도 함/무조건 mse를 사용하여야 손실이 줄어듬
#classifer.compile(optimizer=SGD(lr=0.1,momentum=0.9,nesterov=True,metrics=['accuracy']
# loss='mse',metrics=['accuracy'])
#케라스 모델 별 optimizer정리
#sgd:확률적 경사 하강법/momentum학습률을 고정하고 매개변수를 조정
#adagrad:학습률을 조정하여 학습
#rmsprop,adadelta:adagrad를 보완
#adam이 기본, spare~은 인코딩 필요없이 바로 가능, 측정함수는 모델의 성능 평가=>손실함수 사용가능
return classifer
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,
validation_steps=total_val // batch_size
)
model.summary()
# model.save(top_model_path)
# model.save_weights(top_model_weights_path)
#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,
validation_split = 0.1)
pred_test = model2.predict(test_X)
# Apply inverse transformation to get back true values.
test_y_actual = scaler.inverse_transform(test_Y.values.reshape(test_Y.shape[0], 1))
shuffle=False)
# Instantiate Model
###################
clear_session()
model6 = Sequential()
model6.add(
Conv1D(32, 5, activation='relu', input_shape=(None, df_values.shape[-1])))
model6.add(MaxPooling1D(3))
model6.add(Conv1D(32, 5, activation='relu'))
model6.add(MaxPooling1D(3))
model6.add(Conv1D(32, 5, activation='relu'))
model6.add(GlobalMaxPooling1D())
model6.add(Dense(1))
model6.compile(optimizer=RMSprop(), loss='mae', metrics=['mae'])
print(model6.summary())
# Train
#######
m2_callbacks = [
# interrupt training when there is no more improvement.
# patience=2 means interrupt training when accuracy has stopped improving
# for more than 2 epochs. mae MUST be in the compile step in the metrics
EarlyStopping(monitor='mae', patience=2),
# saves the current weights after every epoch
# only overwrite the model file when val_loss has improved
ModelCheckpoint('weather__v6.h5', monitor='val_loss', save_best_only=True)
]
history6 = model6.fit(train_gen,
steps_per_epoch=500,
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',
optimizer='adam',
metrics=['accuracy'])
model.fit(X, y, batch_size=32, epochs=3, validation_split=0.3)
training=[]
output_empty=[0]*len(classes)
for document in documents:
bag=[]
word_patterns=document[0]
word_patterns=[lemmatizer.lemmatize(word.lower()) for word in word_patterns]
for word in words:
bag.append(1) if word in word_patterns else bag.append(0)
output_row=list(output_empty)
output_row[classes.index(document[1])]=1
training.append([bag,output_row])
random.shuffle(training)
training=numpy.array(training)
train_x=list(training[:,0])
train_y=list(training[:,1])
model=Sequential()
model.add(Dense(128,input_shape=(len(train_x[0]),),activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(64,activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(len(train_y[0]),activation='softmax'))
sgd=SGD(lr=0.01,decay=1e-6,momentum=0.9,nesterov=True)
model.compile(loss='categorical_crossentropy',optimizer=sgd,metrics=['accuracy'])
hist=model.fit(numpy.array(train_x),numpy.array(train_y),epochs=200,batch_size=5,verbose=1)
model.save('chatbot_model.h5',hist)
print("Done")
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"))
opt = tf.keras.optimizers.Adam(lr = 0.001, decay=1e-6)
model.compile(loss='sparse_categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
tensorboard = TensorBoard(log_dir=f"logs/{NAME}")
# Save the Models
filepath = "RNN_Final-{epoch:02d}-{val_acc:.3f}" # unique file name that will include the epoch and the validation acc for that epoch
checkpoint = ModelCheckpoint("models/{}.model".format(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')) # saves only the best ones
history = model.fit(
train_x, train_y,
batch_size=BATCH_SIZE,
epochs = EPOCHS,
validation_data=(validation_x, validation_y),
callbacks=[tensorboard, checkpoint])
input_shape=(28, 28, 1))) # 28x28x1 -> 24x24x16
model.add(MaxPooling2D(pool_size=(2, 2))) # 24x24x16 -> 12x12x16
model.add(
Conv2D(64,
kernel_size=(5, 5),
activation='relu',
kernel_initializer='he_normal')) # 12x12x16 -> 8x8x64
model.add(MaxPooling2D(pool_size=(2, 2))) # 8x8x64 -> 4x4x64
model.add(Flatten()) # 4x4x64-> 1024
model.add(Dense(10, activation='softmax')) # 1024 -> 10
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer='adam',
metrics=['accuracy'])
# 作成したモデルの確認
# SVG(model_to_dot(model, show_shapes=True).create(prog='dot', format='svg'))
early_stopping = EarlyStopping(patience=1, verbose=1)
model.fit(x=x_train,
y=y_train,
batch_size=128,
epochs=100,
verbose=1,
validation_data=(x_test, y_test),
callbacks=[early_stopping])
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])
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,
save_best_only=True,
save_weights_only=False,
mode='auto',
save_freq='epoch')
model.fit(X, y, epochs=150, callbacks=[model_saver])
print(model.evaluate(X, y))
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()
np.set_printoptions(suppress=True)
np.set_printoptions(precision=2)
print('myWeights =', myWeights)
# These are the weights I got, pretty-printed
# myWeights = [
# # # first layer, 7x8
# array([[ 1.2 , -1.16, -1.97, 2.16, 0.97, 0.86, -1.2 , 1.12],
# [ 1.21, -1.17, -1.97, 2.16, 0.84, 0.76, -1.19, 1.22],
y = df_new_columns['survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
# Нейронная сеть
classifier = Sequential()
classifier.add(
Dense(units=32,
kernel_initializer='uniform',
activation='relu',
input_dim=6))
# classifier.add(Dense(units=12, kernel_initializer='uniform', activation='relu'))
# classifier.add(Dense(units=6, kernel_initializer='uniform', activation='relu'))
classifier.add(
Dense(units=1, kernel_initializer='uniform', activation='sigmoid'))
classifier.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])
# Выполняем обучение на тренировочных данных
classifier.fit(X_train, y_train, batch_size=128, epochs=100)
# Определяем точность модели
score = classifier.evaluate(X_test, y_test)
print(score)
# Альтернативный вариант определения точности модели
prediction = classifier.predict(X).tolist()
y_prediction = pd.Series(prediction)
df_new_columns['y_prediction'] = y_prediction
df_new_columns['y_prediction'] = df_new_columns['y_prediction'].str.get(0)
