def train_kmeans(model_index,input,num_of_classes): x =tf.placeholder(tf.float32, shape=np.shape(input),name="pdfs") model = KMeans(inputs=x, num_clusters=num_of_classes, initial_clusters="kmeans_plus_plus")#,distance_metric='cross_entropy_distance') training_graph = model.training_graph() if len(training_graph) > 6: (all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_centers_var, init_op, train_op) = training_graph else: (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = training_graph cluster_idx = cluster_idx[0] avg_distance = tf.reduce_mean(scores) init_vars = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init_vars) sess.run(init_op,feed_dict={x:input}) for i in range(500): _, d,label= sess.run([train_op, avg_distance, cluster_idx],feed_dict={x:input}) if i % 10 == 0: print("step %i, avg distance: %f" % (i, d)) return label
def groupNumber(req_data): f = open('data_list.tdat', 'rb') data_list = pk.load(f) f.close() k = ut.elbow(data_list) num_features = 14 X = tf.placeholder(tf.float32, shape=[None, num_features]) kmeans = KMeans(inputs = X, num_clusters=k, distance_metric='squared_euclidean', use_mini_batch=True) (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = kmeans.training_graph() cluster_idx = cluster_idx[0] avg_distance = tf.reduce_mean(scores) save_file = './trained_data.ckpt' saver = tf.train.Saver() input_data = [] input_data.append(req_data) with tf.Session() as sess: saver.restore(sess, save_file) _, d, idx = sess.run([train_op, avg_distance, cluster_idx], feed_dict={X: input_data}) for i in range(0, k): for j in range(0, idx.size, 1): if(idx[j] == i): return i sess.cllose()
def kmeans(num_clusters, data): num_steps = 100 data_array = np.concatenate(data, axis=0) row, col = np.shape(data_array) # Input features X = tf.placeholder(tf.float32, shape=[row, col]) # Define the Kmeans kmeans = KMeans(inputs=X, num_clusters=num_clusters, distance_metric='squared_euclidean', initial_clusters='kmeans_plus_plus', use_mini_batch=True) all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_centers_var, init_op, training_op = \ kmeans.training_graph() # fix for cluster_idx being a tuple cluster_idx = cluster_idx[0] with tf.Session() as sess: sess.run(tf.global_variables_initializer(), feed_dict={X: data_array}) sess.run(init_op, feed_dict={X: data_array}) for i in range(num_steps): _, idx = sess.run([training_op, cluster_idx], feed_dict={X: data_array}) # Create the k means histogram return histograming(data, idx, num_clusters)
def train(x_train, y_train): # Parameters num_steps = 50 # Total steps to train batch_size = 1024 # The number of samples per batch k = 25 # The number of clusters num_classes = 10 # The 10 digits num_features = 784 # Each image is 28x28 pixels # Put placeholders for input data here X = tf.placeholder(tf.float32, shape=[None, num_features]) Y = tf.placeholder(tf.float32, shape=[None, num_classes]) # Initialize K-means parameters here (KMeans) kmeans = KMeans(inputs=X, num_clusters=k, distance_metric='cosine', use_mini_batch=True) # Build K-means graph (kmeans.training_graph()) training_graph = kmeans.training_graph() # You will need the output of kmeans.training_graph() to calculate the average distance if len(training_graph) > 6: (all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_centers_var, init_op, train_op) = training_graph else: (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = training_graph cluster_idx = cluster_idx[0] # fix for cluster_idx being a tuple avg_distance = tf.reduce_mean(scores) # Initialize the variables (i.e. assign their default value) init_vars = tf.global_variables_initializer() # Start TensorFlow session and run the initializer sess = tf.Session() sess.run(init_vars, feed_dict={X: x_train}) sess.run(init_op, feed_dict={X: x_train}) # Training for i in range(1, num_steps + 1): _, d, idx = sess.run([train_op, avg_distance, cluster_idx], feed_dict={X: x_train}) if i % 10 == 0 or i == 1: print("Step %i, Avg Distance: %f" % (i, d)) # Assign a label to each centroid # Count total number of labels per centroid, using the label of each training # sample to their closest centroid (given by 'idx') counts = np.zeros(shape=(k, num_classes)) for i in range(len(idx)): counts[idx[i]] += y_train[i] # Assign the most frequent label to the centroid labels_map = [np.argmax(c) for c in counts] labels_map = tf.convert_to_tensor(labels_map) # Lookup: centroid_id -> label cluster_label = tf.nn.embedding_lookup(labels_map, cluster_idx) correct_prediction = tf.equal(cluster_label, tf.cast(tf.argmax(Y, 1), tf.int32)) accuracy_op = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # return a model, sess and both placeholders to test the model return sess, accuracy_op, X, Y
def tf_kmeans(full_data_x): num_steps = 50 # Total steps to train batch_size = 1024 # The number of samples per batch k = 3000 # The number of clusters num_features = 128 # Each image is 28x28 pixels full_data_x = full_data_x # Input images X = tf.placeholder(tf.float32, shape=[None, num_features]) # K-Means Parameters kmeans = KMeans(inputs=X, num_clusters=k, distance_metric='cosine', use_mini_batch=True) # Build KMeans graph training_graph = kmeans.training_graph() if len(training_graph) > 6: # Tensorflow 1.4+ (all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_centers_var, init_op, train_op) = training_graph else: (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = training_graph cluster_idx = cluster_idx[0] # fix for cluster_idx being a tuple avg_distance = tf.reduce_mean(scores) # Initialize the variables (i.e. assign their default value) init_vars = tf.global_variables_initializer() # Start TensorFlow session sess = tf.Session() # Run the initializer sess.run(init_vars, feed_dict={X: full_data_x}) sess.run(init_op, feed_dict={X: full_data_x}) # cluster_label = tf.nn.embedding_lookup(labels_map, cluster_idx) # Training for i in range(1, num_steps + 1): _, d, idx = sess.run([train_op, avg_distance, cluster_idx], feed_dict={X: full_data_x}) if i % 10 == 0 or i == 1: print("Step %i, Avg Distance: %f" % (i, d)) return idx
def main(): mnist = input_data.read_data_sets('/tmp/data/', one_hot=True) full_data_x = mnist.train.images num_steps = 50 batch_size = 1024 k = 25 num_classes = 10 num_features = 784 X = tf.placeholder(tf.float32, shape=[None, num_features]) Y = tf.placeholder(tf.float32, shape=[None, num_classes]) kmeans = KMeans(inputs=X, num_clusters=k, distance_metric='cosine', use_mini_batch=True) training_graph = kmeans.training_graph() if len(training_graph) > 6: (all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_centers_var, init_op, train_op) = training_graph else: (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = training_graph cluster_idx = cluster_idx[0] avg_distance = tf.reduce_mean(scores) init_vars = tf.global_variables_initializer() sess=tf.Session() sess.run(init_vars, feed_dict={X: full_data_x}) sess.run(init_op, feed_dict={X: full_data_x}) for i in range(1, num_steps+1): _, d, idx = sess.run( [train_op, avg_distance, cluster_idx], feed_dict={X: full_data_x}) if i % 10 == 0 or i == 1: print("Step %i, Avg Distance: %f" % (i, d)) counts = np.zeros(shape=(k, num_classes)) for i in range(len(idx)): counts[idx[i]] += mnist.train.labels[i] labels_map = [np.argmax(c) for c in counts] labels_map = tf.convert_to_tensor(labels_map) cluter_label = tf.nn.embedding_lookup(labels_map, cluster_idx) correct_prediction = tf.equal( cluter_label, tf.cast(tf.argmax(Y, 1), tf.int32)) accuracy_op = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) test_x, test_y = mnist.test.images, mnist.test.labels print("Test Accucaty", sess.run(accuracy_op, feed_dict={X: test_x, Y: test_y}))
def build_kmeans_model(inputs, params): imgs = inputs["samples"] kmeans_model = KMeans(inputs=imgs, num_clusters=params.k, distance_metric='cosine', use_mini_batch=False, mini_batch_steps_per_iteration=1, initial_clusters='kmeans_plus_plus') # Build KMeans graph training_graph = kmeans_model.training_graph() return training_graph
def init_kmeans(self, num_clusters=25, initial_clusters='kmeans_plus_plus', distance_metric='cosine', use_mini_batch=True, mini_batch_steps_per_iteration=1, random_seed=0, kmeans_plus_plus_num_retries=5, kmc2_chain_length=200): # load saved cluster centers. if self.outputs != None: saver = tf.train.import_meta_graph(self.model_path + '.meta') sess = tf.Session() saver.restore(sess, self.model_path) cluster_centers = sess.run( tf.get_default_graph().get_tensor_by_name(CLUSTERS_VAR_NAME + ':0')) initial_clusters = tf.convert_to_tensor(cluster_centers) sess.close() del sess KMeans.__init__(self, self.kmeans_x, num_clusters, initial_clusters, distance_metric, use_mini_batch, mini_batch_steps_per_iteration, random_seed, kmeans_plus_plus_num_retries, kmc2_chain_length) training_graph = self.training_graph() if len(training_graph) > 6: (all_scores, cluster_index, scores, cluster_centers_initialized, cluster_centers_var, init_op, train_op) = training_graph else: (all_scores, cluster_index, scores, cluster_centers_initialized, init_op, train_op) = training_graph cluster_index = cluster_index[0] avg_distance = tf.reduce_mean(scores) init_vars = tf.global_variables_initializer() self.fetch_kmeans = [train_op, avg_distance, cluster_index, scores] if self.kmeans_session != None: self.kmeans_session.close() del self.kmeans_session self.kmeans_session = tf.Session() self.kmeans_session.run(init_vars, feed_dict={self.kmeans_x: self.inputs}) self.kmeans_session.run(init_op, feed_dict={self.kmeans_x: self.inputs})
def __init__(self, inputs, num_clusters, mini_batch_steps_per_iteration=100): self.num_clusters = tf.convert_to_tensor(num_clusters) self.kmeans = KMeans( inputs, self.num_clusters, use_mini_batch=True, mini_batch_steps_per_iteration=mini_batch_steps_per_iteration) out = self.kmeans.training_graph() self.cluster_centers = tf.get_default_graph().get_tensor_by_name( 'clusters:0') self.all_scores = out[0][0] self.cluster_index = out[1][0] self.scores = out[2][0] self.cluster_centers_initialized = out[3] self.init_op = out[4] self.train_op = out[5]
def _build_nn(self): self.kmeans = KMeans(inputs=self.x, num_clusters=self.k, distance_metric='cosine', use_mini_batch=True) # 构建K-Means的计算图 training_graph = self.kmeans.training_graph() if len(training_graph) > 6: # tensorflow 1.4及以上版本 (all_scores, cluster_idx, scores, cluster_cnters_initialized, cluster_cnters_var, init_op, train_op) = training_graph else: (all_scores, cluster_idx, scores, cluster_cnters_initialized, init_op, train_op) = training_graph self.cluster_idx = cluster_idx[0] # 每个样本的类别,[0, k) self.avg_distance = tf.reduce_mean(scores) self.init_op = init_op self.train_op = train_op
def build_network(self, x_image, num_class): x_image_shape = x_image.get_shape().as_list() x_image = tf.reshape( x_image, [-1, x_image_shape[1] * x_image_shape[2] * x_image_shape[3]]) x = x_image # K-Means 파라미터 x = KMeans(inputs=x, num_clusters=self.k, distance_metric='cosine', use_mini_batch=True) return x
class Clustering: def __init__(self, inputs, num_clusters, mini_batch_steps_per_iteration=100): self.num_clusters = tf.convert_to_tensor(num_clusters) self.kmeans = KMeans( inputs, self.num_clusters, use_mini_batch=True, mini_batch_steps_per_iteration=mini_batch_steps_per_iteration) out = self.kmeans.training_graph() self.cluster_centers = tf.get_default_graph().get_tensor_by_name( 'clusters:0') self.all_scores = out[0][0] self.cluster_index = out[1][0] self.scores = out[2][0] self.cluster_centers_initialized = out[3] self.init_op = out[4] self.train_op = out[5] def lab_to_labels(self, images, name='lab_to_labels'): a = tf.reshape(self.cluster_centers[:, 0], [1, 1, 1, -1]) b = tf.reshape(self.cluster_centers[:, 1], [1, 1, 1, -1]) da = tf.expand_dims(images[:, :, :, 1], 3) - a db = tf.expand_dims(images[:, :, :, 2], 3) - b d = tf.square(da) + tf.square(db) return tf.argmin(d, 3, name=name) def labels_to_lab(self, labels, name='labels_to_lab'): if labels.dtype in [tf.float16, tf.float32, tf.float64]: l = tf.cast(tf.expand_dims(labels, -1), tf.float32) c = tf.reshape(self.cluster_centers, [1, 1, 1, -1, 2]) ab = tf.reduce_sum(l * c, 3) else: ab = tf.gather(self.cluster_centers, labels) l = tf.ones(tf.shape(ab)[:-1], tf.float32) * 75 return tf.concat([tf.expand_dims(l, -1), ab], 3, name=name)
class Model: def __init__(self, args): self.k = args.get('k', 10) self.num_classes = args.get('num_classes', 10) self.num_features = args.get('num_features', 784) self._add_op() self.device = '/gpu:0' if args['gpu'] >= 0 else '/cpu:0' with tf.device(self.device): self._build_nn() def _add_op(self): self.x = tf.placeholder(tf.float32, shape=[None, self.num_features]) self.y = tf.placeholder(tf.float32, shape=[None, self.num_classes]) def _build_nn(self): self.kmeans = KMeans(inputs=self.x, num_clusters=self.k, distance_metric='cosine', use_mini_batch=True) # 构建K-Means的计算图 training_graph = self.kmeans.training_graph() if len(training_graph) > 6: # tensorflow 1.4及以上版本 (all_scores, cluster_idx, scores, cluster_cnters_initialized, cluster_cnters_var, init_op, train_op) = training_graph else: (all_scores, cluster_idx, scores, cluster_cnters_initialized, init_op, train_op) = training_graph self.cluster_idx = cluster_idx[0] # 每个样本的类别,[0, k) self.avg_distance = tf.reduce_mean(scores) self.init_op = init_op self.train_op = train_op
mnist = input_data.read_data_sets("/tmp/data", one_hot=True) full_data_x = mnist.train.images #Params steps = 50 #total steps batch_size = 1024 #sample per batch k = 25 #nmber of clsters num_classes = 10 #digits num_features = 784 # each image si 28x28 #Inpt images X = tf.placeholder(tf.float32, shape=[None, num_features]) Y = tf.placeholder(tf.float32, shape=[None, num_classes]) kMeans = KMeans(inputs=X, num_clusters=k, distance_metric='cosine', use_mini_batch=True) # Build KMeans graph (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = kMeans.training_graph() cluster_idx = cluster_idx[0] # fix for cluster_idx being a tuple avg_distance = tf.reduce_mean(scores) # Initialize the variables (i.e. assign their default value) init_vars = tf.global_variables_initializer() # Start TensorFlow session sess = tf.Session() # Run the initializer
def run(): # 忽略所有的 GPU, 因为随机森林不会从中受益 os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"] = "-1" # 使用mnist数据 mnist = input_data.read_data_sets("/tmp/data/", one_hot=True) full_data_x = mnist.train.images # 设置超参数 # num_steps 训练次数 # batch_size 每次训练用的数据集大小 # k 分类的数量 # num_classes 类的数量 # num_features 特征的数量 num_steps = 50 batch_size = 1024 k = 25 num_classes = 10 num_features = 784 # 定义输入数据 X = tf.placeholder(tf.float32, shape=[None, num_features]) # 定义标签 Y = tf.placeholder(tf.float32, shape=[None, num_classes]) # 利用 Tensorflow 提供的KMeans来进行计算 # KMeans(inputs, 输入张量或者张量列表 # num_clusters, 一个整数张量,指定簇的数量 # initial_clusters=RANDOM_INIT, 指定初始化期间使用的集群。 # distance_metric=SQUARED_EUCLIDEAN_DISTANCE, 用于聚类的距离度量。 支持的选项:“平方欧几里得”,“余弦”。 # use_mini_batch=False, 如果为true,请使用小批量k-means算法。 否则假设使用完整批次。 # mini_batch_steps_per_iteration=1, 更新后的簇中心同步到主副本的最小步数 # random_seed=0, PRNG的种子用于初始化种子 # kmeans_plus_plus_num_retries=2, 对于在kmeans ++初始化期间采样的每个点, # 此参数指定在选择最佳值之前从当前分布中绘制的附加点的数量。 # 如果指定负值,则使用启发式对O(log(num_to_sample))个附加点进行采样。 # kmc2_chain_length=200) 确定k-MC2算法使用多少个候选点来生成一个新的聚类中心。 # 如果(小)批次包含较少的点,则从(小)批次生成一个新的集群中心。 kmeans = KMeans(inputs=X, num_clusters=k, distance_metric='cosine', use_mini_batch=True) # 建立 KMeans 计算图 (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = kmeans.training_graph() cluster_idx = cluster_idx[0] avg_distance = tf.reduce_mean(scores) # 初始化所有变量 init_vars = tf.global_variables_initializer() # 获取计算图 sess = tf.Session() # 初始化变量 sess.run(init_vars, feed_dict={X: full_data_x}) sess.run(init_op, feed_dict={X: full_data_x}) # 训练 for i in range(1, num_steps + 1): _, d, idx = sess.run([train_op, avg_distance, cluster_idx], feed_dict={X: full_data_x}) if i % 10 == 0 or i == 1: print("步数 %i, 平均距离: %f" % (i, d)) # 给每个中心分配标签 # 使用每次训练的标签计算每个中心心的标签总数 # 把样本分配到他们最近的中心 counts = np.zeros(shape=(k, num_classes)) for i in range(len(idx)): counts[idx[i]] += mnist.train.labels[i] # 将最频率最高的标签分配给中心 labels_map = [np.argmax(c) for c in counts] labels_map = tf.convert_to_tensor(labels_map) # 评价模型 cluster_label = tf.nn.embedding_lookup(labels_map, cluster_idx) # 计算准确性 correct_prediction = tf.equal(cluster_label, tf.cast(tf.argmax(Y, 1), tf.int32)) accuracy_op = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # 测试数据 test_x, test_y = mnist.test.images, mnist.test.labels print("在测试集上的准确率:", sess.run(accuracy_op, feed_dict={ X: test_x, Y: test_y })) return
#parameters epochs = 50 batch_size = 64 #give batch size depends upon the Memory capacity your system does num_clusters = 10 num_classes = 10 num_features = 784 with tf.name_scope("Input_Features"): x = tf.placeholder(tf.float32, shape=[None, num_features], name="Input") y_ = tf.placeholder(tf.float32, shape=[None, num_classes], name="Output") #kmeans with tf.name_scope("KMeans_Architecture"): Kmeans = KMeans(inputs=x, num_clusters=num_clusters, distance_metric='cosine', use_mini_batch=True) #Building a graph training_graph = Kmeans.training_graph() if len(training_graph) > 6: (all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_center_var, init_op, train_op) = training_graph else: (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = training_graph cluster_idx = cluster_idx[0] avg_distance = tf.reduce_mean(scores)
full_data_x = mnist.train.images # Parameters num_steps = 50 # Total steps to train batch_size = 1024 # The number of samples per batch k = 25 # The number of clusters num_classes = 10 # The 10 digits num_features = 784 # Each image is 28x28 pixels # Input images X = tf.placeholder(tf.float32, shape=[None, num_features]) # Labels (for assigning a label to a centroid and testing) Y = tf.placeholder(tf.float32, shape=[None, num_classes]) # K-Means Parameters kmeans = KMeans(inputs=X, num_clusters=k, distance_metric='cosine', use_mini_batch=True) # Build KMeans graph (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = kmeans.training_graph() cluster_idx = cluster_idx[0] # fix for cluster_idx being a tuple avg_distance = tf.reduce_mean(scores) # Initialize the variables (i.e. assign their default value) init_vars = tf.global_variables_initializer() # Start TensorFlow session sess = tf.Session() # Run the initializer sess.run(init_vars, feed_dict={X: full_data_x})
data_ = load_data() X_train, Y_train, X_test,Y_test = data_.return_data() #Resturn one hot batch_size = 32 epoch = 30 #Increase epoch n_class =10 n_feature = X_train.shape[1] #Input Images X_data = tf.placeholder(shape=[None,n_feature],dtype=tf.float32) Y_data = tf.placeholder(shape =[None,n_class],dtype=tf.float32) #Kmeans kmeans_ = KMeans(inputs=X_data,num_clusters=n_class,use_mini_batch=True, distance_metric='cosine') (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op,train_op)=kmeans_.training_graph() avg_distance = tf.reduce_mean(scores) #Intra clusters init_vars = tf.global_variables_initializer() sess = tf.Session() sess.run(init_vars,feed_dict={X_data:X_train}) sess.run(init_op,feed_dict={X_data:X_train})#Graph init #Epoch for i in range(epoch): _,avg_d = sess.run([train_op,avg_distance],feed_dict={X_data:X_train}) if i % 5 ==0:
# x = self.fc3(x) # return x # # # model = Network() # # 通过 build 函数完成内部张量的创建,其中 4 为任意的 batch 数量,9 为输入特征长度 # model.build(input_shape=(4, 8)) # model.summary() # 打印网络信息 # # 创建优化器,指定学习率 # optimizer = tf.keras.optimizers.RMSprop(0.001) # # # 网络训练部分。通过 Epoch 和 Step 的双层循环训练网络,共训练 200 个 epoch: # for epoch in range(200): # 200 个 Epoch # for step, (x, y) in enumerate(train_db): # 遍历一次训练集 # # 梯度记录器 # with tf.GradientTape() as tape: # out = model(x) # 通过网络获得输出 # loss = tf.reduce_mean(keras.losses.MSE(y, out)) # 计算 MSE # mae_loss = tf.reduce_mean(keras.losses.MAE(y, out)) # 计算 MAE # # if step % 10 == 0: # print(epoch, step, float(loss)) # # # 计算梯度 并更新 # grads = tape.gradient(loss, model.trainable_variables) # optimizer.apply_gradients(zip(grads, model.trainable_variables)) # vector=tf.constant() kmeans = KMeans(n_clusters=2, random_state=0) kmeans.fit(dataset) print(kmeans.labels_)
def train(): # args = parser.parse_args() args = FLAGS training_readout_layer = args.training_readout_layer testing_readout_layer = args.testing_readout_layer LOG_FREQUENCY = args.test_frequency global condition_1, condition_2, condition_3, condition_4 condition_1 = False condition_2 = False condition_3 = False condition_4 = False if not os.path.exists("./checkpoints"): os.mkdir("./checkpoints") # feed dictionary for dataSetOne def feed_dict(train, i): if train: xs, ys = dataSetTrain.next_batch(FLAGS.batch_size) k_h = FLAGS.dropout_hidden k_i = FLAGS.dropout_input else: xs, ys = dataSetTest.images, dataSetTest.labels k_h = 1.0 k_i = 1.0 return { x: xs, y_: ys, global_step: i, keep_prob_input: k_i, keep_prob_hidden: k_h } def feed_dict_test(train, i, batch_size): if train: xs, ys = dataSetTrain.next_batch(batch_size) k_h = FLAGS.dropout_hidden k_i = FLAGS.dropout_input else: xs, ys = dataSetTest.next_batch(batch_size) k_h = 1.0 k_i = 1.0 return { x: xs, y_: ys, global_step: i, keep_prob_input: k_i, keep_prob_hidden: k_h } # weights initialization def weight_variable(shape, stddev, name="W"): initial = tf.truncated_normal(shape, stddev=stddev) return tf.Variable(initial, name=name) # biases initialization def bias_variable(shape, name="b"): initial = tf.zeros(shape) return tf.Variable(initial, name=name) # define a fully connected layer def fc_layer(input, channels_in, channels_out, stddev, name='fc'): with tf.name_scope(name): with tf.name_scope('weights'): W = weight_variable([channels_in, channels_out], stddev) with tf.name_scope('biases'): b = bias_variable([channels_out]) act = tf.nn.relu(tf.matmul(input, W) + b) tf.summary.histogram("weights", W) tf.summary.histogram("biases", b) tf.summary.histogram("activation", act) return act # define a sotfmax linear classification layer def softmax_linear(input, channels_in, channels_out, stddev, name='read'): with tf.name_scope(name): with tf.name_scope('weights'): W = weight_variable([channels_in, channels_out], stddev, name="WMATRIX") wdict[W] = W with tf.name_scope('biases'): b = bias_variable([channels_out], name="bias") act = tf.matmul(input, W) + b tf.summary.histogram("weights", W) tf.summary.histogram("biases", b) tf.summary.histogram("activation", act) return act # Start an Interactive session config = tf.ConfigProto() config.gpu_options.allow_growth = True config.log_device_placement = False # sess = tf.Session(config=config) sess = tf.InteractiveSession(config=config) # Placeholder for input variables with tf.name_scope('input'): x = tf.placeholder(tf.float32, shape=[None, 784], name='x') y_ = tf.placeholder(tf.float32, shape=[None, 10], name='labels') global global_step global_step = tf.placeholder(tf.float32, shape=[], name="step") # apply dropout to the input layer keep_prob_input = tf.placeholder(tf.float32) tf.summary.scalar('dropout_input', keep_prob_input) x_drop = tf.nn.dropout(x, keep_prob_input) # Create the first hidden layer h_fc1 = fc_layer(x_drop, IMAGE_PIXELS, FLAGS.hidden1, 1.0 / math.sqrt(float(IMAGE_PIXELS)), 'h_fc1') # Apply dropout to first hidden layer keep_prob_hidden = tf.placeholder(tf.float32) tf.summary.scalar('dropout_hidden', keep_prob_hidden) h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob_hidden) # Create the second hidden layer h_fc2 = fc_layer(h_fc1_drop, FLAGS.hidden1, FLAGS.hidden2, 1.0 / math.sqrt(float(FLAGS.hidden1)), 'h_fc2') # Apply dropout to second hidden layer h_fc2_drop = tf.nn.dropout(h_fc2, keep_prob_hidden) # Create a softmax linear classification layer for the outputs if FLAGS.hidden3 == -1: logits_tr1 = softmax_linear(h_fc2_drop, FLAGS.hidden2, NUM_CLASSES, 1.0 / math.sqrt(float(FLAGS.hidden2)), 'softmax_linear_tr1') logits_tr2 = softmax_linear(h_fc2_drop, FLAGS.hidden2, NUM_CLASSES, 1.0 / math.sqrt(float(FLAGS.hidden2)), 'softmax_linear_tr2') logits_tr3 = softmax_linear(h_fc2_drop, FLAGS.hidden2, NUM_CLASSES, 1.0 / math.sqrt(float(FLAGS.hidden2)), 'softmax_linear_tr3') logits_tr4 = softmax_linear(h_fc2_drop, FLAGS.hidden2, NUM_CLASSES, 1.0 / math.sqrt(float(FLAGS.hidden2)), 'softmax_linear_tr4') else: h_fc3 = fc_layer(h_fc2_drop, FLAGS.hidden2, FLAGS.hidden3, 1.0 / math.sqrt(float(FLAGS.hidden3)), 'h_fc3') # Apply dropout to third hidden layer h_fc3_drop = tf.nn.dropout(h_fc3, keep_prob_hidden) logits_tr1 = softmax_linear(h_fc3_drop, FLAGS.hidden3, NUM_CLASSES, 1.0 / math.sqrt(float(FLAGS.hidden3)), 'softmax_linear_tr1') logits_tr2 = softmax_linear(h_fc3_drop, FLAGS.hidden3, NUM_CLASSES, 1.0 / math.sqrt(float(FLAGS.hidden3)), 'softmax_linear_tr2') logits_tr3 = softmax_linear(h_fc3_drop, FLAGS.hidden3, NUM_CLASSES, 1.0 / math.sqrt(float(FLAGS.hidden3)), 'softmax_linear_tr3') logits_tr4 = softmax_linear(h_fc3_drop, FLAGS.hidden3, NUM_CLASSES, 1.0 / math.sqrt(float(FLAGS.hidden3)), 'softmax_linear_tr4') logitsAll = logits_tr1 + logits_tr2 + logits_tr3 + logits_tr4 # Define the loss model as a cross entropy with softmax layer 1 with tf.name_scope('cross_entropy_tr1'): diff_tr1 = tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=logits_tr1) with tf.name_scope('total_tr1'): cross_entropy_tr1 = tf.reduce_mean(diff_tr1) # tf.summary.scalar('cross_entropy_tr1', cross_entropy_tr1) # Define the loss model as a cross entropy with softmax layer 2 with tf.name_scope('cross_entropy_tr2'): diff_tr2 = tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=logits_tr2) with tf.name_scope('total_tr2'): cross_entropy_tr2 = tf.reduce_mean(diff_tr2) # tf.summary.scalar('cross_entropy_tr2', cross_entropy_tr2) # Define the loss model as a cross entropy with softmax layer 3 with tf.name_scope('cross_entropy_tr3'): diff_tr3 = tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=logits_tr3) with tf.name_scope('total_tr3'): cross_entropy_tr3 = tf.reduce_mean(diff_tr3) # tf.summary.scalar('cross_entropy_tr3', cross_entropy_tr3) # Define the loss model as a cross entropy with softmax layer 4 with tf.name_scope('cross_entropy_tr4'): diff_tr4 = tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=logits_tr4) with tf.name_scope('total_tr4'): cross_entropy_tr4 = tf.reduce_mean(diff_tr4) # tf.summary.scalar('cross_entropy_tr4', cross_entropy_tr4) # Use Gradient descent optimizer for training steps and minimize x-entropy # decaying learning rate tickles a few more 0.1% out of the algorithm with tf.name_scope('train_tr1'): lr = tf.train.exponential_decay(FLAGS.learning_rate, global_step, FLAGS.decayStep, FLAGS.decayFactor, staircase=True) train_step_tr1 = tf.train.MomentumOptimizer( learning_rate=lr, momentum=0.99).minimize(cross_entropy_tr1) with tf.name_scope('train_tr2'): lr = tf.train.exponential_decay(FLAGS.learning_rate, global_step, FLAGS.decayStep, FLAGS.decayFactor, staircase=True) train_step_tr2 = tf.train.MomentumOptimizer( learning_rate=lr, momentum=0.99).minimize(cross_entropy_tr2) with tf.name_scope('train_tr3'): lr = tf.train.exponential_decay(FLAGS.learning_rate, global_step, FLAGS.decayStep, FLAGS.decayFactor, staircase=True) train_step_tr3 = tf.train.MomentumOptimizer( learning_rate=lr, momentum=0.99).minimize(cross_entropy_tr3) with tf.name_scope('train_tr4'): lr = tf.train.exponential_decay(FLAGS.learning_rate, global_step, FLAGS.decayStep, FLAGS.decayFactor, staircase=True) train_step_tr4 = tf.train.MomentumOptimizer( learning_rate=lr, momentum=0.99).minimize(cross_entropy_tr4) # Compute correct prediction and accuracy with tf.name_scope('accuracy_tr1'): with tf.name_scope('correct_prediction_tr1'): correct_prediction_tr1 = tf.equal(tf.argmax(logits_tr1, 1), tf.argmax(y_, 1)) with tf.name_scope('accuracy_tr1'): accuracy_tr1 = tf.reduce_mean( tf.cast(correct_prediction_tr1, tf.float32)) tf.summary.scalar('accuracy_tr1', accuracy_tr1) # Compute correct prediction and accuracy with tf.name_scope('accuracy_tr2'): with tf.name_scope('correct_prediction_tr2'): correct_prediction_tr2 = tf.equal(tf.argmax(logits_tr2, 1), tf.argmax(y_, 1)) with tf.name_scope('accuracy_tr2'): accuracy_tr2 = tf.reduce_mean( tf.cast(correct_prediction_tr2, tf.float32)) tf.summary.scalar('accuracy_tr2', accuracy_tr2) # Compute correct prediction and accuracy with tf.name_scope('accuracy_tr3'): with tf.name_scope('correct_prediction_tr3'): correct_prediction_tr3 = tf.equal(tf.argmax(logits_tr3, 1), tf.argmax(y_, 1)) with tf.name_scope('accuracy_tr3'): accuracy_tr3 = tf.reduce_mean( tf.cast(correct_prediction_tr3, tf.float32)) tf.summary.scalar('accuracy_tr3', accuracy_tr3) # Compute correct prediction and accuracy with tf.name_scope('accuracy_tr4'): with tf.name_scope('correct_prediction_tr4'): correct_prediction_tr4 = tf.equal(tf.argmax(logits_tr4, 1), tf.argmax(y_, 1)) with tf.name_scope('accuracy_tr4'): accuracy_tr4 = tf.reduce_mean( tf.cast(correct_prediction_tr4, tf.float32)) tf.summary.scalar('accuracy_tr4', accuracy_tr4) # Compute correct prediction and accuracy with tf.name_scope('accuracy_trAll'): with tf.name_scope('correct_prediction_trAll'): correct_prediction_trAll = tf.equal(tf.argmax(logitsAll, 1), tf.argmax(y_, 1)) with tf.name_scope('accuracy_trAll'): accuracy_trAll = tf.reduce_mean( tf.cast(correct_prediction_trAll, tf.float32)) tf.summary.scalar('accuracy_trAll', accuracy_trAll) # K-means kmeans_tr1 = KMeans( inputs=x, num_clusters=500, #distance_metric=SQUARED_EUCLIDEAN_DISTANCE, use_mini_batch=False) kmeans_tr2 = KMeans( inputs=x, num_clusters=500, #distance_metric=SQUARED_EUCLIDEAN_DISTANCE, use_mini_batch=False) kmeans_tr3 = KMeans( inputs=x, num_clusters=500, #distance_metric=SQUARED_EUCLIDEAN_DISTANCE, use_mini_batch=False) kmeans_tr4 = KMeans( inputs=x, num_clusters=500, #distance_metric=SQUARED_EUCLIDEAN_DISTANCE, use_mini_batch=False) # Build KMeans graph (all_scores_tr1, cluster_idx_tr1, scores_tr1, cluster_centers_initialized_tr1, cluster_centers_var_tr1, init_op_tr1, train_op_tr1) = kmeans_tr1.training_graph() (all_scores_tr2, cluster_idx_tr2, scores_tr2, cluster_centers_initialized_tr2, cluster_centers_var_tr2, init_op_tr2, train_op_tr2) = kmeans_tr2.training_graph() (all_scores_tr3, cluster_idx_tr3, scores_tr3, cluster_centers_initialized_tr3, cluster_centers_var_tr3, init_op_tr3, train_op_tr3) = kmeans_tr3.training_graph() (all_scores_tr4, cluster_idx_tr4, scores_tr4, cluster_centers_initialized_tr4, cluster_centers_var_tr4, init_op_tr4, train_op_tr4) = kmeans_tr4.training_graph() init_graph_1 = tf.placeholder(tf.bool, name="init_graph_1") init_graph_2 = tf.placeholder(tf.bool, name="init_graph_2") init_graph_3 = tf.placeholder(tf.bool, name="init_graph_3") init_graph_4 = tf.placeholder(tf.bool, name="init_graph_4") with tf.name_scope('test_score_tr1'): # minimum_dist_tr1 = tf.reduce_min(tf.reduce_sum(tf.square(tf.subtract(cluster_centers_var_tr1, x)), axis=1)) minimum_dist_tr1 = tf.cond( init_graph_1, lambda: tf.reduce_min( tf.reduce_sum(tf.square(tf.subtract(cluster_centers_var_tr1, x) ), axis=1)), lambda: tf.reduce_max(x) * 1000) with tf.name_scope('test_score_tr2'): minimum_dist_tr2 = tf.cond( init_graph_2, lambda: tf.reduce_min( tf.reduce_sum(tf.square(tf.subtract(cluster_centers_var_tr2, x) ), axis=1)), lambda: tf.reduce_max(x) * 1000) with tf.name_scope('test_score_tr3'): minimum_dist_tr3 = tf.cond( init_graph_3, lambda: tf.reduce_min( tf.reduce_sum(tf.square(tf.subtract(cluster_centers_var_tr3, x) ), axis=1)), lambda: tf.reduce_max(x) * 1000) with tf.name_scope('test_score_tr4'): minimum_dist_tr4 = tf.cond( init_graph_4, lambda: tf.reduce_min( tf.reduce_sum(tf.square(tf.subtract(cluster_centers_var_tr4, x) ), axis=1)), lambda: tf.reduce_max(x) * 1000) # Merge all summaries and write them out to /tmp/tensorflow/mnist/logs # different writers are used to separate test accuracy from train accuracy # also a writer is implemented to observe CF after we trained on both sets merged = tf.summary.merge_all() saver = tf.train.Saver(var_list=None) # Initialize all global variables or load model from pre-saved checkpoints # Open csv file for append when model is loaded, otherwise new file is created. if args.load_model: print('\nLoading Model: ', args.load_model) ckpt = tf.train.get_checkpoint_state( checkpoint_dir=args.checkpoints_dir, latest_filename=args.load_model) saver.restore(sess=sess, save_path=args.checkpoints_dir + args.load_model + '.ckpt') else: tf.global_variables_initializer().run() writer = csv.writer(open(FLAGS.plot_file, "wb")) with tf.name_scope("training"): print('\n\nTraining on given Dataset...') print('____________________________________________________________') print(time.strftime('%X %x %Z')) # train cluster for given training set nrStepsForClustering = 1 if training_readout_layer is 1: sess.run(init_op_tr1, feed_dict={x: dataSetTrain.images}) for i in range(0, nrStepsForClustering): _ = sess.run(train_op_tr1, feed_dict={x: dataSetTrain.images}) elif training_readout_layer is 2: sess.run(init_op_tr2, feed_dict={x: dataSetTrain.images}) for i in range(0, nrStepsForClustering): _ = sess.run(train_op_tr2, feed_dict={x: dataSetTrain.images}) elif training_readout_layer is 3: sess.run(init_op_tr3, feed_dict={x: dataSetTrain.images}) for i in range(0, nrStepsForClustering): _ = sess.run(train_op_tr3, feed_dict={x: dataSetTrain.images}) elif training_readout_layer is 4: sess.run(init_op_tr4, feed_dict={x: dataSetTrain.images}) for i in range(0, nrStepsForClustering): _ = sess.run(train_op_tr4, feed_dict(True, i)) print("Trained clustering!") condition_1 = tf.get_default_graph().get_tensor_by_name( "initialized:0").eval() condition_2 = tf.get_default_graph().get_tensor_by_name( "initialized_1:0").eval() condition_3 = tf.get_default_graph().get_tensor_by_name( "initialized_2:0").eval() condition_4 = tf.get_default_graph().get_tensor_by_name( "initialized_3:0").eval() print(condition_1, "\n\n", condition_2, "\n\n", condition_3, "\n\n", condition_4) # get readout layer by testing trained clusters # for i in range(0, 10): # xs, ys = dataSetTest.next_batch(1) # score_tr1, score_tr2, score_tr3, score_tr4 = sess.run( # [minimum_dist_tr1, minimum_dist_tr2, minimum_dist_tr3, minimum_dist_tr4], # feed_dict={x: xs, init_graph_1: condition_1, init_graph_2: condition_2, init_graph_3: condition_3, # init_graph_4: condition_4}) # print("readout layer for %s is %s " % ( # np.argmax(ys), (np.argmin([score_tr1, score_tr2, score_tr3, score_tr4]) + 1))) # Training for NN for i in range(FLAGS.start_at_step, FLAGS.max_steps + FLAGS.start_at_step): #print ("Training at step",i) if i % LOG_FREQUENCY == 0: # record summaries & test-set accuracy every 5 steps cumm_acc = 0 total_steps = dataSetTest.images.shape[0] / 50 dsClass = np.array([0., 0., 0., 0.]) for xx in range(0, int(total_steps)): idx = random.randint(1, dataSetTest.images.shape[0]) - 1 xs = dataSetTest.images[np.newaxis, idx] ys = dataSetTest.labels[np.newaxis, idx] #xs, ys = dataSetTest.next_batch(1) k_h = 1.0 k_i = 1.0 score_tr1, score_tr2, score_tr3, score_tr4 = sess.run( [ minimum_dist_tr1, minimum_dist_tr2, minimum_dist_tr3, minimum_dist_tr4 ], feed_dict={ x: xs, init_graph_1: condition_1, init_graph_2: condition_2, init_graph_3: condition_3, init_graph_4: condition_4 }) readout_layer = (np.argmin( [score_tr1, score_tr2, score_tr3, score_tr4]) + 1) dsClass[readout_layer - 1] += 1 if readout_layer == 1: l, s, acc = sess.run( [logits_tr1, merged, accuracy_tr1], feed_dict={ x: xs, y_: ys, keep_prob_input: k_i, keep_prob_hidden: k_h, global_step: i }) elif readout_layer == 2: l, s, acc = sess.run( [logits_tr2, merged, accuracy_tr2], feed_dict={ x: xs, y_: ys, keep_prob_input: k_i, keep_prob_hidden: k_h, global_step: i }) elif readout_layer == 3: l, s, acc = sess.run( [logits_tr3, merged, accuracy_tr3], feed_dict={ x: xs, y_: ys, keep_prob_input: k_i, keep_prob_hidden: k_h, global_step: i }) elif readout_layer == 4: l, s, acc = sess.run( [logits_tr4, merged, accuracy_tr4], feed_dict={ x: xs, y_: ys, keep_prob_input: k_i, keep_prob_hidden: k_h, global_step: i }) else: print("PROBLEM:::!") #print("readout layer for %s is %s " % (np.argmax(ys), readout_layer), acc,l.argmax()) cumm_acc = cumm_acc + acc # test_writer_ds.add_summary(s, i) average_accu = cumm_acc / float(total_steps) print( 'test set 1 accuracy at step: %s \t \t %s' % (i, average_accu), "D1D2 acc=", dsClass / dsClass.sum()) writer.writerow([i, average_accu]) else: # record train set summaries, and run training steps if training_readout_layer is 1: s, _ = sess.run([merged, train_step_tr1], feed_dict_test(True, i, 100)) elif training_readout_layer is 2: s, _ = sess.run([merged, train_step_tr2], feed_dict_test(True, i, 100)) elif training_readout_layer is 3: s, _ = sess.run([merged, train_step_tr3], feed_dict_test(True, i, 100)) elif training_readout_layer is 4: s, _ = sess.run([merged, train_step_tr4], feed_dict_test(True, i, 100)) if args.save_model: saver.save(sess=sess, save_path=args.checkpoints_dir + args.save_model + '.ckpt')
# print(data_y.shape) # parameters class_num = 3 feature_num = 4 train_steps = 50 # one-hot encoding data_y = np.reshape(data_y, (data_y.shape[0], 1)) data_y_onehot = np.ndarray((data_y.shape[0], 3), dtype=np.int32) # print(data_y_onehot.shape) for i in range(data_y_onehot.shape[0]): data_y_onehot[i, :] = one_hot_encoding(data_y[i, :], 3) # print(data_y_onehot.shape) # split data from sklearn.cross_validation import train_test_split train_x, test_x, train_y, test_y = train_test_split(data_x, data_y, test_size=0.3) # Graph graph = tf.Graph() with graph.as_default(): x_input = tf.placeholder(tf.float32, shape=[None, feature_num]) y_input = tf.placeholder(tf.int32, shape=[None, class_num]) # Model model = KMeans(inputs=x_input, num_clusters=class_num)
# Parameters num_steps = 2 # Total steps to train batch_size = 1024 # The number of samples per batch k = 25 # The number of clusters num_classes = 10 # The 10 digits num_features = 784 # Each image is 28x28 pixels # Input images X = tf.placeholder(tf.float32, shape=[None, num_features]) # Labels (for assigning a label to a centroid and testing) Y = tf.placeholder(tf.float32, shape=[None, num_classes]) # K-Means Parameters kmeans = KMeans(inputs=X, num_clusters=k, distance_metric="cosine", use_mini_batch=True) # Build KMeans graph training_graph = kmeans.training_graph() if len(training_graph) > 6: # Tensorflow 1.4+ ( all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_centers_var, init_op, train_op, ) = training_graph
mnist = input_data.read_data_sets("E:\data", one_hot=True) full_data = mnist.train.images # 设置模型参数 num_steps = 300 batch_size = 1024 k = 10 num_classes = 10 num_feature = 784 # 定义输入输出占位符 x = tf.placeholder(tf.float32, shape=[None, num_feature], name='input_x') y = tf.placeholder(tf.float32, shape=[None, num_classes], name='output_y') # 使用kmeans函数定义模型 kmeans = KMeans(inputs=x, num_clusters=k, distance_metric='cosine', use_mini_batch=True) pdb.set_trace() # 创建 Kmeans 图 (all_source, cluster_idx, scores, cluster_center_initialized, ini_op, train_op) = kmeans.training_graph() # cluster_idx = cluster_idx[0] avg_distance = tf.reduce_mean(scores) init_op = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init_op) sess.run(ini_op, feed_dict={x: full_data})
full_data_x = mnist.train.images # Parameters num_steps = 50 # Total steps to train batch_size = 1024 # The number of samples per batch k = 25 # The number of clusters num_classes = 10 # The 10 digits num_features = 784 # Each image is 28x28 pixels # Input images X = tf.placeholder(tf.float32, shape=[None, num_features]) # Labels (for assigning a label to a centroid and testing) Y = tf.placeholder(tf.float32, shape=[None, num_classes]) # K-Means Parameters kmeans = KMeans(inputs=X, num_clusters=k, distance_metric='cosine', use_mini_batch=True) # Build KMeans graph training_graph = kmeans.training_graph() if len(training_graph) > 6: # Tensorflow 1.4+ (all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_centers_var, init_op, train_op) = training_graph else: (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = training_graph cluster_idx = cluster_idx[0] # fix for cluster_idx being a tuple avg_distance = tf.reduce_mean(scores) # Initialize the variables (i.e. assign their default value)
mnist = input_data.read_data_sets('./tmp/data/', one_hot=True) full_data_x = mnist.train.images print(full_data_x.shape) # (55000, 784) num_steps = 200 batch_size = 1000 k = 50 num_classes = 10 # 출력 레이블 수 num_features = 784 # 입력 feature 수 x = tf.placeholder(tf.float32, shape=[None, num_features]) y = tf.placeholder(tf.float32, shape=[None, num_classes]) kmodel = KMeans(inputs=x, num_clusters=k, distance_metric='cosine', use_mini_batch=True) training_graph = kmodel.training_graph() (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = training_graph print('cluster_idx : ', cluster_idx) print('cluster_idx[0] : ', cluster_idx[0]) cluster_idx = cluster_idx[0] print('cluster_idx : ', cluster_idx) avg_distance = tf.reduce_mean(scores) sess = tf.Session() sess.run(tf.global_variables_initializer()) sess.run(init_op, feed_dict={x: full_data_x})
numb_steps = 50 # Number of training steps batch_size = 1024 # batch size k = 25 # number of clusters number_classes = 10 numb_features = data.shape[1] input_images = tf.placeholder(tf.float32, shape=[None, numb_features ]) # Input Images to the model input_labels = tf.placeholder(tf.float32, shape=[None, number_classes ]) # Input labels to the model # Kmeans Instance created kmeans = KMeans(inputs=input_images, num_clusters=k, distance_metric='cosine', use_mini_batch=True) #Build Kmeans graph training_graph = kmeans.training_graph() (all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_centers_var, init_op, training_op) = training_graph #print(len(cluster_idx), len(cluster_idx[0])) cluster_idx = cluster_idx[0] avg_distance = tf.reduce_mean(scores) # Initiliaze the variables (i.e. assign there default value) init_vars = tf.global_variables_initializer()
def run_k_means(num_steps=num_steps, k=None, num_classes=None, num_features=num_features, keep_session=True): (new_X_num, num_map, new_y_num, max_t_s_num, num_student, orig_new_X_num, orig_new_y) = get_processed_data() if k is None: k = num_student print('Choosing {} clusters for {} students, {} samples'.format( k, num_student, len(new_y_num))) if num_classes is None: num_classes = num_student full_data_x = np.asarray(new_X_num) # Input X = tf.placeholder(tf.float32, shape=[None, num_features]) # Labels (for assigning a label to a centroid and testing) y = tf.placeholder(tf.float32, shape=[None, num_classes]) # K-Means Parameters kmeans = KMeans(inputs=X, num_clusters=k, distance_metric='squared_euclidean', use_mini_batch=True) # Build KMeans graph training_graph = kmeans.training_graph() if len(training_graph) > 6: # Tensorflow 1.4+ (all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_centers_var, init_op, train_op) = training_graph else: (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = training_graph cluster_idx = cluster_idx[0] # fix for cluster_idx being a tuple avg_distance = tf.reduce_mean(scores) saver = tf.train.Saver() # Start TensorFlow session sess = tf.Session() # Run the initializer sess.run(tf.global_variables_initializer(), feed_dict={X: full_data_x}) sess.run(init_op, feed_dict={X: full_data_x}) one_hot_y = sess.run(tf.one_hot(new_y_num, num_student)) test_one_hot_y = sess.run(tf.one_hot(orig_new_y, num_student)) # Training for i in range(1, num_steps + 1): _, d, idx = sess.run([train_op, avg_distance, cluster_idx], feed_dict={X: full_data_x}) if i % 500 == 0 or i == 1: print("Step %i, Avg Distance: %f" % (i, d)) # Assign a label to each centroid # Count total number of labels per centroid, using the label of each training # sample to their closest centroid (given by 'idx') counts = np.zeros(shape=(k, num_classes)) for i in range(len(idx)): counts[idx[i]] += one_hot_y[i] # Assign the most frequent label to the centroid # labels_map_np = [np.argmax(c) for c in counts] # Different strategy labels_map_np = [ np.random.choice(np.argwhere(c == np.amax(c)).flatten()) for c in counts ] labels_map = tf.convert_to_tensor(labels_map_np) # Evaluation ops # Lookup: centroid_id -> label cluster_label = tf.nn.embedding_lookup(labels_map, cluster_idx) # Compute accuracy correct_prediction = tf.equal(cluster_label, tf.cast(tf.argmax(y, 1), tf.int32)) accuracy_op = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # Test Model test_x, test_y = orig_new_X_num, test_one_hot_y print("Test Accuracy:", sess.run(accuracy_op, feed_dict={ X: test_x, y: test_y })) save_path = saver.save( sess, path.join('data', 'cache', 'kmeans', 'tf_model', 'model.ckpt')) print("Model saved in path: %s" % save_path) save((labels_map_np, k), 'labels_map_np,k', folder=path.join('data', 'cache', 'kmeans')) if not keep_session: sess.close() return k, num_classes, labels_map_np, sess
# PCA降维 pca = PCA(n_components=n) reduced_train_images = pca.fit_transform(train_images) print(len(reduced_train_images), len(reduced_train_images[0]), pca.n_components_) # tf输入输出 tf_in = tf.placeholder(tf.float32, shape=[None, pca.n_components_]) # 输入 tf_out = tf.placeholder(tf.float32, shape=[None, num_labels]) # 输出 # KMeans,注意这是归属在tf下的,产生就会自动加入tf网络 # 距离度量的方式采用余弦距离(余弦相似度) tf_kmeans = KMeans( inputs=tf_in, num_clusters=k, distance_metric='cosine' # 对于没有归一化的使用cos距离比较好,关掉也可以测试 ) (tf_incluster_dis, tf_cluster_id, tf_dis, tf_kmeans_initialized, tf_init_op, tf_train_op) = tf_kmeans.training_graph() # 1.13 tf_cluster_id = tf_cluster_id[0] # 你可以考虑删除,不过会有很神奇的结果 tf_avg_dis = tf.reduce_mean(tf_dis) tf_init_vars = tf.global_variables_initializer() # 准备开始计算 sess = tf.Session() # 初始化网络 sess.run(tf_init_vars, feed_dict={tf_in: reduced_train_images}) sess.run(tf_init_op, feed_dict={tf_in: reduced_train_images}) # init_op在training_graph的输出中
def keeplearning(new_data): #K값 추정을 위해 data_list 파일 불러오기. ofile = open('data_list.tdat', 'rb') ofile_list = pk.load(ofile) #추가된 new_data와 기존의 old file을 합쳐서 저장 if len(new_data) != 0: data_list = new_data + ofile_list else: data_list = ofile_list ofile.close() f = open('data_list.tdat', 'wb') pk.dump(data_list, f) f.close() # data_set = [ # [1,787,24.2,17.7,8.0,5.4,11.7,8.4,1.8,4.0,5.6,2.8,1.3,5.9,3.1], # [2,737,23.6,14.9,11.6,6.5,7.7,6.3,11.3,3.1,3.5,3.1,3.5,2.7,1.9], # [3,754,23.2,11.7,10.9,8.4,10.0,9.1,6.4,4.8,3.3,3.9,4.4,2.4,1.4], # [4,621,24.6,10.8,11.8,11.7,8.2,8.2,4.0,6.2,4.2,5.1,2.5,1.2,1.4], # [5,693,22.8,8.8,12.8,21.4,7.9,5.9,3.1,5.9,3.3,4.6,2.0,0.3,0.8] # ] # data_list = [] # for i in range(0,len(data_set)): # for j in range(2, len(data_set[i])): # data_set[i][j] = data_set[i][j]/10 # for k in range(0,len(data_set)): # for i in range(0, data_set[k][1]): # data = [] # data.append(data_set[k][0]) # for j in range(2, len(data_set[k])): # ans_good = int(data_set[k][1]*data_set[k][j]/100) # ans_bad = data_set[k][1] - ans_good # #numpy 초기하분포를 활용해서 통계청 자료 비복원추출 # target = np.random.hypergeometric(ngood = ans_good, nbad = ans_bad, nsample = 13, size = None) # data.append(target) # data_list.append(data) #파일에 list를 그대로 기록 # f = open('data_list.tdat', 'wb') # pickle.dump(data_list, f) # f.close() #훈련 전에 일단 기존의 체크포인트 삭제 if os.path.isfile('./trained_data.ckpt.data-00000-of-00001'): os.remove('./trained_data.ckpt.data-00000-of-00001') if os.path.isfile('./trained_data.ckpt.index'): os.remove('./trained_data.ckpt.index') if os.path.isfile('./trained_data.ckpt.meta'): os.remove('./trained_data.ckpt.meta') if os.path.isfile('./checkpoint'): os.remove('./checkpoint') #새로운 데이터 훈련 Data_X = data_list k = ut.elbow(data_list) #훈련자료 column의 개수 num_features = 14 X = tf.placeholder(tf.float32, shape=[None, num_features]) kmeans = KMeans(inputs=X, num_clusters=k, distance_metric='squared_euclidean', use_mini_batch=True) (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = kmeans.training_graph() cluster_idx = cluster_idx[0] avg_distance = tf.reduce_mean(scores) saver = tf.train.Saver() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) sess.run(init_op, feed_dict={X: Data_X}) #밥맥이기 for i in range(1, 100): _, d, idx = sess.run([train_op, avg_distance, cluster_idx], feed_dict={X: Data_X}) #훈련된 모델 저장 saver.save(sess, './trained_data.ckpt') print("Trained data save completed.") sess.close()
def kmeans_unsupervised_init(sim_op, templates_var, weights_var): """Initialize a similarity layer using k-means unsupervised learning Initializes the templates using k-means. The function returns two ops. The first is used to initialize the learning and the second should be run iteratively with all the data. Parameters ---------- sim_op : tf.Operation | tf.Tensor the similarity operation (or the tensor which is the output of the similarity) templates_var : tf.Variable the templates variable for this similarity layer weights_var : tf.Variable the weights variable for this similarity layer Returns ------- A tuple (init_op, update_op) where init_op must be executed by a session before using the update op and the update_op is the operation that performs the learning. """ if isinstance(sim_op, tf.Tensor): sim_op = sim_op.op if not sim_op.type == 'Similarity': raise ValueError( 'kmeans_unsupervised_init needs a similarity op, got %s instead' % sim_op.type) assert (isinstance(sim_op, tf.Operation)) name = sim_op.name + '_kmeans_init' with tf.name_scope(name): input_tensor = sim_op.inputs[0] templates_tensor = sim_op.inputs[1] weights_tensor = sim_op.inputs[2] ninstances = templates_tensor.get_shape().as_list()[0] strides = sim_op.get_attr('strides') blocks = sim_op.get_attr('blocks') strides = [1, strides[0], strides[1], 1] blocks = [1, blocks[0], blocks[1], 1] patches = tf.extract_image_patches(tf.transpose( input_tensor, (0, 2, 3, 1)), strides=strides, ksizes=blocks, rates=[1, 1, 1, 1], padding='VALID') _, _, _, ppatch = patches.get_shape().as_list() patches = tf.reshape(patches, [-1, ppatch]) kmeans = KMeans(patches, ninstances, use_mini_batch=True, initial_clusters='kmeans_plus_plus') _, _, _, _, init_op, training_op = kmeans.training_graph() clusters_var = [ v for v in tf.global_variables() if v.name == name + '/' + 'clusters:0' ][0] clusters = clusters_var.op.outputs[0] channels, block_rows, block_cols = templates_tensor.get_shape( ).as_list()[1:] reshaped_clusters = tf.reshape( clusters, (ninstances, block_rows, block_cols, channels)) transposed_clusters = tf.transpose(reshaped_clusters, [0, 3, 1, 2]) with tf.control_dependencies([training_op]): assign1 = tf.assign(templates_var, transposed_clusters) assign2 = tf.assign(weights_var, tf.ones_like(transposed_clusters)) return init_op, tf.group(assign1, assign2, name='kmeans_init_assign')
def main(): data_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data') mnist = input_data.read_data_sets(data_path, one_hot=True) full_data_x = mnist.train.images # total steps to train num_steps = 200 # number of per batch batch_size = 1024 # number of clusters k = 25 # the 10 digits num_classes = 10 # each image is 28*28 pixels num_features = 784 # input images X = tf.placeholder(tf.float32, shape=[None, num_features]) # Lables (for assigning a label to a centroid and testing) Y = tf.placeholder(tf.float32, shape=[None, num_classes]) kmeans = KMeans(inputs=X, num_clusters=k, distance_metric='cosine', use_mini_batch=True) train_graph = kmeans.training_graph() if len(train_graph) > 6: (all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_centers_var, init_op, train_op) = train_graph else: (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op) = train_graph cluster_idx = cluster_idx[0] avg_distance = tf.reduce_mean(scores) with tf.Session() as sess: init = tf.global_variables_initializer() # run the initializer sess.run(init, feed_dict={X: full_data_x}) sess.run(init_op, feed_dict={X: full_data_x}) for i in range(num_steps): _, d, idx = sess.run([train_op, avg_distance, cluster_idx], feed_dict={X: full_data_x}) if i % 10 == 0: print("step {0} avg distance: {1}".format(i, d)) # assign a label to each centroid # count total number of labels per centroid, using the label of each training # sample to their closest centroid counts = np.zeros(shape=(k, num_classes)) for i in range(len(idx)): counts[idx[i]] += mnist.train.labels[i] # assign the most frequent label to the centroid labels_map = [np.argmax(c) for c in counts] labels_map = tf.convert_to_tensor(labels_map) # evaluation ops cluster_label = tf.nn.embedding_lookup(labels_map, cluster_idx) # computer accuracy correct_prediction = tf.equal(cluster_label, tf.cast(tf.argmax(Y, 1), tf.int32)) accuracy_op = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) test_x, test_y = mnist.test.images, mnist.test.labels print('test accuracy : ', sess.run(accuracy_op, feed_dict={ X: test_x, Y: test_y }))
# Parameters num_steps = 50 # Total steps to train batch_size = 1024 # The number of samples per batch k = 25 # The number of clusters num_classes = 10 # The 10 digits num_features = 784 # Each image is 28x28 pixels # Input images X = tf.placeholder(tf.float32, shape=[None, num_features]) # Labels (for assigning a label to a centroid and testing) Y = tf.placeholder(tf.float32, shape=[None, num_classes]) # K-Means Parameters kmeans = KMeans(inputs=X, num_clusters=k, distance_metric='cosine', use_mini_batch=True) # Build KMeans graph (all_scores, cluster_idx, scores, cluster_centers_initialized, cluster_centers_vars, init_op, train_op) = kmeans.training_graph() cluster_idx = cluster_idx[0] # fix for cluster_idx being a tuple avg_distance = tf.reduce_mean(scores) # Initialize the variables (i.e. assign their default value) init_vars = tf.global_variables_initializer() # Start TensorFlow session sess = tf.Session() # Run the initializer
# clustering import tensorflow as tf from tensorflow.contrib.factorization import KMeans k = 3 # num_feature = 1 # arr = [[1],[2],[2],[4],[2]] num_feature = 2 arr = [[1, 2], [2, 3], [3, 4], [5, 5], [5, 10], [15, 5]] x = tf.placeholder(tf.float32, shape=[None, num_feature]) kmodel = KMeans(inputs=x, num_clusters=k, \ distance_metric='squared_euclidean', use_mini_batch=True) #print(kmodel) (all_scores, cluster_idx, scores, cluster_centers_initialized, init_op, train_op)=\ kmodel.training_graph() cluster_idx = cluster_idx[0] avg_distance = tf.reduce_mean(scores) # 요소값 거리의 평균 sess = tf.Session() sess.run(tf.global_variables_initializer()) print(sess.run(init_op, feed_dict={x: arr})) print(sess.run(train_op, feed_dict={x: arr})) print(sess.run(all_scores, feed_dict={x: arr})) print(sess.run(cluster_idx, feed_dict={x: arr})) print(sess.run(scores, feed_dict={x: arr})) print(sess.run(cluster_centers_initialized, feed_dict={x: arr})) # 학습 for i in range(1, 100):