def VFAE_training(source_data,
target_data,
n_train_batches,
n_epochs,
struct,
coef,
description,
process_display=True):
#########################################################
### Data ###
#########################################################
# must input data like [
# [[trainimg, label], [img, label], [img, label]],
# [[validationimg, label], [img, label], [img, label]],
# [[testimg, label], [img, label], [img, label]]
# ]
train_ftd_source, train_labeld_source = source_data[0]
valid_ftd_source, valid_labeld_source = source_data[1]
test_ftd_source, test_labeld_source = source_data[2]
train_ftd_target, train_labeld_target = target_data[0]
valid_ftd_target, valid_labeld_target = target_data[1]
test_ftd_target, test_labeld_target = target_data[2]
train_ftd_source, train_labeld_source = util.shared_dataset(
(train_ftd_source, train_labeld_source))
valid_ftd_source, valid_labeld_source = util.shared_dataset(
(valid_ftd_source, valid_labeld_source))
test_ftd_source, test_labeld_source = util.shared_dataset(
(test_ftd_source, test_labeld_source))
train_ftd_target, train_labeld_target = util.shared_dataset(
(train_ftd_target, train_labeld_target))
valid_ftd_target, valid_labeld_target = util.shared_dataset(
(valid_ftd_target, valid_labeld_target))
test_ftd_target, test_labeld_target = util.shared_dataset(
(test_ftd_target, test_labeld_target))
batch_size_S = train_ftd_source.get_value(
borrow=True).shape[0] // n_train_batches
batch_size_T = train_ftd_target.get_value(
borrow=True).shape[0] // n_train_batches
validate_S_size = valid_ftd_source.get_value(borrow=True).shape[0]
validate_T_size = valid_ftd_target.get_value(borrow=True).shape[0]
test_S_size = test_ftd_source.get_value(borrow=True).shape[0]
test_T_size = test_ftd_target.get_value(borrow=True).shape[0]
print(
'number of minibatch at one epoch: %i, batch size source : %i, target : %i \n validation size, S:%i, T:%i, test size, S:%i, T:%i'
% (n_train_batches, batch_size_S, batch_size_T, validate_S_size,
validate_T_size, test_S_size, test_T_size))
#######################################################################
### BUILD ACTUAL MODEL ###
#######################################################################
print('... building the model')
# allocate symbolic variables for the data
#index_source = T.lscalar() # index to a [mini]batch
#index_target = T.lscalar() # index to a [mini]batch
index = T.lscalar() # index to a [mini]batch
x_source = T.matrix(
'x_source') # the data is presented as rasterized images
y_source = T.matrix(
'y_source') # the labels are presented as signal vector
x_target = T.matrix(
'x_target') # the data is presented as rasterized images
y_target = T.matrix(
'y_target') # the labels are presented as signal vector
rng = np.random.RandomState(1234)
# construct the VFAE class
classifier = VFAE(rng=rng,
input_source=x_source,
input_target=x_target,
label_source=y_source,
batch_size=[batch_size_S, batch_size_T],
struct=struct,
coef=coef,
train=True)
validate_classifier = VFAE(rng=rng,
input_source=x_source,
input_target=x_target,
label_source=y_source,
batch_size=[validate_S_size, validate_T_size],
struct=struct,
coef=coef,
init_params=classifier.params_symbol())
test_classifier = VFAE(rng=rng,
input_source=x_source,
input_target=x_target,
label_source=y_source,
batch_size=[test_S_size, test_T_size],
struct=struct,
coef=coef,
init_params=classifier.params_symbol())
#update function
updates = classifier.updates
test_model = theano.function(inputs=[],
outputs=[
test_classifier.cost,
test_classifier.source_errors(y_source),
test_classifier.target_errors(y_target),
test_classifier.source_predict(),
test_classifier.target_predict()
],
givens={
x_source: test_ftd_source,
y_source: test_labeld_source,
x_target: test_ftd_target,
y_target: test_labeld_target
})
validate_model = theano.function(
inputs=[],
outputs=[
validate_classifier.cost,
validate_classifier.source_errors(y_source),
validate_classifier.target_errors(y_target),
validate_classifier.source_predict_raw(),
validate_classifier.target_predict_raw()
],
givens={
x_source: valid_ftd_source,
y_source: valid_labeld_source,
x_target: valid_ftd_target,
y_target: valid_labeld_target
})
validate_bytraindata_model = theano.function(
inputs=[index],
outputs=[
classifier.cost,
classifier.source_errors(y_source),
classifier.target_errors(y_target),
classifier.source_predict(),
classifier.target_predict()
],
givens={
x_source:
train_ftd_source[index * batch_size_S:(index + 1) *
batch_size_S, :],
y_source:
train_labeld_source[index * batch_size_S:(index + 1) *
batch_size_S, :],
x_target:
train_ftd_target[index * batch_size_T:(index + 1) *
batch_size_T, :],
y_target:
train_labeld_target[index * batch_size_T:(index + 1) *
batch_size_T, :]
})
train_model = theano.function(
inputs=[index],
outputs=[
classifier.cost,
classifier.source_errors(y_source),
classifier.target_errors(y_target),
classifier.source_predict(),
classifier.target_predict()
],
updates=updates,
givens={
x_source:
train_ftd_source[index * batch_size_S:(index + 1) *
batch_size_S, :],
y_source:
train_labeld_source[index * batch_size_S:(index + 1) *
batch_size_S, :],
x_target:
train_ftd_target[index * batch_size_T:(index + 1) *
batch_size_T, :],
y_target:
train_labeld_target[index * batch_size_T:(index + 1) *
batch_size_T, :]
})
################################################################
### TRAIN MODEL ###
################################################################
'''
Define :
xx_loss : Cost function value
xx_score : Classification accuracy rate
'''
print('... training')
# early-stopping parameters
patience = 10000 # look as this many examples regardless
patience_increase = 2 # wait this much longer when a new best is
# found
improvement_threshold = 0.995 # a relative improvement of this much is
# considered significant
validation_frequency = min(1, patience // 2)
# go through this many
# minibatche before checking the network
# on the validation set; in this case we
# check every epoch
validation_frequency = n_train_batches
best_iter = 0
best_train_loss = np.inf
best_validation_loss = np.inf
test_loss = np.inf
train_score = 0.
validation_score = 0.
test_score = 0.
start_time = timeit.default_timer()
epoch = 0
iter = 0
done_looping = False
train_losses_record = []
validate_losses_record = []
test_losses = test_model()[1]
test_score_S = 1 - np.mean(test_losses)
test_losses = test_model()[2]
test_score_T = 1 - np.mean(test_losses)
print(
('Initial, test accuracy: source domain :%f %%, target domain %f %%') %
(test_score_S * 100., test_score_T * 100.))
while (epoch < n_epochs) and (not done_looping):
epoch = epoch + 1
for minibatch_index in range(n_train_batches):
minibatch_avg_cost = train_model(minibatch_index)[0]
# iteration number
iter = (epoch - 1) * n_train_batches + minibatch_index
if (iter + 1) % validation_frequency == 0:
# compute loss on all training set
train_losses = [
validate_bytraindata_model(i)[0]
for i in range(n_train_batches)
]
this_train_loss = np.mean(train_losses)
# compute loss on validation set
this_validation_loss = validate_model()[0]
if (iter + 1) % 5 == 0 and process_display:
print(
'epoch %i, minibatch %i/%i, training loss %f, validation loss %f '
% (epoch, minibatch_index + 1, n_train_batches,
this_train_loss, this_validation_loss))
total_train_losses = [
validate_bytraindata_model(i)[0]
for i in range(n_train_batches)
]
total_train_losses = np.mean(total_train_losses)
train_losses_record.append(total_train_losses)
validate_losses_record.append(this_validation_loss)
# if we got the best validation score until now
if this_validation_loss < best_validation_loss:
#improve patience if loss improvement is good enough
if (this_validation_loss <
best_validation_loss * improvement_threshold):
patience = max(patience, iter * patience_increase)
train_loss = this_train_loss
best_validation_loss = this_validation_loss
best_iter = iter
#Get Accuracy
train_losses = [
validate_bytraindata_model(i)[1]
for i in range(n_train_batches)
]
train_score_S = 1 - np.mean(train_losses)
train_losses = [
validate_bytraindata_model(i)[2]
for i in range(n_train_batches)
]
train_score_T = 1 - np.mean(train_losses)
validation_losses = validate_model()[1]
validation_score_S = 1 - np.mean(validation_losses)
validation_losses = validate_model()[2]
validation_score_T = 1 - np.mean(validation_losses)
# test it on the test set
test_losses = test_model()[1]
test_score_S = 1 - np.mean(test_losses)
test_losses = test_model()[2]
test_score_T = 1 - np.mean(test_losses)
trained_params_name = classifier.params_name()
trained_params_value = classifier.params_value()
if process_display:
print((
' epoch %i, minibatch %i/%i, test accuracy of '
'best model: source domain :%f %%, target domain %f %%'
) % (epoch, minibatch_index + 1, n_train_batches,
test_score_S * 100., test_score_T * 100.))
if patience <= iter:
done_looping = True
break
end_time = timeit.default_timer()
if process_display:
print((
'Optimization complete. Best validation loss of %f '
'obtained at iteration %i, with train loss %f \n'
'train accuracy : source domain %f %%, target domain %f %%\n'
'validation accuracy : source domain %f %%, target domain %f %%\n'
'test accuracy : source domain %f %%, target domain %f %%') %
(best_validation_loss, best_iter + 1, train_loss,
train_score_S * 100., train_score_T * 100.,
validation_score_S * 100., validation_score_T * 100.,
test_score_S * 100., test_score_T * 100.))
print(
'-------------------------------------------------------------------------'
)
#Converge curve
index = range(len(train_losses_record))
title = 'Converge_Curve_%s' % (description)
fts = (index, train_losses_record, index, validate_losses_record)
label = ('train loss', 'validation loss')
color = [1, 2]
marker = [0, 0]
line = True
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend,
plot_enable=process_display)
print(
'-------------------------------------------------------------------------'
)
trained_param = VFAE_params()
trained_param.update_value(trained_params_name, trained_params_value,
struct)
num_S = train_ftd_source.get_value(borrow=True).shape[0]
num_T = train_ftd_target.get_value(borrow=True).shape[0]
feature_classifier = VFAE(rng=rng,
input_source=x_source,
input_target=x_target,
label_source=y_source,
batch_size=[num_S, num_T],
struct=struct,
coef=coef,
init_params=trained_param)
features_model = theano.function(
inputs=[],
outputs=feature_classifier.feature_outputs() + [
feature_classifier.source_predict(),
feature_classifier.target_predict()
] + [
feature_classifier.source_reconstruct(),
feature_classifier.target_reconstruct()
],
givens={
x_source: train_ftd_source,
x_target: train_ftd_target
})
return features_model, test_model, trained_param
def features_plot(features_model, test_model, source_data, target_data,
description):
train_fts_source, train_labels_source = source_data[0]
valid_fts_source, valid_labels_source = source_data[1]
test_fts_source, test_labels_source = source_data[2]
train_fts_target, train_labels_target = target_data[0]
valid_fts_target, valid_labels_target = target_data[1]
test_fts_target, test_labels_target = target_data[2]
y_dim = np.shape(train_labels_source)[1]
S_labels = train_labels_source
T_labels = train_labels_target
zy_S = features_model()[0]
zy_T = features_model()[1]
zy_S, zy_T = util.feature_tsne(zy_S, zy_T)
label_zy_S = []
label_zy_T = []
for i in range(y_dim):
label_zy_S.append(zy_S[np.where(S_labels[:, i] == 1)[0], :])
label_zy_T.append(zy_T[np.where(T_labels[:, i] == 1)[0], :])
#Source zy feature
title = 'Source_zy_feature_%s' % (description)
fts = ()
for i in range(y_dim):
fts = fts + (label_zy_S[i][:, 0], label_zy_S[i][:, 1])
label = [
'back pack', 'bike', 'calculator', 'headphones', 'keyboard',
'laptop computer', 'monitor', 'mouse', 'mug', 'projector'
]
color = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
marker = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
line = False
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend)
#Target zy feature
title = 'Target_zy_feature_%s' % (description)
fts = ()
for i in range(y_dim):
fts = fts + (label_zy_T[i][:, 0], label_zy_T[i][:, 1])
label = [
'back pack', 'bike', 'calculator', 'headphones', 'keyboard',
'laptop computer', 'monitor', 'mouse', 'mug', 'projector'
]
color = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
marker = [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
line = False
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend)
#Both source, target zy feature
title = 'Zy_feature_%s' % (description)
fts = ()
tmp = ()
for i in range(y_dim):
fts = fts + (label_zy_S[i][:, 0], label_zy_S[i][:, 1])
fts = fts + (label_zy_T[i][:, 0], label_zy_T[i][:, 1])
label = [
'Source:back pack', 'Target:back pack', 'Source:bike', 'Target:bike',
'Source:calculator', 'Target:calculator', 'Source:headphones',
'Target:headphones', 'Source:keyboard', 'Target:keyboard',
'Source:laptop computer', 'Target:laptop computer', 'Source:monitor',
'Target:monitor', 'Source:mouse', 'Target:mouse', 'Source:mug',
'Target:mug', 'Source:projector', 'Target:projector'
]
color = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10]
marker = [1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
line = False
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend)
#Both source, target zy feature
title = 'Test_zy_feature_%s' % (description)
fts = ()
tmp = ()
for i in range(y_dim):
fts = fts + (label_zy_S[i][:, 0], label_zy_S[i][:, 1])
fts = fts + (label_zy_T[i][:, 0], label_zy_T[i][:, 1])
label = [
'Source:back pack', 'Target:back pack', 'Source:bike', 'Target:bike',
'Source:calculator', 'Target:calculator', 'Source:headphones',
'Target:headphones', 'Source:keyboard', 'Target:keyboard',
'Source:laptop computer', 'Target:laptop computer', 'Source:monitor',
'Target:monitor', 'Source:mouse', 'Target:mouse', 'Source:mug',
'Target:mug', 'Source:projector', 'Target:projector'
]
color = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10]
marker = [1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
line = False
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend)
def features_plot(features,labels_source, labels_target ,sample_n, description):
# features = [source_share_feature, target_share_feature, source_private_feature, target_private_feature]
y_dim=np.shape(labels_source)[1]
S_labels=labels_source[0:sample_n]
T_labels=labels_target[0:sample_n]
source_share_feature=features[0][0:sample_n,:]
target_share_feature=features[1][0:sample_n,:]
source_private_feature=features[2][0:sample_n,:]
target_private_feature=features[3][0:sample_n,:]
z_ssf, z_tsf, z_spf, z_tpf = util.feature_tsne(source_share_feature, target_share_feature, source_private_feature, target_private_feature)
#save tsen feature
np.savetxt('z_ssf.txt', z_ssf)
np.savetxt('z_tsf.txt', z_tsf)
np.savetxt('z_spf.txt', z_spf)
np.savetxt('z_tpf.txt', z_tpf)
label_z_ssf=[]
label_z_tsf=[]
label_z_spf=[]
label_z_tpf=[]
for i in range(y_dim):
label_z_ssf.append( z_ssf[np.where(S_labels[:,i]==1)[0],:] )
label_z_tsf.append( z_tsf[np.where(T_labels[:,i]==1)[0],:] )
label_z_spf.append( z_spf[np.where(S_labels[:,i]==1)[0],:] )
label_z_tpf.append( z_tpf[np.where(T_labels[:,i]==1)[0],:] )
# Source zy feature
title = 'Source_z_feature_%s' % (description)
fts=()
for i in range(y_dim):
fts=fts+(label_z_ssf[i][:,0],label_z_ssf[i][:,1])
fts=fts+(label_z_spf[i][:,0],label_z_spf[i][:,1])
label = ['negative_share', 'positive_share', 'negative_private', 'positive_private']
color=[1, 2, 3 , 7]
marker=[1,1, 1, 1]
line = False
legend=True
util.data2plot(title=title, fts=fts, label=label, color=color, marker=marker, line=line, legend = legend, plot_enable=True)
# Target zy feature
title = 'Target_z_feature_%s' % (description)
fts=()
for i in range(y_dim):
fts=fts+(label_z_tsf[i][:,0],label_z_tsf[i][:,1])
fts=fts+(label_z_tpf[i][:,0],label_z_tpf[i][:,1])
label = ['negative_share', 'positive_share', 'negative_private', 'positive_private']
color=[1, 2, 3, 7]
marker=[3,3, 3,3]
line = False
legend=True
util.data2plot(title=title, fts=fts, label=label, color=color, marker=marker, line=line, legend = legend, plot_enable=True)
# Both source, target zy feature
title = 'Zy_feature_%s' % (description)
fts = ()
tmp = ()
for i in range(y_dim):
fts=fts+(label_z_ssf[i][:,0],label_z_ssf[i][:,1])
fts=fts+(label_z_spf[i][:,0],label_z_spf[i][:,1])
fts=fts+(label_z_tsf[i][:,0],label_z_tsf[i][:,1])
fts=fts+(label_z_tpf[i][:,0],label_z_tpf[i][:,1])
label = ['negative_share_S', 'positive_share_S', 'negative_private_S', 'positive_private_S', 'negative_share_T', 'positive_share_T', 'negative_private_T', 'positive_private_T']
color = [1, 2, 3, 7, 1, 2, 3, 7]
marker = [1, 1, 1, 1, 3, 3, 3, 3]
line = False
legend = True
util.data2plot(title=title, fts=fts, label=label, color=color, marker=marker, line=line, legend = legend, plot_enable=True)
def features_plot(features_model,
test_model,
source_data,
target_data,
sample_n,
description,
reconstruction=False):
train_fts_source, train_labels_source = source_data[0]
valid_fts_source, valid_labels_source = source_data[1]
test_fts_source, test_labels_source = source_data[2]
train_fts_target, train_labels_target = target_data[0]
valid_fts_target, valid_labels_target = target_data[1]
test_fts_target, test_labels_target = target_data[2]
y_dim = np.shape(train_labels_source)[1]
S_labels = train_labels_source
T_labels = train_labels_target
#-------------------------------------------------------------------------------------------
zy_S = features_model()[0][0:sample_n, :]
zy_T = features_model()[1][0:sample_n, :]
zy_S, zy_T = util.feature_tsne(zy_S, zy_T)
label_zy_S = []
label_zy_T = []
for i in range(y_dim):
label_zy_S.append(zy_S[np.where(S_labels[0:sample_n, i] == 1)[0], :])
label_zy_T.append(zy_T[np.where(T_labels[0:sample_n, i] == 1)[0], :])
#Source zy feature
title = 'Source_zy_feature_%s' % (description)
fts = ()
for i in range(y_dim):
fts = fts + (label_zy_S[i][:, 0], label_zy_S[i][:, 1])
label = ('label 0', 'label 1')
color = [1, 2]
marker = [1, 1]
line = False
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line)
#Target zy feature
title = 'Target_zy_feature_%s' % (description)
fts = ()
for i in range(y_dim):
fts = fts + (label_zy_T[i][:, 0], label_zy_T[i][:, 1])
label = ('label 0', 'label 1')
color = [1, 2]
marker = [2, 2]
line = False
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line)
#Both source, target zy feature
title = 'Zy_feature_%s' % (description)
fts = ()
for i in range(y_dim):
fts = fts + (label_zy_S[i][:, 0], label_zy_S[i][:, 1])
fts = fts + (label_zy_T[i][:, 0], label_zy_T[i][:, 1])
label = ('Source label 0', 'Target label 0', 'Source label 1',
'Target label 1')
color = [1, 1, 2, 2]
marker = [1, 2, 1, 2]
line = False
legend = False
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend)
#print('-------------------------------------------------------------------------')
#Classification Result of Training Data
S_labels_predict = features_model()[2]
T_labels_predict = features_model()[3]
S_0 = train_fts_source[np.where(S_labels_predict == 0)[0], :]
S_1 = train_fts_source[np.where(S_labels_predict == 1)[0], :]
T_0 = train_fts_target[np.where(T_labels_predict == 0)[0], :]
T_1 = train_fts_target[np.where(T_labels_predict == 1)[0], :]
title = 'Train_classification_%s' % (description)
fts = (S_0[:, 0], S_0[:, 1], S_1[:, 0], S_1[:, 1], T_0[:, 0], T_0[:, 1],
T_1[:, 0], T_1[:, 1])
label = ('Source label 0', 'Target label 0', 'Source label 1',
'Target label 1')
color = [1, 2, 1, 2]
marker = [1, 1, 2, 2]
line = False
legend = False
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend)
#Classification Result of Testing Data
S_labels_predict = test_model()[3]
T_labels_predict = test_model()[4]
S_0 = test_fts_source[np.where(S_labels_predict == 0)[0], :]
S_1 = test_fts_source[np.where(S_labels_predict == 1)[0], :]
T_0 = test_fts_target[np.where(T_labels_predict == 0)[0], :]
T_1 = test_fts_target[np.where(T_labels_predict == 1)[0], :]
title = 'Test_classification_%s' % (description)
fts = (S_0[:, 0], S_0[:, 1], S_1[:, 0], S_1[:, 1], T_0[:, 0], T_0[:, 1],
T_1[:, 0], T_1[:, 1])
label = ('Source label 0', 'Target label 0', 'Source label 1',
'Target label 1')
color = [1, 2, 1, 2]
marker = [1, 1, 2, 2]
line = False
legend = False
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend)
print(
'-------------------------------------------------------------------------'
)
#Reconstruction of generative model(VFAE, VLDF)
if reconstruction == False:
return
S_recon_x = features_model()[4]
T_recon_x = features_model()[5]
title = 'Reconstruction_%s' % (description)
fts = (S_recon_x[:, 0], S_recon_x[:, 1], T_recon_x[:, 0], T_recon_x[:, 1])
label = ('Source', 'Target')
color = [2, 2]
marker = [1, 2]
line = False
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend)
def features_plot(features_model,
source_data,
target_data,
sample_n,
description,
plot_enable=True):
train_fts_source, train_labels_source = source_data[0]
valid_fts_source, valid_labels_source = source_data[1]
test_fts_source, test_labels_source = source_data[2]
train_fts_target, train_labels_target = target_data[0]
valid_fts_target, valid_labels_target = target_data[1]
test_fts_target, test_labels_target = target_data[2]
y_dim = np.shape(train_labels_source)[1]
S_labels = train_labels_source[0:sample_n, :]
T_labels = train_labels_target[0:sample_n, :]
zj_S = features_model[0][0:sample_n, :]
zj_T = features_model[1][0:sample_n, :]
zi_S = features_model[2][0:sample_n, :]
zi_T = features_model[3][0:sample_n, :]
zj_S, zj_T, zi_S, zi_T = util.domain_feature_tsne(zj_S, zj_T, zi_S, zi_T)
filename = '/home/jay/DSN/tensorflow/DSN_GAN_loss/Experimental_Result/Amazon/%s.png'
label_zj_S = []
label_zj_T = []
label_zi_S = []
label_zi_T = []
for i in range(y_dim):
'''
label_zj_S.append( zj_S[np.where(S_labels[:,i] == 1)[0], :] )
label_zj_T.append( zj_T[np.where(T_labels[:,i] == 1)[0], :] )
label_zi_S.append( zi_S[np.where(S_labels[:,i] == 1)[0], :] )
label_zi_T.append( zi_T[np.where(T_labels[:,i] == 1)[0], :] )
'''
#Source zy feature
title = 'Source_zy_feature_%s' % (description)
fts = ()
'''
for i in range(y_dim):
fts = fts+(label_zj_S[i][:,0], label_zj_S[i][:,1])
label = ['negative', 'positive']
'''
fts = (zj_S[:, 0], zj_S[:, 1]) + (zi_S[:, 0], zi_S[:, 1])
label = ['joint', 'individual']
color = [1, 2]
marker = [1, 1]
line = False
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend,
plot_enable=plot_enable,
filename=filename)
#Target zy feature
title = 'Target_zy_feature_%s' % (description)
fts = ()
'''
for i in range(y_dim):
fts = fts+(label_zy_T[i][:,0], label_zy_T[i][:,1])
label = ['negative', 'positive']
'''
fts = (zj_T[:, 0], zj_T[:, 1]) + (zi_T[:, 0], zi_T[:, 1])
label = ['joint', 'individual']
color = [1, 2]
marker = [3, 3]
line = False
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend,
plot_enable=plot_enable,
filename=filename)
#Both source, target zy feature
title = 'Zy_feature_%s' % (description)
fts = ()
tmp = ()
'''
for i in range(y_dim):
fts = fts+(label_zy_S[i][:,0], label_zy_S[i][:,1])
fts = fts+(label_zy_T[i][:,0], label_zy_T[i][:,1])
label = ['Source:negative', 'Target:negative', 'Source:positive', 'Target:positive']
'''
fts = (zj_S[:, 0], zj_S[:, 1]) + (zi_S[:, 0], zi_S[:, 1]) + (
zj_T[:, 0], zj_T[:, 1]) + (zi_T[:, 0], zi_T[:, 1])
label = [
'source joint', 'source individual', 'target joint',
'target individual'
]
color = [1, 2, 1, 2]
marker = [1, 1, 3, 3]
line = False
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend,
plot_enable=plot_enable,
filename=filename)
def features_plot(features_model,
test_model,
source_data,
target_data,
sample_n,
description,
plot_enable=True):
train_fts_source, train_labels_source = source_data[0]
valid_fts_source, valid_labels_source = source_data[1]
test_fts_source, test_labels_source = source_data[2]
train_fts_target, train_labels_target = target_data[0]
valid_fts_target, valid_labels_target = target_data[1]
test_fts_target, test_labels_target = target_data[2]
y_dim = np.shape(train_labels_source)[1]
S_labels = train_labels_source[0:sample_n, :]
T_labels = train_labels_target[0:sample_n, :]
zy_S = features_model()[0][0:sample_n, :]
zy_T = features_model()[1][0:sample_n, :]
zy_S, zy_T = util.feature_tsne(zy_S, zy_T)
label_zy_S = []
label_zy_T = []
for i in range(y_dim):
label_zy_S.append(zy_S[np.where(S_labels[:, i] == 1)[0], :])
label_zy_T.append(zy_T[np.where(T_labels[:, i] == 1)[0], :])
#Source zy feature
title = 'Source_zy_feature_%s' % (description)
fts = ()
for i in range(y_dim):
fts = fts + (label_zy_S[i][:, 0], label_zy_S[i][:, 1])
label = ['negative', 'positive']
color = [1, 2]
marker = [1, 1]
line = False
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend,
plot_enable=plot_enable)
#Target zy feature
title = 'Target_zy_feature_%s' % (description)
fts = ()
for i in range(y_dim):
fts = fts + (label_zy_T[i][:, 0], label_zy_T[i][:, 1])
label = ['negative', 'positive']
color = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
marker = [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
line = False
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend,
plot_enable=plot_enable)
#Both source, target zy feature
title = 'Zy_feature_%s' % (description)
fts = ()
tmp = ()
for i in range(y_dim):
fts = fts + (label_zy_S[i][:, 0], label_zy_S[i][:, 1])
fts = fts + (label_zy_T[i][:, 0], label_zy_T[i][:, 1])
label = [
'Source:negative', 'Target:negative', 'Source:positive',
'Target:positive'
]
color = [1, 1, 2, 2]
marker = [1, 2, 1, 2]
line = False
legend = True
util.data2plot(title=title,
fts=fts,
label=label,
color=color,
marker=marker,
line=line,
legend=legend,
plot_enable=plot_enable)
