论文

import tensorflow as tf
import numpy as np
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt


class SEN():

    def __init__(self, sample_num, feature_num, layer_size, lsd_dim, learning_rate):
        self.sample_num = sample_num  # 2000
        self.feature_num = feature_num  # 6
        self.layer_size = layer_size  # [[150,64], ..., [150,4]]
        self.lsd_dim = lsd_dim  # 30

        # self.h = tf.Variable(xavier_init(self.sample_num, self.lsd_dim), name="h")
        self.h = tf.Variable(tf.random_uniform((self.sample_num, self.lsd_dim), minval=-0.5, maxval=0.5, dtype=tf.float32))

        self.input = dict()

        for f_num in range(self.feature_num):
            self.input[str(f_num)] = tf.placeholder(tf.float32, shape=[None, self.layer_size[f_num][-1]],
                                                    name='input' + str(f_num))

        self.train_op, self.loss = self.bulid_model(self.h, learning_rate)

        self.sess = tf.Session()
        self.sess.run(tf.global_variables_initializer())

    def bulid_model(self, h, learning_rate):
        net = dict()

        for f_num in range(self.feature_num):
            net[str(f_num)] = self.Encoding_net(self.h, f_num)

        reco_loss = self.reconstruction_loss(net)

        train_net_op = tf.train.AdamOptimizer(learning_rate).minimize(reco_loss, var_list=tf.get_collection('weight'))
        train_h_op = tf.train.AdamOptimizer(learning_rate).minimize(reco_loss, var_list=h)

        return [train_net_op, train_h_op], reco_loss

    def Encoding_net(self, h, f):
        weight = self.initialize_weight(self.layer_size[f])

        layer = tf.matmul(h, weight['w0']) + weight['b0']
        # layer = tf.nn.relu(layer)
        layer = tf.matmul(layer, weight['w1']) + weight['b1']

        return layer

    def initialize_weight(self, dims_net):
        all_weight = dict()

        # with tf.variable_scope('weight'):
        all_weight['w0'] = tf.Variable(xavier_init(self.lsd_dim, dims_net[0]))
        all_weight['b0'] = tf.Variable(tf.zeros([dims_net[0]]))
        tf.add_to_collection("weight", all_weight['w0'])
        tf.add_to_collection("weight", all_weight['b0'])

        all_weight['w1'] = tf.Variable(xavier_init(dims_net[0], dims_net[1]))
        all_weight['b1'] = tf.Variable(tf.zeros([dims_net[1]]))
        tf.add_to_collection("weight", all_weight['w1'])
        tf.add_to_collection("weight", all_weight['b1'])

        return all_weight

    def reconstruction_loss(self, net):
        loss = 0
        for num in range(self.feature_num):
            loss = loss + tf.reduce_sum(
                tf.pow(tf.subtract(net[str(num)], self.input[str(num)])
                       , 2.0)
            )
        return loss

    def train(self, data, epoch, step=5):
        feed_dict = {self.input[str(f_num)]: data[f_num] for f_num in range(self.feature_num)}

        for iter in range(epoch):
            # update subnet
            for i in range(step):
                self.sess.run([self.train_op[0]], feed_dict=feed_dict)
            # update embeddings
            for i in range(step):
                _, reconstruction_loss = self.sess.run([self.train_op[1], self.loss], feed_dict=feed_dict)
            output = "Epoch : {:.0f}  ===> Reconstruction Loss = {:.4f} ".format((iter + 1), reconstruction_loss)
            print(output)

        return self.sess.run(self.h)


def xavier_init(fan_in, fan_out, constant=1):
    low = -constant * np.sqrt(6.0 / (fan_in + fan_out))
    high = constant * np.sqrt(6.0 / (fan_in + fan_out))

    return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high, dtype=tf.float32)

dataset = np.load("../data/generate_data/data_6.npy", allow_pickle=True).tolist()
def Normalize(data):
    m = np.mean(data)
    mx = np.max(data)
    mn = np.min(data)
    
    return (data - m) / (mx - mn)

feature_num = 6
for f_num in range(feature_num):
    dataset[f_num] = Normalize(dataset[f_num])

epoch = 30
learning_rate = 0.01
lsd_dim = 30
sample_num = 2000
feature_num = 6

outdim_size = [len(dataset[i][0]) for i in range(feature_num)]
layer_size = [[150, outdim_size[i]] for i in range(feature_num)]

model = SEN(sample_num, feature_num, layer_size, lsd_dim, learning_rate)

embedding = model.train(dataset, epoch)
tsne = TSNE(n_components=2)
tsne.fit(embedding)
scatter_pos_list = tsne.embedding_

label = []
for i in range(1, 11):
    for j in range(200):
        label.append(i)

plt.figure(i, figsize=(5, 5))
plt.scatter(scatter_pos_list[:, 0], scatter_pos_list[:, 1], c=label, s=100)
plt.axis('square')
plt.show()