def train(x_target, x_ref, y_ref, epoch_num):
#Read VGG16, S network
print("Model build...")
#mobile = VGG16(include_top=False, input_shape=input_shape, weights='imagenet')
#Read mobile net, S network
mobile = MobileNetV2(include_top=False,
input_shape=input_shape,
alpha=alpha,
depth_multiplier=1,
weights='imagenet')
#Delete last layer
mobile.layers.pop()
#Fixed weight
for layer in mobile.layers:
if layer.name == "block_13_expand": # "block5_conv1": for VGG16
break
else:
layer.trainable = False
model_t = Model(inputs=mobile.input, outputs=mobile.layers[-1].output)
#R network S and Weight sharing
model_r = Network(inputs=model_t.input,
outputs=model_t.output,
name="shared_layer")
#Apply a Fully Connected Layer to R
prediction = Dense(classes, activation='softmax')(model_t.output)
model_r = Model(inputs=model_r.input, outputs=prediction)
#Compile
optimizer = SGD(lr=5e-5, decay=0.00005)
model_r.compile(optimizer=optimizer, loss="categorical_crossentropy")
model_t.compile(optimizer=optimizer, loss=original_loss)
model_t.summary()
model_r.summary()
print("x_target is", x_target.shape[0], 'samples')
print("x_ref is", x_ref.shape[0], 'samples')
ref_samples = np.arange(x_ref.shape[0])
loss, loss_c = [], []
print("training...")
#Learning
for epochnumber in range(epoch_num):
x_r, y_r, lc, ld = [], [], [], []
#Shuffle target data
np.random.shuffle(x_target)
#Shuffle reference data
np.random.shuffle(ref_samples)
for i in range(len(x_target)):
x_r.append(x_ref[ref_samples[i]])
y_r.append(y_ref[ref_samples[i]])
x_r = np.array(x_r)
y_r = np.array(y_r)
for i in range(int(len(x_target) / batchsize)):
#Load data for batch size
batch_target = x_target[i * batchsize:i * batchsize + batchsize]
batch_ref = x_r[i * batchsize:i * batchsize + batchsize]
batch_y = y_r[i * batchsize:i * batchsize + batchsize]
#target data
#Get loss while learning
lc.append(
model_t.train_on_batch(batch_target,
np.zeros((batchsize, feature_out))))
#reference data
#Get loss while learning
ld.append(model_r.train_on_batch(batch_ref, batch_y))
loss.append(np.mean(ld))
loss_c.append(np.mean(lc))
if (epochnumber + 1) % 5 == 0:
print("epoch:", epochnumber + 1)
print("Descriptive loss:", loss[-1])
print("Compact loss", loss_c[-1])
#Result graph
plt.plot(loss, label="Descriptive loss")
plt.xlabel("epoch")
plt.legend()
plt.show()
plt.plot(loss_c, label="Compact loss")
plt.xlabel("epoch")
plt.legend()
plt.show()
return model_t
def train(x_target, x_ref, y_ref, epoch_num):
# VGG16読み込み, S network用
print("Model build...")
#mobile = VGG16(include_top=False, input_shape=input_shape, weights='imagenet')
# mobile net読み込み, S network用
mobile = MobileNetV2(include_top=True, input_shape=input_shape, alpha=alpha,
, weights='imagenet')
#最終層削除
mobile.layers.pop()
# 重みを固定
for layer in mobile.layers:
if layer.name == "block_13_expand": # "block5_conv1": for VGG16
break
else:
layer.trainable = False
model_t = Model(inputs=mobile.input,outputs=mobile.layers[-1].output)
# R network用 Sと重み共有
model_r = Network(inputs=model_t.input,
outputs=model_t.output,
name="shared_layer")
#Rに全結合層を付ける
prediction = Dense(classes, activation='softmax')(model_t.output)
model_r = Model(inputs=model_r.input,outputs=prediction)
#コンパイル
optimizer = SGD(lr=5e-5, decay=0.00005)
model_r.compile(optimizer=optimizer, loss="categorical_crossentropy")
model_t.compile(optimizer=optimizer, loss=original_loss)
model_t.summary()
model_r.summary()
print("x_target is",x_target.shape[0],'samples')
print("x_ref is",x_ref.shape[0],'samples')
ref_samples = np.arange(x_ref.shape[0])
loss, loss_c = [], []
print("training...")
#学習
for epochnumber in range(epoch_num):
x_r, y_r, lc, ld = [], [], [], []
#ターゲットデータシャッフル
np.random.shuffle(x_target)
#リファレンスデータシャッフル
np.random.shuffle(ref_samples)
for i in range(len(x_target)):
x_r.append(x_ref[ref_samples[i]])
y_r.append(y_ref[ref_samples[i]])
x_r = np.array(x_r)
y_r = np.array(y_r)
for i in range(int(len(x_target) / batchsize)):
#batchsize分のデータロード
batch_target = x_target[i*batchsize:i*batchsize+batchsize]
batch_ref = x_r[i*batchsize:i*batchsize+batchsize]
batch_y = y_r[i*batchsize:i*batchsize+batchsize]
#target data
#学習しながら、損失を取得
lc.append(model_t.train_on_batch(batch_target, np.zeros((batchsize, feature_out))))
#reference data
#学習しながら、損失を取得
ld.append(model_r.train_on_batch(batch_ref, batch_y))
loss.append(np.mean(ld))
loss_c.append(np.mean(lc))
if (epochnumber+1) % 5 == 0:
print("epoch:",epochnumber+1)
print("Descriptive loss:", loss[-1])
print("Compact loss", loss_c[-1])
#結果グラフ
plt.plot(loss,label="Descriptive loss")
plt.xlabel("epoch")
plt.legend()
plt.show()
plt.plot(loss_c,label="Compact loss")
plt.xlabel("epoch")
plt.legend()
plt.show()
return model_t
def train_test(result_df, df_t, df_r, df_test):
# data
x_target = np.array(df_t.vecs.to_list())
x_ref = np.array(df_r.vecs.to_list())
y_ref = np.array(df_r.target.to_list())
y_ref = to_categorical(y_ref)
test_vecs = np.array(df_test.vecs.to_list())
n_sup = 10000
n_per_targ = 1000
df_r_temp = df_r.groupby('target', group_keys=False).apply(
lambda df: df.sample(n=min(df.shape[0], n_per_targ), random_state=42))
x_tr = np.array(df_t.head(n_sup).append(df_r_temp).vecs.to_list())
y_tr = np.array(df_t.head(n_sup).append(df_r_temp).label.to_list())
#y_tr = to_categorical(y_tr)
#print(f"{df.where(df.label == 0).dropna().target.value_counts()}")
#print(f"x_target: {x_target.shape}\nx_ref: {x_ref.shape}\ny_ref: {y_ref.shape}\n")
res_path = "/home/philipp/projects/dad4td/reports/one_class/all.tsv"
classes = df_r.target.unique().shape[0]
print(f"classes: {classes}")
batchsize = 128
epoch_num = 15
epoch_report = 5
feature_out = 64
pred_mode = "nn"
# get the loss for compactness
original_loss = create_loss(classes, batchsize)
# model creation
model = create_model(loss="binary_crossentropy", n_in=x_target[0].shape[0])
model_t = Model(inputs=model.input, outputs=model.output)
model_r = Network(inputs=model_t.input,
outputs=model_t.output,
name="shared_layer")
prediction = Dense(classes, activation='softmax')(model_t.output)
model_r = Model(inputs=model_r.input, outputs=prediction)
#latent_t = Dense(2, activation='relu')(model_t.output)
#model_t = Model(inputs=model_t.input,outputs=latent_t)
prediction_t = Dense(feature_out, activation='softmax')(model_t.output)
model_t = Model(inputs=model_t.input, outputs=prediction_t)
#optimizer = SGD(lr=5e-5, decay=0.00005)
optimizer = Adam(learning_rate=5e-5)
model_r.compile(optimizer=optimizer, loss="categorical_crossentropy")
model_t.compile(optimizer=optimizer, loss=original_loss)
model_t.summary()
model_r.summary()
ref_samples = np.arange(x_ref.shape[0])
loss, loss_c = [], []
epochs = []
best_acc = 0
print("training...")
for epochnumber in range(epoch_num):
x_r, y_r, lc, ld = [], [], [], []
np.random.shuffle(x_target)
np.random.shuffle(ref_samples)
for i in range(len(x_ref)):
x_r.append(x_ref[ref_samples[i]])
y_r.append(y_ref[ref_samples[i]])
x_r = np.array(x_r)
y_r = np.array(y_r)
for i in range(int(len(x_target) / batchsize)):
batch_target = x_target[i * batchsize:i * batchsize + batchsize]
batch_ref = x_r[i * batchsize:i * batchsize + batchsize]
batch_y = y_r[i * batchsize:i * batchsize + batchsize]
# target data
lc.append(
model_t.train_on_batch(batch_target,
np.zeros((batchsize, feature_out))))
# reference data
ld.append(model_r.train_on_batch(batch_ref, batch_y))
loss.append(np.mean(ld))
loss_c.append(np.mean(lc))
epochs.append(epochnumber)
if epochnumber % epoch_report == 0 or epochnumber == epoch_num - 1:
print(
f"-----\n\nepoch : {epochnumber+1} ,Descriptive loss : {loss[-1]}, Compact loss : {loss_c[-1]}"
)
model_t.save_weights(
'/home/philipp/projects/dad4td/models/one_class/model_t_smd_{}.h5'
.format(epochnumber))
model_r.save_weights(
'/home/philipp/projects/dad4td/models/one_class/model_r_smd_{}.h5'
.format(epochnumber))
#test_b = model_t.predict(test_vecs)
#od = OCSVM()
# od.fit(test_b)
#decision_scores = od.labels_
# decision_scores = decision_scores.astype(float)
labels = df_test["label"].astype(int).values
# threshold = 0.5
# scores = get_scores(dict(),labels, np.where(decision_scores > threshold, 0, 1), outlabel=0)
if pred_mode == "svm":
x_tr_pred = model_t.predict(x_tr)
clf = SVC()
clf.fit(x_tr_pred, y_tr)
preds = model_t.predict(test_vecs)
preds = clf.predict(preds)
elif pred_mode == "nn":
y_tr = y_tr.astype(int)
print(y_tr)
x_tr_pred = model_t.predict(x_tr)
clf = create_sup_model(n_in=feature_out)
clf.summary()
clf.fit(x_tr_pred,
y=y_tr,
epochs=15,
batch_size=64,
verbose=True)
decision_scores = model_t.predict(test_vecs)
decision_scores = clf.predict(decision_scores)
preds = decision_scores.astype(float)
_ = plt.hist(preds, bins=10)
plt.show()
else:
raise Exception(f"{pred_mode} must be one of svm, nn, osvm")
scores = get_scores(dict(), labels, preds, outlabel=0)
print(f"\n\nTest scores:\n{pd.DataFrame([scores], index=[0])}")
if scores["accuracy"] > best_acc:
best_acc = scores["accuracy"]
print(f"best_acc updated to: {best_acc}")
normalize = "true"
print(f"{confusion_matrix(labels, preds, normalize=normalize)}")
result_df = result_df.append(dict(cclass=list(df_test.target.unique()),
accuracy=best_acc),
ignore_index=True)
result_df.to_csv(res_path, sep="\t")
return result_df
