Unverified Commit c21a603f authored by Saman Nia's avatar Saman Nia Committed by GitHub
Browse files

Delete random factor on wine dataset.ipynb

parent aaae941d
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Author: Saman Paidar Nia"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"All resources are listed at the bottom of the page."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# Get important libraries for this class.\n",
"import tensorflow as tf\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import warnings\n",
"import csv\n",
"import random\n",
"import math\n",
"import scipy\n",
"#--------------------------------------------------------\n",
"from tensorflow.python.ops import control_flow_ops\n",
"from IPython.display import clear_output\n",
"from scipy.spatial.distance import squareform, pdist\n",
"from sklearn.preprocessing import normalize\n",
"from numpy import linalg as LA\n",
"from scipy.cluster.vq import kmeans, vq\n",
"from sklearn.metrics import normalized_mutual_info_score\n",
"from math import sqrt"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"class Compute_Standardization:\n",
" def standardization(self, X):\n",
" return normalize(X, axis=0)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"class Similarity_Laplacian:\n",
" def laplacian(self, A):\n",
" S = np.sum(A, 0)\n",
" D = np.diag(S)\n",
" D = LA.matrix_power(D, -1)\n",
" L = np.dot(D, A)\n",
" return L"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"class Similarity_Normalization:\n",
" def normalization(self, V):\n",
" return (V - min(V)) / (max(V) - min(V))"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"class Cosine_Similarity(Compute_Standardization, Similarity_Laplacian, Similarity_Normalization):\n",
" def get_matrix(self, Data):\n",
" X = self.standardization(Data)\n",
" X = pdist(X, 'cosine')\n",
" X = squareform(X)\n",
" L = self.laplacian(X)\n",
" Y = np.apply_along_axis(self.normalization, 1, L)\n",
" np.fill_diagonal(Y, 0.)\n",
" return Y"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"class Correlation_Similarity(Compute_Standardization, Similarity_Laplacian, Similarity_Normalization):\n",
" def get_matrix(self, Data):\n",
" X = self.standardization(Data)\n",
" X = pdist(X, 'correlation')\n",
" X = squareform(X)\n",
" L = self.laplacian(X)\n",
" Y = np.apply_along_axis(self.normalization, 1, L)\n",
" np.fill_diagonal(Y, 0.)\n",
" return Y"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"class Similarity_Dataset_Iterator():\n",
" def __init__(self, data, labels, similarity):\n",
" self.data = data\n",
" self.labels = labels\n",
" self.matrix = similarity.get_matrix(data)\n",
" self.data_size = self.matrix.shape[0]\n",
" self.current_index = 0\n",
" def next_batch(self, num):\n",
" data=self.matrix.transpose()\n",
" labels=self.labels\n",
" idx = np.arange(0 , len(data))\n",
" np.random.shuffle(idx)\n",
" idx = idx[:num]\n",
" data_shuffle = [data[ i] for i in idx]\n",
" labels_shuffle = [labels[ i] for i in idx]\n",
" return data_shuffle, labels_shuffle\n",
" def whole_dataset(self):\n",
" return (self.matrix.transpose(), self.labels)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def read_wine_data(similarity):\n",
" with open('../Random Factor/Wine_Dataset/wine_data.csv') as csvfile:\n",
" csvreader = csv.reader(csvfile)\n",
" next(csvreader, None) # skip header\n",
" dataset = list(csvreader)\n",
" random.shuffle(dataset)\n",
" datatrain = dataset[:int(len(dataset))]\n",
" data = [data for data in datatrain]\n",
" labels = [data[13] for data in datatrain] \n",
" return Similarity_Dataset_Iterator(data, labels, similarity)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"# Call Correlation_Similarity as similarity dataset.\n",
"trainSet_correlation = read_wine_data(Correlation_Similarity())"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"# Call Cosine_Similarity as similarity dataset.\n",
"trainSet_cosine = read_wine_data(Cosine_Similarity())"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"n_input = trainSet_correlation.data_size #--------- Number of input data.\n",
"# Define the number of hidden layer. \n",
"if n_input >= 256:\n",
" Nn = int(512)\n",
"elif n_input >= 128:\n",
" Nn = int(256)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"n_hidden_1 = int(Nn/2) #-------------------- The autoencoder hidden layer 1.\n",
"n_code = str(int(n_hidden_1/2)) #----------- The number of output dimension value."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"n_nodes = (n_input+n_hidden_1+int(n_code))"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layer 1: 178\n",
"Layer 2: 128\n",
"Layer 3: 64\n"
]
}
],
"source": [
"print('Layer 1: ', n_input)\n",
"print('Layer 2: ', n_hidden_1)\n",
"print('Layer 3: ', int(n_code))"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"def k_means_(X, n_clusters):\n",
" kmeans_centroids,_ = kmeans(X,n_clusters)\n",
" kmeans_, _ = vq(X, kmeans_centroids)\n",
" return kmeans_"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"def encoder(x, n_code, phase_train): \n",
" with tf.variable_scope(\"encoder\"): \n",
" with tf.variable_scope(\"hidden_1\"):\n",
" hidden_1 = layer(x, [n_input, n_hidden_1], [n_hidden_1], phase_train) \n",
" with tf.variable_scope(\"code\"):\n",
" code = layer(hidden_1, [n_hidden_1, n_code], [n_code], phase_train)\n",
" return code"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"def decoder(code, n_code, phase_train):\n",
" with tf.variable_scope(\"decoder\"):\n",
" with tf.variable_scope(\"hidden_1\"):\n",
" hidden_1 = layer(code, [n_code, n_hidden_1], [n_hidden_1], phase_train) \n",
" with tf.variable_scope(\"output\"):\n",
" output = layer(hidden_1, [n_hidden_1, n_input], [n_input], phase_train)\n",
" return output"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"def layer_batch_norm(x, n_out, phase_train):\n",
" beta_init = tf.constant_initializer(value=0.0, dtype=tf.float32)\n",
" gamma_init = tf.constant_initializer(value=1.0, dtype=tf.float32)\n",
" beta = tf.get_variable(\"beta\", [n_out], initializer=beta_init)\n",
" gamma = tf.get_variable(\"gamma\", [n_out], initializer=gamma_init)\n",
" batch_mean, batch_var = tf.nn.moments(x, [0], name='moments')\n",
" ema = tf.train.ExponentialMovingAverage(decay=0.9)\n",
" ema_apply_op = ema.apply([batch_mean, batch_var])\n",
" ema_mean, ema_var = ema.average(batch_mean), ema.average(batch_var)\n",
" def mean_var_with_update():\n",
" with tf.control_dependencies([ema_apply_op]):\n",
" return tf.identity(batch_mean), tf.identity(batch_var)\n",
" mean, var = control_flow_ops.cond(phase_train, mean_var_with_update, lambda: (ema_mean, ema_var))\n",
" reshaped_x = tf.reshape(x, [-1, 1, 1, n_out])\n",
" normed = tf.nn.batch_norm_with_global_normalization(reshaped_x, mean, var, beta, gamma, 1e-3, True)\n",
" return tf.reshape(normed, [-1, n_out])"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"def layer(input, weight_shape, bias_shape, phase_train):\n",
" value_init = (1.0 / weight_shape[0] ** 0.5)\n",
" weight_init = tf.random_normal_initializer(stddev = value_init, seed = None)\n",
" bias_init = tf.constant_initializer(value=0.0, dtype=tf.float32)\n",
" W = tf.get_variable(\"W\", weight_shape, initializer=weight_init)\n",
" b = tf.get_variable(\"b\", bias_shape, initializer=bias_init)\n",
" logits = tf.matmul(input, W) + b\n",
" return tf.nn.sigmoid(layer_batch_norm(logits, weight_shape[1], phase_train))"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"def loss(output, x):\n",
" with tf.variable_scope(\"training\"):\n",
" train_loss = tf.reduce_mean(tf.reduce_sum(tf.square(tf.subtract(output, x)), 1))\n",
" return train_loss"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"def training(cost, learning_rate, beta1, beta2, global_step):\n",
" optimizer = tf.train.AdamOptimizer(learning_rate, beta1, beta2, epsilon=1e-08, use_locking=False, name='Adam')\n",
" train_op = optimizer.minimize(cost, global_step=global_step)\n",
" return train_op"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"# Parameters\n",
"n_layers = 3 #------------------------------ Number of Neural Networks Layers.\n",
"beta1 = 0.9 #------------------------------- The decay rate 1. \n",
"beta2 = 0.999 #----------------------------- The decay rate 2.\n",
"learning_rate = (beta1/n_input) #----------- The learning rate.\n",
"n_epoch = n_nodes #------------------------- The stop learning point.\n",
"n_batch = math.ceil(sqrt(sqrt(n_input))) #-- Number of selection data in per step.\n",
"n_backpro = math.ceil(n_input/n_batch) #---- Number of Backpro in per epoch.\n",
"n_clusters = 3 #---------------------------- Number of clusters.\n",
"n_diplay = math.ceil(n_epoch/n_layers) #---- Number of getting code and runnig the K-Means."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"results_cos=[] #--------------------------- A list to keep all NMI scores.\n",
"loss_cost_cos=[] #------------------------- A list to keep all training evaluations.\n",
"seeding_cos=[] #--------------------------- A list to keep all steps."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"NMI score for AE is: 97.38 and new cost is: 2.83 in 1 step of seeding.\n",
"NMI score for AE is: 100.00 and new cost is: 2.00 in 2 step of seeding.\n",
"NMI score for AE is: 97.33 and new cost is: 0.80 in 3 step of seeding.\n",
"NMI score for AE is: 100.00 and new cost is: 2.53 in 4 step of seeding.\n",
"NMI score for AE is: 100.00 and new cost is: 1.13 in 5 step of seeding.\n",
"NMI score for AE is: 100.00 and new cost is: 6.18 in 6 step of seeding.\n",
"NMI score for AE is: 100.00 and new cost is: 2.55 in 7 step of seeding.\n",
"NMI score for AE is: 97.32 and new cost is: 2.68 in 8 step of seeding.\n",
"NMI score for AE is: 100.00 and new cost is: 1.38 in 9 step of seeding.\n",
"NMI score for AE is: 100.00 and new cost is: 1.10 in 10 step of seeding.\n"
]
}
],
"source": [
"for i in range(1, 11):\n",
" with tf.Graph().as_default(): \n",
" with tf.variable_scope(\"autoencoder_model\"): \n",
" x = tf.placeholder(\"float\", [None, n_input]) \n",
" phase_train = tf.placeholder(tf.bool)\n",
" code = encoder(x, int(n_code), phase_train)\n",
" output = decoder(code, int(n_code), phase_train)\n",
" cost = loss(output, x)\n",
" global_step = tf.Variable(0, name='global_step', trainable=False)\n",
" train_optimizer = training(cost, learning_rate, beta1, beta2, global_step)\n",
" sess = tf.Session()\n",
" init_op = tf.global_variables_initializer()\n",
" sess.run(init_op)\n",
" # Training cycle\n",
" epoch = 0\n",
" while epoch == 0 or epoch <= n_epoch:\n",
" # Fit training with backpropagation using batch data.\n",
" for j in range(n_backpro):\n",
" miniData, _ = trainSet_cosine.next_batch(n_batch)\n",
" _, new_cost = sess.run([train_optimizer,cost], feed_dict={x: miniData,\n",
" phase_train: True}) \n",
" #------------------------- End of the Optimization ------------------------------\n",
" epoch += 1\n",
" # Getting embedded codes and running K-Means on them.\n",
" ae_codes = sess.run(code, feed_dict={x: trainSet_cosine.whole_dataset()[0],\n",
" phase_train: False}) \n",
" idx = k_means_(ae_codes, n_clusters)\n",
" ae_nmi_cos = normalized_mutual_info_score(trainSet_cosine.whole_dataset()[1], idx)\n",
" ae_nmi_cos = ae_nmi_cos*100\n",
" results_cos.append(ae_nmi_cos) \n",
" seeding_cos.append(i)\n",
" loss_cost_cos.append(new_cost) \n",
" print(\"NMI score for AE is: {:0.2f} and new cost is: {:0.2f} in {:d} step of seeding.\"\n",
" .format(ae_nmi_cos, new_cost, i))"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The Average of NMI Score for >>> 10 <<< Random Factors in Autoencoder Cosine is >>> 99.20 <<<\n"
]
}
],
"source": [
"print(\"The Average of NMI Score for >>> {:d} <<< Random Factors in Autoencoder Cosine is >>> {:0.2f} <<<\"\n",
" .format(len(seeding_cos),(np.mean(results_cos))))"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[97.380652119019118,\n",
" 100.0,\n",
" 97.326382964867364,\n",
" 100.0,\n",
" 100.0,\n",
" 100.0,\n",
" 100.0,\n",
" 97.324565996287149,\n",
" 100.0,\n",
" 100.0]"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"results_cos"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"results_cor=[] #--------------------------- A list to keep all NMI scores.\n",
"loss_cost_cor=[] #------------------------- A list to keep all training evaluations.\n",
"seeding_cor=[] #--------------------------- A list to keep all steps."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"NMI score for AE is: 82.12 and new cost is: 13.55 in 1 step of seeding.\n",
"NMI score for AE is: 91.20 and new cost is: 7.18 in 2 step of seeding.\n",
"NMI score for AE is: 91.20 and new cost is: 1.60 in 3 step of seeding.\n",
"NMI score for AE is: 91.19 and new cost is: 5.52 in 4 step of seeding.\n",
"NMI score for AE is: 92.82 and new cost is: 12.15 in 5 step of seeding.\n",
"NMI score for AE is: 90.16 and new cost is: 6.54 in 6 step of seeding.\n",
"NMI score for AE is: 92.82 and new cost is: 7.28 in 7 step of seeding.\n",
"NMI score for AE is: 74.88 and new cost is: 0.67 in 8 step of seeding.\n",
"NMI score for AE is: 77.40 and new cost is: 8.31 in 9 step of seeding.\n",
"NMI score for AE is: 91.20 and new cost is: 1.60 in 10 step of seeding.\n"
]
}
],
"source": [
"for i in range(1, 11):\n",
" with tf.Graph().as_default(): \n",
" with tf.variable_scope(\"autoencoder_model\"): \n",
" x = tf.placeholder(\"float\", [None, n_input]) \n",
" phase_train = tf.placeholder(tf.bool)\n",
" code = encoder(x, int(n_code), phase_train)\n",
" output = decoder(code, int(n_code), phase_train)\n",
" cost = loss(output, x)\n",
" global_step = tf.Variable(0, name='global_step', trainable=False)\n",
" train_optimizer = training(cost, learning_rate, beta1, beta2, global_step)\n",
" sess = tf.Session()\n",
" init_op = tf.global_variables_initializer()\n",
" sess.run(init_op)\n",
" # Training cycle\n",
" epoch = 0\n",
" while epoch == 0 or epoch <= n_epoch:\n",
" # Fit training with backpropagation using batch data.\n",
" for j in range(n_backpro):\n",
" miniData, _ = trainSet_correlation.next_batch(n_batch)\n",
" _, new_cost = sess.run([train_optimizer,cost], feed_dict={x: miniData,\n",
" phase_train: True}) \n",
" #------------------------- End of the Optimization ------------------------------\n",
" epoch += 1\n",
" # Getting embedded codes and running K-Means on them.\n",
" ae_codes = sess.run(code, feed_dict={x: trainSet_correlation.whole_dataset()[0],\n",
" phase_train: False}) \n",
" idx = k_means_(ae_codes, n_clusters)\n",
" ae_nmi_cor = normalized_mutual_info_score(trainSet_correlation.whole_dataset()[1], idx)\n",
" ae_nmi_cor = ae_nmi_cor*100\n",
" results_cor.append(ae_nmi_cor) \n",
" seeding_cor.append(i)\n",
" loss_cost_cor.append(new_cost) \n",
" print(\"NMI score for AE is: {:0.2f} and new cost is: {:0.2f} in {:d} step of seeding.\"\n",
" .format(ae_nmi_cor, new_cost, i))"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The Average of NMI Score for >>> 10 <<< Random Factors in Autoencoder Correlation is >>> 87.50 <<<\n"
]
}
],
"source": [
"print(\"The Average of NMI Score for >>> {:d} <<< Random Factors in Autoencoder Correlation is >>> {:0.2f} <<<\"\n",
" .format(len(seeding_cor), (np.mean(results_cor))))"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[82.116307862121147,\n",
" 91.197433589135997,\n",
" 91.197433589135983,\n",
" 91.191389182136902,\n",
" 92.820412415237172,\n",
" 90.164037687895785,\n",
" 92.815104601913305,\n",
" 74.879008652959129,\n",
" 77.402426727696692,\n",
" 91.197433589135983]"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"results_cor"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAElCAYAAAAV9s4VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
"text/plain": [
"<matplotlib.figure.Figure at 0x287b340ee48>"
]