Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Facial Emotion Recognition - WSL
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Dataset Generation"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Read and process images into matrices"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"text/plain": [
"'/home/psh/OneDrive/DeepLearning/advanced-tensorflow/basic'"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import os\n",
"os.getcwd()"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['../../img_dataset/face_emotion/1_disgust',\n",
" '../../img_dataset/face_emotion/2_fear',\n",
" '../../img_dataset/face_emotion/4_sad',\n",
" '../../img_dataset/face_emotion/0_angry',\n",
" '../../img_dataset/face_emotion/5_surprise',\n",
" '../../img_dataset/face_emotion/3_happy',\n",
" '../../img_dataset/face_emotion/6_neutral']"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"base_path = \"../../img_dataset/face_emotion/\"\n",
"paths = map(lambda x: os.path.join(base_path, x), os.listdir(base_path))\n",
"if '../../img_dataset/face_emotion/.DS_Store' in paths:\n",
" paths.remove('../../img_dataset/face_emotion/.DS_Store')\n",
"paths"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['.tiff', '.jpg', '.jpeg', '.png', '.gif', '.tga', '.TIFF', '.JPG', '.JPEG', '.PNG', '.GIF', '.TGA']\n"
]
}
],
"source": [
"valid_exts = [\".tiff\", \".jpg\", \".jpeg\", \".png\", \".gif\", \".tga\"]\n",
"valid_exts += map(lambda x: x.upper(), valid_exts)\n",
"print valid_exts"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TOTAL IMAGES: 35886\n"
]
}
],
"source": [
"imgsize = (48, 48)\n",
"grayscale = False\n",
"\n",
"n_imgs = 0\n",
"one_hot_labels = np.eye(len(paths))\n",
"images = []\n",
"labels = []\n",
"\n",
"for i, path in enumerate(paths):\n",
" lbl = one_hot_labels[i]#.reshape(1, -1) # one-hot label for current folder \n",
" for fname in os.listdir(path):\n",
" whole_fname = os.path.join(path, fname)\n",
" if os.path.splitext(fname)[-1] not in valid_exts:\n",
" continue\n",
" \n",
" # load and process image\n",
" img = imread(whole_fname)\n",
" img = img.flatten()#reshape(1, -1)\n",
" \n",
" # save as numpy.array object\n",
" #if n_imgs == 0:\n",
" # images = img\n",
" # labels = lbl\n",
" #images = np.concatenate((images, img), axis=0)\n",
" #labels = np.concatenate((labels, lbl), axis=0)\n",
" images.append(img)\n",
" labels.append(lbl)\n",
" n_imgs += 1\n",
" \n",
"images = np.array(images)\n",
"labels = np.array(labels)\n",
"print \"TOTAL IMAGES:\", n_imgs"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## train-test split"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"seed = np.random.randint(100, size=1)[0]\n",
"\n",
"np.random.seed(seed)\n",
"np.random.shuffle(images)\n",
"np.random.seed(seed)\n",
"np.random.shuffle(labels)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TRAIN SHAPE: (25120, 2304) (25120, 7)\n",
"TEST SHAPE: (5382, 2304) (5382, 7)\n",
"VAL SHAPE: (5384, 2304) (5384, 7)\n"
]
}
],
"source": [
"train_test_val_ratio = (.7, .15, .15)\n",
"train_idx, test_idx, _ = np.array(map(lambda x: int(x * n_imgs), train_test_val_ratio)).cumsum()\n",
"\n",
"X_train = images[:train_idx]\n",
"X_test = images[train_idx:test_idx]\n",
"X_val = images[test_idx:]\n",
"y_train = labels[:train_idx]\n",
"y_test = labels[train_idx:test_idx]\n",
"y_val = labels[test_idx:]\n",
"\n",
"print \"TRAIN SHAPE:\", X_train.shape, y_train.shape\n",
"print \"TEST SHAPE:\", X_test.shape, y_test.shape\n",
"print \"VAL SHAPE:\", X_val.shape, y_val.shape"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Save as .npz"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"SAVED!\n"
]
}
],
"source": [
"categories = [os.path.basename(path) for path in paths]\n",
"dataname = \"face_emotion\"\n",
"savepath = os.path.join(os.getcwd(), \"data\", dataname+\".npz\")\n",
"\n",
"np.savez(\n",
" savepath, \n",
" xtrain=X_train, xtest=X_test, xval=X_val,\n",
" ytrain=y_train, ytest=y_test, yval=y_val,\n",
" imgsize=imgsize, categories=categories\n",
")\n",
"print \"SAVED!\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"# Using ConvNet to classify custom data"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Load custom data"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['ytest', 'imgsize', 'yval', 'ytrain', 'xtest', 'xtrain', 'xval', 'categories']\n"
]
}
],
"source": [
"fer = np.load(\"data/face_emotion.npz\")\n",
"print fer.files"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"((25120, 2304), (25120, 7))"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fer[\"xtrain\"].shape, fer[\"ytrain\"].shape"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## CNN implementation"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Without TF-slim"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"img_w, img_h = (48, 48)\n",
"img_ch = 1\n",
"n_class = 7\n",
"\n",
"c1_ch = 64\n",
"c2_ch = 64\n",
"c3_ch = 64\n",
"d1_n = 1024\n",
"d2_n = 1024\n",
"\n",
"X = tf.placeholder(tf.float32, [None, img_w*img_h*img_ch])\n",
"y = tf.placeholder(tf.float32, [None, n_class])\n",
"_W = {\n",
" \"c1\": tf.Variable(tf.random_normal([3, 3, img_ch, c1_ch], stddev=.01)),\n",
" \"c2\": tf.Variable(tf.random_normal([3, 3, c1_ch, c2_ch], stddev=.01)),\n",
" \"c3\": tf.Variable(tf.random_normal([3, 3, c2_ch, c3_ch], stddev=.01)),\n",
" \"d1\": tf.Variable(tf.random_normal([img_w*img_h*c3_ch//64, d1_n], stddev=.01)),\n",
" \"d2\": tf.Variable(tf.random_normal([d1_n, d2_n], stddev=.01)),\n",
" \"d3\": tf.Variable(tf.random_normal([d2_n, n_class], stddev=.01))\n",
"}\n",
"_b = {\n",
" \"c1\": tf.Variable(tf.zeros([c1_ch])),\n",
" \"c2\": tf.Variable(tf.zeros([c2_ch])),\n",
" \"c3\": tf.Variable(tf.zeros([c3_ch])),\n",
" \"d1\": tf.Variable(tf.zeros([d1_n])),\n",
" \"d2\": tf.Variable(tf.zeros([d2_n])),\n",
" \"d3\": tf.Variable(tf.zeros([n_class]))\n",
"}\n",
"\n",
"def convnet(X, _W, _b):\n",
" input_r = tf.reshape(X, [-1, img_w, img_h, img_ch])\n",
" conv1 = tf.nn.conv2d(input_r, _W[\"c1\"], [1, 1, 1, 1], \"SAME\") + _b[\"c1\"]\n",
" relu1 = tf.nn.relu(conv1)\n",
" pool1 = tf.nn.max_pool(relu1, [1, 2, 2, 1], [1, 2, 2, 1], \"SAME\")\n",
" \n",
" conv2 = tf.nn.conv2d(pool1, _W[\"c2\"], [1, 1, 1, 1], \"SAME\") + _b[\"c2\"]\n",
" relu2 = tf.nn.relu(conv2)\n",
" pool2 = tf.nn.max_pool(relu2, [1, 2, 2, 1], [1, 2, 2, 1], \"SAME\")\n",
" \n",
" conv3 = tf.nn.conv2d(pool2, _W[\"c3\"], [1, 1, 1, 1], \"SAME\") + _b[\"c3\"]\n",
" relu3 = tf.nn.relu(conv3)\n",
" pool3 = tf.nn.max_pool(relu3, [1, 2, 2, 1], [1, 2, 2, 1], \"SAME\")\n",
"\n",
" dense = tf.reshape(pool3, [-1, img_w*img_h*c3_ch//64])\n",
" fc1 = tf.matmul(dense, _W[\"d1\"]) + _b[\"d1\"]\n",
" actv1 = tf.nn.relu(fc1)\n",
" fc2 = tf.matmul(actv1, _W[\"d2\"]) + _b[\"d2\"]\n",
" actv2 = tf.nn.relu(fc2)\n",
" fc3 = tf.matmul(actv2, _W[\"d3\"]) + _b[\"d3\"]\n",
" score = tf.nn.softmax(fc3)\n",
"\n",
" out = {\n",
" \"input_r\": input_r,\n",
" \"conv1\": conv1, \"relu1\": relu1, \"pool1\": pool1,\n",
" \"conv2\": conv2, \"relu2\": relu2, \"pool2\": pool2,\n",
" \"conv3\": conv3, \"relu3\": relu3, \"pool3\": pool3,\n",
" \"dense\": dense,\n",
" \"fc1\": fc1, \"actv1\": actv1,\n",
" \"fc2\": fc2, \"actv2\": actv2,\n",
" \"fc3\": fc3,\n",
" \"score\": score\n",
" }\n",
"\n",
" return out"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### With TF-Slim"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def lrelu(x, leak=.2, scope=\"lrelu\"):\n",
" with tf.variable_scope(scope):\n",
" f1 = (1-leak) / 2.\n",
" f2 = (1+leak) / 2.\n",
" return f1*x + f2*tf.abs(x)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"def slim_convnet(X, is_training):\n",
" init_w = tf.truncated_normal_initializer(stddev=.01)\n",
" batchnorm_params = {\"is_training\": is_training, \"decay\": 0.9, \"updates_collections\": None}\n",
" \n",
" X_r = tf.reshape(X, [-1, 48, 48, 1])\n",
" net = slim.conv2d(X_r, 128, [3,3], padding=\"SAME\",\n",
" normalizer_fn=slim.batch_norm,\n",
" normalizer_params=batchnorm_params,\n",
" activation_fn=lrelu,\n",
" weights_initializer=init_w,\n",
" scope=\"CONV1\")\n",
" net = slim.conv2d(net, 128, [3,3], padding=\"SAME\",\n",
" normalizer_fn=slim.batch_norm,\n",
" normalizer_params=batchnorm_params,\n",
" activation_fn=lrelu,\n",
" weights_initializer=init_w,\n",
" scope=\"CONV2\")\n",
" net = slim.max_pool2d(net, [2,2], scope=\"POOL1\")\n",
" \n",
" net = slim.conv2d(X_r, 128, [3,3], padding=\"SAME\",\n",
" normalizer_fn=slim.batch_norm,\n",
" normalizer_params=batchnorm_params,\n",
" activation_fn=lrelu,\n",
" weights_initializer=init_w,\n",
" scope=\"CONV3\")\n",
" net = slim.conv2d(net, 128, [3,3], padding=\"SAME\",\n",
" normalizer_fn=slim.batch_norm,\n",
" normalizer_params=batchnorm_params,\n",
" activation_fn=lrelu,\n",
" weights_initializer=init_w,\n",
" scope=\"CONV4\")\n",
" net = slim.max_pool2d(net, [2,2], scope=\"POOL2\")\n",
" \n",
" net = slim.conv2d(net, 128, [3,3], padding=\"SAME\",\n",
" normalizer_fn=slim.batch_norm,\n",
" normalizer_params=batchnorm_params,\n",
" activation_fn=lrelu,\n",
" weights_initializer=init_w,\n",
" scope=\"CONV5\")\n",
" net = slim.conv2d(net, 128, [3,3], padding=\"SAME\",\n",
" normalizer_fn=slim.batch_norm,\n",
" normalizer_params=batchnorm_params,\n",
" activation_fn=lrelu,\n",
" weights_initializer=init_w,\n",
" scope=\"CONV6\")\n",
" net = slim.max_pool2d(net, [2,2], scope=\"POOL3\")\n",
" \n",
" net = slim.flatten(net, \"FLAT\")\n",
" net = slim.fully_connected(net, 1024,\n",
" normalizer_fn=slim.batch_norm,\n",
" normalizer_params=batchnorm_params,\n",
" weights_initializer=init_w,\n",
" activation_fn=lrelu,\n",
" scope=\"DENSE1\")\n",
" net = slim.dropout(net, .7, is_training=is_training, scope=\"DROP1\")\n",
" net = slim.fully_connected(net, 1024,\n",
" normalizer_fn=slim.batch_norm,\n",
" normalizer_params=batchnorm_params,\n",
" weights_initializer=init_w,\n",
" activation_fn=lrelu,\n",
" scope=\"DENSE2\")\n",
" net = slim.dropout(net, .7, is_training=is_training, scope=\"DROP2\")\n",
" out = slim.fully_connected(net, 7,\n",
" weights_initializer=init_w,\n",
" activation_fn=tf.nn.softmax,\n",
" scope=\"LOGIT\")\n",
" \n",
" return out"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Loss function & optimizer & eval metrics\n",
"* Use weighted loss to compensate for label skewness"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"tf.reset_default_graph()\n",
"X = tf.placeholder(tf.float32, [None, 48*48*1])\n",
"y = tf.placeholder(tf.float32, [None, 7])\n",
"is_training = tf.placeholder(tf.bool)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"logit = slim_convnet(X, is_training)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 5.74696866, 7.0324748 , 3.99173685, 5.90225564, 8.93950178,\n",
" 7.31082654, 65.7591623 ])"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"class_counts = np.unique(np.argmax(fer[\"ytrain\"], axis=1), return_counts=True)[1]\n",
"class_weights = (class_counts.sum() / class_counts.astype(float))\n",
"class_weights"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"learning_rate = .005\n",
"global_step = tf.Variable(0, trainable=False)\n",
"decay_steps = 50.\n",
"decay_rate = .93\n",
"learning_rate = tf.train.inverse_time_decay(learning_rate, global_step, \n",
" decay_steps, decay_rate, staircase=True)\n",
"\n",
"weights = tf.placeholder(tf.float32, [None])\n",
"loss = tf.losses.softmax_cross_entropy(y, logit, weights=weights)\n",
"#optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=.9, use_nesterov=True).minimize(loss)\n",
"optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate, epsilon=.0001).minimize(loss, global_step=global_step)\n",
"\n",
"pred = tf.argmax(logit, 1)\n",
"truth = tf.argmax(y, 1)\n",
"acc = tf.reduce_mean(tf.cast(tf.equal(truth, pred), tf.float32))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Data augmentation"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"from scipy import ndimage"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"def augment_data(images):\n",
" images_r = images.reshape(-1, 48, 48)\n",
" images_aug = []\n",
" for img in images_r:\n",
" # FLIP\n",
" if np.random.randint(0, 2) == 1:\n",
" img_flipped = np.fliplr(img)\n",
" else:\n",
" img_flipped = img\n",
" # ROTATE\n",
" angle = np.random.randint(-10, 10)\n",
" img_rotated = ndimage.rotate(img_flipped, angle, reshape=False)\n",
" # scaled\n",
" scale = np.random.uniform(1., 1.1)\n",
" img_scaled = ndimage.zoom(img_rotated, scale)\n",
" center = img_scaled.shape[0] // 2\n",
" st = (center-24); en = (center+24)\n",
" img_scaled = img_scaled[st:en, st:en]\n",
" # SHIFT\n",
" shift = np.random.randint(-2, 2)\n",
" img_shifted = ndimage.shift(img_scaled, shift)\n",
" # add to the list\n",
" img_flattend = img_shifted.flatten()\n",
" images_aug.append(img_flattend)\n",
" images_aug = np.array(images_aug)\n",
" return images_aug"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/psh/.local/lib/python2.7/site-packages/scipy/ndimage/interpolation.py:583: UserWarning: From scipy 0.13.0, the output shape of zoom() is calculated with round() instead of int() - for these inputs the size of the returned array has changed.\n",
" \"the returned array has changed.\", UserWarning)\n"
]
},
{
"data": {
"text/plain": [
"<matplotlib.image.AxesImage at 0x7fc188250b90>"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"idx = 12\n",
"plt.subplot(121)\n",
"plt.imshow(fer[\"xtrain\"][idx].reshape(48, 48), cmap=mpl.cm.gray)\n",
"plt.subplot(122)\n",
"plt.imshow(augment_data(fer[\"xtrain\"][idx])[0].reshape(48, 48), cmap=mpl.cm.gray)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"xtrain = fer[\"xtrain\"]\n",
"ytrain = fer[\"ytrain\"]\n",
"xtest = fer[\"xtest\"]\n",
"ytest = fer[\"ytest\"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Whiten inputs"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"train_mean = np.mean(xtrain, axis=0)\n",
"train_std = np.std(xtrain, axis=0)\n",
" \n",
"def whiten(x, train_mean=train_mean, train_std=train_std):\n",
" return (x - train_mean) / train_std"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Training process"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/psh/.local/lib/python2.7/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n",
" warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n"
]
},
{
"data": {
"text/plain": [
"<matplotlib.axes._subplots.AxesSubplot at 0x7fc188280250>"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"sns.distplot(np.argmax(ytrain, 1), bins=7, norm_hist=True, kde=False)\n",
"sns.distplot(np.argmax(fer[\"ytest\"], 1), bins=7, norm_hist=True, kde=False)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"sess = tf.Session()\n",
"init = tf.global_variables_initializer()\n",
"sess.run(init)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"saver = tf.train.Saver(max_to_keep=10)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"005th: loss 11.98410, train_acc 0.522, test_acc 0.541\n",
"010th: loss 11.60389, train_acc 0.588, test_acc 0.559\n",
"015th: loss 11.37983, train_acc 0.625, test_acc 0.580\n",
"020th: loss 11.23594, train_acc 0.649, test_acc 0.586\n",
"025th: loss 11.12284, train_acc 0.668, test_acc 0.576\n",
"030th: loss 11.04105, train_acc 0.681, test_acc 0.584\n",
"035th: loss 10.95620, train_acc 0.696, test_acc 0.588\n",
"040th: loss 10.89005, train_acc 0.706, test_acc 0.594\n",
"045th: loss 10.82822, train_acc 0.717, test_acc 0.592\n",
"050th: loss 10.78203, train_acc 0.723, test_acc 0.590\n",
"055th: loss 10.74615, train_acc 0.728, test_acc 0.592\n",
"060th: loss 10.70861, train_acc 0.736, test_acc 0.586\n",
"065th: loss 10.66698, train_acc 0.742, test_acc 0.580\n",
"070th: loss 10.63692, train_acc 0.746, test_acc 0.594\n",
"075th: loss 10.62256, train_acc 0.748, test_acc 0.592\n",
"080th: loss 10.59369, train_acc 0.752, test_acc 0.594\n",
"085th: loss 10.54309, train_acc 0.760, test_acc 0.605\n",
"090th: loss 10.52803, train_acc 0.764, test_acc 0.605\n",
"095th: loss 10.51590, train_acc 0.766, test_acc 0.604\n",
"100th: loss 10.50317, train_acc 0.767, test_acc 0.609\n",
"105th: loss 10.47712, train_acc 0.772, test_acc 0.607\n",
"110th: loss 10.44771, train_acc 0.777, test_acc 0.604\n",
"115th: loss 10.43361, train_acc 0.779, test_acc 0.605\n",
"120th: loss 10.43110, train_acc 0.779, test_acc 0.615\n",
"125th: loss 10.40474, train_acc 0.784, test_acc 0.611\n",
"130th: loss 10.37671, train_acc 0.788, test_acc 0.611\n",
"135th: loss 10.37927, train_acc 0.787, test_acc 0.619\n",
"140th: loss 10.35974, train_acc 0.789, test_acc 0.619\n",
"145th: loss 10.33949, train_acc 0.793, test_acc 0.611\n",
"150th: loss 10.33469, train_acc 0.794, test_acc 0.619\n",
"155th: loss 10.32647, train_acc 0.796, test_acc 0.615\n",
"160th: loss 10.31313, train_acc 0.798, test_acc 0.623\n",
"165th: loss 10.30494, train_acc 0.800, test_acc 0.623\n",
"170th: loss 10.28598, train_acc 0.802, test_acc 0.625\n",
"175th: loss 10.27716, train_acc 0.804, test_acc 0.615\n",
"180th: loss 10.27948, train_acc 0.805, test_acc 0.623\n",
"185th: loss 10.25671, train_acc 0.807, test_acc 0.629\n",
"190th: loss 10.27322, train_acc 0.803, test_acc 0.625\n",
"195th: loss 10.23416, train_acc 0.810, test_acc 0.625\n",
"200th: loss 10.24615, train_acc 0.809, test_acc 0.623\n",
"DONE\n"
]
}
],
"source": [
"n_epochs = 200\n",
"batch_size = 64\n",
"display_step = 5\n",
"save_step = 5\n",
"\n",
"n_batches = int(xtrain.shape[0] / batch_size)\n",
"losses, train_accs, test_accs = [], [], []\n",
"\n",
"ylabels = np.argmax(ytrain, 1)\n",
"yweights = class_weights[ylabels]\n",
"ytestweights = class_weights[np.argmax(ytest[:512], 1)]\n",
"\n",
"for epoch in range(n_epochs):\n",
" avg_loss, avg_train_acc = 0., 0.\n",
" for i in range(n_batches):\n",
" batch_xs = xtrain[(i * batch_size):((i+1) * batch_size)]\n",
" batch_ys = ytrain[(i * batch_size):((i+1) * batch_size)]\n",
" batch_weights = yweights[(i * batch_size):((i+1) * batch_size)]\n",
" batch_xs = whiten(augment_data(batch_xs))\n",
" \n",
" if (epoch+1) % display_step != 0:\n",
" sess.run(optimizer, feed_dict={X: batch_xs, y: batch_ys, \n",
" is_training: True,\n",
" weights: batch_weights})\n",
" else:\n",
" _, curr_loss, curr_train_acc = sess.run([optimizer, loss, acc], feed_dict={X: batch_xs, y: batch_ys, \n",
" is_training: True,\n",
" weights: batch_weights})\n",
" avg_loss += curr_loss / n_batches\n",
" avg_train_acc += curr_train_acc / n_batches\n",
" \n",
" if (epoch+1) % display_step == 0:\n",
" test_acc = sess.run(acc, feed_dict={X: whiten(xtest[:512]), y: ytest[:512], \n",
" is_training: False,\n",
" weights: ytestweights})\n",
" losses.append(avg_loss)\n",
" train_accs.append(avg_train_acc)\n",
" test_accs.append(test_acc)\n",
" \n",
" if (epoch+1) % display_step == 0:\n",
" print \"{:03d}th: loss {:0.5f}, train_acc {:0.3f}, test_acc {:0.3f}\".format(epoch+1, avg_loss, avg_train_acc, test_acc)\n",
" \n",
" if (epoch+1) % save_step == 0:\n",
" saver.save(sess, \"fe_challenge/fe_cnn-NAG-whiten\", global_step=epoch+1)\n",
" \n",
"print \"DONE\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Evaluation"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7fc17c67a3d0>]"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.plot(losses)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7fc188343390>]"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.plot(train_accs)\n",
"plt.plot(test_accs)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"## EVAL"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<tf.Variable 'CONV1/weights:0' shape=(3, 3, 1, 128) dtype=float32_ref>,\n",
" <tf.Variable 'CONV1/BatchNorm/beta:0' shape=(128,) dtype=float32_ref>,\n",
" <tf.Variable 'CONV2/weights:0' shape=(3, 3, 128, 128) dtype=float32_ref>,\n",
" <tf.Variable 'CONV2/BatchNorm/beta:0' shape=(128,) dtype=float32_ref>,\n",
" <tf.Variable 'CONV3/weights:0' shape=(3, 3, 1, 128) dtype=float32_ref>,\n",
" <tf.Variable 'CONV3/BatchNorm/beta:0' shape=(128,) dtype=float32_ref>,\n",
" <tf.Variable 'CONV4/weights:0' shape=(3, 3, 128, 128) dtype=float32_ref>,\n",
" <tf.Variable 'CONV4/BatchNorm/beta:0' shape=(128,) dtype=float32_ref>,\n",
" <tf.Variable 'CONV5/weights:0' shape=(3, 3, 128, 128) dtype=float32_ref>,\n",
" <tf.Variable 'CONV5/BatchNorm/beta:0' shape=(128,) dtype=float32_ref>,\n",
" <tf.Variable 'CONV6/weights:0' shape=(3, 3, 128, 128) dtype=float32_ref>,\n",
" <tf.Variable 'CONV6/BatchNorm/beta:0' shape=(128,) dtype=float32_ref>,\n",
" <tf.Variable 'DENSE1/weights:0' shape=(18432, 1024) dtype=float32_ref>,\n",
" <tf.Variable 'DENSE1/BatchNorm/beta:0' shape=(1024,) dtype=float32_ref>,\n",
" <tf.Variable 'DENSE2/weights:0' shape=(1024, 1024) dtype=float32_ref>,\n",
" <tf.Variable 'DENSE2/BatchNorm/beta:0' shape=(1024,) dtype=float32_ref>,\n",
" <tf.Variable 'LOGIT/weights:0' shape=(1024, 7) dtype=float32_ref>,\n",
" <tf.Variable 'LOGIT/biases:0' shape=(7,) dtype=float32_ref>]"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"trainable_vars = tf.trainable_variables()\n",
"trainable_vars"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"weights = sess.run(trainable_vars[0])"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 864x648 with 15 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Filters are in shape: (3, 3, 128)\n"
]
}
],
"source": [
"weights = weights.reshape(3, 3, -1)\n",
"\n",
"plt.figure(figsize=(12, 9))\n",
"for i in range(15):\n",
" plt.subplot(3, 5, i+1)\n",
" plt.imshow(weights[:, :, i], cmap=mpl.cm.gray)\n",
" plt.title(\"{}\".format(i))\n",
" \n",
"plt.suptitle(\"CONV filters\", fontsize=16)\n",
"plt.tight_layout()\n",
"plt.show()\n",
"\n",
"print \"Filters are in shape:\", weights.shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 2",
"language": "python",
"name": "python2"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 2
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython2",
"version": "2.7.15rc1"
}
},
"nbformat": 4,
"nbformat_minor": 1
}
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment