def train():
data, train_ind, test_ind = load_data()
print(train_ind.shape, test_ind.shape)
model = create_train_pconv_unet()
model.summary()
model.compile("rmsprop", identity_loss, [PSNR])
# TPUモデルに変換
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
batch_size = 8
cb = SamplingCallback(model, data, test_ind)
scheduler = LearningRateScheduler(lr_decay)
model.fit_generator(data_generator(data, train_ind, batch_size, True),
steps_per_epoch=len(train_ind) // batch_size,
validation_data=data_generator(data, test_ind,
batch_size, False),
validation_steps=len(test_ind) // batch_size,
callbacks=[cb, scheduler],
epochs=70,
max_queue_size=5)
def create_wideresnet(k, N, use_tpu):
input = Input(shape=(32, 32, 3))
# conv1 : 32x32
x = Conv2D(16*k, 1)(input)
x = create_residual_blocks(x, 16, k, N)
# downsampling 32->16
x = AveragePooling2D(2)(x)
x = Conv2D(32*k, 1)(x)
# conv2 : 16x16
x = create_residual_blocks(x, 32, k, N)
# downsampling 16->8
x = AveragePooling2D(2)(x)
x = Conv2D(64*k, 1)(x)
# conv4 : 8x8
x = create_residual_blocks(x, 64, k, N)
x = GlobalAveragePooling2D()(x)
x = Dense(100, activation="softmax")(x)
model = Model(input, x)
model.compile(Adam(), loss="categorical_crossentropy", metrics=["acc"])
if use_tpu:
tpu_grpc_url = "grpc://"+os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
return model
def train():
data, train_ind, test_ind = load_data()
print(train_ind.shape, test_ind.shape)
model = create_train_pconv_unet()
model.load_weights("oppai_train.hdf5")
model.summary()
model.compile(tf.train.RMSPropOptimizer(5e-5), identity_loss, [PSNR])
# TPUモデルに変換
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
batch_size = 8
cb = SamplingCallback(model, data, test_ind)
model.fit_generator(data_generator(data, train_ind, batch_size, True),
steps_per_epoch=len(train_ind) // batch_size,
validation_data=data_generator(data, test_ind,
batch_size, False),
validation_steps=len(test_ind) // batch_size,
callbacks=[cb],
epochs=70,
max_queue_size=1)
def train(inbalance_size):
(X_train, y_train), (X_test, y_test) = inbalanced_cifar(inbalance_size)
y_train, y_test = y_train[:, :10], y_test[:, :10]
model = create_models()
model.compile("adam", "categorical_crossentropy", ["acc"])
tf.logging.set_verbosity(tf.logging.FATAL)
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
scheduler = LearningRateScheduler(step_decay)
f1 = F1Callback(model, X_test, y_test)
history = model.fit(X_train,
y_train,
validation_data=(X_test, y_test),
callbacks=[scheduler, f1],
batch_size=640,
epochs=100,
verbose=0).history
max_acc = max(history["val_acc"])
max_f1 = max(f1.f1_log)
print(f"{inbalance_size} {max_acc:.04} {max_f1:.04}")
def train(use_augmentation, use_stem_block):
tf.logging.set_verbosity(tf.logging.FATAL)
(X_train, y_train), (X_test, y_test) = keras.datasets.cifar10.load_data()
y_train = keras.utils.to_categorical(y_train)
y_test = keras.utils.to_categorical(y_test)
# generator
batch_size = 512
scale = 7 if use_stem_block else 1
train_gen = generator(X_train, y_train, batch_size=batch_size,
use_augmentation=use_augmentation, shuffle=True, scale=scale)
test_gen = generator(X_test, y_test, batch_size=1000,
use_augmentation=False, shuffle=False, scale=scale)
# network
input_shape = (224,224,3) if use_stem_block else (32,32,3)
model = PeleeNet(input_shape=input_shape, use_stem_block=use_stem_block, n_classes=10)
model.compile(keras.optimizers.SGD(0.4, 0.9), "categorical_crossentropy", ["acc"])
# GoogleColab TPU training
# Plese comment out following 4 lines if train on GPUs
tpu_grpc_url = "grpc://"+os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
scheduler = keras.callbacks.LearningRateScheduler(lr_scheduler)
hist = keras.callbacks.History()
model.fit_generator(train_gen, steps_per_epoch=X_train.shape[0]//batch_size,
validation_data=test_gen, validation_steps=X_test.shape[0]//1000,
callbacks=[scheduler, hist], epochs=1, max_queue_size=1)
history = hist.history
with open(f"pelee_aug_{use_augmentation}_stem_{use_stem_block}.pkl", "wb") as fp:
pickle.dump(history, fp)
def train(batch_size, use_tpu, load_existing_weights):
model = create_resnet()
gen = CatGenerator()
if load_existing_weights:
model.load_weights("weights.hdf5")
model.compile(tf.train.MomentumOptimizer(1e-3, 0.9), loss=loss_function_multiple_distance_and_area, metrics=[loss_function_simple])
if use_tpu:
tpu_grpc_url = "grpc://"+os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
cb = CatsCallback(model)
history = History()
model.fit_generator(gen.flow_from_directory(batch_size, True), steps_per_epoch=6996//batch_size,
validation_data=gen.flow_from_directory(batch_size, False), validation_steps=2999//batch_size,
callbacks=[cb, history], epochs=200)
with open("history.dat", "wb") as fp:
pickle.dump(history.history, fp)
with zipfile.ZipFile("cats_result.zip", "w") as zip:
zip.write("history.dat")
zip.write("cats_weights.hdf5")
def train(lambd, sigma, n_centers, trial):
K.clear_session()
(X_train, y_train), (X_test, y_test) = inbalanced_cifar(200)
model = create_models(sigma, n_centers)
model.compile("adam", affinity_loss(lambd), [acc])
tf.logging.set_verbosity(tf.logging.FATAL) # ログを埋めないようにする
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
scheduler = LearningRateScheduler(step_decay)
f1 = F1Callback(model, X_test, y_test, trial)
history = model.fit(X_train,
y_train,
callbacks=[scheduler, f1],
batch_size=640,
epochs=100,
verbose=0).history
max_f1 = max(f1.f1_log)
print(
f"lambda:{lambd:.04}, sigma:{sigma:.04} n_centers:{n_centers} / f1 = {max_f1:.04}"
)
return max_f1
def main(argv):
logging.info('Building Keras ResNet-50 model.')
model = tf.keras.applications.resnet50.ResNet50(include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
pooling=None,
classes=NUM_CLASSES)
if FLAGS.tpu is not None:
logging.info('Converting from CPU to TPU model.')
strategy = keras_support.TPUDistributionStrategy(num_cores_per_host=8)
model = keras_support.tpu_model(model,
strategy=strategy,
tpu_name_or_address=FLAGS.tpu)
logging.info('Compiling model.')
model.compile(
optimizer=tf.train.GradientDescentOptimizer(learning_rate=1.0),
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'])
training_images = np.random.randn(128, IMAGE_SIZE, IMAGE_SIZE,
3).astype(np.float32)
training_labels = np.random.randint(NUM_CLASSES, size=128, dtype=np.int32)
logging.info('Training model.')
model.fit(training_images,
training_labels,
epochs=NUM_EPOCHS,
batch_size=128)
def train():
(X_train, _), (_, _) = mnist.load_data()
X_train = X_train / 255.0
model = create_model()
model.compile(tf.train.AdamOptimizer(), loss_function)
model.summary()
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
cb = Sampling(model)
hist = History()
dummy_rand = np.zeros((X_train.shape[0], 64))
y_train = np.concatenate(
(X_train.reshape(-1, 784), np.zeros((X_train.shape[0], 1))), axis=-1)
model.fit([X_train, dummy_rand],
y_train,
batch_size=1024,
callbacks=[cb, hist],
epochs=20)
history = hist.history
with open("vae_history.json", "w") as fp:
json.dump(history, fp)
def get_transformer_model(config,
model_path=None,
weights_only=True,
custom_objects=None):
_custom_objects = get_custom_objects()
if custom_objects is not None:
_custom_objects.update(custom_objects)
with tf.keras.utils.custom_object_scope(_custom_objects):
if model_path is None:
model = _get_transformer_model(**config.asdict())
else:
if weights_only:
model = _get_transformer_model(**config.asdict())
model.load_weights(model_path)
else:
model = tf.keras.models.load_model(model_path)
if config.use_tpu:
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
config.tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(
tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
return model
def main(argv):
logging.info('Building Keras ResNet-50 model.')
model = tf.keras.applications.resnet50.ResNet50(
include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
pooling=None,
classes=NUM_CLASSES)
per_core_batch_size = 128
num_cores = 8
batch_size = per_core_batch_size * num_cores
if FLAGS.tpu is not None:
logging.info('Converting from CPU to TPU model.')
strategy = keras_support.TPUDistributionStrategy(
num_cores_per_host=num_cores)
model = keras_support.tpu_model(model, strategy=strategy,
tpu_name_or_address=FLAGS.tpu)
logging.info('Compiling model.')
model.compile(
optimizer=tf.train.GradientDescentOptimizer(learning_rate=1.0),
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'])
if FLAGS.data is None:
training_images = np.random.randn(
batch_size, IMAGE_SIZE, IMAGE_SIZE, 3).astype(np.float32)
training_labels = np.random.randint(NUM_CLASSES, size=batch_size,
dtype=np.int32)
logging.info('Training model using synthetica data.')
num_epochs = 100 # TPUs are very fast when running a single step per epoch!
model.fit(training_images, training_labels, epochs=num_epochs,
batch_size=batch_size)
logging.info('Evaluating the model on synthetic data.')
model.evaluate(training_images, training_labels, verbose=0)
else:
imagenet_train, imagenet_eval = [imagenet_input.ImageNetInput(
is_training=is_training,
data_dir=FLAGS.data,
per_core_batch_size=per_core_batch_size)
for is_training in [True, False]]
logging.info('Training model using real data in directory "%s".',
FLAGS.data)
num_epochs = 90 # Standard imagenet training regime.
model.fit(imagenet_train.input_fn,
epochs=num_epochs,
steps_per_epoch=int(APPROX_IMAGENET_TRAINING_IMAGES / batch_size))
logging.info('Evaluating the model on the validation dataset.')
model.evaluate(imagenet_eval.input_fn)
def train(alpha):
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
train_gen = ImageDataGenerator(rescale=1.0 / 255,
horizontal_flip=True,
width_shift_range=4.0 / 32.0,
height_shift_range=4.0 / 32.0)
test_gen = ImageDataGenerator(rescale=1.0 / 255)
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
tf.logging.set_verbosity(tf.logging.FATAL)
if alpha <= 0:
model = create_normal_wide_resnet()
else:
model = create_octconv_wide_resnet(alpha)
model.compile(SGD(0.1, momentum=0.9), "categorical_crossentropy", ["acc"])
model.summary()
# convert to tpu model
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
batch_size = 128
scheduler = LearningRateScheduler(lr_scheduler)
hist = History()
start_time = time.time()
model.fit_generator(train_gen.flow(X_train,
y_train,
batch_size,
shuffle=True),
steps_per_epoch=X_train.shape[0] // batch_size,
validation_data=test_gen.flow(X_test,
y_test,
batch_size,
shuffle=False),
validation_steps=X_test.shape[0] // batch_size,
callbacks=[scheduler, hist],
max_queue_size=5,
epochs=200)
elapsed = time.time() - start_time
print(elapsed)
history = hist.history
history["elapsed"] = elapsed
with open(f"octconv_alpha_{alpha}.pkl", "wb") as fp:
pickle.dump(history, fp)
def train(content_path, style_path):
# Store the original image size
input_size = 256
with Image.open(content_path) as content:
original_width, original_height = content.size
content_numpy = np.asarray(
content.convert("RGB").resize((input_size, input_size),
Image.LANCZOS), np.uint8)
# Loading the style image
with Image.open(style_path) as style:
style_numpy = np.asarray(
style.convert("RGB").resize((input_size, input_size),
Image.LANCZOS), np.uint8)
# To Batch
batch_size = 8
content_batch = np.expand_dims(content_numpy, axis=0) * np.ones(
(batch_size, 1, 1, 3), np.uint8)
style_batch = np.expand_dims(style_numpy, axis=0) * np.ones(
(batch_size, 1, 1, 3), np.uint8)
dummy_y = np.zeros((batch_size, input_size, input_size, 3), np.float32)
# preprocessing
content_batch = preprocess_input(content_batch)
style_batch = preprocess_input(style_batch)
# create model
model = create_neural_style_transfer_train(input_size, input_size)
# initialize generating layer with content image
# [0,1] -> logit
content_r = content_numpy.astype(np.float32) / 255.0
content_logit = np.log(content_r / (1 - content_r + 1e-8))
model.get_layer("generated").set_weights([content_logit])
# compile
model.compile(tf.train.AdamOptimizer(5e-2), identity_loss)
# convert to tpu model
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
# train
cb = SamplingCallback(model, content_batch, style_batch, original_width,
original_height)
model.fit([content_batch, style_batch],
dummy_y,
callbacks=[cb],
epochs=3000,
batch_size=batch_size)
model.save_weights("style_trainsfer_train.hdf5")
def train(use_ricap):
batch_size = 1024
if use_ricap:
train_gen_instance = RICAPGenerator(rescale=1.0 / 255,
width_shift_range=15.0 / 160,
height_shift_range=15.0 / 160,
horizontal_flip=True,
ricap_beta=0.3)
else:
train_gen_instance = ImageDataGenerator(rescale=1.0 / 255,
width_shift_range=15.0 / 160,
height_shift_range=15.0 / 160,
horizontal_flip=True)
train_gen = train_gen_instance.flow_from_directory(
"animeface-character-dataset/train",
target_size=(160, 160),
batch_size=batch_size)
test_gen = ImageDataGenerator(rescale=1.0 / 255).flow_from_directory(
"animeface-character-dataset/test",
target_size=(160, 160),
batch_size=batch_size)
model = create_network()
model.compile(tf.train.RMSPropOptimizer(1e-4), "categorical_crossentropy",
["acc"])
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
hist = History()
model.fit_generator(train_gen,
steps_per_epoch=10062 // batch_size,
callbacks=[hist],
validation_data=test_gen,
validation_steps=4428 // batch_size,
epochs=1)
history = hist.history
with open(f"anime_ricap_{use_ricap}.dat", "wb") as fp:
pickle.dump(history, fp)
def train():
# データの読み込み
data = np.load("wiki_crop/wiki_all.npz")
image, gender, age = data["image"], data["gender"], data["age"]
# TrainとTestのSplit（インデックスを指定するだけ）
np.random.seed(45)
indices = np.random.permutation(image.shape[0])
n_test = 8192 # 8192枚をテストとする
test_indices = indices[:n_test]
train_indices = indices[n_test:]
# モデルの作成
model = create_model()
# 損失関数を自作してコンパイル
model.compile(tf.train.RMSPropOptimizer(3e-3), multitask_loss)
# TPUモデルに変換
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
# 訓練
batch_size = 512
history = History()
checkpoint = Checkpoint(model)
model.fit_generator(data_generator(image, gender, age, train_indices,
batch_size, True),
steps_per_epoch=len(train_indices) // batch_size,
validation_data=data_generator(image, gender, age,
test_indices,
batch_size, False),
validation_steps=len(test_indices) // batch_size,
max_queue_size=1,
callbacks=[history, checkpoint],
epochs=50)
# 結果保存
hist = history.history
with open("history.dat", "wb") as fp:
pickle.dump(hist, fp)
def train(network, epoch_offset):
if network == "resnet50":
model = resnet50.ResNet50(include_top=True, weights=None)
size = 224
preprocess = resnet50.preprocess_input
if network == "test":
model = sandbox_model.SandboxModelA()
size = 224
preprocess = resnet50.preprocess_input
if USE_TPU:
train_batch_size, val_batch_size = 1280, 1000
nb_epoch = 2
initial_lr = 0.1 * train_batch_size / 256
model.compile(keras.optimizers.SGD(initial_lr, 0.9), "categorical_crossentropy",
[top1])
if USE_TPU:
# convert to tpu model
tpu_grpc_url = "grpc://"+os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
cache = load_caches(IMAGE_NET_ROOT)
n_train, n_val = len(cache["train"]), len(cache["val"])
# train_gen = imagenet_generator(cache["train"], size, True, train_batch_size, preprocess)
# val_gen = imagenet_generator(cache["val"], size, False, val_batch_size, preprocess)
train_gen = fake_data_generator(size, train_batch_size, preprocess)
val_gen = fake_data_generator(size, train_batch_size, preprocess)
# fake_data_generator
scheduler_obj = CustomScuduling(epoch_offset, initial_lr)
scheduler = keras.callbacks.LearningRateScheduler(scheduler_obj.scheduler)
cp = Checkpoint(model, network, nb_epoch)
model.fit_generator(train_gen, steps_per_epoch=n_train//train_batch_size, epochs=nb_epoch,
validation_data=val_gen, validation_steps=n_val//val_batch_size,
max_queue_size=3, callbacks=[scheduler])
def train(self, X_train, y_train, X_val, y_val):
# コンパイル
self.model.compile(optimizer=SGD(lr=self.initial_lr, momentum=0.9),
loss="categorical_crossentropy",
metrics=["acc"])
# Data Augmentation
traingen = ImageDataGenerator(rescale=1. / 255,
width_shift_range=4. / 32,
height_shift_range=4. / 32,
horizontal_flip=True)
valgen = ImageDataGenerator(rescale=1. / 255)
# TPU
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
self.model = tf.contrib.tpu.keras_to_tpu_model(self.model,
strategy=strategy)
# Callback
time_cb = TimeHistory()
lr_cb = LearningRateScheduler(self.lr_schduler)
# Train
history = self.model.fit_generator(traingen.flow(X_train,
y_train,
batch_size=1024),
epochs=self.nb_epochs,
steps_per_epoch=len(X_train) / 1024,
validation_data=valgen.flow(
X_val, y_val, batch_size=1024),
validation_steps=len(X_val) / 1024,
callbacks=[time_cb, lr_cb]).history
history["time"] = time_cb.times
# Save history
file_name = f"{self.framework}_n{self.n}.dat"
with open(file_name, "wb") as fp:
pickle.dump(history, fp)
def train_and_generate_model():
#global scaler
K.clear_session()
data_len = len(exchange_rates)
train_len = int(len(exchange_rates) / TRAINDATA_DIV)
print("data size: " + str(data_len))
print("train len: " + str(train_len))
tr_input_mat = []
tr_angle_mat = []
for i in range(1000, train_len, OUTPUT_LEN):
tr_input_mat.append([
exchange_rates[i], (exchange_rates[i] - exchange_rates[i - 1]) /
exchange_rates[i - 1],
get_rsi(exchange_rates, i),
get_ma(exchange_rates, i),
get_ma_kairi(exchange_rates, i),
get_bb_1(exchange_rates, i),
get_bb_2(exchange_rates, i),
get_ema(exchange_rates, i),
get_ema_rsi(exchange_rates, i),
get_cci(exchange_rates, i),
get_mo(exchange_rates, i),
get_lw(exchange_rates, i),
get_ss(exchange_rates, i),
get_dmi(exchange_rates, i),
get_vorarity(exchange_rates, i),
get_macd(exchange_rates, i),
judge_chart_type(exchange_rates[i - CHART_TYPE_JDG_LEN:i])
])
tr_input_mat.append([
reverse_exchange_rates[i],
(reverse_exchange_rates[i] - reverse_exchange_rates[i - 1]) /
reverse_exchange_rates[i - 1],
get_rsi(reverse_exchange_rates, i),
get_ma(reverse_exchange_rates, i),
get_ma_kairi(reverse_exchange_rates, i),
get_bb_1(reverse_exchange_rates, i),
get_bb_2(reverse_exchange_rates, i),
get_ema(reverse_exchange_rates, i),
get_ema_rsi(reverse_exchange_rates, i),
get_cci(reverse_exchange_rates, i),
get_mo(reverse_exchange_rates, i),
get_lw(reverse_exchange_rates, i),
get_ss(reverse_exchange_rates, i),
get_dmi(reverse_exchange_rates, i),
get_vorarity(reverse_exchange_rates, i),
get_macd(reverse_exchange_rates, i),
judge_chart_type(reverse_exchange_rates[i - CHART_TYPE_JDG_LEN:i])
])
tmp = (exchange_rates[i + OUTPUT_LEN] -
exchange_rates[i]) / float(OUTPUT_LEN)
if tmp >= 0:
tr_angle_mat.append(1)
else:
tr_angle_mat.append(0)
tmp = (reverse_exchange_rates[i + OUTPUT_LEN] -
reverse_exchange_rates[i]) / float(OUTPUT_LEN)
if tmp >= 0:
tr_angle_mat.append(1)
else:
tr_angle_mat.append(0)
X = np.array(tr_input_mat, dtype=np.float32)
Y = np.array(tr_angle_mat, dtype=np.float32)
X, scaler = preprocess_data(X)
Y, encoder = preprocess_labels(Y)
joblib.dump(scaler, "./sklearn.scaler.dump")
np.random.seed(1337) # for reproducibility
nb_classes = Y.shape[1]
print(nb_classes, 'classes')
dims = X.shape[1]
print(dims, 'dims')
neuro_num = 50
# setup deep NN
model = Sequential()
model.add(Dense(neuro_num, input_shape=(dims, ), activation="relu"))
#model.add(Dense(neuro_num, activation="relu"))
#model.add(BatchNormalization((neuro_num,)))
model.add(BatchNormalization())
model.add(Dropout(0.5))
model.add(Dense(int(neuro_num / 2), activation="relu"))
#model.add(BatchNormalization((neuro_num/2,)))
model.add(BatchNormalization())
model.add(Dropout(0.5))
model.add(Dense(nb_classes, activation="sigmoid"))
model.summary()
model.compile(loss='binary_crossentropy', optimizer="adam")
# # TPU
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
tpu_model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
print("Training model...")
start = time.time()
tpu_model.fit(X,
Y,
batch_size=1024,
epochs=1000,
verbose=2,
validation_split=0.15)
process_time = time.time() - start
print("excecution time of training: " + str(process_time))
dump_fd = open("./keras.model.json", "w")
model_json_str = model.to_json()
dump_fd.write(model_json_str)
model.save_weights("./keras.weight")
dump_fd.close()
def main(unused_dev):
use_tpu = flags.FLAGS.use_tpu
print('Mode:', 'TPU' if use_tpu else 'CPU')
if flags.FLAGS.fake_data:
print('Using fake data')
x_train = np.random.random((128, img_rows, img_cols))
y_train = np.zeros([128, 1], dtype=np.int32)
x_test, y_test = x_train, y_train
else:
# the data, split between train and test sets
print('Using real data')
(x_train, y_train), (x_test,
y_test) = tf.keras.datasets.mnist.load_data()
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
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 = tf.keras.utils.to_categorical(y_train, num_classes)
y_test = tf.keras.utils.to_categorical(y_test, num_classes)
model = tf.keras.models.Sequential()
model.add(
tf.keras.layers.Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(tf.keras.layers.Conv2D(64, (3, 3), activation='relu'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
model.add(tf.keras.layers.Dropout(0.25))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Dense(num_classes, activation='softmax'))
if use_tpu:
strategy = keras_support.TPUDistributionStrategy(num_cores_per_host=8)
model = keras_support.tpu_model(model,
strategy=strategy,
tpu_name_or_address=flags.FLAGS.tpu)
model.compile(
loss=tf.keras.losses.categorical_crossentropy,
optimizer=tf.train.GradientDescentOptimizer(learning_rate=0.05),
metrics=['accuracy'])
model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test))
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
"""
epochs = 100
batch_size = 100
steps_per_epoch = 5050 // batch_size * 15 # 元は 5050 // batch_size * 15 （15=trainのh5ファイル数）
validation_steps = 5050 // batch_size * 5 # 元は 5050 // batch_size * 5 （5=testのh5ファイル数）
"""
以降は、原則いじらない.
ただし、early stopping, 学習率減衰などを使う場合は、訓練ループ内をいじる。
"""
if tpu:
tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"]
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
history = {"train_loss": [], "train_acc": [], "val_loss": [], "val_acc": []}
train_generator = flow_from_h5(train_path, batch_size, data_aug=True)
validation_generator = flow_from_h5(test_path, batch_size, data_aug=False)
# 訓練ループ fitの代わり
for e in range(epochs):
train_loss, train_acc, val_loss, val_acc = 0, 0, 0, 0
print("=" * 30)
print(f"epoch: {e + 1}/{epochs}")
# train
for step in range(steps_per_epoch):
x_batch, y_batch = next(train_generator)
def target_train_tpu_main(gen_targets_dir,
model_file_path,
early_stopping_patience=None,
length=None,
batch_size=1,
period=1,
retrain_file=None,
retrain_do_compile=False,
base_model_file_path='target_common.h5',
optimizer=Adam(),
optimizer_lr=0.001,
epochs=100000):
gc.collect()
with CustomObjectScope({'RandomLayer': RandomLayer}):
if retrain_file is None:
gen = VoiceGeneratorTargetTpu(gen_targets_dir,
0.1,
batch_size,
length,
train=True)
shape0 = gen[0][0].shape[1]
val_gen = VoiceGeneratorTargetTpu(gen_targets_dir,
0.1,
train=False,
max_size=shape0)
model = load_model(base_model_file_path)
config = model.get_config()
config['layers'][0]['config']['batch_input_shape'] = (None, shape0,
139)
config['layers'][3]['config']['rate'] = 0.1
config['layers'][6]['config']['target_shape'] = (shape0 * 2, 64)
config['layers'][8]['config']['rate'] = 0.1
config['layers'][11]['config']['target_shape'] = (shape0 * 4, 32)
config['layers'][13]['config']['rate'] = 0.1
config['layers'][16]['config']['target_shape'] = (shape0 * 8, 16)
config['layers'][18]['config']['rate'] = 0.1
model = Sequential.from_config(config)
model.load_weights(base_model_file_path, by_name=True)
model.summary()
model.compile(loss='mse', optimizer=optimizer)
baseline = None
else:
model = load_model(retrain_file)
if retrain_do_compile:
model.compile(loss='mse', optimizer=optimizer)
config = model.get_config()
shape0 = config['layers'][0]['config']['batch_input_shape'][1]
gen = VoiceGeneratorTargetTpu(gen_targets_dir,
0.1,
batch_size,
length,
train=True,
max_size=shape0)
val_gen = VoiceGeneratorTargetTpu(gen_targets_dir,
0.1,
train=False,
max_size=shape0)
baseline = model.test_on_batch(val_gen[0][0], val_gen[0][1])
tpu_grpc_url = 'grpc://' + os.environ['COLAB_TPU_ADDR']
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
tpu_grpc_url)
strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver)
model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy)
cp = ModelCheckpoint(filepath=model_file_path,
monitor='val_loss',
save_best_only=True,
period=period)
if baseline is not None:
cp.best = baseline
def lr_scheduler(epoch):
return optimizer_lr
scheduler = LearningRateScheduler(lr_scheduler)
if early_stopping_patience is not None:
es = EarlyStopping(monitor='val_loss',
patience=early_stopping_patience,
verbose=0,
mode='auto',
baseline=baseline)
callbacks = [es, cp, scheduler]
else:
callbacks = [cp, scheduler]
model.fit_generator(gen,
shuffle=True,
epochs=epochs,
verbose=1,
callbacks=callbacks,
validation_data=val_gen)
K.clear_session()
