11_Process_training_tears_TF_old.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# RUN Main import block and TODO list\n",
    "\n",
    "# TODO: see how uri calculated the ridges\n",
    "\n",
    "# TODO: Perform Histogram equalization - start with it\n",
    "# TODO: \n",
    "# take integral from the Highest peak+-0.005 divide by integral of the entire graph \n",
    "# This will be the peakness measure for the PSD ==> The desired ridge index\n",
    "# TODO:\n",
    "# take integral from the Highest peak+-0.005 divide by integral of the entire graph - it's the peakness measure for the PSD\n",
    "# must select a peak above a min threshold in order to ignore noisy frequency\n",
    "# must ignore peaks above a certain threshold in order to detect meaningful frequency\n",
    "# run the PSD in moving windows every 200 px (deduced from the below PSD pointing to a freq of 1/0.02=50-> times 4= 200px)\n",
    "# and medianf the result of the windows\n",
    "# TODO:\n",
    "# Another alternative: (with Yariv)\n",
    "# Run PSD column by column - get the phase, freq, peakness and reconstruct an artificial ridge slice\n",
    "# from this - reconstruct a \"clean\" artificial ridge image\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.image as img\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import urllib.request\n",
    "import os\n",
    "import shutil\n",
    "import glob\n",
    "from scipy import ndimage\n",
    "from scipy import signal\n",
    "#import cv2\n",
    "\n",
    "from PIL import Image, ImageDraw, ImageFont\n",
    "\n",
    "import mahotas as mh\n",
    "from mahotas import polygon\n",
    "# import pymorph as pm\n",
    "\n",
    "import networkx as nx\n",
    "\n",
    "from scipy import ndimage as nd\n",
    "import skimage.transform as transform\n",
    "import skimage.morphology as mp\n",
    "import skimage.io as sio\n",
    "import scipy.misc as sm\n",
    "from skimage.filters import threshold_otsu, threshold_adaptive\n",
    "from skimage.feature import hessian_matrix, hessian_matrix_eigvals\n",
    "from skimage import exposure\n",
    "from skimage import data, img_as_float\n",
    "from sklearn.metrics import precision_recall_fscore_support\n",
    "\n",
    "from bisect import bisect_left\n",
    "import math\n",
    "import warnings\n",
    "import csv\n",
    "import tensorflow as tf\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "code_folding": [
     0,
     28,
     46,
     54,
     68,
     74,
     80,
     94,
     103,
     118,
     136,
     153,
     171,
     206,
     212,
     217,
     222,
     229,
     234,
     261,
     268,
     309,
     418,
     452,
     475,
     490
    ],
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found a ZERO index cube with the name:ZERO\n"
     ]
    }
   ],
   "source": [
    "# RUN Utility functions\n",
    "\n",
    "# One time init\n",
    "# with open('results.csv', 'w') as csvfile:\n",
    "#     csvout = csv.writer(csvfile)\n",
    "#     csvout.writerow([\"File\", \"Model\", \"Gap\", \"Slice_size\", \"Count\", \"Precision\", \"Recall\", \"F-score\", \"True Count\", \"Error Rate\"])\n",
    "\n",
    "#BASIC CROP FRAME\n",
    "X_START = 1000\n",
    "X_END = 6000\n",
    "Y_START = 800\n",
    "Y_END = 4300\n",
    "BG_2_OBJ_RATIO = 0.91\n",
    "CUBE_SIZE = 250\n",
    "ROOT_FOLDER = \"/Users/il239838/Downloads/private/Thesis/Papyrus/\"\n",
    "LEARNING_RATE = 0.001\n",
    "BATCHES = 400\n",
    "BATCH_SIZE = 50\n",
    "BREAK_VAL = 1000\n",
    "\n",
    "# Simple crop by x/y ranges\n",
    "def crop(image, ymin, ymax, xmin, xmax):\n",
    "    return image[ymin:ymax, xmin:xmax]\n",
    "\n",
    "# returns a logical matrix of values beyond a threshld\n",
    "def thresholded(image, val): \n",
    "    return np.logical_and(*[image[...] > val  for t in enumerate([0, 0])])\n",
    "\n",
    "def find_min_max_without_orphand_pixels(nonzero_dimension, crop_filter=20):\n",
    "    sorted = np.sort(nonzero_dimension)\n",
    "    prev=-1\n",
    "    min_val = sorted[0]\n",
    "    for i, x in enumerate(sorted[:100]):\n",
    "        if prev >= 0 and x - prev > crop_filter:\n",
    "            min_val = x\n",
    "        prev = x\n",
    "    prev=-1\n",
    "    max_val = sorted[-1]\n",
    "    for i, x in enumerate(sorted[-100:]):\n",
    "        if prev >= 0 and x - prev > crop_filter:\n",
    "            max_val = prev\n",
    "            break\n",
    "        prev = x\n",
    "    \n",
    "    return min_val, max_val\n",
    "\n",
    "def calc_min_max_coordinates(image, crop_val=50):\n",
    "    temp = thresholded(image, crop_val)\n",
    "    temp = temp * 1\n",
    "    temp = np.nonzero(temp)\n",
    "    ymin, ymax = find_min_max_without_orphand_pixels(temp[0])\n",
    "    xmin,xmax = find_min_max_without_orphand_pixels(temp[1])\n",
    "    return ymin, ymax, xmin, xmax\n",
    "\n",
    "def calc_min_max_coordinates_dynamic(image, cutoff=1):\n",
    "    temp = exposure.equalize_adapthist(image, clip_limit=0.03)\n",
    "    flat = np.sort(np.matrix.getA1(temp))\n",
    "    sum_all = np.sum(flat)\n",
    "    index = np.argmin(flat.cumsum() < (sum_all * cutoff))\n",
    "\n",
    "    temp = thresholded(temp, flat[index])\n",
    "    temp = temp * 1\n",
    "    temp = np.nonzero(temp)\n",
    "    ymin, ymax = find_min_max_without_orphand_pixels(temp[0])\n",
    "    xmin,xmax = find_min_max_without_orphand_pixels(temp[1])\n",
    "    return ymin, ymax, xmin, xmax\n",
    "\n",
    "# initial static crop and a seondary dynamic crop based on signal2noise ratio\n",
    "def crop_full_scan(image):\n",
    "    temp = crop(image, Y_START, Y_END, X_START, X_END)\n",
    "    ymin, ymax, xmin, xmax = calc_min_max_coordinates_dynamic(temp, cutoff=BG_2_OBJ_RATIO)\n",
    "    temp = crop(image, Y_START+ymin, Y_START+ymax, X_START+xmin, X_START+xmax)\n",
    "    return temp\n",
    "\n",
    "def crop_thresholded(image):\n",
    "    temp = crop(image, 0, image.shape[0]-1, 0, image.shape[1]-1)\n",
    "    ymin, ymax, xmin, xmax = calc_min_max_coordinates(temp)\n",
    "    temp = crop(image, ymin, ymax, xmin, xmax)\n",
    "    return temp\n",
    "\n",
    "def read_and_crop(image_name):\n",
    "    if \"il239838\" in os.getcwd():\n",
    "        image = img.imread(ROOT_FOLDER + image_name)\n",
    "    else:\n",
    "        f = urllib.request.urlopen(\"https://dl.dropboxusercontent.com/s/31b96942qdcn73k/\" + image_name)\n",
    "        image = img.imread(f, format='jpeg')\n",
    "\n",
    "    # Smart-crop the image to get rid of all the noise and redundant area\n",
    "    # return crop_full_scan(image)\n",
    "    cropped = crop_full_scan(image)\n",
    "    return exposure.equalize_adapthist(cropped, clip_limit=0.03)\n",
    "\n",
    "\n",
    "# TODO: fix performance!!! http://scikit-image.org/docs/dev/user_guide/tutorial_parallelization.html\n",
    "def combine_3_images_to_RGB(red, green, blue):\n",
    "    new_image = np.empty((blue.shape[0],blue.shape[1],3))\n",
    "    for x in range(0, blue.shape[0]):\n",
    "        for y in range(0, blue.shape[1]):\n",
    "            new_image[x,y,0] = red[x,y]\n",
    "            new_image[x,y,1] = green[x,y]\n",
    "            new_image[x,y,2] = blue[x,y]\n",
    "    return new_image\n",
    "\n",
    "def slice_image_left_edge(original, width=200, rotate=0):\n",
    "    rot = ndimage.rotate(original, rotate)\n",
    "    # Slice the left slice of the so-called \"blue\" image\n",
    "    left_edge_orig = crop(rot, 1, 1400, 1, width)\n",
    "    left_edge_orig = crop_thresholded(left_edge_orig)\n",
    "\n",
    "    # Copy to a new array so we don't thrash the origin\n",
    "    left_edge = np.empty_like (left_edge_orig)\n",
    "    np.copyto(left_edge, left_edge_orig)\n",
    "\n",
    "    # Zero down low level \"noise\" values\n",
    "    low_values_indices = left_edge < 30  # Where values are low\n",
    "    left_edge[low_values_indices] = 0  # All low values set to 0\n",
    "    return left_edge\n",
    "\n",
    "def get_best_angle_rotation(original, crop=True, width=200):\n",
    "    min_var = 99999999999\n",
    "    best_angle = -10\n",
    "    for x in range(-5,5):\n",
    "        if crop:            \n",
    "            rot_edge = slice_image_left_edge(original, width, x)\n",
    "        else:\n",
    "            rot_edge = ndimage.rotate(original, x)\n",
    "        left_var = np.var(rot_edge, axis=1)\n",
    "        # left_var = np.apply_along_axis(lambda v: np.var(v[np.nonzero(v)]), 1, rot_edge)\n",
    "        var_sum = np.sum(left_var)\n",
    "        if (var_sum < min_var):\n",
    "            min_var = var_sum\n",
    "            best_angle = x\n",
    "    print (\"best_angle=\"+str(best_angle))\n",
    "    return best_angle\n",
    "\n",
    "#     import pdb; pdb.set_trace()\n",
    "def calc_neighbors(slice_map, col, row):\n",
    "    # import pdb; pdb.set_trace()\n",
    "    if ((col-1, row) in slice_map and slice_map[(col-1, row)] != None):\n",
    "        slice_map[(col, row)][\"left\"] = slice_map[(col-1, row)]\n",
    "        slice_map[(col-1, row)][\"right\"] = slice_map[(col, row)]\n",
    "    if ((col+1, row) in slice_map and slice_map[(col+1, row)] != None):\n",
    "        slice_map[(col, row)][\"right\"] = slice_map[(col+1, row)]\n",
    "        slice_map[(col+1, row)][\"left\"] = slice_map[(col, row)]\n",
    "    if ((col, row-1) in slice_map and slice_map[(col, row-1)] != None):\n",
    "        slice_map[(col, row)][\"top\"] = slice_map[(col, row-1)]\n",
    "        slice_map[(col, row-1)][\"bottom\"] = slice_map[(col, row)]\n",
    "    if ((col, row+1) in slice_map and slice_map[(col, row+1)] != None):\n",
    "        slice_map[(col, row)][\"bottom\"] = slice_map[(col, row+1)]\n",
    "        slice_map[(col, row+1)][\"top\"] = slice_map[(col, row)]\n",
    "    \n",
    "\n",
    "\n",
    "def VAL_create_cube(name, raw, x, y):\n",
    "    cube = {}\n",
    "    cube[\"cube\"] = raw\n",
    "    cube[\"file\"] = name\n",
    "    if name.find('P') == 0:\n",
    "        cube[\"index\"] = int(name[name.find('P')+1:name.find('P')+4]) * 1000 + int(name[name.find('Fg')+2:name.find('Fg')+5])\n",
    "    else:\n",
    "        print(\"Found a ZERO index cube with the name:\"+name)\n",
    "        cube[\"index\"] = 0\n",
    "    cube[\"top_row\"] = x\n",
    "    cube[\"left_col\"] = y\n",
    "    cube[\"right_col\"] = y + CUBE_SIZE\n",
    "    return cube\n",
    "    \n",
    "\n",
    "ZERO_CUBE = VAL_create_cube(\"ZERO\", np.zeros((CUBE_SIZE, CUBE_SIZE), dtype=np.int), -1, -2)\n",
    "\n",
    "# slice an image to cubes with 250X250 pixel size\n",
    "def VAL_slice_TEAR_to_static_slices(name, cropped_original):\n",
    "    structure = []\n",
    "    # cropped_original = cropped_original / 256 # divide by 256 to \"normalize\" between 0 and 1\n",
    "\n",
    "    # import pdb; pdb.set_trace()\n",
    "    x, y = cropped_original[\"cut\"].shape\n",
    "    print (x,y)\n",
    "    n = 0\n",
    "    # every 250 pixels on the x axis == rows\n",
    "    while ((n + 1) * CUBE_SIZE < x):\n",
    "        m = 0\n",
    "        # every 250 pixels on the y axis == cols\n",
    "        while ((m + 1) * CUBE_SIZE < y):\n",
    "            if ((m == 0) or ((m + 2) * CUBE_SIZE >= y)): # Only keep the left and right edges of the piece for matching!!\n",
    "                # cut a cube of 250X250\n",
    "                cube = crop(cropped_original[\"cut\"], n * CUBE_SIZE, (n + 1) * CUBE_SIZE, m * CUBE_SIZE, (m + 1) * CUBE_SIZE)\n",
    "                # keep only cubes for which half of the pixels have some \"color\"\n",
    "                # print(np.median(cube))\n",
    "                if np.median(cube) > 0.2: # aligned with the normalization 0.2 correlates to 50\n",
    "                    # keep the cube\n",
    "                    new_cube = VAL_create_cube(name, cube, n * CUBE_SIZE, m * CUBE_SIZE)\n",
    "                    new_cube[\"col\"] = m\n",
    "                    new_cube[\"row\"] = n\n",
    "                    new_cube[\"orig\"] = cropped_original\n",
    "                    new_cube[\"col_px_left\"] = cropped_original[\"col_px\"] + m * CUBE_SIZE\n",
    "                    new_cube[\"col_px_right\"] = cropped_original[\"col_px\"] + (m + 1) * CUBE_SIZE\n",
    "                    new_cube[\"row_px_top\"] = cropped_original[\"row_px\"] + n * CUBE_SIZE\n",
    "                    new_cube[\"row_px_bottom\"] = cropped_original[\"row_px\"] + (n + 1) * CUBE_SIZE\n",
    "                    structure.append(new_cube)\n",
    "            m += 1\n",
    "        n += 1\n",
    "            \n",
    "    # return the data structure with all the cubes and the counters of the rows and columns\n",
    "    return structure\n",
    "\n",
    "def pad_above(original, above, amount):\n",
    "    res = np.insert(original[\"cube\"], np.zeros(amount), above[\"cube\"][-amount:], axis=0)\n",
    "    res = np.delete(res, np.arange(CUBE_SIZE,CUBE_SIZE+amount), axis=0)\n",
    "    return create_cube(res, original[\"top_row\"] - amount, original[\"left_col\"])\n",
    "  \n",
    "\n",
    "def pad_below(original, below, amount):\n",
    "    res = np.insert(original[\"cube\"], np.full(amount, CUBE_SIZE), below[\"cube\"][:amount], axis=0)\n",
    "    res = np.delete(res, np.arange(0, amount), axis=0)\n",
    "    return create_cube(res, original[\"top_row\"] + amount, original[\"left_col\"])\n",
    "\n",
    "def pad_left(original, left, amount):\n",
    "    res = np.insert(original[\"cube\"], np.zeros(amount, dtype=int), left[\"cube\"][:,-amount:], axis=1)\n",
    "    res = np.delete(res, np.arange(CUBE_SIZE, CUBE_SIZE+amount), axis=1)\n",
    "    return create_cube(res, original[\"top_row\"], original[\"left_col\"] - amount)\n",
    "\n",
    "def pad_right(original, right, amount):\n",
    "    res = np.insert(original[\"cube\"], [CUBE_SIZE], right[\"cube\"][:,:amount], axis=1)\n",
    "    res = np.delete(res, np.arange(0, amount), axis=1)\n",
    "    return create_cube(res, original[\"top_row\"], original[\"left_col\"] + amount)\n",
    "    \n",
    "\n",
    "# \"Shave\" the right edge of the cube with <gap> pixels and pad with zeros on the left\n",
    "def shave_right(original, amount):\n",
    "    return pad_left(original, ZERO_CUBE, amount)\n",
    "    \n",
    "\n",
    "# \"Shave\" the left edge of the cube with <gap> pixels and pad with zeros on the right    \n",
    "def shave_left(original, amount):\n",
    "    return pad_right(original, ZERO_CUBE, amount)\n",
    "    \n",
    "\n",
    "# concatenate cubes \n",
    "def VAL_concatenate_cubes(left, right, slice_size):\n",
    "    right_img = right[\"cube\"]\n",
    "    # next block is not relevant for training now that we moved to euclidean distance... or at all ...\n",
    "    #     # if the left cube is matched to another left cube (or right cube to another right cube) then rotate the right\n",
    "    #     # cube by 180 so we try to match it upside down, covering the option that the cube was pictured rotated\n",
    "    #     if ((left[\"col\"] == 0 and right[\"col\"] == 0) or (left[\"col\"] != 0 and right[\"col\"] != 0)):\n",
    "    #         right_img = np.rot90(right[\"cube\"], 2);\n",
    "\n",
    "    con = np.concatenate((left[\"cube\"][:,-slice_size:], right_img[:,:slice_size]), axis=1)\n",
    "\n",
    "    # next block calculates distance based on the distance between left's right-top corner and right's left-top corner    \n",
    "    #     x_delta = right[\"top_row\"] - left[\"top_row\"]\n",
    "    #     y_delta = right[\"left_col\"] - left[\"right_col\"] \n",
    "\n",
    "    # next block calculates the distance between the centers of cubes, accounting for test set's possibility of reverse slices (left instead of right and vice versa)\n",
    "    x_delta = right[\"top_row\"] - left[\"top_row\"] # equivalent to distance between vertical centers\n",
    "    y_delta = (right[\"left_col\"] + (slice_size / 2)) - (left[\"right_col\"] - (slice_size / 2)) # measuring the distance between horizontal centers of the slices\n",
    "\n",
    "    return con, x_delta, y_delta, left[\"file\"], right[\"file\"]\n",
    "    \n",
    "\n",
    "# concatenate cubes while artificially creating a gap between them. Pad the other end of the cube with zeros\n",
    "def concatenate_cubes_zero_pad_gaps(left_orig, right_orig, gap):\n",
    "    left = left_orig if gap == 0 else shave_right(left_orig, gap)\n",
    "    right = right_orig if gap == 0 else shave_left(right_orig, gap)\n",
    "    return concatenate_cubes(left, right)    \n",
    "\n",
    "# concatenate cubes while artificially creating a gap between them. Pad the other end of the cobe with the nearby\n",
    "# continuation of the cubes\n",
    "def concatenate_cubes_with_gap(left_orig, right_orig, gap, left_pad, right_pad, slice_size):\n",
    "    # import pdb; pdb.set_trace()\n",
    "    left = left_orig if gap == 0 else pad_left(left_orig, left_pad, gap)\n",
    "    right = right_orig if gap == 0 else pad_right(right_orig, right_pad, gap)\n",
    "    return concatenate_cubes(left, right, slice_size)        \n",
    "\n",
    "# convert the data structure of cubes into a train set of 2 arrays of images and labels\n",
    "# each image is a concatanation of 2 images from the original cubes set, covering all combinations of images\n",
    "# effectively creating Nx(N-1) images\n",
    "def VAL_build_train_set_for_euclidean_distance(cubes, slice_size, folder):\n",
    "    #import pdb; pdb.set_trace()\n",
    "    warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "    train_imgs = []\n",
    "    train_x_delta = []\n",
    "    train_y_delta = []\n",
    "    train_left_obj = []\n",
    "    train_right_obj = []\n",
    "    # iterate over all cubes   \n",
    "    for curr in cubes:\n",
    "        # iterate over the others (effectively n^2)\n",
    "        for adj in cubes:\n",
    "            if (adj[\"file\"] != curr[\"file\"]): # no need to test against self CURRENTLY checking from directions!!!\n",
    "                #import pdb; pdb.set_trace()\n",
    "                # append the adjacent image to the current image\n",
    "                conc, x_delta, y_delta, x_file, y_file = VAL_concatenate_cubes(curr, adj, slice_size)\n",
    "                output = folder+x_file+\"_\"+str(curr[\"top_row\"])+\"_\"+str(curr[\"left_col\"])+\"---\"+y_file+\"_\"+str(adj[\"top_row\"])+\"_\"+str(adj[\"left_col\"])\n",
    "                np.save(output, conc)\n",
    "                train_imgs.append(output)\n",
    "                train_x_delta.append(x_delta)\n",
    "                train_y_delta.append(y_delta)\n",
    "                train_left_obj.append(curr)\n",
    "                train_right_obj.append(adj)\n",
    "\n",
    "    warnings.filterwarnings(\"default\")\n",
    "    return train_imgs, train_x_delta, train_y_delta, train_left_obj, train_right_obj\n",
    "\n",
    "\n",
    "# convert the data structure of cubes into a train set of 2 arrays of images and labels\n",
    "# each image is a concatanation of 2 images from the original cubes set, covering all combinations of images\n",
    "# effectively creating Nx(N-1) images\n",
    "def ORIG_build_train_set(cubes, gap):\n",
    "    # import pdb; pdb.set_trace()\n",
    "    warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "    train_imgs = []\n",
    "    train_lbls = []\n",
    "    train_x_delta = []\n",
    "    train_y_delta = []\n",
    "    # iterate over the rows and cols, essentially going over the grid of sliced cubes\n",
    "    for row in range(0, rows):\n",
    "        for col in range(0, cols):\n",
    "            # if this cube exists (could have been removed previously due to lack of data)\n",
    "            if (cubes[(col, row)] != None):\n",
    "                # for each \"current\" image in the iteration\n",
    "                curr = cubes[(col, row)]\n",
    "                # iterate over all the cubes to find all the \"other\" (adjacent) cubes\n",
    "                for adj_row in range(0, rows):\n",
    "                    for adj_col in range(0, cols):\n",
    "                        if (adj_row != row or adj_col != col):\n",
    "                            if (cubes[(adj_col, adj_row)] != None):\n",
    "                                adj = cubes[(adj_col, adj_row)]\n",
    "                                # append the adjacent image to the current image\n",
    "                                # pass the filling cubes on the right and left to pad against the gap\n",
    "                                if (gap == 0 or (\"left\" in curr.keys() and \"right\" in adj.keys())):\n",
    "                                    if (gap == 0):\n",
    "                                        conc, x_delta, y_delta = concatenate_cubes(curr, adj, slice_size)\n",
    "                                    else:\n",
    "                                        conc, x_delta, y_delta = concatenate_cubes_with_gap(curr, adj, gap, curr[\"left\"], adj[\"right\"], slice_size)\n",
    "                                    train_imgs.append(conc)\n",
    "                                    train_x_delta.append(x_delta)\n",
    "                                    train_y_delta.append(y_delta)\n",
    "                                    # if the adj image is on the same row and on the right of the curr image - it will be marked as match    \n",
    "                                    if (adj_row == row and adj_col == (col + 1)):\n",
    "                                        # mark the image as matched\n",
    "                                        train_lbls.append([0,1])\n",
    "                                        # need to enrich the set with a few more tru positive samples - so we offset \n",
    "                                        # the matched images up ad down a few times and create more matches\n",
    "                                        if (\"top\" in curr.keys() and \"top\"in adj.keys()):\n",
    "                                            for i in range(5, 101, 5):\n",
    "                                                curr1 = pad_above(curr, curr[\"top\"],i)\n",
    "                                                adj1 = pad_above(adj, adj[\"top\"],i)\n",
    "                                                if (gap == 0 or (\"left\" in curr.keys() and \"right\" in adj.keys() and \"top\" in curr[\"left\"].keys() and \"top\"in curr[\"right\"].keys())):\n",
    "                                                    if (gap == 0):\n",
    "                                                        conc, x_delta, y_delta = concatenate_cubes(curr1, adj1, slice_size)\n",
    "                                                    else:\n",
    "                                                        curr1Left = pad_above(curr[\"left\"], curr[\"left\"][\"top\"], i) # FIXIT?\n",
    "                                                        adj1Right = pad_above(adj[\"right\"], curr[\"right\"][\"top\"], i) # FIXIT?\n",
    "                                                        conc, x_delta, y_delta = concatenate_cubes_with_gap(curr1, adj1, gap, curr1Left, adj1Right, slice_size)\n",
    "                                                    train_imgs.append(conc)\n",
    "                                                    train_x_delta.append(x_delta)\n",
    "                                                    train_y_delta.append(y_delta)\n",
    "                                                    # mark the image as matched\n",
    "                                                    train_lbls.append([0,1])\n",
    "                                        if (\"bottom\" in curr.keys() and \"bottom\"in adj.keys()):\n",
    "                                            for i in range(5, 101, 5):\n",
    "                                                curr1 = pad_below(curr, curr[\"bottom\"],i)\n",
    "                                                adj1 = pad_below(adj, adj[\"bottom\"],i)\n",
    "                                                if (gap == 0 or (\"left\" in curr.keys() and \"right\" in adj.keys() and \"bottom\" in curr[\"left\"].keys() and \"bottom\"in curr[\"right\"].keys())):\n",
    "                                                    if (gap == 0):\n",
    "                                                        conc, x_delta, y_delta = concatenate_cubes(curr1, adj1, slice_size)\n",
    "                                                    else:\n",
    "                                                        curr1Left = pad_below(curr[\"left\"], curr[\"left\"][\"bottom\"], i) # FIXIT?\n",
    "                                                        adj1Right = pad_below(adj[\"right\"], curr[\"right\"][\"bottom\"], i) # FIXIT?\n",
    "                                                        conc, x_delta, y_delta = concatenate_cubes_with_gap(curr1, adj1, gap, curr1Left, adj1Right, slice_size)\n",
    "                                                    train_imgs.append(conc)\n",
    "                                                    train_x_delta.append(x_delta)\n",
    "                                                    train_y_delta.append(y_delta)\n",
    "                                                    # mark the image as matched\n",
    "                                                    train_lbls.append([0,1])\n",
    "                                        if (\"left\" in curr.keys()): # enough to check only the curr as the left of the adj is the curr\n",
    "                                            for i in range(5, 101, 5):\n",
    "                                                curr1 = pad_left(curr, curr[\"left\"],i)\n",
    "                                                adj1 = pad_left(adj, adj[\"left\"],i) # essentially the curr\n",
    "                                                if (gap == 0 or (\"left\" in curr.keys() and \"right\" in adj.keys())):\n",
    "                                                    if (gap == 0):\n",
    "                                                        conc, x_delta, y_delta = concatenate_cubes(curr1, adj1, slice_size)\n",
    "                                                    else:\n",
    "                                                        curr1Left = pad_left(curr[\"left\"], ZERO_CUBE, i) # FIXIT? + assuming the gap will not be more than 150\n",
    "                                                        adj1Right = pad_left(adj[\"right\"], ZERO_CUBE, i) # FIXIT? + assuming the gap will not be more than 150\n",
    "                                                        conc, x_delta, y_delta = concatenate_cubes_with_gap(curr1, adj1, gap, curr1Left, adj1Right, slice_size)\n",
    "                                                    train_imgs.append(conc)\n",
    "                                                    train_x_delta.append(x_delta)\n",
    "                                                    train_y_delta.append(y_delta)\n",
    "                                                    # mark the image as matched\n",
    "                                                    train_lbls.append([0,1])\n",
    "                                        if (\"right\" in adj.keys()): # enough to check only the adj as the right of the curr is the adj\n",
    "                                            for i in range(5, 101, 5):\n",
    "                                                curr1 = pad_right(curr, curr[\"right\"],i) # essentially the adj\n",
    "                                                adj1 = pad_right(adj, adj[\"right\"],i)\n",
    "                                                if (gap == 0 or (\"left\" in curr.keys() and \"right\" in adj.keys())):\n",
    "                                                    if (gap == 0):\n",
    "                                                        conc, x_delta, y_delta = concatenate_cubes(curr1, adj1, slice_size)\n",
    "                                                    else:\n",
    "                                                        curr1Left = pad_right(curr[\"left\"], ZERO_CUBE, i) # FIXIT? + assuming the gap will not be more than 150\n",
    "                                                        adj1Right = pad_right(adj[\"right\"], ZERO_CUBE, i) # FIXIT? + assuming the gap will not be more than 150\n",
    "                                                        conc, x_delta, y_delta = concatenate_cubes_with_gap(curr1, adj1, gap, curr1Left, adj1Right, slice_size)\n",
    "                                                    train_imgs.append(conc)\n",
    "                                                    train_x_delta.append(x_delta)\n",
    "                                                    train_y_delta.append(y_delta)\n",
    "                                                    # mark the image as matched\n",
    "                                                    train_lbls.append([0,1])\n",
    "                                    else:\n",
    "                                        # mark the image as not matched\n",
    "                                        train_lbls.append([1,0])\n",
    "                                \n",
    "    warnings.filterwarnings(\"default\")\n",
    "    return train_imgs, train_lbls, train_x_delta, train_y_delta\n",
    "\n",
    "\n",
    "def NEW_build_train_set_for_binary_labeling(cubes, gap, slice_size):\n",
    "    print(\"#####################################################################\")\n",
    "    print(\"TRAINING\")\n",
    "    print(\"#####################################################################\")\n",
    "\n",
    "    train_imgs = []\n",
    "    train_lbls = []\n",
    "    train_x_delta = []\n",
    "    train_y_delta = []\n",
    "\n",
    "    # iterate over the cubes\n",
    "    for curr in cubes:\n",
    "        # iterate over the others (effectively n^2)\n",
    "        for adj in cubes:\n",
    "            if (adj[\"file\"] != curr[\"file\"]) and curr[\"index\"] < adj[\"index\"]: # no need to test against self and avoid checking from both directions\n",
    "                # import pdb; pdb.set_trace()\n",
    "                # append the adjacent image to the current image\n",
    "                conc, x_delta, y_delta, x_file, y_file = VAL_concatenate_cubes(curr, adj, slice_size)\n",
    "                output = folder+x_file[:x_file.rfind(' ')]+\"_\"+str(curr[\"top_row\"])+\"_\"+str(curr[\"left_col\"])+\"---\"+y_file[:y_file.rfind(' ')]+\"_\"+str(adj[\"top_row\"])+\"_\"+str(adj[\"left_col\"])\n",
    "                np.save(output, conc)\n",
    "                train_imgs.append(output)\n",
    "                train_x_delta.append(x_delta)\n",
    "                train_y_delta.append(y_delta)\n",
    "\n",
    "    warnings.filterwarnings(\"default\")\n",
    "    return train_imgs, train_lbls, train_x_delta, train_y_delta\n",
    "        \n",
    "    print(\"#####################################################################\")\n",
    "    print(\"VALIDATION ENDED\")\n",
    "    print(\"#####################################################################\")\n",
    "    print(\" \")\n",
    "    print(\" \")\n",
    "\n",
    "\n",
    "def frame_to_n_by_m(orig, start_vector, end_vector, is_col):\n",
    "    max_val = np.amax(end_vector)\n",
    "    min_val = np.amin(start_vector)\n",
    "    width = max_val - min_val\n",
    "    if (is_col):\n",
    "        result = np.zeros((start_vector.size, width))\n",
    "    else:\n",
    "        result = np.zeros((width, start_vector.size))\n",
    "    \n",
    "    for i in range(0, start_vector.size):\n",
    "        if (is_col):\n",
    "            row_vec = orig[i, start_vector[i]:end_vector[i]]\n",
    "        else:\n",
    "            row_vec = orig[start_vector[i]:end_vector[i],i]\n",
    "        temp = np.lib.pad(row_vec, (start_vector[i]-min_val, max_val-end_vector[i]), 'constant', constant_values=(0.09, 0.09))\n",
    "        if (is_col):\n",
    "            if (result[i].size != width):\n",
    "                import pdb; pdb.set_trace()\n",
    "            result[i] = temp[0:width]\n",
    "        else:\n",
    "            result[:,i] = temp[0:width]\n",
    "    return min_val, result\n",
    "\n",
    "def rough_tear_line(orig, start_vector, cut_mean, is_col, chew_factor):\n",
    "    end_vector = np.empty(start_vector.size).astype(int)\n",
    "    if (is_col and np.absolute(cut_mean-orig.shape[1]) < 10):\n",
    "        end_vector.fill(orig.shape[1])\n",
    "    elif (not is_col and np.absolute(cut_mean-orig.shape[0]) < 10):\n",
    "        end_vector.fill(orig.shape[0])\n",
    "    else:\n",
    "        deviation_vector = np.random.normal(0, chew_factor, start_vector.size).astype(int)\n",
    "        end_vector[0] = cut_mean + deviation_vector[0]\n",
    "        for i in range(1, end_vector.size):\n",
    "            end_vector[i] = end_vector[i - 1] + deviation_vector[i]\n",
    "    \n",
    "    start_px, cut_piece = frame_to_n_by_m(orig, start_vector, end_vector, is_col)    \n",
    "    return start_px, cut_piece, end_vector\n",
    "\n",
    "def rough_tear_image(image, cols, rows):\n",
    "    pieces = []\n",
    "    col_width = int(image.shape[1] / cols)\n",
    "    row_height = int(image.shape[0] / rows)\n",
    "    print(col_width, row_height)\n",
    "    next_col_start_vec = np.zeros((image.shape[0],), dtype=int)\n",
    "    for col_idx in range(0, cols):\n",
    "    #         import pdb; pdb.set_trace()\n",
    "        start_col_px, cut_column, next_col_start_vec =  rough_tear_line(image, next_col_start_vec, col_width * (col_idx + 1), True, 5)\n",
    "        next_row_start_vec = np.zeros((cut_column.shape[1],), dtype=int)\n",
    "        for row_idx in range(0, rows):\n",
    "            start_row_px, cut_piece, next_row_start_vec = rough_tear_line(cut_column, next_row_start_vec, row_height * (row_idx + 1), False, 1)\n",
    "\n",
    "            ymin, ymax, xmin, xmax = calc_min_max_coordinates_dynamic(cut_piece, cutoff=BG_2_OBJ_RATIO)\n",
    "            temp = crop(cut_piece, ymin, ymax, xmin, xmax)\n",
    "            \n",
    "            #import pdb; pdb.set_trace()\n",
    "            piece = {}\n",
    "            piece[\"orig\"] = cut_piece\n",
    "            piece[\"cut\"] = temp\n",
    "            piece[\"col\"] = col_idx\n",
    "            piece[\"row\"] = row_idx\n",
    "            piece[\"col_px\"] = start_col_px + xmin\n",
    "            piece[\"row_px\"] = start_row_px + ymin\n",
    "            pieces.append(piece)\n",
    "            \n",
    "    return pieces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# RUN Define model util functions\n",
    "\n",
    "# initialize a shaped matrix of weights with random values\n",
    "def weight_variable(shape):\n",
    "  initial = tf.truncated_normal(shape, stddev=0.1)\n",
    "  return tf.Variable(initial)\n",
    "\n",
    "# initialize a shaped matrix of bias with random values\n",
    "def bias_variable(shape):\n",
    "  initial = tf.constant(0.1, shape=shape)\n",
    "  return tf.Variable(initial)\n",
    "\n",
    "def conv2d(x, W):\n",
    "  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')\n",
    "\n",
    "def max_pool_2x2(x):\n",
    "  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],\n",
    "                        strides=[1, 2, 2, 1], padding='SAME')\n",
    "\n",
    "def max_pool_1x2(x):\n",
    "  return tf.nn.max_pool(x, ksize=[1, 1, 2, 1],\n",
    "                        strides=[1, 1, 2, 1], padding='SAME')\n",
    "\n",
    "def max_pool_2x1(x):\n",
    "  return tf.nn.max_pool(x, ksize=[1, 2, 1, 1],\n",
    "                        strides=[1, 2, 1, 1], padding='SAME')\n",
    "\n",
    "def max_pool_1x1(x):\n",
    "  return tf.nn.max_pool(x, ksize=[1, 1, 1, 1],\n",
    "                        strides=[1, 1, 1, 1], padding='SAME')\n",
    "\n",
    "def max_pool_5x5(x):\n",
    "  return tf.nn.max_pool(x, ksize=[1, 5, 5, 1],\n",
    "                        strides=[1, 5, 5, 1], padding='SAME')\n",
    "\n",
    "def max_pool_5x2(x):\n",
    "  return tf.nn.max_pool(x, ksize=[1, 5, 2, 1],\n",
    "                        strides=[1, 5, 2, 1], padding='SAME')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# RUN Image utility functions (external source)\n",
    "def branchedPoints(skel):\n",
    "    branch1=np.array([[2, 1, 2], [1, 1, 1], [2, 2, 2]])\n",
    "    branch2=np.array([[1, 2, 1], [2, 1, 2], [1, 2, 1]])\n",
    "    branch3=np.array([[1, 2, 1], [2, 1, 2], [1, 2, 2]])\n",
    "    branch4=np.array([[2, 1, 2], [1, 1, 2], [2, 1, 2]])\n",
    "    branch5=np.array([[1, 2, 2], [2, 1, 2], [1, 2, 1]])\n",
    "    branch6=np.array([[2, 2, 2], [1, 1, 1], [2, 1, 2]])\n",
    "    branch7=np.array([[2, 2, 1], [2, 1, 2], [1, 2, 1]])\n",
    "    branch8=np.array([[2, 1, 2], [2, 1, 1], [2, 1, 2]])\n",
    "    branch9=np.array([[1, 2, 1], [2, 1, 2], [2, 2, 1]])\n",
    "    br1=mh.morph.hitmiss(skel,branch1)\n",
    "    br2=mh.morph.hitmiss(skel,branch2)\n",
    "    br3=mh.morph.hitmiss(skel,branch3)\n",
    "    br4=mh.morph.hitmiss(skel,branch4)\n",
    "    br5=mh.morph.hitmiss(skel,branch5)\n",
    "    br6=mh.morph.hitmiss(skel,branch6)\n",
    "    br7=mh.morph.hitmiss(skel,branch7)\n",
    "    br8=mh.morph.hitmiss(skel,branch8)\n",
    "    br9=mh.morph.hitmiss(skel,branch9)\n",
    "    return br1+br2+br3+br4+br5+br6+br7+br8+br9\n",
    "\n",
    "def endPoints(skel):\n",
    "    endpoint1=np.array([[0, 0, 0],\n",
    "                        [0, 1, 0],\n",
    "                        [2, 1, 2]])\n",
    "    \n",
    "    endpoint2=np.array([[0, 0, 0],\n",
    "                        [0, 1, 2],\n",
    "                        [0, 2, 1]])\n",
    "    \n",
    "    endpoint3=np.array([[0, 0, 2],\n",
    "                        [0, 1, 1],\n",
    "                        [0, 0, 2]])\n",
    "    \n",
    "    endpoint4=np.array([[0, 2, 1],\n",
    "                        [0, 1, 2],\n",
    "                        [0, 0, 0]])\n",
    "    \n",
    "    endpoint5=np.array([[2, 1, 2],\n",
    "                        [0, 1, 0],\n",
    "                        [0, 0, 0]])\n",
    "    \n",
    "    endpoint6=np.array([[1, 2, 0],\n",
    "                        [2, 1, 0],\n",
    "                        [0, 0, 0]])\n",
    "    \n",
    "    endpoint7=np.array([[2, 0, 0],\n",
    "                        [1, 1, 0],\n",
    "                        [2, 0, 0]])\n",
    "    \n",
    "    endpoint8=np.array([[0, 0, 0],\n",
    "                        [2, 1, 0],\n",
    "                        [1, 2, 0]])\n",
    "    \n",
    "    ep1=mh.morph.hitmiss(skel,endpoint1)\n",
    "    ep2=mh.morph.hitmiss(skel,endpoint2)\n",
    "    ep3=mh.morph.hitmiss(skel,endpoint3)\n",
    "    ep4=mh.morph.hitmiss(skel,endpoint4)\n",
    "    ep5=mh.morph.hitmiss(skel,endpoint5)\n",
    "    ep6=mh.morph.hitmiss(skel,endpoint6)\n",
    "    ep7=mh.morph.hitmiss(skel,endpoint7)\n",
    "    ep8=mh.morph.hitmiss(skel,endpoint8)\n",
    "    ep = ep1+ep2+ep3+ep4+ep5+ep6+ep7+ep8\n",
    "    return ep\n",
    "\n",
    "def pruning(skeleton, size):\n",
    "    '''remove iteratively end points \"size\" \n",
    "       times from the skeleton\n",
    "    '''\n",
    "    for i in range(0, size):\n",
    "        endpoints = endPoints(skeleton)\n",
    "        endpoints = np.logical_not(endpoints)\n",
    "        skeleton = np.logical_and(skeleton,endpoints)\n",
    "    return skeleton\n",
    "\n",
    "def plot_comparison(original, filtered, filter_name):\n",
    "\n",
    "    fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(8, 4), sharex=True, sharey=True)\n",
    "    ax1.imshow(original, cmap=plt.cm.gray)\n",
    "    ax1.set_title('original')\n",
    "    ax1.axis('off')\n",
    "    ax1.set_adjustable('box-forced')\n",
    "    ax2.imshow(filtered, cmap=plt.cm.gray)\n",
    "    ax2.set_title(filter_name)\n",
    "    ax2.axis('off')\n",
    "    ax2.set_adjustable('box-forced')\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# RUN Define the linear model - 250, 125, 62, 25\n",
    "def linear_model_tf(input_width): \n",
    "    global accuracy, correct_prediction, train_step, x, y_, y_conv, keep_prob, W_fc, b_fc, cost, y_conv_temp\n",
    "    \n",
    "    # foundation of the model - the input layer of the image 250 x input_width*2\n",
    "    x = tf.placeholder(tf.float32, [None, 250, input_width*2], \"001\")\n",
    "    x_image = tf.reshape(x, [-1,250,input_width*2,1], \"0011\") # 1 is the number of color channels\n",
    "\n",
    "    # the target digits of the model\n",
    "    y_ = tf.placeholder(tf.float32, [None, 1], \"002\")\n",
    "\n",
    "    # first convolutional layer: one input image and 32 output filters of 5x5\n",
    "    W_conv1 = weight_variable([5, 5, 1, 32])\n",
    "    b_conv1 = bias_variable([32])\n",
    "    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1, \"0021\")\n",
    "    if (input_width == 250):\n",
    "        h_pool1 = max_pool_2x2(h_conv1) # size is reduced to 125x250\n",
    "    elif (input_width == 125):\n",
    "        h_pool1 = max_pool_2x1(h_conv1) # size is reduced to 125x250\n",
    "    elif (input_width == 62):\n",
    "        h_pool1 = max_pool_2x1(h_conv1) # size is reduced to 125x125\n",
    "    elif (input_width == 25):\n",
    "        h_pool1 = max_pool_2x1(h_conv1) # size is reduced to 125x50\n",
    "    else:\n",
    "        print(\"ERROR - unsupported slice width\")\n",
    "        return\n",
    "\n",
    "    # second convolutional layer: 32 input (filtered) images and 32 output filters of 5x5\n",
    "    W_conv2 = weight_variable([5, 5, 32, 32])\n",
    "    b_conv2 = bias_variable([32])\n",
    "    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2, \"0022\")\n",
    "    if (input_width == 62):\n",
    "        h_pool2 = max_pool_1x1(h_conv2) # size is reduced to 125x125\n",
    "    elif (input_width == 25):\n",
    "        h_pool2 = max_pool_1x1(h_conv2) # size is reduced to 125x50\n",
    "    else:\n",
    "        h_pool2 = max_pool_1x2(h_conv2) # size is reduced to 125x125\n",
    "\n",
    "\n",
    "    # third convolutional layer: 32 input (filtered) images and 32 output filters of 5x5\n",
    "    W_conv3 = weight_variable([5, 5, 32, 32])\n",
    "    b_conv3 = bias_variable([32])\n",
    "    h_conv3 = tf.nn.relu(conv2d(h_pool2, W_conv3) + b_conv3, \"0023\")\n",
    "    if (input_width == 25):\n",
    "        h_pool3 = max_pool_5x2(h_conv3) # size is reduced to 25x25\n",
    "    else:\n",
    "        h_pool3 = max_pool_5x5(h_conv3) # size is reduced to 25x25\n",
    "\n",
    "\n",
    "    h_pool3_flat = tf.reshape(h_pool3, [-1, 25*25*32]) # shape as an array \n",
    "\n",
    "    # fourth layer - fully connected with input 25*25*128 and output 1024\n",
    "    W_fc1 = weight_variable([25*25*32, 1024])\n",
    "    b_fc1 = bias_variable([1024])\n",
    "    h_fc1 = tf.nn.relu(tf.matmul(h_pool3_flat, W_fc1) + b_fc1, \"0024\")\n",
    "\n",
    "    # a drop layer with probability \n",
    "    keep_prob = tf.placeholder(tf.float32, name=\"003\")\n",
    "    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob, name=\"0031\")\n",
    "\n",
    "    # final layer - reduce to one \"class\" for the linear regression\n",
    "    W_fc = weight_variable([1024, 1]) \n",
    "    b_fc = bias_variable([1])         \n",
    "    y_conv_temp = tf.matmul(h_fc1_drop, W_fc, name=\"0032\") + b_fc\n",
    "    y_conv = tf.minimum(y_conv_temp, tf.constant(BREAK_VAL, tf.float32))\n",
    "    \n",
    "    #     # minimize loss function\n",
    "    #     cross_entropy = tf.reduce_mean(\n",
    "    #       tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))\n",
    "    # cost = tf.reduce_sum(tf.pow(y_conv - y_, 2))/(2*BATCHES*BATCH_SIZE) # Mean squared error\n",
    "    cost = tf.reduce_mean(tf.square(y_conv_temp - y_), name=\"0033\") # Mean squared error\n",
    "\n",
    "    #     # define train step and rate\n",
    "    #     train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)\n",
    "    train_step = tf.train.AdamOptimizer(LEARNING_RATE).minimize(cost) # Gradient descent\n",
    "    \n",
    "    # evaluate the prediction and the accuracy on the train test - needed only for printing during the training\n",
    "    correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))\n",
    "    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# RUN Define the classify model - 250, 125, 62, 25\n",
    "def model_tf(input_width): \n",
    "    global accuracy, correct_prediction, train_step, x, y_, y_conv, keep_prob\n",
    "    \n",
    "    # foundation of the model - the input layer of the image 250 x input_width*2\n",
    "    x = tf.placeholder(tf.float32, [None, 250, input_width*2])\n",
    "    x_image = tf.reshape(x, [-1,250,input_width*2,1]) # 1 is the number of color channels\n",
    "\n",
    "    # the target digits of the model\n",
    "    y_ = tf.placeholder(tf.float32, [None, 2])\n",
    "\n",
    "    # first convolutional layer: one input image and 32 output filters of 5x5\n",
    "    W_conv1 = weight_variable([5, 5, 1, 32])\n",
    "    b_conv1 = bias_variable([32])\n",
    "    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)\n",
    "    if (input_width == 250):\n",
    "        h_pool1 = max_pool_2x2(h_conv1) # size is reduced to 125x250\n",
    "    elif (input_width == 125):\n",
    "        h_pool1 = max_pool_2x1(h_conv1) # size is reduced to 125x250\n",
    "    elif (input_width == 62):\n",
    "        h_pool1 = max_pool_2x1(h_conv1) # size is reduced to 125x125\n",
    "    elif (input_width == 25):\n",
    "        h_pool1 = max_pool_2x1(h_conv1) # size is reduced to 125x50\n",
    "    else:\n",
    "        print(\"ERROR - unsupported slice width\")\n",
    "        return\n",
    "\n",
    "    # second convolutional layer: 32 input (filtered) images and 32 output filters of 5x5\n",
    "    W_conv2 = weight_variable([5, 5, 32, 32])\n",
    "    b_conv2 = bias_variable([32])\n",
    "    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)\n",
    "    if (input_width == 62):\n",
    "        h_pool2 = max_pool_1x1(h_conv2) # size is reduced to 125x125\n",
    "    elif (input_width == 25):\n",
    "        h_pool2 = max_pool_1x1(h_conv2) # size is reduced to 125x50\n",
    "    else:\n",
    "        h_pool2 = max_pool_1x2(h_conv2) # size is reduced to 125x125\n",
    "\n",
    "\n",
    "    # third convolutional layer: 32 input (filtered) images and 32 output filters of 5x5\n",
    "    W_conv3 = weight_variable([5, 5, 32, 32])\n",
    "    b_conv3 = bias_variable([32])\n",
    "    h_conv3 = tf.nn.relu(conv2d(h_pool2, W_conv3) + b_conv3)\n",
    "    if (input_width == 25):\n",
    "        h_pool3 = max_pool_5x2(h_conv3) # size is reduced to 25x25\n",
    "    else:\n",
    "        h_pool3 = max_pool_5x5(h_conv3) # size is reduced to 25x25\n",
    "\n",
    "\n",
    "    h_pool3_flat = tf.reshape(h_pool3, [-1, 25*25*32]) # shape as an array \n",
    "\n",
    "    # fourth layer - fully connected with input 25*25*128 and output 1024\n",
    "    W_fc1 = weight_variable([25*25*32, 1024])\n",
    "    b_fc1 = bias_variable([1024])\n",
    "    h_fc1 = tf.nn.relu(tf.matmul(h_pool3_flat, W_fc1) + b_fc1)\n",
    "\n",
    "    # a drop layer with probability \n",
    "    keep_prob = tf.placeholder(tf.float32)\n",
    "    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)\n",
    "\n",
    "    # final layer - softmax reduction 2 outputs\n",
    "    W_fc2 = weight_variable([1024, 2])\n",
    "    b_fc2 = bias_variable([2])\n",
    "    y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2\n",
    "\n",
    "    # minimize loss function\n",
    "    cross_entropy = tf.reduce_mean(\n",
    "      tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))\n",
    "\n",
    "    # define train step and rate\n",
    "    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)\n",
    "\n",
    "    # evaluate the prediction and the accuracy on the train test - needed only for printing during the training\n",
    "    correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))\n",
    "    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def train(train_imgs, train_diagonal_delta, output_model):\n",
    "    print(\"#####################################################################\")\n",
    "    print(\"TRAINING:\")\n",
    "    print(\"MODEL:\"+output_model)\n",
    "    print(\"#####################################################################\")\n",
    "\n",
    "    from random import randrange\n",
    "    \n",
    "    # TRAIN Prepare the session\n",
    "\n",
    "    # create a saver object\n",
    "    saver = tf.train.Saver()\n",
    "\n",
    "    # start session and initialize variables\n",
    "    sess = tf.InteractiveSession()\n",
    "    sess.run(tf.initialize_all_variables())\n",
    "\n",
    "    # TRAIN Train the model\n",
    "    x_batch = []\n",
    "    y_batch = []\n",
    "    # run the train batches\n",
    "    for i in range(BATCHES * BATCH_SIZE):\n",
    "        x_batch = []\n",
    "        y_batch = []\n",
    "        for _ in range(1):\n",
    "            random_index = randrange(0,len(train_imgs))\n",
    "            image = np.load(train_imgs[random_index]+\".npy\")\n",
    "            x_batch.append(image)\n",
    "            y_batch.append([train_diagonal_delta[random_index]])\n",
    "\n",
    "        # train\n",
    "        # print(\"step %d\"%(i))\n",
    "        train_step.run(feed_dict={x: x_batch, y_: y_batch, keep_prob: 0.5})\n",
    "\n",
    "        # print the accuracy thus far\n",
    "        if (i+1)%50 == 0:\n",
    "            # import pdb; pdb.set_trace()\n",
    "            # train_y = y_conv.eval(feed_dict={x:x_batch, y_: y_batch, keep_prob: 1.0})\n",
    "            train_y = y_conv_temp.eval(feed_dict={x:x_batch, y_: y_batch, keep_prob: 1.0})\n",
    "            train_cost = cost.eval(feed_dict={x:x_batch, y_: y_batch, keep_prob: 1.0})\n",
    "            print(\"Epoch:\", '%04d' % (i+1), \"cost=\", \"{:.9f}\".format(train_cost),\n",
    "                #\"W=\", sess.run(W_fc), \n",
    "                \"b=\", sess.run(b_fc), \"y_conv=\", train_y, \"y_real=\", y_batch)\n",
    "\n",
    "\n",
    "\n",
    "    print(\"Optimization Finished!\")\n",
    "    train_cost = cost.eval(feed_dict={\n",
    "        x:x_batch, y_: y_batch, keep_prob: 1.0})\n",
    "    print(\"Training cost=\", train_cost, \"W=\", sess.run(W_fc), \"b=\", sess.run(b_fc))\n",
    "\n",
    "\n",
    "    #     train_accuracy = accuracy.eval(feed_dict={\n",
    "    #         x:x_batch, y_: y_batch, keep_prob: 1.0})\n",
    "    #     print(\"step %d, training accuracy %g\"%(i, train_accuracy))\n",
    "\n",
    "    # Save the variables to disk.\n",
    "    save_path = saver.save(sess, output_model)\n",
    "    print(\"Model saved in file: %s\" % save_path)\n",
    "\n",
    "    # Close the Session when we're done. If un-commented - need to run next bock of restore...\n",
    "    sess.close()   \n",
    "    print(\"#####################################################################\")\n",
    "    print(\"TRIANING ENDED\")\n",
    "    print(\"#####################################################################\")\n",
    "    print(\" \")\n",
    "    print(\" \")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def pre_process(folder):\n",
    "    print(\"#####################################################################\")\n",
    "    print(\"PRE_PROCESS:\"+folder)\n",
    "    print(\"#####################################################################\")\n",
    "    result = []\n",
    "    \n",
    "    for root, dirs, files in os.walk(folder):\n",
    "        for file_ in files:\n",
    "            # Read the image\n",
    "            # image = img.imread(os.path.join(root, file_))\n",
    "            image = np.load(os.path.join(root, file_))\n",
    "            # import pdb; pdb.set_trace()\n",
    "            cubes = VAL_slice_to_static_slices(file_, image)\n",
    "            print(\"File: %s >>> cubes: %d\"%(file_, len(cubes)))\n",
    "            result.extend(cubes)\n",
    "    \n",
    "    return result\n",
    "    print(\"#####################################################################\")\n",
    "    print(\"PRE_PROCESS ENDED\")\n",
    "    print(\"#####################################################################\")\n",
    "    print(\" \")\n",
    "    print(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def pre_process_training(img_name):\n",
    "    print(\"#####################################################################\")\n",
    "    print(\"PRE_PROCESS:\"+img_name)\n",
    "    print(\"#####################################################################\")\n",
    "    image = read_and_crop(img_name)\n",
    "    result = []\n",
    "    \n",
    "    for col_cut in range(3, 5): # ...10\n",
    "        for row_cut in range(2, 3): # ...5\n",
    "            print(\"PRE_PROCESS:::\"+\"TEAR_\"+str(col_cut)+\"X\"+str(row_cut))\n",
    "            pieces = rough_tear_image(image, col_cut, row_cut)\n",
    "            \n",
    "            for piece in pieces:\n",
    "                print(\"PRE_PROCESS:::\"+\"PIECE_\"+str(piece[\"col\"])+\"X\"+str(piece[\"row\"]))\n",
    "                file_ = \"TEAR_\"+str(col_cut)+\"X\"+str(row_cut)+\"_PIECE_\"+str(piece[\"col\"])+\"X\"+str(piece[\"row\"])\n",
    "                cubes = VAL_slice_TEAR_to_static_slices(file_, piece)\n",
    "                for cube in cubes:\n",
    "                    cube[\"tear\"] = str(col_cut)+\"X\"+str(row_cut)\n",
    "                    cube[\"piece_col\"] = piece[\"col\"]\n",
    "                    cube[\"piece_row\"] = piece[\"row\"]\n",
    "                print(\"File: %s >>> cubes: %d\"%(file_, len(cubes)))\n",
    "                result.extend(cubes)\n",
    "    \n",
    "    return result\n",
    "    print(\"#####################################################################\")\n",
    "    print(\"PRE_PROCESS ENDED\")\n",
    "    print(\"#####################################################################\")\n",
    "    print(\" \")\n",
    "    print(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def validate1(cubes, model, slice_size, folder, curr_cube):    \n",
    "    # VALIDATE prepare the data sets\n",
    "    test_imgs, test_x_delta, test_y_delta, test_x_file, test_y_file = VAL_build_train_set(cubes, slice_size, folder, curr_cube)\n",
    "    print(\"loaded %d images\"%(len(test_imgs)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def validate2(folder, model, slice_size):\n",
    "    test_imgs = []\n",
    "    test_x_file = []\n",
    "    test_y_file = []\n",
    "    the_root = \"\"\n",
    "    for root, dirs, files in os.walk(folder):\n",
    "        the_root = root\n",
    "        for file_ in files:\n",
    "            test_imgs.append( os.path.join(root, file_) )\n",
    "            test_x_file.append(file_[:file_.rfind('---P')])\n",
    "            test_y_file.append(file_[file_.rfind('---P')+3:])\n",
    "            \n",
    "    print(len(test_imgs))\n",
    "    \n",
    "    # VALIDATE Prepare a test session \n",
    "\n",
    "    # Add ops to save and restore all the variables.\n",
    "    saver = tf.train.Saver()\n",
    "\n",
    "    # start session and initialize variables\n",
    "    sess = tf.InteractiveSession()\n",
    "\n",
    "    # Restore variables from disk.\n",
    "    saver.restore(sess, model)\n",
    "    print(\"Model restored.\")\n",
    "\n",
    "    # VALIDATE Validate the model\n",
    "\n",
    "    # import pdb; pdb.set_trace()\n",
    "    v1t = []\n",
    "    count = 0\n",
    "    length = len(test_imgs)\n",
    "    batch = 100\n",
    "    x_batch = []\n",
    "    # change the ranges in the loop below - first number is the start point (multiplied by batch size)\n",
    "    # second number is the end point (multiplied by batch size)\n",
    "    # third number is the jump from batch to batch\n",
    "    # use the length about to set the batch length\n",
    "    for start in range(0, length, batch):\n",
    "        for i in range(start, start+batch):\n",
    "            if (i < length):\n",
    "                image = np.load(test_imgs[i])\n",
    "                x_batch.append(image)\n",
    "                count += 1\n",
    "\n",
    "        # print(\"Validating start at #%d end at %d\"%(start*batch,(start+length)*batch))\n",
    "        my_prediction=tf.argmax(y_conv,1)\n",
    "        v1 = my_prediction.eval(feed_dict={x:x_batch, keep_prob: 1.0})\n",
    "        v1t = np.concatenate((v1t, v1), axis=0)\n",
    "        x_batch = []\n",
    "        print(\">>> step %d\"%(start+batch))\n",
    "\n",
    "\n",
    "    match_indexes = np.nonzero(v1t)[0]\n",
    "    A = np.array(test_x_file)\n",
    "    B = np.array(test_y_file)\n",
    "    C = np.array(test_imgs)\n",
    "    match_x_files = A[match_indexes]\n",
    "    match_y_files = B[match_indexes]\n",
    "    match_images = C[match_indexes]\n",
    "    \n",
    "    for matched_img in match_images:\n",
    "        load_img = np.load(matched_img)\n",
    "        plt.imsave(os.path.join(\"/Volumes/250GB/matched/\",matched_img[matched_img.rfind('/')+1:]+\".png\"), load_img, cmap=plt.cm.gray)\n",
    "    \n",
    "    for root, dirs, files in os.walk(folder):\n",
    "        for file_ in files:\n",
    "            os.remove( os.path.join(root, file_) ) # delete it from the FS\n",
    "                \n",
    "    with open('matches.csv', 'a') as csvfile:\n",
    "        csvout = csv.writer(csvfile)\n",
    "        for match_index in match_indexes:\n",
    "            print(\"MATCH %s === %s\"%(test_x_file[match_index], test_y_file[match_index]))\n",
    "            # print(\"MATCH %s === %s\"%(A[match_index], B[match_index]))\n",
    "            # csvout.writerow([A[match_index], B[match_index]])\n",
    "            csvout.writerow([test_x_file[match_index], test_y_file[match_index]])\n",
    "            # plt.imsave(\"match_\"+match_index+\".jpg\", C[match_index])\n",
    "\n",
    "    # Close the Session when we're done.\n",
    "    sess.close()   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def iter_validate(cubes, model, slice_size, folder):\n",
    "    print(\"#####################################################################\")\n",
    "    print(\"VALIDATING\")\n",
    "    print(\"#####################################################################\")\n",
    "    cubes_len = len(cubes)\n",
    "    batch_size = 100\n",
    "    count = 0\n",
    "    # iterate over the cubes\n",
    "    for curr in cubes:\n",
    "        count += 1\n",
    "        if count < batch_size: ### TEMP LIMITATION\n",
    "            print(\"CUBE:%s\"%(curr[\"file\"]+\"_\"+str(curr[\"top_row\"])+\"_\"+str(curr[\"left_col\"])))\n",
    "            validate1(cubes, model, slice_size, folder, curr)\n",
    "            validate2(folder, model, slice_size)\n",
    "        \n",
    "    print(\"#####################################################################\")\n",
    "    print(\"VALIDATION ENDED\")\n",
    "    print(\"#####################################################################\")\n",
    "    print(\" \")\n",
    "    print(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def run_all(folder, model, slice_size):\n",
    "    model_tf(slice_size)\n",
    "    cubes_set = pre_process(folder)\n",
    "    validate(cubes_set, model, slice_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# run_all(\"/Volumes/250GB/cropped/\", \"/Users/il239838/Development/models/ML924__012_250px_model400x50.ckpt.meta\", 250)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# iter_validate(cubes_set, \"/Users/il239838/Downloads/models/ML924__012_160gap_250px_model400x50.ckpt\", 250, \"/Volumes/250gb/mixed/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#####################################################################\n",
      "PRE_PROCESS:PX303/FG001/PX303-Fg001-V-C01-R01-D05032015-T112602-ML924__012.jpg\n",
      "#####################################################################\n",
      "PRE_PROCESS:::TEAR_3X2\n",
      "1666 1132\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/il239838/anaconda/envs/tensorflow/lib/python3.5/site-packages/skimage/util/dtype.py:110: UserWarning: Possible precision loss when converting from float64 to uint16\n",
      "  \"%s to %s\" % (dtypeobj_in, dtypeobj))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PRE_PROCESS:::PIECE_0X0\n",
      "1106 2018\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_0X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_0X0\n",
      "File: TEAR_3X2_PIECE_0X0 >>> cubes: 2\n",
      "PRE_PROCESS:::PIECE_0X1\n",
      "1149 2045\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_0X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_0X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_0X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_0X1\n",
      "File: TEAR_3X2_PIECE_0X1 >>> cubes: 4\n",
      "PRE_PROCESS:::PIECE_1X0\n",
      "1114 1694\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X0\n",
      "File: TEAR_3X2_PIECE_1X0 >>> cubes: 6\n",
      "PRE_PROCESS:::PIECE_1X1\n",
      "1136 1587\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_1X1\n",
      "File: TEAR_3X2_PIECE_1X1 >>> cubes: 6\n",
      "PRE_PROCESS:::PIECE_2X0\n",
      "1129 1811\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X0\n",
      "File: TEAR_3X2_PIECE_2X0 >>> cubes: 7\n",
      "PRE_PROCESS:::PIECE_2X1\n",
      "1146 1652\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_3X2_PIECE_2X1\n",
      "File: TEAR_3X2_PIECE_2X1 >>> cubes: 8\n",
      "PRE_PROCESS:::TEAR_4X2\n",
      "1249 1132\n",
      "PRE_PROCESS:::PIECE_0X0\n",
      "1090 1458\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_0X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_0X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_0X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_0X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_0X0\n",
      "File: TEAR_4X2_PIECE_0X0 >>> cubes: 5\n",
      "PRE_PROCESS:::PIECE_0X1\n",
      "1163 1409\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_0X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_0X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_0X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_0X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_0X1\n",
      "File: TEAR_4X2_PIECE_0X1 >>> cubes: 5\n",
      "PRE_PROCESS:::PIECE_1X0\n",
      "1114 1257\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_1X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_1X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_1X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_1X0\n",
      "File: TEAR_4X2_PIECE_1X0 >>> cubes: 4\n",
      "PRE_PROCESS:::PIECE_1X1\n",
      "1122 1229\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_1X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_1X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_1X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_1X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_1X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_1X1\n",
      "File: TEAR_4X2_PIECE_1X1 >>> cubes: 6\n",
      "PRE_PROCESS:::PIECE_2X0\n",
      "1135 1501\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X0\n",
      "File: TEAR_4X2_PIECE_2X0 >>> cubes: 7\n",
      "PRE_PROCESS:::PIECE_2X1\n",
      "1151 1494\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_2X1\n",
      "File: TEAR_4X2_PIECE_2X1 >>> cubes: 8\n",
      "PRE_PROCESS:::PIECE_3X0\n",
      "1132 1242\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X0\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X0\n",
      "File: TEAR_4X2_PIECE_3X0 >>> cubes: 8\n",
      "PRE_PROCESS:::PIECE_3X1\n",
      "1123 1268\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X1\n",
      "Found a ZERO index cube with the name:TEAR_4X2_PIECE_3X1\n",
      "File: TEAR_4X2_PIECE_3X1 >>> cubes: 8\n"
     ]
    }
   ],
   "source": [
    "# cut the image into multiple variations of very rough cuts, then, per piece in a cut slice the edges into 250px cubes\n",
    "cubes_set = pre_process_training(\"PX303/FG001/PX303-Fg001-V-C01-R01-D05032015-T112602-ML924__012.jpg\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# create paired images for training from all the cuves produced in the previous step. \n",
    "# Provide also the distance between the cubes in the pair\n",
    "train_imgs, train_x_delta, train_y_delta, train_x_obj, train_y_obj = \\\n",
    "    VAL_build_train_set_for_euclidean_distance(cubes_set, CUBE_SIZE, ROOT_FOLDER + \"train_concats/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# build a CNN with a linear regression at the last layer, accepting input of pairs of cubes of 250px\n",
    "linear_model_tf(250)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# The training for the linear regression is either the diagonal distance of horizontal (X) or vertical (Y)\n",
    "# train_diagonal_delta = np.sqrt(np.asarray(train_x_delta)**2 + np.asarray(train_y_delta)**2) # pitagoras\n",
    "train_diagonal_delta = train_x_delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Cap the distance at a certain break_val beyond which we train as \"too long\"\n",
    "train_diagonal_delta = [(x if x < BREAK_VAL else BREAK_VAL) for x in train_diagonal_delta]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#####################################################################\n",
      "TRAINING:\n",
      "MODEL:/Users/il239838/Downloads/private/Thesis/Papyrus/tear_model.ckpt\n",
      "#####################################################################\n",
      "WARNING:tensorflow:From /Users/il239838/anaconda/envs/tensorflow/lib/python3.5/site-packages/tensorflow/python/util/tf_should_use.py:170: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n",
      "Instructions for updating:\n",
      "Use `tf.global_variables_initializer` instead.\n",
      "Epoch: 0050 cost= 79135.296875000 b= [ 0.10033246] y_conv= [[-31.30997658]] y_real= [[250]]\n",
      "Epoch: 0100 cost= 64573.117187500 b= [ 0.10102955] y_conv= [[ 4.11241341]] y_real= [[-250]]\n",
      "Epoch: 0150 cost= 22696.992187500 b= [ 0.09759969] y_conv= [[-99.3447876]] y_real= [[-250]]\n",
      "Epoch: 0200 cost= 521918.750000000 b= [ 0.10097144] y_conv= [[-27.56055069]] y_real= [[-750]]\n",
      "Epoch: 0250 cost= 76251.726562500 b= [ 0.0930209] y_conv= [[-26.13715363]] y_real= [[250]]\n",
      "Epoch: 0300 cost= 55342.750000000 b= [ 0.09935217] y_conv= [[-264.74960327]] y_real= [[-500]]\n",
      "Epoch: 0350 cost= 27627.830078125 b= [ 0.10113488] y_conv= [[-166.21621704]] y_real= [[0]]\n",
      "Epoch: 0400 cost= 18463.060546875 b= [ 0.09995479] y_conv= [[ 385.87884521]] y_real= [[250]]\n",
      "Epoch: 0450 cost= 25721.570312500 b= [ 0.10060409] y_conv= [[-160.37945557]] y_real= [[0]]\n",
      "Epoch: 0500 cost= 15411.309570312 b= [ 0.10173687] y_conv= [[-124.14229584]] y_real= [[0]]\n",
      "Epoch: 0550 cost= 32291.195312500 b= [ 0.10663415] y_conv= [[ 320.30249023]] y_real= [[500]]\n",
      "Epoch: 0600 cost= 82636.703125000 b= [ 0.10411785] y_conv= [[ 537.46600342]] y_real= [[250]]\n",
      "Epoch: 0650 cost= 31445.068359375 b= [ 0.10422892] y_conv= [[ 72.67241669]] y_real= [[250]]\n",
      "Epoch: 0700 cost= 47258.351562500 b= [ 0.10374741] y_conv= [[ 467.38986206]] y_real= [[250]]\n",
      "Epoch: 0750 cost= 27454.740234375 b= [ 0.099461] y_conv= [[ 165.69471741]] y_real= [[0]]\n",
      "Epoch: 0800 cost= 57063.832031250 b= [ 0.09803837] y_conv= [[-238.88037109]] y_real= [[0]]\n",
      "Epoch: 0850 cost= 355581.968750000 b= [ 0.10044682] y_conv= [[-96.30696106]] y_real= [[500]]\n",
      "Epoch: 0900 cost= 3206.770019531 b= [ 0.10143308] y_conv= [[ 56.6283493]] y_real= [[0]]\n",
      "Epoch: 0950 cost= 31237.972656250 b= [ 0.1007358] y_conv= [[-323.25732422]] y_real= [[-500]]\n",
      "Epoch: 1000 cost= 440.083953857 b= [ 0.09922068] y_conv= [[ 20.97817802]] y_real= [[0]]\n",
      "Epoch: 1050 cost= 199554.812500000 b= [ 0.10302105] y_conv= [[-303.28442383]] y_real= [[-750]]\n",
      "Epoch: 1100 cost= 122569.242187500 b= [ 0.10145668] y_conv= [[-100.0989151]] y_real= [[250]]\n",
      "Epoch: 1150 cost= 2078.838134766 b= [ 0.10023458] y_conv= [[-45.59427643]] y_real= [[0]]\n",
      "Epoch: 1200 cost= 11071.839843750 b= [ 0.10024748] y_conv= [[-355.22280884]] y_real= [[-250]]\n",
      "Epoch: 1250 cost= 42951.765625000 b= [ 0.09961067] y_conv= [[-42.75191879]] y_real= [[-250]]\n",
      "Epoch: 1300 cost= 8611.013671875 b= [ 0.10131762] y_conv= [[-157.20445251]] y_real= [[-250]]\n",
      "Epoch: 1350 cost= 10905.451171875 b= [ 0.10098262] y_conv= [[-354.4291687]] y_real= [[-250]]\n",
      "Epoch: 1400 cost= 30.304407120 b= [ 0.09976381] y_conv= [[-744.49505615]] y_real= [[-750]]\n",
      "Epoch: 1450 cost= 88039.445312500 b= [ 0.10167323] y_conv= [[ 203.28559875]] y_real= [[500]]\n",
      "Epoch: 1500 cost= 48190.265625000 b= [ 0.09970389] y_conv= [[-30.47719193]] y_real= [[-250]]\n",
      "Epoch: 1550 cost= 736.305419922 b= [ 0.10144862] y_conv= [[ 472.86505127]] y_real= [[500]]\n",
      "Epoch: 1600 cost= 11323.341796875 b= [ 0.09957316] y_conv= [[-606.41119385]] y_real= [[-500]]\n",
      "Epoch: 1650 cost= 11618.062500000 b= [ 0.10074065] y_conv= [[-107.787117]] y_real= [[0]]\n",
      "Epoch: 1700 cost= 3433.442138672 b= [ 0.10135761] y_conv= [[ 308.59558105]] y_real= [[250]]\n",
      "Epoch: 1750 cost= 19796.638671875 b= [ 0.10342634] y_conv= [[ 359.29946899]] y_real= [[500]]\n",
      "Epoch: 1800 cost= 51262.082031250 b= [ 0.10421475] y_conv= [[ 726.41131592]] y_real= [[500]]\n",
      "Epoch: 1850 cost= 13974.958984375 b= [ 0.10650625] y_conv= [[-381.78427124]] y_real= [[-500]]\n",
      "Epoch: 1900 cost= 8378.038085938 b= [ 0.10605833] y_conv= [[-91.53162384]] y_real= [[0]]\n",
      "Epoch: 1950 cost= 24701.320312500 b= [ 0.10618346] y_conv= [[ 342.83346558]] y_real= [[500]]\n",
      "Epoch: 2000 cost= 1254.683227539 b= [ 0.106751] y_conv= [[ 714.57849121]] y_real= [[750]]\n",
      "Epoch: 2050 cost= 716.642089844 b= [ 0.10662706] y_conv= [[-276.77017212]] y_real= [[-250]]\n",
      "Epoch: 2100 cost= 1064.581298828 b= [ 0.10545876] y_conv= [[-32.62792206]] y_real= [[0]]\n",
      "Epoch: 2150 cost= 31646.529296875 b= [ 0.10476317] y_conv= [[-177.89471436]] y_real= [[0]]\n",
      "Epoch: 2200 cost= 1403.641967773 b= [ 0.10496797] y_conv= [[ 37.46520996]] y_real= [[0]]\n",
      "Epoch: 2250 cost= 1053.171630859 b= [ 0.10459671] y_conv= [[ 217.5473938]] y_real= [[250]]\n",
      "Epoch: 2300 cost= 1006.555419922 b= [ 0.10179225] y_conv= [[ 718.27374268]] y_real= [[750]]\n",
      "Epoch: 2350 cost= 1291.398681641 b= [ 0.10294266] y_conv= [[ 214.06396484]] y_real= [[250]]\n",
      "Epoch: 2400 cost= 9509.237304688 b= [ 0.10404247] y_conv= [[-402.48468018]] y_real= [[-500]]\n",
      "Epoch: 2450 cost= 2635.616699219 b= [ 0.10354612] y_conv= [[ 51.33825684]] y_real= [[0]]\n",
      "Epoch: 2500 cost= 3224.377685547 b= [ 0.10363252] y_conv= [[ 56.78360367]] y_real= [[0]]\n",
      "Epoch: 2550 cost= 33.859165192 b= [ 0.10403616] y_conv= [[-244.18113708]] y_real= [[-250]]\n",
      "Epoch: 2600 cost= 52.404644012 b= [ 0.10283411] y_conv= [[ 257.23910522]] y_real= [[250]]\n",
      "Epoch: 2650 cost= 1132.826416016 b= [ 0.102465] y_conv= [[-216.34251404]] y_real= [[-250]]\n",
      "Epoch: 2700 cost= 5561.946777344 b= [ 0.1044089] y_conv= [[ 425.42153931]] y_real= [[500]]\n",
      "Epoch: 2750 cost= 5559.854492188 b= [ 0.10321245] y_conv= [[ 74.56443024]] y_real= [[0]]\n",
      "Epoch: 2800 cost= 15493.920898438 b= [ 0.10006056] y_conv= [[-124.47457886]] y_real= [[0]]\n",
      "Epoch: 2850 cost= 4651.411132812 b= [ 0.10146595] y_conv= [[-68.2012558]] y_real= [[0]]\n",
      "Epoch: 2900 cost= 4669.410156250 b= [ 0.10155125] y_conv= [[ 181.66691589]] y_real= [[250]]\n",
      "Epoch: 2950 cost= 1274.046386719 b= [ 0.10496275] y_conv= [[ 214.30621338]] y_real= [[250]]\n",
      "Epoch: 3000 cost= 6782.111816406 b= [ 0.10144434] y_conv= [[ 332.35357666]] y_real= [[250]]\n",
      "Epoch: 3050 cost= 24638.306640625 b= [ 0.10294262] y_conv= [[ 593.03405762]] y_real= [[750]]\n",
      "Epoch: 3100 cost= 24509.646484375 b= [ 0.10080698] y_conv= [[ 343.44442749]] y_real= [[500]]\n",
      "Epoch: 3150 cost= 4336.243164062 b= [ 0.10118417] y_conv= [[ 315.85015869]] y_real= [[250]]\n",
      "Epoch: 3200 cost= 577.844055176 b= [ 0.10073922] y_conv= [[ 24.0383873]] y_real= [[0]]\n",
      "Epoch: 3250 cost= 18045.070312500 b= [ 0.10329729] y_conv= [[-115.66806793]] y_real= [[-250]]\n",
      "Epoch: 3300 cost= 4675.366210938 b= [ 0.10059201] y_conv= [[ 181.62335205]] y_real= [[250]]\n",
      "Epoch: 3350 cost= 3735.094238281 b= [ 0.10130017] y_conv= [[-188.88458252]] y_real= [[-250]]\n",
      "Epoch: 3400 cost= 11.463870049 b= [ 0.09959625] y_conv= [[ 253.38583374]] y_real= [[250]]\n",
      "Epoch: 3450 cost= 0.216477096 b= [ 0.10130116] y_conv= [[ 499.534729]] y_real= [[500]]\n",
      "Epoch: 3500 cost= 247.223510742 b= [ 0.1005755] y_conv= [[-234.2766571]] y_real= [[-250]]\n",
      "Epoch: 3550 cost= 17498.523437500 b= [ 0.09931355] y_conv= [[ 367.71801758]] y_real= [[500]]\n",
      "Epoch: 3600 cost= 2332.391845703 b= [ 0.10079533] y_conv= [[ 48.29484177]] y_real= [[0]]\n",
      "Epoch: 3650 cost= 40.122062683 b= [ 0.10061291] y_conv= [[ 243.665802]] y_real= [[250]]\n",
      "Epoch: 3700 cost= 1708.084594727 b= [ 0.10192151] y_conv= [[ 208.67102051]] y_real= [[250]]\n",
      "Epoch: 3750 cost= 65.202865601 b= [ 0.10135888] y_conv= [[-491.9251709]] y_real= [[-500]]\n",
      "Epoch: 3800 cost= 5890.796875000 b= [ 0.09983078] y_conv= [[ 673.24847412]] y_real= [[750]]\n",
      "Epoch: 3850 cost= 581.332885742 b= [ 0.10040115] y_conv= [[-24.11084557]] y_real= [[0]]\n",
      "Epoch: 3900 cost= 2041.233520508 b= [ 0.0995631] y_conv= [[-45.18001175]] y_real= [[0]]\n",
      "Epoch: 3950 cost= 1121.612182617 b= [ 0.09642993] y_conv= [[ 783.49047852]] y_real= [[750]]\n",
      "Epoch: 4000 cost= 6583.137207031 b= [ 0.09915807] y_conv= [[ 831.13653564]] y_real= [[750]]\n",
      "Epoch: 4050 cost= 5.685360432 b= [ 0.0965166] y_conv= [[ 502.38439941]] y_real= [[500]]\n",
      "Epoch: 4100 cost= 2034.601074219 b= [ 0.09613363] y_conv= [[-204.89344788]] y_real= [[-250]]\n",
      "Epoch: 4150 cost= 7775.355957031 b= [ 0.095048] y_conv= [[-838.17797852]] y_real= [[-750]]\n",
      "Epoch: 4200 cost= 903.076965332 b= [ 0.0940273] y_conv= [[ 219.94876099]] y_real= [[250]]\n",
      "Epoch: 4250 cost= 13047.672851562 b= [ 0.0965062] y_conv= [[ 385.77359009]] y_real= [[500]]\n",
      "Epoch: 4300 cost= 108.328666687 b= [ 0.09649762] y_conv= [[ 10.40810585]] y_real= [[0]]\n",
      "Epoch: 4350 cost= 2056.800292969 b= [ 0.09705158] y_conv= [[-454.64804077]] y_real= [[-500]]\n",
      "Epoch: 4400 cost= 19936.832031250 b= [ 0.09386244] y_conv= [[-391.19784546]] y_real= [[-250]]\n",
      "Epoch: 4450 cost= 167.837219238 b= [ 0.09675454] y_conv= [[ 262.9552002]] y_real= [[250]]\n",
      "Epoch: 4500 cost= 10996.512695312 b= [ 0.10188341] y_conv= [[-604.86425781]] y_real= [[-500]]\n",
      "Epoch: 4550 cost= 1614.927246094 b= [ 0.10192604] y_conv= [[ 709.81384277]] y_real= [[750]]\n",
      "Epoch: 4600 cost= 314.856689453 b= [ 0.10088126] y_conv= [[ 232.25579834]] y_real= [[250]]\n",
      "Epoch: 4650 cost= 2405.602050781 b= [ 0.10809572] y_conv= [[ 799.04693604]] y_real= [[750]]\n",
      "Epoch: 4700 cost= 3083.550292969 b= [ 0.10832334] y_conv= [[-194.47027588]] y_real= [[-250]]\n",
      "Epoch: 4750 cost= 359.535675049 b= [ 0.10929753] y_conv= [[-518.96142578]] y_real= [[-500]]\n",
      "Epoch: 4800 cost= 1261.524658203 b= [ 0.1087995] y_conv= [[-35.51794815]] y_real= [[0]]\n",
      "Epoch: 4850 cost= 5732.432617188 b= [ 0.11000606] y_conv= [[ 424.28717041]] y_real= [[500]]\n",
      "Epoch: 4900 cost= 1998.617309570 b= [ 0.10951444] y_conv= [[ 44.70589828]] y_real= [[0]]\n",
      "Epoch: 4950 cost= 709.957092285 b= [ 0.10918828] y_conv= [[-723.35498047]] y_real= [[-750]]\n",
      "Epoch: 5000 cost= 323.767120361 b= [ 0.11058573] y_conv= [[ 482.00646973]] y_real= [[500]]\n",
      "Epoch: 5050 cost= 7926.622070312 b= [ 0.10847425] y_conv= [[-89.03157806]] y_real= [[0]]\n",
      "Epoch: 5100 cost= 4370.183105469 b= [ 0.1082237] y_conv= [[-683.89263916]] y_real= [[-750]]\n",
      "Epoch: 5150 cost= 1364.435302734 b= [ 0.1064736] y_conv= [[-213.06173706]] y_real= [[-250]]\n",
      "Epoch: 5200 cost= 2621.534912109 b= [ 0.10306017] y_conv= [[-51.20092773]] y_real= [[0]]\n",
      "Epoch: 5250 cost= 256.819793701 b= [ 0.1046247] y_conv= [[ 16.02559853]] y_real= [[0]]\n",
      "Epoch: 5300 cost= 77.764541626 b= [ 0.10666507] y_conv= [[-258.81842041]] y_real= [[-250]]\n",
      "Epoch: 5350 cost= 132.031097412 b= [ 0.10746958] y_conv= [[-761.49047852]] y_real= [[-750]]\n",
      "Epoch: 5400 cost= 510.664855957 b= [ 0.10308769] y_conv= [[-22.59789467]] y_real= [[0]]\n",
      "Epoch: 5450 cost= 13158.502929688 b= [ 0.10659748] y_conv= [[ 114.71051788]] y_real= [[0]]\n",
      "Epoch: 5500 cost= 5529.715820312 b= [ 0.10636175] y_conv= [[ 675.63793945]] y_real= [[750]]\n",
      "Epoch: 5550 cost= 3478.666992188 b= [ 0.10292999] y_conv= [[ 691.01977539]] y_real= [[750]]\n",
      "Epoch: 5600 cost= 269.515136719 b= [ 0.10360638] y_conv= [[ 233.58308411]] y_real= [[250]]\n",
      "Epoch: 5650 cost= 4845.108398438 b= [ 0.10372221] y_conv= [[ 680.39318848]] y_real= [[750]]\n",
      "Epoch: 5700 cost= 3830.698730469 b= [ 0.10131772] y_conv= [[ 311.89263916]] y_real= [[250]]\n",
      "Epoch: 5750 cost= 10.015052795 b= [ 0.10550724] y_conv= [[ 3.16465688]] y_real= [[0]]\n",
      "Epoch: 5800 cost= 1.319486499 b= [ 0.10612055] y_conv= [[-1.14868903]] y_real= [[0]]\n",
      "Epoch: 5850 cost= 638.738159180 b= [ 0.10424381] y_conv= [[ 224.72673035]] y_real= [[250]]\n",
      "Epoch: 5900 cost= 285.441680908 b= [ 0.10506355] y_conv= [[ 233.10498047]] y_real= [[250]]\n",
      "Epoch: 5950 cost= 1006.497314453 b= [ 0.10441664] y_conv= [[-281.7253418]] y_real= [[-250]]\n",
      "Epoch: 6000 cost= 282.135009766 b= [ 0.10330692] y_conv= [[-483.203125]] y_real= [[-500]]\n",
      "Epoch: 6050 cost= 163.408508301 b= [ 0.1015759] y_conv= [[ 12.78313351]] y_real= [[0]]\n",
      "Epoch: 6100 cost= 61.249027252 b= [ 0.09777374] y_conv= [[-7.82617569]] y_real= [[0]]\n",
      "Epoch: 6150 cost= 805.266174316 b= [ 0.10040413] y_conv= [[ 221.62278748]] y_real= [[250]]\n",
      "Epoch: 6200 cost= 193.391433716 b= [ 0.09913357] y_conv= [[ 263.90652466]] y_real= [[250]]\n",
      "Epoch: 6250 cost= 163.076904297 b= [ 0.09737261] y_conv= [[-237.22984314]] y_real= [[-250]]\n",
      "Epoch: 6300 cost= 5738.662597656 b= [ 0.0969938] y_conv= [[ 75.75395966]] y_real= [[0]]\n",
      "Epoch: 6350 cost= 627.288635254 b= [ 0.09351646] y_conv= [[ 25.04573059]] y_real= [[0]]\n",
      "Epoch: 6400 cost= 1385.174072266 b= [ 0.0914185] y_conv= [[-287.21792603]] y_real= [[-250]]\n",
      "Epoch: 6450 cost= 1045.403686523 b= [ 0.09378235] y_conv= [[-32.33270264]] y_real= [[0]]\n",
      "Epoch: 6500 cost= 1835.061401367 b= [ 0.09283313] y_conv= [[ 457.16238403]] y_real= [[500]]\n",
      "Epoch: 6550 cost= 0.003173646 b= [ 0.09548554] y_conv= [[-0.05633512]] y_real= [[0]]\n",
      "Epoch: 6600 cost= 1184.033447266 b= [ 0.09507126] y_conv= [[-34.40978622]] y_real= [[0]]\n",
      "Epoch: 6650 cost= 3514.152099609 b= [ 0.09385094] y_conv= [[ 59.28028488]] y_real= [[0]]\n",
      "Epoch: 6700 cost= 7283.886230469 b= [ 0.09640735] y_conv= [[ 85.34568787]] y_real= [[0]]\n",
      "Epoch: 6750 cost= 87.710083008 b= [ 0.095521] y_conv= [[ 9.36536598]] y_real= [[0]]\n",
      "Epoch: 6800 cost= 616.258422852 b= [ 0.09339839] y_conv= [[ 24.82455254]] y_real= [[0]]\n",
      "Epoch: 6850 cost= 3170.417236328 b= [ 0.0964717] y_conv= [[-693.69354248]] y_real= [[-750]]\n",
      "Epoch: 6900 cost= 30230.521484375 b= [ 0.09597418] y_conv= [[ 923.8692627]] y_real= [[750]]\n",
      "Epoch: 6950 cost= 4332.297363281 b= [ 0.09608137] y_conv= [[ 315.82019043]] y_real= [[250]]\n",
      "Epoch: 7000 cost= 377.516082764 b= [ 0.09819237] y_conv= [[-19.42977333]] y_real= [[0]]\n",
      "Epoch: 7050 cost= 2946.006347656 b= [ 0.09511254] y_conv= [[-54.27712631]] y_real= [[0]]\n",
      "Epoch: 7100 cost= 2611.627685547 b= [ 0.09382027] y_conv= [[-51.10408783]] y_real= [[0]]\n",
      "Epoch: 7150 cost= 189.110595703 b= [ 0.09173705] y_conv= [[ 13.75174904]] y_real= [[0]]\n",
      "Epoch: 7200 cost= 3.760354042 b= [ 0.09265399] y_conv= [[-251.93916321]] y_real= [[-250]]\n",
      "Epoch: 7250 cost= 7.364495277 b= [ 0.09677191] y_conv= [[-252.71376038]] y_real= [[-250]]\n",
      "Epoch: 7300 cost= 10248.235351562 b= [ 0.09140326] y_conv= [[ 148.76643372]] y_real= [[250]]\n",
      "Epoch: 7350 cost= 1463.309082031 b= [ 0.09415165] y_conv= [[-38.25322342]] y_real= [[0]]\n",
      "Epoch: 7400 cost= 2243.303466797 b= [ 0.09575143] y_conv= [[-202.63647461]] y_real= [[-250]]\n",
      "Epoch: 7450 cost= 2126.291259766 b= [ 0.09589507] y_conv= [[ 453.88827515]] y_real= [[500]]\n",
      "Epoch: 7500 cost= 6275.054199219 b= [ 0.10122833] y_conv= [[-170.78475952]] y_real= [[-250]]\n",
      "Epoch: 7550 cost= 648.852355957 b= [ 0.09869839] y_conv= [[-224.52742004]] y_real= [[-250]]\n",
      "Epoch: 7600 cost= 3356.677490234 b= [ 0.09574632] y_conv= [[-57.93684006]] y_real= [[0]]\n",
      "Epoch: 7650 cost= 3898.822509766 b= [ 0.09906939] y_conv= [[ 812.44055176]] y_real= [[750]]\n",
      "Epoch: 7700 cost= 2157.254882812 b= [ 0.0995473] y_conv= [[ 453.55374146]] y_real= [[500]]\n",
      "Epoch: 7750 cost= 1820.967041016 b= [ 0.09692703] y_conv= [[ 207.32720947]] y_real= [[250]]\n",
      "Epoch: 7800 cost= 233.456909180 b= [ 0.09807434] y_conv= [[-515.27929688]] y_real= [[-500]]\n",
      "Epoch: 7850 cost= 2741.028076172 b= [ 0.10013559] y_conv= [[ 52.35482788]] y_real= [[0]]\n",
      "Epoch: 7900 cost= 60.666641235 b= [ 0.0968191] y_conv= [[ 257.78887939]] y_real= [[250]]\n",
      "Epoch: 7950 cost= 521.308593750 b= [ 0.09636439] y_conv= [[-227.16781616]] y_real= [[-250]]\n",
      "Epoch: 8000 cost= 4584.870117188 b= [ 0.09640221] y_conv= [[ 682.28833008]] y_real= [[750]]\n",
      "Epoch: 8050 cost= 7061.091796875 b= [ 0.09505477] y_conv= [[-334.03030396]] y_real= [[-250]]\n",
      "Epoch: 8100 cost= 918.283447266 b= [ 0.09694612] y_conv= [[ 219.69680786]] y_real= [[250]]\n",
      "Epoch: 8150 cost= 3453.262451172 b= [ 0.09562039] y_conv= [[-308.76446533]] y_real= [[-250]]\n",
      "Epoch: 8200 cost= 2729.683105469 b= [ 0.09839445] y_conv= [[-447.75363159]] y_real= [[-500]]\n",
      "Epoch: 8250 cost= 1358.027587891 b= [ 0.09977268] y_conv= [[-213.14857483]] y_real= [[-250]]\n",
      "Epoch: 8300 cost= 34.235782623 b= [ 0.09932386] y_conv= [[-505.85113525]] y_real= [[-500]]\n",
      "Epoch: 8350 cost= 2250.339599609 b= [ 0.09997989] y_conv= [[ 452.56225586]] y_real= [[500]]\n",
      "Epoch: 8400 cost= 1759.358032227 b= [ 0.09643371] y_conv= [[-541.94470215]] y_real= [[-500]]\n",
      "Epoch: 8450 cost= 511.443298340 b= [ 0.09994999] y_conv= [[-272.6151123]] y_real= [[-250]]\n",
      "Epoch: 8500 cost= 2508.888916016 b= [ 0.09450787] y_conv= [[-50.08880997]] y_real= [[0]]\n",
      "Epoch: 8550 cost= 13719.766601562 b= [ 0.09257256] y_conv= [[ 382.86859131]] y_real= [[500]]\n",
      "Epoch: 8600 cost= 598.698791504 b= [ 0.09554406] y_conv= [[ 725.53167725]] y_real= [[750]]\n",
      "Epoch: 8650 cost= 441.265594482 b= [ 0.09770407] y_conv= [[ 21.00632286]] y_real= [[0]]\n",
      "Epoch: 8700 cost= 3297.636230469 b= [ 0.09231295] y_conv= [[-57.42504883]] y_real= [[0]]\n",
      "Epoch: 8750 cost= 11315.082031250 b= [ 0.09550571] y_conv= [[ 143.62762451]] y_real= [[250]]\n",
      "Epoch: 8800 cost= 10.993389130 b= [ 0.09999195] y_conv= [[-253.31562805]] y_real= [[-250]]\n",
      "Epoch: 8850 cost= 220.128845215 b= [ 0.09719943] y_conv= [[ 14.83673954]] y_real= [[0]]\n",
      "Epoch: 8900 cost= 230.525070190 b= [ 0.09930392] y_conv= [[-15.18305206]] y_real= [[0]]\n",
      "Epoch: 8950 cost= 342.636291504 b= [ 0.10297164] y_conv= [[ 18.51043701]] y_real= [[0]]\n",
      "Epoch: 9000 cost= 13473.960937500 b= [ 0.10347248] y_conv= [[-616.07739258]] y_real= [[-500]]\n",
      "Epoch: 9050 cost= 10853.359375000 b= [ 0.10453413] y_conv= [[-145.82054138]] y_real= [[-250]]\n",
      "Epoch: 9100 cost= 2337.631591797 b= [ 0.1021298] y_conv= [[ 451.65093994]] y_real= [[500]]\n",
      "Epoch: 9150 cost= 1640.912597656 b= [ 0.10493602] y_conv= [[ 459.49182129]] y_real= [[500]]\n",
      "Epoch: 9200 cost= 4661.229003906 b= [ 0.10414381] y_conv= [[-818.27319336]] y_real= [[-750]]\n",
      "Epoch: 9250 cost= 399.528961182 b= [ 0.10442581] y_conv= [[ 480.01177979]] y_real= [[500]]\n",
      "Epoch: 9300 cost= 2608.276611328 b= [ 0.10606402] y_conv= [[ 551.07128906]] y_real= [[500]]\n",
      "Epoch: 9350 cost= 4080.842285156 b= [ 0.10493486] y_conv= [[ 313.88146973]] y_real= [[250]]\n",
      "Epoch: 9400 cost= 1914.448730469 b= [ 0.10465049] y_conv= [[ 43.7544136]] y_real= [[0]]\n",
      "Epoch: 9450 cost= 1220.435913086 b= [ 0.10043941] y_conv= [[-215.06526184]] y_real= [[-250]]\n",
      "Epoch: 9500 cost= 2247.022705078 b= [ 0.09753625] y_conv= [[-452.597229]] y_real= [[-500]]\n",
      "Epoch: 9550 cost= 5311.483886719 b= [ 0.09799287] y_conv= [[-72.87992859]] y_real= [[0]]\n",
      "Epoch: 9600 cost= 928.242431641 b= [ 0.10315888] y_conv= [[-219.53292847]] y_real= [[-250]]\n",
      "Epoch: 9650 cost= 120.462150574 b= [ 0.10400585] y_conv= [[ 260.9755249]] y_real= [[250]]\n",
      "Epoch: 9700 cost= 6585.103515625 b= [ 0.10844979] y_conv= [[-418.85134888]] y_real= [[-500]]\n",
      "Epoch: 9750 cost= 7822.048339844 b= [ 0.09950662] y_conv= [[-88.44234467]] y_real= [[0]]\n",
      "Epoch: 9800 cost= 4564.782226562 b= [ 0.10332561] y_conv= [[-567.56317139]] y_real= [[-500]]\n",
      "Epoch: 9850 cost= 3508.299072266 b= [ 0.09944916] y_conv= [[ 440.769104]] y_real= [[500]]\n",
      "Epoch: 9900 cost= 2104.818115234 b= [ 0.10496765] y_conv= [[-795.8782959]] y_real= [[-750]]\n",
      "Epoch: 9950 cost= 4189.618652344 b= [ 0.10029081] y_conv= [[-64.7272644]] y_real= [[0]]\n",
      "Epoch: 10000 cost= 1586.230957031 b= [ 0.10554914] y_conv= [[-710.17248535]] y_real= [[-750]]\n",
      "Epoch: 10050 cost= 1190.031005859 b= [ 0.10193471] y_conv= [[ 534.49682617]] y_real= [[500]]\n",
      "Epoch: 10100 cost= 70.789512634 b= [ 0.10359934] y_conv= [[-241.58634949]] y_real= [[-250]]\n",
      "Epoch: 10150 cost= 10.567460060 b= [ 0.09908202] y_conv= [[ 246.74923706]] y_real= [[250]]\n",
      "Epoch: 10200 cost= 1978.921386719 b= [ 0.10059503] y_conv= [[ 44.48506927]] y_real= [[0]]\n",
      "Epoch: 10250 cost= 222.120788574 b= [ 0.09951345] y_conv= [[ 264.90371704]] y_real= [[250]]\n",
      "Epoch: 10300 cost= 212.031295776 b= [ 0.10493735] y_conv= [[ 235.43870544]] y_real= [[250]]\n",
      "Epoch: 10350 cost= 16998.976562500 b= [ 0.1017863] y_conv= [[ 369.61987305]] y_real= [[500]]\n",
      "Epoch: 10400 cost= 12.123011589 b= [ 0.10397587] y_conv= [[ 753.48181152]] y_real= [[750]]\n",
      "Epoch: 10450 cost= 6618.344726562 b= [ 0.10481758] y_conv= [[-668.64678955]] y_real= [[-750]]\n",
      "Epoch: 10500 cost= 1347.571899414 b= [ 0.10053838] y_conv= [[-286.70928955]] y_real= [[-250]]\n",
      "Epoch: 10550 cost= 5036.459472656 b= [ 0.10394306] y_conv= [[ 429.03198242]] y_real= [[500]]\n",
      "Epoch: 10600 cost= 222.581298828 b= [ 0.10123245] y_conv= [[ 485.08084106]] y_real= [[500]]\n",
      "Epoch: 10650 cost= 672.647033691 b= [ 0.09849314] y_conv= [[ 224.06455994]] y_real= [[250]]\n",
      "Epoch: 10700 cost= 0.062271327 b= [ 0.09973615] y_conv= [[ 250.24954224]] y_real= [[250]]\n",
      "Epoch: 10750 cost= 1651.412353516 b= [ 0.10389934] y_conv= [[ 790.63757324]] y_real= [[750]]\n",
      "Epoch: 10800 cost= 397.654815674 b= [ 0.09729395] y_conv= [[-730.05871582]] y_real= [[-750]]\n",
      "Epoch: 10850 cost= 3812.333251953 b= [ 0.09779508] y_conv= [[ 188.25590515]] y_real= [[250]]\n",
      "Epoch: 10900 cost= 335.492980957 b= [ 0.10178682] y_conv= [[-768.31646729]] y_real= [[-750]]\n",
      "Epoch: 10950 cost= 2844.466796875 b= [ 0.09789284] y_conv= [[-53.33354187]] y_real= [[0]]\n",
      "Epoch: 11000 cost= 11474.536132812 b= [ 0.1026058] y_conv= [[ 857.1192627]] y_real= [[750]]\n",
      "Epoch: 11050 cost= 369.216094971 b= [ 0.10277303] y_conv= [[ 269.21499634]] y_real= [[250]]\n",
      "Epoch: 11100 cost= 22.749584198 b= [ 0.10089723] y_conv= [[ 4.76965237]] y_real= [[0]]\n",
      "Epoch: 11150 cost= 2786.678710938 b= [ 0.09999859] y_conv= [[-302.78900146]] y_real= [[-250]]\n",
      "Epoch: 11200 cost= 4062.296142578 b= [ 0.09910563] y_conv= [[ 563.73614502]] y_real= [[500]]\n",
      "Epoch: 11250 cost= 61.507030487 b= [ 0.10033274] y_conv= [[-7.84264183]] y_real= [[0]]\n",
      "Epoch: 11300 cost= 5288.389648438 b= [ 0.10320752] y_conv= [[ 572.72131348]] y_real= [[500]]\n",
      "Epoch: 11350 cost= 21.837110519 b= [ 0.10165244] y_conv= [[ 245.32698059]] y_real= [[250]]\n",
      "Epoch: 11400 cost= 2.025418520 b= [ 0.0999299] y_conv= [[-248.576828]] y_real= [[-250]]\n",
      "Epoch: 11450 cost= 82.613052368 b= [ 0.09859693] y_conv= [[ 259.08917236]] y_real= [[250]]\n",
      "Epoch: 11500 cost= 486.899353027 b= [ 0.10170102] y_conv= [[-227.9342041]] y_real= [[-250]]\n",
      "Epoch: 11550 cost= 1721.553466797 b= [ 0.10112096] y_conv= [[ 291.49160767]] y_real= [[250]]\n",
      "Epoch: 11600 cost= 17.912103653 b= [ 0.10306878] y_conv= [[ 504.23226929]] y_real= [[500]]\n",
      "Epoch: 11650 cost= 35.689392090 b= [ 0.1061077] y_conv= [[ 744.02593994]] y_real= [[750]]\n",
      "Epoch: 11700 cost= 3939.178955078 b= [ 0.10099302] y_conv= [[-312.76287842]] y_real= [[-250]]\n",
      "Epoch: 11750 cost= 1724.026000977 b= [ 0.10532738] y_conv= [[ 291.52139282]] y_real= [[250]]\n",
      "Epoch: 11800 cost= 4994.643554688 b= [ 0.10502055] y_conv= [[ 70.67279053]] y_real= [[0]]\n",
      "Epoch: 11850 cost= 3508.082031250 b= [ 0.10200528] y_conv= [[-440.77093506]] y_real= [[-500]]\n",
      "Epoch: 11900 cost= 2805.961669922 b= [ 0.10132339] y_conv= [[ 197.02867126]] y_real= [[250]]\n",
      "Epoch: 11950 cost= 3531.013671875 b= [ 0.10137617] y_conv= [[ 309.42233276]] y_real= [[250]]\n",
      "Epoch: 12000 cost= 582.719665527 b= [ 0.10222205] y_conv= [[ 725.8604126]] y_real= [[750]]\n",
      "Epoch: 12050 cost= 1121.475219727 b= [ 0.10401575] y_conv= [[-466.51156616]] y_real= [[-500]]\n",
      "Epoch: 12100 cost= 10970.862304688 b= [ 0.10264742] y_conv= [[-604.74188232]] y_real= [[-500]]\n",
      "Epoch: 12150 cost= 1193.297119141 b= [ 0.10130148] y_conv= [[ 34.54413223]] y_real= [[0]]\n",
      "Epoch: 12200 cost= 174.857986450 b= [ 0.10101453] y_conv= [[ 13.22338772]] y_real= [[0]]\n",
      "Epoch: 12250 cost= 201.029785156 b= [ 0.10242898] y_conv= [[-264.17849731]] y_real= [[-250]]\n",
      "Epoch: 12300 cost= 141.428314209 b= [ 0.10073367] y_conv= [[ 11.89236355]] y_real= [[0]]\n",
      "Epoch: 12350 cost= 3.976962090 b= [ 0.09776986] y_conv= [[ 501.99423218]] y_real= [[500]]\n",
      "Epoch: 12400 cost= 31511.662109375 b= [ 0.09922819] y_conv= [[ 177.51524353]] y_real= [[0]]\n",
      "Epoch: 12450 cost= 113.919532776 b= [ 0.09837255] y_conv= [[ 489.32669067]] y_real= [[500]]\n",
      "Epoch: 12500 cost= 303.999359131 b= [ 0.09744638] y_conv= [[-232.56442261]] y_real= [[-250]]\n",
      "Epoch: 12550 cost= 13642.665039062 b= [ 0.09577684] y_conv= [[ 866.80181885]] y_real= [[750]]\n",
      "Epoch: 12600 cost= 720.139404297 b= [ 0.09829496] y_conv= [[-26.83541298]] y_real= [[0]]\n",
      "Epoch: 12650 cost= 6125.799316406 b= [ 0.09621101] y_conv= [[-328.26748657]] y_real= [[-250]]\n",
      "Epoch: 12700 cost= 1662.172119141 b= [ 0.09761918] y_conv= [[-459.23025513]] y_real= [[-500]]\n",
      "Epoch: 12750 cost= 133.106307983 b= [ 0.0926895] y_conv= [[-261.53717041]] y_real= [[-250]]\n",
      "Epoch: 12800 cost= 1250.487792969 b= [ 0.09398944] y_conv= [[-35.36223602]] y_real= [[0]]\n",
      "Epoch: 12850 cost= 434.503906250 b= [ 0.09696186] y_conv= [[-479.15524292]] y_real= [[-500]]\n",
      "Epoch: 12900 cost= 447.874511719 b= [ 0.09600645] y_conv= [[-21.16304588]] y_real= [[0]]\n",
      "Epoch: 12950 cost= 46.468849182 b= [ 0.096704] y_conv= [[ 6.81680632]] y_real= [[0]]\n",
      "Epoch: 13000 cost= 2754.661621094 b= [ 0.09687966] y_conv= [[ 52.48487091]] y_real= [[0]]\n",
      "Epoch: 13050 cost= 629.022583008 b= [ 0.09736856] y_conv= [[-275.08032227]] y_real= [[-250]]\n",
      "Epoch: 13100 cost= 629.840270996 b= [ 0.09341481] y_conv= [[-224.90338135]] y_real= [[-250]]\n",
      "Epoch: 13150 cost= 3223.223144531 b= [ 0.09276231] y_conv= [[-556.7734375]] y_real= [[-500]]\n",
      "Epoch: 13200 cost= 2386.415527344 b= [ 0.09145527] y_conv= [[-298.85095215]] y_real= [[-250]]\n",
      "Epoch: 13250 cost= 574.215759277 b= [ 0.09348236] y_conv= [[-226.03720093]] y_real= [[-250]]\n",
      "Epoch: 13300 cost= 3.910476923 b= [ 0.09073422] y_conv= [[-1.97749257]] y_real= [[0]]\n",
      "Epoch: 13350 cost= 2237.610351562 b= [ 0.0915723] y_conv= [[ 47.30338669]] y_real= [[0]]\n",
      "Epoch: 13400 cost= 1589.670043945 b= [ 0.09062674] y_conv= [[ 460.1293335]] y_real= [[500]]\n",
      "Epoch: 13450 cost= 339.972930908 b= [ 0.09108769] y_conv= [[-518.43835449]] y_real= [[-500]]\n",
      "Epoch: 13500 cost= 9.376552582 b= [ 0.09126655] y_conv= [[-3.06211567]] y_real= [[0]]\n",
      "Epoch: 13550 cost= 1080.998413086 b= [ 0.09483232] y_conv= [[ 717.12145996]] y_real= [[750]]\n",
      "Epoch: 13600 cost= 1840.714477539 b= [ 0.09198953] y_conv= [[ 42.90354919]] y_real= [[0]]\n",
      "Epoch: 13650 cost= 5566.308593750 b= [ 0.09236856] y_conv= [[ 425.39230347]] y_real= [[500]]\n",
      "Epoch: 13700 cost= 90.557571411 b= [ 0.09467613] y_conv= [[-490.48382568]] y_real= [[-500]]\n",
      "Epoch: 13750 cost= 1752.240478516 b= [ 0.09724598] y_conv= [[-458.14022827]] y_real= [[-500]]\n",
      "Epoch: 13800 cost= 864.016967773 b= [ 0.09194555] y_conv= [[ 279.39416504]] y_real= [[250]]\n",
      "Epoch: 13850 cost= 33.539218903 b= [ 0.09765763] y_conv= [[ 255.79130554]] y_real= [[250]]\n",
      "Epoch: 13900 cost= 100.969940186 b= [ 0.09611329] y_conv= [[-10.0483799]] y_real= [[0]]\n",
      "Epoch: 13950 cost= 341.681152344 b= [ 0.09467697] y_conv= [[-518.48461914]] y_real= [[-500]]\n",
      "Epoch: 14000 cost= 2943.632080078 b= [ 0.09614928] y_conv= [[ 445.74475098]] y_real= [[500]]\n",
      "Epoch: 14050 cost= 1388.190063477 b= [ 0.09844656] y_conv= [[ 537.25842285]] y_real= [[500]]\n",
      "Epoch: 14100 cost= 1456.793823242 b= [ 0.09524156] y_conv= [[-461.83203125]] y_real= [[-500]]\n",
      "Epoch: 14150 cost= 402.405944824 b= [ 0.09573634] y_conv= [[ 229.93994141]] y_real= [[250]]\n",
      "Epoch: 14200 cost= 176.281646729 b= [ 0.09625994] y_conv= [[ 13.2771101]] y_real= [[0]]\n",
      "Epoch: 14250 cost= 1430.567626953 b= [ 0.09515922] y_conv= [[-287.82284546]] y_real= [[-250]]\n",
      "Epoch: 14300 cost= 1844.955200195 b= [ 0.0970762] y_conv= [[ 42.95294189]] y_real= [[0]]\n",
      "Epoch: 14350 cost= 384.723907471 b= [ 0.09885626] y_conv= [[-230.38562012]] y_real= [[-250]]\n",
      "Epoch: 14400 cost= 702.961853027 b= [ 0.10150462] y_conv= [[ 276.51342773]] y_real= [[250]]\n",
      "Epoch: 14450 cost= 2413.655517578 b= [ 0.09694023] y_conv= [[ 450.87103271]] y_real= [[500]]\n",
      "Epoch: 14500 cost= 2733.061035156 b= [ 0.09521793] y_conv= [[ 697.72131348]] y_real= [[750]]\n",
      "Epoch: 14550 cost= 193.692871094 b= [ 0.09760188] y_conv= [[-736.0826416]] y_real= [[-750]]\n",
      "Epoch: 14600 cost= 3.844019175 b= [ 0.09535703] y_conv= [[-251.96061707]] y_real= [[-250]]\n",
      "Epoch: 14650 cost= 0.345400125 b= [ 0.10087892] y_conv= [[ 500.58770752]] y_real= [[500]]\n",
      "Epoch: 14700 cost= 868.187805176 b= [ 0.09466139] y_conv= [[-279.46502686]] y_real= [[-250]]\n",
      "Epoch: 14750 cost= 697.170776367 b= [ 0.09821445] y_conv= [[-526.4039917]] y_real= [[-500]]\n",
      "Epoch: 14800 cost= 16682.195312500 b= [ 0.09929998] y_conv= [[ 370.84042358]] y_real= [[500]]\n",
      "Epoch: 14850 cost= 1550.698242188 b= [ 0.10322757] y_conv= [[ 539.37890625]] y_real= [[500]]\n",
      "Epoch: 14900 cost= 240.444458008 b= [ 0.10378732] y_conv= [[ 234.49372864]] y_real= [[250]]\n",
      "Epoch: 14950 cost= 6108.037109375 b= [ 0.10496314] y_conv= [[ 671.84606934]] y_real= [[750]]\n",
      "Epoch: 15000 cost= 766.639892578 b= [ 0.1071863] y_conv= [[ 222.31173706]] y_real= [[250]]\n",
      "Epoch: 15050 cost= 53.089954376 b= [ 0.11177159] y_conv= [[ 492.7137146]] y_real= [[500]]\n",
      "Epoch: 15100 cost= 198.449310303 b= [ 0.10390493] y_conv= [[-235.91279602]] y_real= [[-250]]\n",
      "Epoch: 15150 cost= 0.132616654 b= [ 0.10683497] y_conv= [[-0.36416569]] y_real= [[0]]\n",
      "Epoch: 15200 cost= 29.921747208 b= [ 0.1056257] y_conv= [[ 255.47007751]] y_real= [[250]]\n",
      "Epoch: 15250 cost= 28491.673828125 b= [ 0.10387795] y_conv= [[-418.79476929]] y_real= [[-250]]\n",
      "Epoch: 15300 cost= 2795.977050781 b= [ 0.10589507] y_conv= [[-197.1230011]] y_real= [[-250]]\n",
      "Epoch: 15350 cost= 5270.384277344 b= [ 0.10700867] y_conv= [[ 322.59741211]] y_real= [[250]]\n",
      "Epoch: 15400 cost= 130.616134644 b= [ 0.10493702] y_conv= [[-488.57125854]] y_real= [[-500]]\n",
      "Epoch: 15450 cost= 353.869964600 b= [ 0.10438969] y_conv= [[ 231.18856812]] y_real= [[250]]\n",
      "Epoch: 15500 cost= 108.340263367 b= [ 0.10584619] y_conv= [[ 10.4086628]] y_real= [[0]]\n",
      "Epoch: 15550 cost= 88.720558167 b= [ 0.10716009] y_conv= [[-259.41915894]] y_real= [[-250]]\n",
      "Epoch: 15600 cost= 1786.037353516 b= [ 0.10389716] y_conv= [[-707.73846436]] y_real= [[-750]]\n",
      "Epoch: 15650 cost= 532.190063477 b= [ 0.10419173] y_conv= [[ 226.93075562]] y_real= [[250]]\n",
      "Epoch: 15700 cost= 2709.506103516 b= [ 0.10585191] y_conv= [[-552.05291748]] y_real= [[-500]]\n",
      "Epoch: 15750 cost= 376.976928711 b= [ 0.10796488] y_conv= [[-769.41589355]] y_real= [[-750]]\n",
      "Epoch: 15800 cost= 339.954925537 b= [ 0.11177047] y_conv= [[-268.43786621]] y_real= [[-250]]\n",
      "Epoch: 15850 cost= 1.967419386 b= [ 0.10946874] y_conv= [[-1.40264726]] y_real= [[0]]\n",
      "Epoch: 15900 cost= 577.497131348 b= [ 0.10878521] y_conv= [[-24.03116989]] y_real= [[0]]\n",
      "Epoch: 15950 cost= 13527.747070312 b= [ 0.11532426] y_conv= [[ 116.30884552]] y_real= [[0]]\n",
      "Epoch: 16000 cost= 436.909240723 b= [ 0.10684905] y_conv= [[-270.90237427]] y_real= [[-250]]\n",
      "Epoch: 16050 cost= 497.809539795 b= [ 0.1078909] y_conv= [[ 522.31164551]] y_real= [[500]]\n",
      "Epoch: 16100 cost= 79.328353882 b= [ 0.10411637] y_conv= [[ 491.09335327]] y_real= [[500]]\n",
      "Epoch: 16150 cost= 16.105030060 b= [ 0.11167368] y_conv= [[-245.9868927]] y_real= [[-250]]\n",
      "Epoch: 16200 cost= 868.432434082 b= [ 0.10930151] y_conv= [[-720.53082275]] y_real= [[-750]]\n",
      "Epoch: 16250 cost= 2442.406982422 b= [ 0.10928316] y_conv= [[-549.42071533]] y_real= [[-500]]\n",
      "Epoch: 16300 cost= 581.292846680 b= [ 0.10714383] y_conv= [[-24.11001587]] y_real= [[0]]\n",
      "Epoch: 16350 cost= 60.245937347 b= [ 0.10729512] y_conv= [[-242.23817444]] y_real= [[-250]]\n",
      "Epoch: 16400 cost= 1961.079101562 b= [ 0.1071419] y_conv= [[-205.71592712]] y_real= [[-250]]\n",
      "Epoch: 16450 cost= 99.546089172 b= [ 0.1077467] y_conv= [[-9.97727871]] y_real= [[0]]\n",
      "Epoch: 16500 cost= 1223.069580078 b= [ 0.10861243] y_conv= [[-715.02758789]] y_real= [[-750]]\n",
      "Epoch: 16550 cost= 313.824340820 b= [ 0.11244345] y_conv= [[ 267.71508789]] y_real= [[250]]\n",
      "Epoch: 16600 cost= 11.359014511 b= [ 0.10396379] y_conv= [[ 3.37031364]] y_real= [[0]]\n",
      "Epoch: 16650 cost= 82.221946716 b= [ 0.10205913] y_conv= [[-9.06763172]] y_real= [[0]]\n",
      "Epoch: 16700 cost= 223.139846802 b= [ 0.10309938] y_conv= [[-735.06213379]] y_real= [[-750]]\n",
      "Epoch: 16750 cost= 241.112625122 b= [ 0.10835909] y_conv= [[-265.52780151]] y_real= [[-250]]\n",
      "Epoch: 16800 cost= 95.957237244 b= [ 0.10437597] y_conv= [[-740.20422363]] y_real= [[-750]]\n",
      "Epoch: 16850 cost= 881.474731445 b= [ 0.11018773] y_conv= [[ 29.68964005]] y_real= [[0]]\n",
      "Epoch: 16900 cost= 6811.729492188 b= [ 0.10744498] y_conv= [[ 167.46679688]] y_real= [[250]]\n",
      "Epoch: 16950 cost= 4.769414425 b= [ 0.11058893] y_conv= [[ 497.81610107]] y_real= [[500]]\n",
      "Epoch: 17000 cost= 70.337562561 b= [ 0.10868396] y_conv= [[ 508.38674927]] y_real= [[500]]\n",
      "Epoch: 17050 cost= 632.934387207 b= [ 0.1061554] y_conv= [[-224.84181213]] y_real= [[-250]]\n",
      "Epoch: 17100 cost= 3280.987792969 b= [ 0.10756595] y_conv= [[ 307.27990723]] y_real= [[250]]\n",
      "Epoch: 17150 cost= 777.846984863 b= [ 0.1082757] y_conv= [[-222.11009216]] y_real= [[-250]]\n",
      "Epoch: 17200 cost= 342.002563477 b= [ 0.10630283] y_conv= [[ 18.49331093]] y_real= [[0]]\n",
      "Epoch: 17250 cost= 13951.967773438 b= [ 0.10738358] y_conv= [[-118.11844635]] y_real= [[0]]\n",
      "Epoch: 17300 cost= 415.954956055 b= [ 0.10604654] y_conv= [[-229.60502625]] y_real= [[-250]]\n",
      "Epoch: 17350 cost= 0.749687076 b= [ 0.10320792] y_conv= [[ 250.86584473]] y_real= [[250]]\n",
      "Epoch: 17400 cost= 709.153930664 b= [ 0.10720985] y_conv= [[ 473.37005615]] y_real= [[500]]\n",
      "Epoch: 17450 cost= 5995.791503906 b= [ 0.11104628] y_conv= [[ 672.56750488]] y_real= [[750]]\n",
      "Epoch: 17500 cost= 149.769546509 b= [ 0.10352427] y_conv= [[ 512.23803711]] y_real= [[500]]\n",
      "Epoch: 17550 cost= 897.520629883 b= [ 0.10526957] y_conv= [[-279.95864868]] y_real= [[-250]]\n",
      "Epoch: 17600 cost= 638.378784180 b= [ 0.10124951] y_conv= [[ 224.73384094]] y_real= [[250]]\n",
      "Epoch: 17650 cost= 405.174102783 b= [ 0.10155735] y_conv= [[-270.12893677]] y_real= [[-250]]\n",
      "Epoch: 17700 cost= 0.292400807 b= [ 0.1036872] y_conv= [[ 250.54074097]] y_real= [[250]]\n",
      "Epoch: 17750 cost= 5950.448730469 b= [ 0.10102037] y_conv= [[-77.13915253]] y_real= [[0]]\n",
      "Epoch: 17800 cost= 849.578063965 b= [ 0.1016463] y_conv= [[ 529.14752197]] y_real= [[500]]\n",
      "Epoch: 17850 cost= 0.048226133 b= [ 0.10477076] y_conv= [[-249.78039551]] y_real= [[-250]]\n",
      "Epoch: 17900 cost= 811.429138184 b= [ 0.10424754] y_conv= [[ 278.4855957]] y_real= [[250]]\n",
      "Epoch: 17950 cost= 14.820848465 b= [ 0.10670517] y_conv= [[-3.84978557]] y_real= [[0]]\n",
      "Epoch: 18000 cost= 1252.528686523 b= [ 0.10562637] y_conv= [[ 285.39108276]] y_real= [[250]]\n",
      "Epoch: 18050 cost= 3614.009765625 b= [ 0.10360277] y_conv= [[-60.11663437]] y_real= [[0]]\n",
      "Epoch: 18100 cost= 2564.964355469 b= [ 0.10594171] y_conv= [[-300.64547729]] y_real= [[-250]]\n",
      "Epoch: 18150 cost= 46.957710266 b= [ 0.10369889] y_conv= [[ 493.14743042]] y_real= [[500]]\n",
      "Epoch: 18200 cost= 357.474548340 b= [ 0.10653224] y_conv= [[-231.09300232]] y_real= [[-250]]\n",
      "Epoch: 18250 cost= 11584.940429688 b= [ 0.10645973] y_conv= [[ 857.63336182]] y_real= [[750]]\n",
      "Epoch: 18300 cost= 33894.667968750 b= [ 0.11054885] y_conv= [[ 565.8949585]] y_real= [[750]]\n",
      "Epoch: 18350 cost= 806.629333496 b= [ 0.1095573] y_conv= [[-28.40122032]] y_real= [[0]]\n",
      "Epoch: 18400 cost= 2962.368408203 b= [ 0.11230054] y_conv= [[-445.57235718]] y_real= [[-500]]\n",
      "Epoch: 18450 cost= 207.575271606 b= [ 0.11200552] y_conv= [[ 14.40747261]] y_real= [[0]]\n",
      "Epoch: 18500 cost= 3.138455153 b= [ 0.1104233] y_conv= [[ 1.77156854]] y_real= [[0]]\n",
      "Epoch: 18550 cost= 3879.661132812 b= [ 0.11041279] y_conv= [[ 437.71307373]] y_real= [[500]]\n",
      "Epoch: 18600 cost= 1212.500976562 b= [ 0.11362705] y_conv= [[-715.17901611]] y_real= [[-750]]\n",
      "Epoch: 18650 cost= 2195.955078125 b= [ 0.10929503] y_conv= [[-46.86101913]] y_real= [[0]]\n",
      "Epoch: 18700 cost= 949.113037109 b= [ 0.10645954] y_conv= [[ 530.80767822]] y_real= [[500]]\n",
      "Epoch: 18750 cost= 6973.972656250 b= [ 0.10859835] y_conv= [[ 333.51031494]] y_real= [[250]]\n",
      "Epoch: 18800 cost= 324.368286133 b= [ 0.10673704] y_conv= [[ 18.0102272]] y_real= [[0]]\n",
      "Epoch: 18850 cost= 3.128649235 b= [ 0.10728158] y_conv= [[-751.76879883]] y_real= [[-750]]\n",
      "Epoch: 18900 cost= 19222.746093750 b= [ 0.10265862] y_conv= [[ 611.35388184]] y_real= [[750]]\n",
      "Epoch: 18950 cost= 55.236991882 b= [ 0.10932615] y_conv= [[ 257.43215942]] y_real= [[250]]\n",
      "Epoch: 19000 cost= 698.739746094 b= [ 0.10798126] y_conv= [[ 276.4336853]] y_real= [[250]]\n",
      "Epoch: 19050 cost= 252.699188232 b= [ 0.10569727] y_conv= [[-484.10348511]] y_real= [[-500]]\n",
      "Epoch: 19100 cost= 10.464340210 b= [ 0.10531482] y_conv= [[-496.76513672]] y_real= [[-500]]\n",
      "Epoch: 19150 cost= 0.154257640 b= [ 0.10671806] y_conv= [[-0.39275646]] y_real= [[0]]\n",
      "Epoch: 19200 cost= 272.015716553 b= [ 0.10789714] y_conv= [[-16.49289894]] y_real= [[0]]\n",
      "Epoch: 19250 cost= 268.969299316 b= [ 0.10534069] y_conv= [[ 233.59971619]] y_real= [[250]]\n",
      "Epoch: 19300 cost= 2368.143554688 b= [ 0.10475446] y_conv= [[ 701.33642578]] y_real= [[750]]\n",
      "Epoch: 19350 cost= 1371.939941406 b= [ 0.10524947] y_conv= [[-37.03970718]] y_real= [[0]]\n",
      "Epoch: 19400 cost= 5765.543457031 b= [ 0.10416433] y_conv= [[-75.93117523]] y_real= [[0]]\n",
      "Epoch: 19450 cost= 752.814758301 b= [ 0.10350163] y_conv= [[-277.43746948]] y_real= [[-250]]\n",
      "Epoch: 19500 cost= 641.606689453 b= [ 0.10620055] y_conv= [[-724.67004395]] y_real= [[-750]]\n",
      "Epoch: 19550 cost= 11.777832985 b= [ 0.10387834] y_conv= [[-496.56811523]] y_real= [[-500]]\n",
      "Epoch: 19600 cost= 532.605590820 b= [ 0.10091862] y_conv= [[-23.07824898]] y_real= [[0]]\n",
      "Epoch: 19650 cost= 12.051288605 b= [ 0.10011848] y_conv= [[ 503.47149658]] y_real= [[500]]\n",
      "Epoch: 19700 cost= 311.631622314 b= [ 0.10028341] y_conv= [[ 232.34690857]] y_real= [[250]]\n",
      "Epoch: 19750 cost= 45.949832916 b= [ 0.10575996] y_conv= [[ 6.77863073]] y_real= [[0]]\n",
      "Epoch: 19800 cost= 253.372009277 b= [ 0.10336602] y_conv= [[-484.08233643]] y_real= [[-500]]\n",
      "Epoch: 19850 cost= 3617.999755859 b= [ 0.10173222] y_conv= [[ 60.14981079]] y_real= [[0]]\n",
      "Epoch: 19900 cost= 480.446258545 b= [ 0.10296009] y_conv= [[ 21.91908455]] y_real= [[0]]\n",
      "Epoch: 19950 cost= 873.128601074 b= [ 0.10388621] y_conv= [[ 29.54874992]] y_real= [[0]]\n",
      "Epoch: 20000 cost= 281.480285645 b= [ 0.102619] y_conv= [[ 483.22262573]] y_real= [[500]]\n",
      "Optimization Finished!\n",
      "Training cost= 281.48 W= [[ 0.03152444]\n",
      " [ 0.0805411 ]\n",
      " [-0.12351368]\n",
      " ..., \n",
      " [ 0.21376164]\n",
      " [ 0.00378552]\n",
      " [-0.08892885]] b= [ 0.102619]\n",
      "Model saved in file: /Users/il239838/Downloads/private/Thesis/Papyrus/tear_model.ckpt\n",
      "#####################################################################\n",
      "TRIANING ENDED\n",
      "#####################################################################\n",
      " \n",
      " \n"
     ]
    }
   ],
   "source": [
    "# train...\n",
    "train(train_imgs, train_diagonal_delta, ROOT_FOLDER + \"tear_model.ckpt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "len(train_imgs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# train_diagonal_delta = np.sqrt(np.asarray(train_x_delta)**2 + np.asarray(train_y_delta)**2) # pitagoras\n",
    "train_diagonal_delta = train_y_delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "train_diagonal_delta = [(x if x < BREAK_VAL else BREAK_VAL) for x in train_diagonal_delta]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "linear_model_tf(250)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#####################################################################\n",
      "TRAINING:\n",
      "MODEL:/Users/il239838/Downloads/private/Thesis/Papyrus/tear_model.ckpt\n",
      "#####################################################################\n",
      "WARNING:tensorflow:From /Users/il239838/anaconda/envs/tensorflow/lib/python3.5/site-packages/tensorflow/python/util/tf_should_use.py:170: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n",
      "Instructions for updating:\n",
      "Use `tf.global_variables_initializer` instead.\n",
      "Epoch: 0050 cost= 1118509.250000000 b= [ 0.09676699] y_conv= [[-57.59593582]] y_real= [[1000]]\n",
      "Epoch: 0100 cost= 413787.218750000 b= [ 0.09920032] y_conv= [[-643.26293945]] y_real= [[0.0]]\n",
      "Epoch: 0150 cost= 31366.087890625 b= [ 0.09715088] y_conv= [[-822.89526367]] y_real= [[-1000.0]]\n",
      "Epoch: 0200 cost= 22785.722656250 b= [ 0.10253438] y_conv= [[-849.05059814]] y_real= [[-1000.0]]\n",
      "Epoch: 0250 cost= 25982.630859375 b= [ 0.10196024] y_conv= [[-588.80871582]] y_real= [[-750.0]]\n",
      "Epoch: 0300 cost= 174056.000000000 b= [ 0.10271593] y_conv= [[-832.79980469]] y_real= [[-1250.0]]\n",
      "Epoch: 0350 cost= 17873.306640625 b= [ 0.10012232] y_conv= [[ 133.69108582]] y_real= [[0.0]]\n",
      "Epoch: 0400 cost= 101688.953125000 b= [ 0.0973198] y_conv= [[-318.88705444]] y_real= [[0.0]]\n",
      "Epoch: 0450 cost= 19067.388671875 b= [ 0.10132968] y_conv= [[ 888.0847168]] y_real= [[750.0]]\n",
      "Epoch: 0500 cost= 0.277672857 b= [ 0.09733324] y_conv= [[-0.52694672]] y_real= [[0.0]]\n",
      "Epoch: 0550 cost= 5830.222656250 b= [ 0.0962989] y_conv= [[ 923.644104]] y_real= [[1000]]\n",
      "Epoch: 0600 cost= 130804.335937500 b= [ 0.10020285] y_conv= [[ 638.33117676]] y_real= [[1000]]\n",
      "Epoch: 0650 cost= 12768.089843750 b= [ 0.10113262] y_conv= [[ 887.00402832]] y_real= [[1000]]\n",
      "Epoch: 0700 cost= 466298.843750000 b= [ 0.10040839] y_conv= [[ 67.13922882]] y_real= [[750.0]]\n",
      "Epoch: 0750 cost= 4766.097167969 b= [ 0.09832337] y_conv= [[ 930.96307373]] y_real= [[1000]]\n",
      "Epoch: 0800 cost= 37088.496093750 b= [ 0.1004981] y_conv= [[-192.58374023]] y_real= [[0.0]]\n",
      "Epoch: 0850 cost= 252.985488892 b= [ 0.0948961] y_conv= [[-1265.90551758]] y_real= [[-1250.0]]\n",
      "Epoch: 0900 cost= 18756.894531250 b= [ 0.09339907] y_conv= [[ 1136.95581055]] y_real= [[1000]]\n",
      "Epoch: 0950 cost= 110777.320312500 b= [ 0.09459099] y_conv= [[ 667.16772461]] y_real= [[1000]]\n",
      "Epoch: 1000 cost= 84603.031250000 b= [ 0.09649163] y_conv= [[-40.86599731]] y_real= [[250.0]]\n",
      "Epoch: 1050 cost= 5718.411132812 b= [ 0.09884178] y_conv= [[ 924.37982178]] y_real= [[1000]]\n",
      "Epoch: 1100 cost= 9575.095703125 b= [ 0.10225552] y_conv= [[ 1097.85241699]] y_real= [[1000]]\n",
      "Epoch: 1150 cost= 42.054244995 b= [ 0.10291579] y_conv= [[-1006.48492432]] y_real= [[-1000.0]]\n",
      "Epoch: 1200 cost= 72275.710937500 b= [ 0.10013673] y_conv= [[ 18.84143829]] y_real= [[-250.0]]\n",
      "Epoch: 1250 cost= 74691.414062500 b= [ 0.0936878] y_conv= [[ 273.29730225]] y_real= [[0.0]]\n",
      "Epoch: 1300 cost= 48829.917968750 b= [ 0.09375121] y_conv= [[ 29.02507401]] y_real= [[250.0]]\n",
      "Epoch: 1350 cost= 68494.148437500 b= [ 0.09297858] y_conv= [[-11.713871]] y_real= [[250.0]]\n",
      "Epoch: 1400 cost= 1009.555236816 b= [ 0.09096697] y_conv= [[ 968.22650146]] y_real= [[1000]]\n",
      "Epoch: 1450 cost= 24874.394531250 b= [ 0.08781354] y_conv= [[ 842.28381348]] y_real= [[1000]]\n",
      "Epoch: 1500 cost= 9732.669921875 b= [ 0.09520342] y_conv= [[ 651.34570312]] y_real= [[750.0]]\n",
      "Epoch: 1550 cost= 6982.711914062 b= [ 0.09707994] y_conv= [[-166.43737793]] y_real= [[-250.0]]\n",
      "Epoch: 1600 cost= 51774.289062500 b= [ 0.09397843] y_conv= [[-227.53964233]] y_real= [[0.0]]\n",
      "Epoch: 1650 cost= 32716.224609375 b= [ 0.09447724] y_conv= [[ 180.87626648]] y_real= [[0.0]]\n",
      "Epoch: 1700 cost= 10978.598632812 b= [ 0.0936398] y_conv= [[ 1104.77880859]] y_real= [[1000]]\n",
      "Epoch: 1750 cost= 158.630218506 b= [ 0.09109885] y_conv= [[-1237.40515137]] y_real= [[-1250.0]]\n",
      "Epoch: 1800 cost= 29891.716796875 b= [ 0.09390058] y_conv= [[-1422.89221191]] y_real= [[-1250.0]]\n",
      "Epoch: 1850 cost= 394.632385254 b= [ 0.09408395] y_conv= [[-730.13464355]] y_real= [[-750.0]]\n",
      "Epoch: 1900 cost= 57.678016663 b= [ 0.09181975] y_conv= [[ 1007.59460449]] y_real= [[1000]]\n",
      "Epoch: 1950 cost= 518.793457031 b= [ 0.0882825] y_conv= [[ 227.22296143]] y_real= [[250.0]]\n",
      "Epoch: 2000 cost= 15378.204101562 b= [ 0.08888186] y_conv= [[ 125.99111176]] y_real= [[250.0]]\n",
      "Epoch: 2050 cost= 3837.652832031 b= [ 0.08963487] y_conv= [[ 938.0512085]] y_real= [[1000]]\n",
      "Epoch: 2100 cost= 135866.578125000 b= [ 0.09045801] y_conv= [[-1381.39916992]] y_real= [[-1750.0]]\n",
      "Epoch: 2150 cost= 36609.253906250 b= [ 0.08583771] y_conv= [[-1058.66455078]] y_real= [[-1250.0]]\n",
      "Epoch: 2200 cost= 13419.844726562 b= [ 0.08368356] y_conv= [[ 884.15594482]] y_real= [[1000]]\n",
      "Epoch: 2250 cost= 44450.171875000 b= [ 0.08551118] y_conv= [[-960.83209229]] y_real= [[-750.0]]\n",
      "Epoch: 2300 cost= 7962.098144531 b= [ 0.08538693] y_conv= [[-1089.23059082]] y_real= [[-1000.0]]\n",
      "Epoch: 2350 cost= 72752.960937500 b= [ 0.08437736] y_conv= [[ 19.72757721]] y_real= [[-250.0]]\n",
      "Epoch: 2400 cost= 25319.857421875 b= [ 0.08244622] y_conv= [[ 159.12214661]] y_real= [[0.0]]\n",
      "Epoch: 2450 cost= 21.055728912 b= [ 0.08114401] y_conv= [[-4.58865213]] y_real= [[0.0]]\n",
      "Epoch: 2500 cost= 12482.469726562 b= [ 0.08334216] y_conv= [[-111.72497559]] y_real= [[0.0]]\n",
      "Epoch: 2550 cost= 5479.396972656 b= [ 0.08378512] y_conv= [[-1074.02294922]] y_real= [[-1000.0]]\n",
      "Epoch: 2600 cost= 49080.257812500 b= [ 0.08638468] y_conv= [[ 1221.54064941]] y_real= [[1000]]\n",
      "Epoch: 2650 cost= 8478.291015625 b= [ 0.08702578] y_conv= [[ 907.92236328]] y_real= [[1000]]\n",
      "Epoch: 2700 cost= 44356.753906250 b= [ 0.08720789] y_conv= [[ 210.61042786]] y_real= [[0.0]]\n",
      "Epoch: 2750 cost= 80.373519897 b= [ 0.08888036] y_conv= [[-8.96512794]] y_real= [[0.0]]\n",
      "Epoch: 2800 cost= 53680.171875000 b= [ 0.08458813] y_conv= [[-1018.31018066]] y_real= [[-1250.0]]\n",
      "Epoch: 2850 cost= 8764.977539062 b= [ 0.08879782] y_conv= [[ 906.37854004]] y_real= [[1000]]\n",
      "Epoch: 2900 cost= 446.113494873 b= [ 0.09082627] y_conv= [[ 271.12139893]] y_real= [[250.0]]\n",
      "Epoch: 2950 cost= 74.125030518 b= [ 0.0847441] y_conv= [[ 8.60958958]] y_real= [[0.0]]\n",
      "Epoch: 3000 cost= 50.741806030 b= [ 0.0866128] y_conv= [[ 7.12332821]] y_real= [[0.0]]\n",
      "Epoch: 3050 cost= 12856.547851562 b= [ 0.08608931] y_conv= [[ 886.61328125]] y_real= [[1000]]\n",
      "Epoch: 3100 cost= 12960.107421875 b= [ 0.08414588] y_conv= [[ 863.84246826]] y_real= [[750.0]]\n",
      "Epoch: 3150 cost= 2416.024902344 b= [ 0.08814865] y_conv= [[ 950.84692383]] y_real= [[1000]]\n",
      "Epoch: 3200 cost= 12580.804687500 b= [ 0.087973] y_conv= [[-1362.16418457]] y_real= [[-1250.0]]\n",
      "Epoch: 3250 cost= 1873.007690430 b= [ 0.09091966] y_conv= [[-293.27825928]] y_real= [[-250.0]]\n",
      "Epoch: 3300 cost= 3.714748144 b= [ 0.0919683] y_conv= [[ 998.07263184]] y_real= [[1000]]\n",
      "Epoch: 3350 cost= 6550.377441406 b= [ 0.08705261] y_conv= [[-80.93440247]] y_real= [[0.0]]\n",
      "Epoch: 3400 cost= 12612.781250000 b= [ 0.08743068] y_conv= [[ 887.69335938]] y_real= [[1000]]\n",
      "Epoch: 3450 cost= 176144.828125000 b= [ 0.08920678] y_conv= [[-830.30389404]] y_real= [[-1250.0]]\n",
      "Epoch: 3500 cost= 3065.782226562 b= [ 0.08207691] y_conv= [[ 1055.36950684]] y_real= [[1000]]\n",
      "Epoch: 3550 cost= 22375.789062500 b= [ 0.08407169] y_conv= [[ 850.41461182]] y_real= [[1000]]\n",
      "Epoch: 3600 cost= 224.685165405 b= [ 0.08530619] y_conv= [[-1014.98950195]] y_real= [[-1000.0]]\n",
      "Epoch: 3650 cost= 20248.244140625 b= [ 0.08483217] y_conv= [[ 857.70367432]] y_real= [[1000]]\n",
      "Epoch: 3700 cost= 28827.931640625 b= [ 0.08944703] y_conv= [[ 419.78790283]] y_real= [[250.0]]\n",
      "Epoch: 3750 cost= 49174.308593750 b= [ 0.08731485] y_conv= [[-278.24719238]] y_real= [[-500.0]]\n",
      "Epoch: 3800 cost= 10601.583007812 b= [ 0.08559837] y_conv= [[ 647.03601074]] y_real= [[750.0]]\n",
      "Epoch: 3850 cost= 1198.493408203 b= [ 0.08606641] y_conv= [[ 534.6192627]] y_real= [[500.0]]\n",
      "Epoch: 3900 cost= 977.677551270 b= [ 0.08624569] y_conv= [[ 31.26783562]] y_real= [[0.0]]\n",
      "Epoch: 3950 cost= 2321.993896484 b= [ 0.08835925] y_conv= [[ 548.18707275]] y_real= [[500.0]]\n",
      "Epoch: 4000 cost= 15797.694335938 b= [ 0.08643978] y_conv= [[-125.68888092]] y_real= [[0.0]]\n",
      "Epoch: 4050 cost= 21717.326171875 b= [ 0.08827594] y_conv= [[ 147.36799622]] y_real= [[0.0]]\n",
      "Epoch: 4100 cost= 19736.236328125 b= [ 0.0830851] y_conv= [[-609.51428223]] y_real= [[-750.0]]\n",
      "Epoch: 4150 cost= 58523.949218750 b= [ 0.08595049] y_conv= [[-1508.08276367]] y_real= [[-1750.0]]\n",
      "Epoch: 4200 cost= 30306.445312500 b= [ 0.08488723] y_conv= [[ 174.08746338]] y_real= [[0.0]]\n",
      "Epoch: 4250 cost= 81.929901123 b= [ 0.08912718] y_conv= [[-990.94848633]] y_real= [[-1000.0]]\n",
      "Epoch: 4300 cost= 2643.570556641 b= [ 0.08537666] y_conv= [[ 51.41566467]] y_real= [[0.0]]\n",
      "Epoch: 4350 cost= 12196.252929688 b= [ 0.08411725] y_conv= [[ 889.56335449]] y_real= [[1000]]\n",
      "Epoch: 4400 cost= 19457.644531250 b= [ 0.08592549] y_conv= [[-610.50933838]] y_real= [[-750.0]]\n",
      "Epoch: 4450 cost= 16476.783203125 b= [ 0.08386482] y_conv= [[-128.36192322]] y_real= [[0.0]]\n",
      "Epoch: 4500 cost= 32100.832031250 b= [ 0.08098154] y_conv= [[-70.83295441]] y_real= [[-250.0]]\n",
      "Epoch: 4550 cost= 47696.332031250 b= [ 0.08302465] y_conv= [[ 781.60510254]] y_real= [[1000]]\n",
      "Epoch: 4600 cost= 12016.542968750 b= [ 0.08302858] y_conv= [[-890.38000488]] y_real= [[-1000.0]]\n",
      "Epoch: 4650 cost= 126420.132812500 b= [ 0.08511212] y_conv= [[ 144.44392395]] y_real= [[500.0]]\n",
      "Epoch: 4700 cost= 2871.617431641 b= [ 0.08258088] y_conv= [[-53.58747482]] y_real= [[0.0]]\n",
      "Epoch: 4750 cost= 617.465148926 b= [ 0.08075581] y_conv= [[-274.84884644]] y_real= [[-250.0]]\n",
      "Epoch: 4800 cost= 754.438354492 b= [ 0.08523965] y_conv= [[ 1027.46704102]] y_real= [[1000]]\n",
      "Epoch: 4850 cost= 13530.145507812 b= [ 0.0864242] y_conv= [[ 116.31915283]] y_real= [[0.0]]\n",
      "Epoch: 4900 cost= 6160.026855469 b= [ 0.08241291] y_conv= [[ 921.51416016]] y_real= [[1000]]\n",
      "Epoch: 4950 cost= 9239.288085938 b= [ 0.08253983] y_conv= [[-903.87878418]] y_real= [[-1000.0]]\n",
      "Epoch: 5000 cost= 53438.039062500 b= [ 0.08270716] y_conv= [[ 481.16668701]] y_real= [[250.0]]\n",
      "Epoch: 5050 cost= 7845.370605469 b= [ 0.07833418] y_conv= [[ 1088.57409668]] y_real= [[1000]]\n",
      "Epoch: 5100 cost= 897.184326172 b= [ 0.08079012] y_conv= [[ 29.95303535]] y_real= [[0.0]]\n",
      "Epoch: 5150 cost= 1355.196166992 b= [ 0.0836231] y_conv= [[-213.18701172]] y_real= [[-250.0]]\n",
      "Epoch: 5200 cost= 292.046783447 b= [ 0.08575374] y_conv= [[-17.08937645]] y_real= [[0.0]]\n",
      "Epoch: 5250 cost= 114.076583862 b= [ 0.08556507] y_conv= [[ 1010.68066406]] y_real= [[1000]]\n",
      "Epoch: 5300 cost= 2990.979736328 b= [ 0.08589147] y_conv= [[-304.68984985]] y_real= [[-250.0]]\n",
      "Epoch: 5350 cost= 37704.511718750 b= [ 0.08265035] y_conv= [[-194.17649841]] y_real= [[0.0]]\n",
      "Epoch: 5400 cost= 10907.834960938 b= [ 0.08256207] y_conv= [[-145.55941772]] y_real= [[-250.0]]\n",
      "Epoch: 5450 cost= 12848.936523438 b= [ 0.08588064] y_conv= [[ 863.35314941]] y_real= [[750.0]]\n",
      "Epoch: 5500 cost= 42.929805756 b= [ 0.0872274] y_conv= [[-6.55208397]] y_real= [[0.0]]\n",
      "Epoch: 5550 cost= 1652.345092773 b= [ 0.08894641] y_conv= [[ 959.35095215]] y_real= [[1000]]\n",
      "Epoch: 5600 cost= 201501.593750000 b= [ 0.09089697] y_conv= [[ 51.11073303]] y_real= [[500.0]]\n",
      "Epoch: 5650 cost= 4591.589355469 b= [ 0.09008197] y_conv= [[-67.76126862]] y_real= [[0.0]]\n",
      "Epoch: 5700 cost= 7145.645507812 b= [ 0.09549747] y_conv= [[-915.46807861]] y_real= [[-1000.0]]\n",
      "Epoch: 5750 cost= 48300.847656250 b= [ 0.09000005] y_conv= [[ 780.22546387]] y_real= [[1000]]\n",
      "Epoch: 5800 cost= 18696.755859375 b= [ 0.09088403] y_conv= [[ 863.26391602]] y_real= [[1000]]\n",
      "Epoch: 5850 cost= 5267.171386719 b= [ 0.09221654] y_conv= [[ 72.57527924]] y_real= [[0.0]]\n",
      "Epoch: 5900 cost= 2057.909423828 b= [ 0.09198776] y_conv= [[ 45.36418533]] y_real= [[0.0]]\n",
      "Epoch: 5950 cost= 20365.417968750 b= [ 0.08993025] y_conv= [[-607.2925415]] y_real= [[-750.0]]\n",
      "Epoch: 6000 cost= 43288.402343750 b= [ 0.08943909] y_conv= [[ 791.94134521]] y_real= [[1000]]\n",
      "Epoch: 6050 cost= 1635.723266602 b= [ 0.09062411] y_conv= [[ 209.55592346]] y_real= [[250.0]]\n",
      "Epoch: 6100 cost= 79.145805359 b= [ 0.08876604] y_conv= [[ 258.89639282]] y_real= [[250.0]]\n",
      "Epoch: 6150 cost= 2753.997070312 b= [ 0.09062219] y_conv= [[-52.47853851]] y_real= [[0.0]]\n",
      "Epoch: 6200 cost= 1311.576782227 b= [ 0.08930972] y_conv= [[-1213.78430176]] y_real= [[-1250.0]]\n",
      "Epoch: 6250 cost= 3253.956054688 b= [ 0.09096646] y_conv= [[-1307.04345703]] y_real= [[-1250.0]]\n",
      "Epoch: 6300 cost= 221.045059204 b= [ 0.08809662] y_conv= [[ 485.13241577]] y_real= [[500.0]]\n",
      "Epoch: 6350 cost= 1761.267700195 b= [ 0.08985003] y_conv= [[-41.96746063]] y_real= [[0.0]]\n",
      "Epoch: 6400 cost= 2436.637207031 b= [ 0.09057868] y_conv= [[ 950.63769531]] y_real= [[1000]]\n",
      "Epoch: 6450 cost= 4072.748046875 b= [ 0.08956753] y_conv= [[ 63.81808472]] y_real= [[0.0]]\n",
      "Epoch: 6500 cost= 53252.152343750 b= [ 0.0916552] y_conv= [[ 1230.76428223]] y_real= [[1000]]\n",
      "Epoch: 6550 cost= 107.877174377 b= [ 0.0957445] y_conv= [[ 10.38639355]] y_real= [[0.0]]\n",
      "Epoch: 6600 cost= 406.250427246 b= [ 0.09038612] y_conv= [[ 229.84434509]] y_real= [[250.0]]\n",
      "Epoch: 6650 cost= 3751.091552734 b= [ 0.09502367] y_conv= [[ 811.24615479]] y_real= [[750.0]]\n",
      "Epoch: 6700 cost= 43888.613281250 b= [ 0.09346563] y_conv= [[ 540.50390625]] y_real= [[750.0]]\n",
      "Epoch: 6750 cost= 28989.841796875 b= [ 0.09273493] y_conv= [[ 1170.26403809]] y_real= [[1000]]\n",
      "Epoch: 6800 cost= 1568.785278320 b= [ 0.08762777] y_conv= [[ 210.3921051]] y_real= [[250.0]]\n",
      "Epoch: 6850 cost= 2034.112426758 b= [ 0.09119651] y_conv= [[ 45.10113525]] y_real= [[0.0]]\n",
      "Epoch: 6900 cost= 4874.087890625 b= [ 0.08994677] y_conv= [[ 69.81466675]] y_real= [[0.0]]\n",
      "Epoch: 6950 cost= 328.232482910 b= [ 0.09380025] y_conv= [[ 1018.1171875]] y_real= [[1000]]\n",
      "Epoch: 7000 cost= 2105.055419922 b= [ 0.09119476] y_conv= [[ 45.88088226]] y_real= [[0.0]]\n",
      "Epoch: 7050 cost= 3093.312255859 b= [ 0.09425763] y_conv= [[-1194.38244629]] y_real= [[-1250.0]]\n",
      "Epoch: 7100 cost= 13531.465820312 b= [ 0.09455474] y_conv= [[-1116.3248291]] y_real= [[-1000.0]]\n",
      "Epoch: 7150 cost= 1913.950317383 b= [ 0.09456438] y_conv= [[-793.74871826]] y_real= [[-750.0]]\n",
      "Epoch: 7200 cost= 12385.445312500 b= [ 0.0924063] y_conv= [[-638.71008301]] y_real= [[-750.0]]\n",
      "Epoch: 7250 cost= 10934.605468750 b= [ 0.09363033] y_conv= [[ 895.43133545]] y_real= [[1000]]\n",
      "Epoch: 7300 cost= 5788.811035156 b= [ 0.09505295] y_conv= [[ 76.08423615]] y_real= [[0.0]]\n",
      "Epoch: 7350 cost= 17958.060546875 b= [ 0.09827951] y_conv= [[ 115.99230194]] y_real= [[250.0]]\n",
      "Epoch: 7400 cost= 333.369018555 b= [ 0.09826502] y_conv= [[-18.25839615]] y_real= [[0.0]]\n",
      "Epoch: 7450 cost= 7.408869267 b= [ 0.09689859] y_conv= [[ 1002.72192383]] y_real= [[1000]]\n",
      "Epoch: 7500 cost= 958.591674805 b= [ 0.09502971] y_conv= [[ 30.96113205]] y_real= [[0.0]]\n",
      "Epoch: 7550 cost= 473.312103271 b= [ 0.09391577] y_conv= [[-1271.7557373]] y_real= [[-1250.0]]\n",
      "Epoch: 7600 cost= 6747.097167969 b= [ 0.09814605] y_conv= [[ 82.14071655]] y_real= [[0.0]]\n",
      "Epoch: 7650 cost= 2468.289794922 b= [ 0.09931195] y_conv= [[ 700.31811523]] y_real= [[750.0]]\n",
      "Epoch: 7700 cost= 2896.760009766 b= [ 0.09610887] y_conv= [[-53.82155609]] y_real= [[0.0]]\n",
      "Epoch: 7750 cost= 47712.648437500 b= [ 0.09703887] y_conv= [[-1031.56774902]] y_real= [[-1250.0]]\n",
      "Epoch: 7800 cost= 1841.132202148 b= [ 0.09004105] y_conv= [[ 457.09158325]] y_real= [[500.0]]\n",
      "Epoch: 7850 cost= 246.358139038 b= [ 0.09517214] y_conv= [[-15.69579983]] y_real= [[0.0]]\n",
      "Epoch: 7900 cost= 17474.224609375 b= [ 0.09343245] y_conv= [[-132.19010925]] y_real= [[0.0]]\n",
      "Epoch: 7950 cost= 3044.023437500 b= [ 0.09848685] y_conv= [[-694.82733154]] y_real= [[-750.0]]\n",
      "Epoch: 8000 cost= 4585.333007812 b= [ 0.09237519] y_conv= [[ 1067.71508789]] y_real= [[1000]]\n",
      "Epoch: 8050 cost= 89641.289062500 b= [ 0.09520686] y_conv= [[-700.59844971]] y_real= [[-1000.0]]\n",
      "Epoch: 8100 cost= 2493.455322266 b= [ 0.09208453] y_conv= [[ 799.93450928]] y_real= [[750.0]]\n",
      "Epoch: 8150 cost= 20980.048828125 b= [ 0.09016595] y_conv= [[ 855.15509033]] y_real= [[1000]]\n",
      "Epoch: 8200 cost= 25215.207031250 b= [ 0.09311702] y_conv= [[-908.79296875]] y_real= [[-750.0]]\n",
      "Epoch: 8250 cost= 588.201660156 b= [ 0.09231791] y_conv= [[-975.74713135]] y_real= [[-1000.0]]\n",
      "Epoch: 8300 cost= 147.251052856 b= [ 0.09251606] y_conv= [[-762.13470459]] y_real= [[-750.0]]\n",
      "Epoch: 8350 cost= 79.991317749 b= [ 0.09530511] y_conv= [[ 758.94378662]] y_real= [[750.0]]\n",
      "Epoch: 8400 cost= 2690.299316406 b= [ 0.09467437] y_conv= [[-51.8680954]] y_real= [[0.0]]\n",
      "Epoch: 8450 cost= 27500.667968750 b= [ 0.09608261] y_conv= [[-1165.83325195]] y_real= [[-1000.0]]\n",
      "Epoch: 8500 cost= 375.276306152 b= [ 0.09678794] y_conv= [[-19.37204933]] y_real= [[0.0]]\n",
      "Epoch: 8550 cost= 639.157043457 b= [ 0.09784759] y_conv= [[-275.28155518]] y_real= [[-250.0]]\n",
      "Epoch: 8600 cost= 14192.685546875 b= [ 0.10061468] y_conv= [[-380.86694336]] y_real= [[-500.0]]\n",
      "Epoch: 8650 cost= 26417.359375000 b= [ 0.09997746] y_conv= [[ 1162.53417969]] y_real= [[1000]]\n",
      "Epoch: 8700 cost= 4833.378906250 b= [ 0.09901178] y_conv= [[-180.47749329]] y_real= [[-250.0]]\n",
      "Epoch: 8750 cost= 193.295532227 b= [ 0.09793809] y_conv= [[ 986.09692383]] y_real= [[1000]]\n",
      "Epoch: 8800 cost= 5843.801757812 b= [ 0.09791696] y_conv= [[ 673.55523682]] y_real= [[750.0]]\n",
      "Epoch: 8850 cost= 7285.326660156 b= [ 0.09817713] y_conv= [[-1835.35412598]] y_real= [[-1750.0]]\n",
      "Epoch: 8900 cost= 1228.316284180 b= [ 0.10121644] y_conv= [[ 35.04734421]] y_real= [[0.0]]\n",
      "Epoch: 8950 cost= 353.138977051 b= [ 0.09947224] y_conv= [[-231.20800781]] y_real= [[-250.0]]\n",
      "Epoch: 9000 cost= 16839.599609375 b= [ 0.10163665] y_conv= [[ 129.76748657]] y_real= [[0.0]]\n",
      "Epoch: 9050 cost= 7.120011330 b= [ 0.10080462] y_conv= [[ 997.33166504]] y_real= [[1000]]\n",
      "Epoch: 9100 cost= 9909.823242188 b= [ 0.09694922] y_conv= [[-1099.5480957]] y_real= [[-1000.0]]\n",
      "Epoch: 9150 cost= 1219.432861328 b= [ 0.10074095] y_conv= [[ 284.92037964]] y_real= [[250.0]]\n",
      "Epoch: 9200 cost= 478.435516357 b= [ 0.10342055] y_conv= [[ 978.12683105]] y_real= [[1000]]\n",
      "Epoch: 9250 cost= 13958.645507812 b= [ 0.09971879] y_conv= [[ 131.85328674]] y_real= [[250.0]]\n",
      "Epoch: 9300 cost= 20879.685546875 b= [ 0.10286836] y_conv= [[-1105.50195312]] y_real= [[-1250.0]]\n",
      "Epoch: 9350 cost= 9662.011718750 b= [ 0.10269649] y_conv= [[-1098.29553223]] y_real= [[-1000.0]]\n",
      "Epoch: 9400 cost= 1536.947265625 b= [ 0.10345948] y_conv= [[-289.20391846]] y_real= [[-250.0]]\n",
      "Epoch: 9450 cost= 196.022216797 b= [ 0.1024974] y_conv= [[ 485.99920654]] y_real= [[500.0]]\n",
      "Epoch: 9500 cost= 1917.620971680 b= [ 0.10023187] y_conv= [[-1043.79064941]] y_real= [[-1000.0]]\n",
      "Epoch: 9550 cost= 3874.059570312 b= [ 0.10061283] y_conv= [[-1062.24194336]] y_real= [[-1000.0]]\n",
      "Epoch: 9600 cost= 40.260200500 b= [ 0.10312767] y_conv= [[ 1006.34509277]] y_real= [[1000]]\n",
      "Epoch: 9650 cost= 2491.133300781 b= [ 0.09865613] y_conv= [[-1200.08874512]] y_real= [[-1250.0]]\n",
      "Epoch: 9700 cost= 140.249114990 b= [ 0.10137334] y_conv= [[ 511.84268188]] y_real= [[500.0]]\n",
      "Epoch: 9750 cost= 10625.300781250 b= [ 0.10110653] y_conv= [[-1146.92089844]] y_real= [[-1250.0]]\n",
      "Epoch: 9800 cost= 68.445220947 b= [ 0.1018576] y_conv= [[-508.27316284]] y_real= [[-500.0]]\n",
      "Epoch: 9850 cost= 3734.706298828 b= [ 0.0956577] y_conv= [[ 938.88775635]] y_real= [[1000]]\n",
      "Epoch: 9900 cost= 24167.117187500 b= [ 0.09924202] y_conv= [[-1094.54223633]] y_real= [[-1250.0]]\n",
      "Epoch: 9950 cost= 5587.927734375 b= [ 0.09959351] y_conv= [[ 1074.75244141]] y_real= [[1000]]\n",
      "Epoch: 10000 cost= 21085.259765625 b= [ 0.09656832] y_conv= [[-1145.2076416]] y_real= [[-1000.0]]\n",
      "Epoch: 10050 cost= 19114.109375000 b= [ 0.09399811] y_conv= [[-1388.25378418]] y_real= [[-1250.0]]\n",
      "Epoch: 10100 cost= 3445.958251953 b= [ 0.09797184] y_conv= [[ 191.29771423]] y_real= [[250.0]]\n",
      "Epoch: 10150 cost= 33323.917968750 b= [ 0.092988] y_conv= [[ 817.45159912]] y_real= [[1000]]\n",
      "Epoch: 10200 cost= 42394.089843750 b= [ 0.09531634] y_conv= [[-294.10174561]] y_real= [[-500.0]]\n",
      "Epoch: 10250 cost= 19203.169921875 b= [ 0.09560692] y_conv= [[ 861.42449951]] y_real= [[1000]]\n",
      "Epoch: 10300 cost= 15754.233398438 b= [ 0.09138913] y_conv= [[ 874.48413086]] y_real= [[1000]]\n",
      "Epoch: 10350 cost= 37519.269531250 b= [ 0.09468932] y_conv= [[ 806.30108643]] y_real= [[1000]]\n",
      "Epoch: 10400 cost= 1093.629394531 b= [ 0.09721955] y_conv= [[-966.92993164]] y_real= [[-1000.0]]\n",
      "Epoch: 10450 cost= 4128.101562500 b= [ 0.09582926] y_conv= [[ 935.74969482]] y_real= [[1000]]\n",
      "Epoch: 10500 cost= 5136.437500000 b= [ 0.09722617] y_conv= [[-1821.66894531]] y_real= [[-1750.0]]\n",
      "Epoch: 10550 cost= 25828.064453125 b= [ 0.09444422] y_conv= [[ 839.28887939]] y_real= [[1000]]\n",
      "Epoch: 10600 cost= 0.022576053 b= [ 0.09775522] y_conv= [[-250.1502533]] y_real= [[-250.0]]\n",
      "Epoch: 10650 cost= 4617.287109375 b= [ 0.09968319] y_conv= [[-932.04937744]] y_real= [[-1000.0]]\n",
      "Epoch: 10700 cost= 7367.137695312 b= [ 0.09756016] y_conv= [[-1085.83203125]] y_real= [[-1000.0]]\n",
      "Epoch: 10750 cost= 929.728820801 b= [ 0.09951292] y_conv= [[ 1030.49145508]] y_real= [[1000]]\n",
      "Epoch: 10800 cost= 36394.878906250 b= [ 0.09699446] y_conv= [[-809.22558594]] y_real= [[-1000.0]]\n",
      "Epoch: 10850 cost= 1392.531494141 b= [ 0.10250938] y_conv= [[ 37.31663895]] y_real= [[0.0]]\n",
      "Epoch: 10900 cost= 3784.753173828 b= [ 0.10147136] y_conv= [[ 61.5203476]] y_real= [[0.0]]\n",
      "Epoch: 10950 cost= 121.296554565 b= [ 0.1028963] y_conv= [[ 11.0134716]] y_real= [[0.0]]\n",
      "Epoch: 11000 cost= 13818.200195312 b= [ 0.09804367] y_conv= [[ 882.44915771]] y_real= [[1000]]\n",
      "Epoch: 11050 cost= 11059.710937500 b= [ 0.10203683] y_conv= [[-1394.83483887]] y_real= [[-1500.0]]\n",
      "Epoch: 11100 cost= 9164.559570312 b= [ 0.10092392] y_conv= [[-154.26829529]] y_real= [[-250.0]]\n",
      "Epoch: 11150 cost= 54.897750854 b= [ 0.10258786] y_conv= [[ 992.59069824]] y_real= [[1000]]\n",
      "Epoch: 11200 cost= 7922.673339844 b= [ 0.103689] y_conv= [[-89.00939941]] y_real= [[0.0]]\n",
      "Epoch: 11250 cost= 3103.055664062 b= [ 0.10530516] y_conv= [[ 944.29492188]] y_real= [[1000]]\n",
      "Epoch: 11300 cost= 2315.071777344 b= [ 0.10247732] y_conv= [[-48.11519241]] y_real= [[0.0]]\n",
      "Epoch: 11350 cost= 1582.319580078 b= [ 0.10254651] y_conv= [[ 960.22161865]] y_real= [[1000]]\n",
      "Epoch: 11400 cost= 11068.904296875 b= [ 0.10335048] y_conv= [[-1144.7911377]] y_real= [[-1250.0]]\n",
      "Epoch: 11450 cost= 25079.392578125 b= [ 0.09970577] y_conv= [[-1908.36474609]] y_real= [[-1750.0]]\n",
      "Epoch: 11500 cost= 8618.477539062 b= [ 0.10470074] y_conv= [[-407.16424561]] y_real= [[-500.0]]\n",
      "Epoch: 11550 cost= 4546.680664062 b= [ 0.10259265] y_conv= [[-1317.42907715]] y_real= [[-1250.0]]\n",
      "Epoch: 11600 cost= 4006.000000000 b= [ 0.10483694] y_conv= [[ 936.70703125]] y_real= [[1000]]\n",
      "Epoch: 11650 cost= 185.663909912 b= [ 0.1134673] y_conv= [[-736.37414551]] y_real= [[-750.0]]\n",
      "Epoch: 11700 cost= 2826.003906250 b= [ 0.10730953] y_conv= [[-53.16017151]] y_real= [[0.0]]\n",
      "Epoch: 11750 cost= 915.417053223 b= [ 0.10823551] y_conv= [[ 780.25585938]] y_real= [[750.0]]\n",
      "Epoch: 11800 cost= 3875.980712891 b= [ 0.10867356] y_conv= [[-62.25737381]] y_real= [[0.0]]\n",
      "Epoch: 11850 cost= 10.581849098 b= [ 0.10866944] y_conv= [[-246.74702454]] y_real= [[-250.0]]\n",
      "Epoch: 11900 cost= 7689.761230469 b= [ 0.10919157] y_conv= [[-1087.69128418]] y_real= [[-1000.0]]\n",
      "Epoch: 11950 cost= 1672.617309570 b= [ 0.10387658] y_conv= [[-790.89764404]] y_real= [[-750.0]]\n",
      "Epoch: 12000 cost= 203.013793945 b= [ 0.10426335] y_conv= [[-1235.75170898]] y_real= [[-1250.0]]\n",
      "Epoch: 12050 cost= 45013.484375000 b= [ 0.1057436] y_conv= [[-1037.83618164]] y_real= [[-1250.0]]\n",
      "Epoch: 12100 cost= 703.107482910 b= [ 0.1021595] y_conv= [[-223.48382568]] y_real= [[-250.0]]\n",
      "Epoch: 12150 cost= 937.389770508 b= [ 0.10549388] y_conv= [[-1030.61682129]] y_real= [[-1000.0]]\n",
      "Epoch: 12200 cost= 2320.936035156 b= [ 0.10304032] y_conv= [[ 48.17609406]] y_real= [[0.0]]\n",
      "Epoch: 12250 cost= 6576.479492188 b= [ 0.10582153] y_conv= [[-81.09549713]] y_real= [[0.0]]\n",
      "Epoch: 12300 cost= 2485.731445312 b= [ 0.10989756] y_conv= [[ 49.85710907]] y_real= [[0.0]]\n",
      "Epoch: 12350 cost= 126.431381226 b= [ 0.10644401] y_conv= [[ 261.24417114]] y_real= [[250.0]]\n",
      "Epoch: 12400 cost= 2066.265136719 b= [ 0.10535152] y_conv= [[-45.4561882]] y_real= [[0.0]]\n",
      "Epoch: 12450 cost= 47.619163513 b= [ 0.10799801] y_conv= [[-6.90066385]] y_real= [[0.0]]\n",
      "Epoch: 12500 cost= 405.305572510 b= [ 0.11245873] y_conv= [[-1520.13220215]] y_real= [[-1500.0]]\n",
      "Epoch: 12550 cost= 3650.485839844 b= [ 0.10744993] y_conv= [[-810.41925049]] y_real= [[-750.0]]\n",
      "Epoch: 12600 cost= 10300.267578125 b= [ 0.10294381] y_conv= [[-1101.49023438]] y_real= [[-1000.0]]\n",
      "Epoch: 12650 cost= 1910.475341797 b= [ 0.10860291] y_conv= [[-1293.70898438]] y_real= [[-1250.0]]\n",
      "Epoch: 12700 cost= 3266.332763672 b= [ 0.10929186] y_conv= [[-192.84815979]] y_real= [[-250.0]]\n",
      "Epoch: 12750 cost= 10357.434570312 b= [ 0.11357927] y_conv= [[ 648.22851562]] y_real= [[750.0]]\n",
      "Epoch: 12800 cost= 587.346374512 b= [ 0.11235508] y_conv= [[ 274.23522949]] y_real= [[250.0]]\n",
      "Epoch: 12850 cost= 3509.766845703 b= [ 0.11233571] y_conv= [[-1309.24328613]] y_real= [[-1250.0]]\n",
      "Epoch: 12900 cost= 396.837341309 b= [ 0.11352845] y_conv= [[-230.07922363]] y_real= [[-250.0]]\n",
      "Epoch: 12950 cost= 3746.293212891 b= [ 0.10807435] y_conv= [[ 938.79302979]] y_real= [[1000]]\n",
      "Epoch: 13000 cost= 5690.284667969 b= [ 0.11022091] y_conv= [[ 75.43397522]] y_real= [[0.0]]\n",
      "Epoch: 13050 cost= 4597.541992188 b= [ 0.10756099] y_conv= [[-1317.80517578]] y_real= [[-1250.0]]\n",
      "Epoch: 13100 cost= 3106.170898438 b= [ 0.10852827] y_conv= [[-1055.73303223]] y_real= [[-1000.0]]\n",
      "Epoch: 13150 cost= 215.251373291 b= [ 0.10721092] y_conv= [[ 985.32855225]] y_real= [[1000]]\n",
      "Epoch: 13200 cost= 1493.536621094 b= [ 0.10822687] y_conv= [[-961.35369873]] y_real= [[-1000.0]]\n",
      "Epoch: 13250 cost= 7259.156250000 b= [ 0.10749797] y_conv= [[ 664.79931641]] y_real= [[750.0]]\n",
      "Epoch: 13300 cost= 1917.826782227 b= [ 0.1093672] y_conv= [[ 456.20700073]] y_real= [[500.0]]\n",
      "Epoch: 13350 cost= 12630.456054688 b= [ 0.11091331] y_conv= [[ 137.61470032]] y_real= [[250.0]]\n",
      "Epoch: 13400 cost= 6183.323242188 b= [ 0.10598944] y_conv= [[-78.6341095]] y_real= [[0.0]]\n",
      "Epoch: 13450 cost= 4889.085449219 b= [ 0.11086775] y_conv= [[-819.92199707]] y_real= [[-750.0]]\n",
      "Epoch: 13500 cost= 32215.298828125 b= [ 0.10972121] y_conv= [[-179.48620605]] y_real= [[0.0]]\n",
      "Epoch: 13550 cost= 100.426788330 b= [ 0.11204785] y_conv= [[ 239.97868347]] y_real= [[250.0]]\n",
      "Epoch: 13600 cost= 18.557668686 b= [ 0.11019132] y_conv= [[ 1004.30786133]] y_real= [[1000]]\n",
      "Epoch: 13650 cost= 196.247879028 b= [ 0.10803451] y_conv= [[-1014.0088501]] y_real= [[-1000.0]]\n",
      "Epoch: 13700 cost= 239.022659302 b= [ 0.1165338] y_conv= [[ 265.46035767]] y_real= [[250.0]]\n",
      "Epoch: 13750 cost= 200.755172729 b= [ 0.11233618] y_conv= [[-14.16880989]] y_real= [[0.0]]\n",
      "Epoch: 13800 cost= 668.421630859 b= [ 0.11362561] y_conv= [[-25.85385132]] y_real= [[0.0]]\n",
      "Epoch: 13850 cost= 2247.498779297 b= [ 0.11222301] y_conv= [[-202.59220886]] y_real= [[-250.0]]\n",
      "Epoch: 13900 cost= 1521.826660156 b= [ 0.11885672] y_conv= [[ 39.01059723]] y_real= [[0.0]]\n",
      "Epoch: 13950 cost= 1.355183601 b= [ 0.11767421] y_conv= [[ 1001.16412354]] y_real= [[1000]]\n",
      "Epoch: 14000 cost= 3961.804931641 b= [ 0.12193344] y_conv= [[ 937.05712891]] y_real= [[1000]]\n",
      "Epoch: 14050 cost= 24561.072265625 b= [ 0.12476674] y_conv= [[ 1156.71972656]] y_real= [[1000]]\n",
      "Epoch: 14100 cost= 2636.820068359 b= [ 0.11789583] y_conv= [[-1448.65002441]] y_real= [[-1500.0]]\n",
      "Epoch: 14150 cost= 13342.873046875 b= [ 0.12030815] y_conv= [[ 884.48864746]] y_real= [[1000]]\n",
      "Epoch: 14200 cost= 494.752929688 b= [ 0.12027603] y_conv= [[ 522.24304199]] y_real= [[500.0]]\n",
      "Epoch: 14250 cost= 383.075958252 b= [ 0.12117003] y_conv= [[ 980.42767334]] y_real= [[1000]]\n",
      "Epoch: 14300 cost= 21809.177734375 b= [ 0.1237346] y_conv= [[ 147.67930603]] y_real= [[0.0]]\n",
      "Epoch: 14350 cost= 57645.917968750 b= [ 0.12291759] y_conv= [[-1009.90435791]] y_real= [[-1250.0]]\n",
      "Epoch: 14400 cost= 518.101379395 b= [ 0.11865769] y_conv= [[-1227.23815918]] y_real= [[-1250.0]]\n",
      "Epoch: 14450 cost= 2637.033203125 b= [ 0.12024689] y_conv= [[ 948.64794922]] y_real= [[1000]]\n",
      "Epoch: 14500 cost= 1220.407470703 b= [ 0.12066326] y_conv= [[-34.93432999]] y_real= [[0.0]]\n",
      "Epoch: 14550 cost= 223.888015747 b= [ 0.12425314] y_conv= [[-14.96288776]] y_real= [[0.0]]\n",
      "Epoch: 14600 cost= 59.103858948 b= [ 0.12214912] y_conv= [[ 7.6879034]] y_real= [[0.0]]\n",
      "Epoch: 14650 cost= 2059.203613281 b= [ 0.12831193] y_conv= [[-454.62155151]] y_real= [[-500.0]]\n",
      "Epoch: 14700 cost= 941.850036621 b= [ 0.12532496] y_conv= [[ 969.3104248]] y_real= [[1000]]\n",
      "Epoch: 14750 cost= 12076.752929688 b= [ 0.12216629] y_conv= [[ 109.89427948]] y_real= [[0.0]]\n",
      "Epoch: 14800 cost= 1112.086547852 b= [ 0.12461741] y_conv= [[-533.34796143]] y_real= [[-500.0]]\n",
      "Epoch: 14850 cost= 1.039817333 b= [ 0.12425414] y_conv= [[-1001.01971436]] y_real= [[-1000.0]]\n",
      "Epoch: 14900 cost= 2083.400878906 b= [ 0.1231985] y_conv= [[-295.64428711]] y_real= [[-250.0]]\n",
      "Epoch: 14950 cost= 446.188507080 b= [ 0.12305242] y_conv= [[ 21.12317467]] y_real= [[0.0]]\n",
      "Epoch: 15000 cost= 3747.372802734 b= [ 0.12052596] y_conv= [[ 311.21578979]] y_real= [[250.0]]\n",
      "Epoch: 15050 cost= 630.082336426 b= [ 0.11919115] y_conv= [[-224.89855957]] y_real= [[-250.0]]\n",
      "Epoch: 15100 cost= 427.698059082 b= [ 0.11945935] y_conv= [[-229.31913757]] y_real= [[-250.0]]\n",
      "Epoch: 15150 cost= 3803.766357422 b= [ 0.12878968] y_conv= [[ 1061.67468262]] y_real= [[1000]]\n",
      "Epoch: 15200 cost= 23544.208984375 b= [ 0.11655856] y_conv= [[ 846.55877686]] y_real= [[1000]]\n",
      "Epoch: 15250 cost= 4241.941406250 b= [ 0.11891985] y_conv= [[-434.86981201]] y_real= [[-500.0]]\n",
      "Epoch: 15300 cost= 16.959274292 b= [ 0.11480548] y_conv= [[ 995.88183594]] y_real= [[1000]]\n",
      "Epoch: 15350 cost= 26470.123046875 b= [ 0.11656956] y_conv= [[-1162.69641113]] y_real= [[-1000.0]]\n",
      "Epoch: 15400 cost= 818.936462402 b= [ 0.11485574] y_conv= [[ 1028.61706543]] y_real= [[1000]]\n",
      "Epoch: 15450 cost= 325.263549805 b= [ 0.11656169] y_conv= [[ 18.0350647]] y_real= [[0.0]]\n",
      "Epoch: 15500 cost= 8289.522460938 b= [ 0.11932506] y_conv= [[ 908.95318604]] y_real= [[1000]]\n",
      "Epoch: 15550 cost= 58.523086548 b= [ 0.11481971] y_conv= [[-7.65003824]] y_real= [[0.0]]\n",
      "Epoch: 15600 cost= 20136.037109375 b= [ 0.11976756] y_conv= [[-141.90150452]] y_real= [[0.0]]\n",
      "Epoch: 15650 cost= 401.182434082 b= [ 0.12285408] y_conv= [[ 20.02953911]] y_real= [[0.0]]\n",
      "Epoch: 15700 cost= 526.841735840 b= [ 0.1185311] y_conv= [[ 272.95303345]] y_real= [[250.0]]\n",
      "Epoch: 15750 cost= 757.090393066 b= [ 0.12112413] y_conv= [[ 27.51527596]] y_real= [[0.0]]\n",
      "Epoch: 15800 cost= 912.855529785 b= [ 0.12294682] y_conv= [[-30.21349907]] y_real= [[0.0]]\n",
      "Epoch: 15850 cost= 326.816406250 b= [ 0.1236756] y_conv= [[-981.92193604]] y_real= [[-1000.0]]\n",
      "Epoch: 15900 cost= 1812.564086914 b= [ 0.1256322] y_conv= [[ 1042.57421875]] y_real= [[1000]]\n",
      "Epoch: 15950 cost= 8170.685546875 b= [ 0.12272927] y_conv= [[ 159.6081543]] y_real= [[250.0]]\n",
      "Epoch: 16000 cost= 3115.552978516 b= [ 0.12716362] y_conv= [[-944.18286133]] y_real= [[-1000.0]]\n",
      "Epoch: 16050 cost= 7002.514648438 b= [ 0.12753136] y_conv= [[ 1083.68103027]] y_real= [[1000]]\n",
      "Epoch: 16100 cost= 155.183715820 b= [ 0.12647203] y_conv= [[ 262.45727539]] y_real= [[250.0]]\n",
      "Epoch: 16150 cost= 10.505844116 b= [ 0.12718137] y_conv= [[ 996.75872803]] y_real= [[1000]]\n",
      "Epoch: 16200 cost= 850.595947266 b= [ 0.12530898] y_conv= [[ 970.83502197]] y_real= [[1000]]\n",
      "Epoch: 16250 cost= 13981.706054688 b= [ 0.13014697] y_conv= [[-1381.7557373]] y_real= [[-1500.0]]\n",
      "Epoch: 16300 cost= 176845.921875000 b= [ 0.12589312] y_conv= [[-1329.46948242]] y_real= [[-1750.0]]\n",
      "Epoch: 16350 cost= 1214.947631836 b= [ 0.12557971] y_conv= [[ 34.85609818]] y_real= [[0.0]]\n",
      "Epoch: 16400 cost= 53.117752075 b= [ 0.12049235] y_conv= [[-242.71180725]] y_real= [[-250.0]]\n",
      "Epoch: 16450 cost= 4126.462890625 b= [ 0.1208906] y_conv= [[-1314.23754883]] y_real= [[-1250.0]]\n",
      "Epoch: 16500 cost= 117.124366760 b= [ 0.12058929] y_conv= [[-10.82240105]] y_real= [[0.0]]\n",
      "Epoch: 16550 cost= 1983.157226562 b= [ 0.12636007] y_conv= [[-544.53265381]] y_real= [[-500.0]]\n",
      "Epoch: 16600 cost= 5935.362792969 b= [ 0.12319931] y_conv= [[-77.04130554]] y_real= [[0.0]]\n",
      "Epoch: 16650 cost= 6429.506347656 b= [ 0.12606601] y_conv= [[ 919.8157959]] y_real= [[1000]]\n",
      "Epoch: 16700 cost= 0.595282316 b= [ 0.12473646] y_conv= [[-499.22845459]] y_real= [[-500.0]]\n",
      "Epoch: 16750 cost= 0.001687292 b= [ 0.12377181] y_conv= [[ 749.95892334]] y_real= [[750.0]]\n",
      "Epoch: 16800 cost= 0.617335558 b= [ 0.12645884] y_conv= [[-0.78570706]] y_real= [[0.0]]\n",
      "Epoch: 16850 cost= 1695.183593750 b= [ 0.12869254] y_conv= [[-1041.17260742]] y_real= [[-1000.0]]\n",
      "Epoch: 16900 cost= 17088.349609375 b= [ 0.12548317] y_conv= [[ 869.27758789]] y_real= [[1000]]\n",
      "Epoch: 16950 cost= 446.820220947 b= [ 0.12357488] y_conv= [[-478.86187744]] y_real= [[-500.0]]\n",
      "Epoch: 17000 cost= 14977.014648438 b= [ 0.12419718] y_conv= [[-877.61938477]] y_real= [[-1000.0]]\n",
      "Epoch: 17050 cost= 982.102233887 b= [ 0.12712374] y_conv= [[-31.33851051]] y_real= [[0.0]]\n",
      "Epoch: 17100 cost= 67.744270325 b= [ 0.13054278] y_conv= [[-8.23069096]] y_real= [[0.0]]\n",
      "Epoch: 17150 cost= 9066.988281250 b= [ 0.12905958] y_conv= [[ 404.77926636]] y_real= [[500.0]]\n",
      "Epoch: 17200 cost= 324.974121094 b= [ 0.13121833] y_conv= [[-768.02703857]] y_real= [[-750.0]]\n",
      "Epoch: 17250 cost= 11171.214843750 b= [ 0.13324994] y_conv= [[ 855.69396973]] y_real= [[750.0]]\n",
      "Epoch: 17300 cost= 2768.491455078 b= [ 0.12653914] y_conv= [[ 1052.61645508]] y_real= [[1000]]\n",
      "Epoch: 17350 cost= 12842.876953125 b= [ 0.12962803] y_conv= [[-1136.67358398]] y_real= [[-1250.0]]\n",
      "Epoch: 17400 cost= 25888.740234375 b= [ 0.13090546] y_conv= [[-910.89978027]] y_real= [[-750.0]]\n",
      "Epoch: 17450 cost= 176.730606079 b= [ 0.12864141] y_conv= [[ 1013.29400635]] y_real= [[1000]]\n",
      "Epoch: 17500 cost= 10153.726562500 b= [ 0.12677863] y_conv= [[ 149.23429871]] y_real= [[250.0]]\n",
      "Epoch: 17550 cost= 4847.096679688 b= [ 0.1268888] y_conv= [[ 930.37890625]] y_real= [[1000]]\n",
      "Epoch: 17600 cost= 21930.494140625 b= [ 0.12839855] y_conv= [[-1601.91052246]] y_real= [[-1750.0]]\n",
      "Epoch: 17650 cost= 489.217987061 b= [ 0.12527727] y_conv= [[-22.11827278]] y_real= [[0.0]]\n",
      "Epoch: 17700 cost= 13426.626953125 b= [ 0.13190444] y_conv= [[ 365.87332153]] y_real= [[250.0]]\n",
      "Epoch: 17750 cost= 12241.820312500 b= [ 0.12947381] y_conv= [[ 639.35723877]] y_real= [[750.0]]\n",
      "Epoch: 17800 cost= 2864.385986328 b= [ 0.12968189] y_conv= [[ 946.4800415]] y_real= [[1000]]\n",
      "Epoch: 17850 cost= 428.247253418 b= [ 0.12944102] y_conv= [[-20.69413567]] y_real= [[0.0]]\n",
      "Epoch: 17900 cost= 8025.678710938 b= [ 0.13163327] y_conv= [[ 160.41384888]] y_real= [[250.0]]\n",
      "Epoch: 17950 cost= 140.164550781 b= [ 0.13205482] y_conv= [[ 988.16088867]] y_real= [[1000]]\n",
      "Epoch: 18000 cost= 278.326019287 b= [ 0.13153252] y_conv= [[ 1016.68310547]] y_real= [[1000]]\n",
      "Epoch: 18050 cost= 10625.527343750 b= [ 0.13066332] y_conv= [[ 896.9197998]] y_real= [[1000]]\n",
      "Epoch: 18100 cost= 1894.912231445 b= [ 0.13450199] y_conv= [[-43.53059006]] y_real= [[0.0]]\n",
      "Epoch: 18150 cost= 299.456420898 b= [ 0.13787922] y_conv= [[ 732.69519043]] y_real= [[750.0]]\n",
      "Epoch: 18200 cost= 313.182403564 b= [ 0.13351867] y_conv= [[-1017.69696045]] y_real= [[-1000.0]]\n",
      "Epoch: 18250 cost= 13084.041992188 b= [ 0.13744342] y_conv= [[ 864.38549805]] y_real= [[750.0]]\n",
      "Epoch: 18300 cost= 345.523284912 b= [ 0.13143685] y_conv= [[ 981.41174316]] y_real= [[1000]]\n",
      "Epoch: 18350 cost= 6837.916503906 b= [ 0.13887295] y_conv= [[-82.69169617]] y_real= [[0.0]]\n",
      "Epoch: 18400 cost= 657.998901367 b= [ 0.13574919] y_conv= [[-1275.65148926]] y_real= [[-1250.0]]\n",
      "Epoch: 18450 cost= 130.275253296 b= [ 0.1373778] y_conv= [[ 988.58618164]] y_real= [[1000]]\n",
      "Epoch: 18500 cost= 1043.269531250 b= [ 0.13977639] y_conv= [[ 967.70031738]] y_real= [[1000]]\n",
      "Epoch: 18550 cost= 1775.464843750 b= [ 0.1369471] y_conv= [[ 42.1362648]] y_real= [[0.0]]\n",
      "Epoch: 18600 cost= 543.361694336 b= [ 0.13469274] y_conv= [[-773.31011963]] y_real= [[-750.0]]\n",
      "Epoch: 18650 cost= 751.741638184 b= [ 0.13651541] y_conv= [[ 972.58209229]] y_real= [[1000]]\n",
      "Epoch: 18700 cost= 8541.698242188 b= [ 0.13894454] y_conv= [[-157.57868958]] y_real= [[-250.0]]\n",
      "Epoch: 18750 cost= 786.074584961 b= [ 0.1346705] y_conv= [[-28.03702164]] y_real= [[0.0]]\n",
      "Epoch: 18800 cost= 750.184509277 b= [ 0.13408592] y_conv= [[ 277.38949585]] y_real= [[250.0]]\n",
      "Epoch: 18850 cost= 2380.289306641 b= [ 0.13625677] y_conv= [[ 48.78820801]] y_real= [[0.0]]\n",
      "Epoch: 18900 cost= 12803.673828125 b= [ 0.13441031] y_conv= [[ 886.84667969]] y_real= [[1000]]\n",
      "Epoch: 18950 cost= 8834.014648438 b= [ 0.13365208] y_conv= [[ 656.01055908]] y_real= [[750.0]]\n",
      "Epoch: 19000 cost= 13057.860351562 b= [ 0.1407017] y_conv= [[ 1114.27099609]] y_real= [[1000]]\n",
      "Epoch: 19050 cost= 84.009971619 b= [ 0.1362457] y_conv= [[-240.83430481]] y_real= [[-250.0]]\n",
      "Epoch: 19100 cost= 1479.842407227 b= [ 0.13809994] y_conv= [[ 461.53128052]] y_real= [[500.0]]\n",
      "Epoch: 19150 cost= 759.146423340 b= [ 0.13904381] y_conv= [[ 972.4473877]] y_real= [[1000]]\n",
      "Epoch: 19200 cost= 1188.556518555 b= [ 0.13775915] y_conv= [[ 215.52455139]] y_real= [[250.0]]\n",
      "Epoch: 19250 cost= 2394.840332031 b= [ 0.14442493] y_conv= [[-48.93710709]] y_real= [[0.0]]\n",
      "Epoch: 19300 cost= 184.338775635 b= [ 0.13801496] y_conv= [[ 13.57714176]] y_real= [[0.0]]\n",
      "Epoch: 19350 cost= 2679.032714844 b= [ 0.13823766] y_conv= [[-51.75937271]] y_real= [[0.0]]\n",
      "Epoch: 19400 cost= 1734.287353516 b= [ 0.14533375] y_conv= [[-208.35522461]] y_real= [[-250.0]]\n",
      "Epoch: 19450 cost= 578.291442871 b= [ 0.14106369] y_conv= [[ 24.04769135]] y_real= [[0.0]]\n",
      "Epoch: 19500 cost= 3010.917236328 b= [ 0.1414557] y_conv= [[ 304.87182617]] y_real= [[250.0]]\n",
      "Epoch: 19550 cost= 6970.805175781 b= [ 0.14739709] y_conv= [[-166.50865173]] y_real= [[-250.0]]\n",
      "Epoch: 19600 cost= 958.658996582 b= [ 0.14111999] y_conv= [[-780.96221924]] y_real= [[-750.0]]\n",
      "Epoch: 19650 cost= 6272.223632812 b= [ 0.14451443] y_conv= [[-79.19737244]] y_real= [[0.0]]\n",
      "Epoch: 19700 cost= 176.360946655 b= [ 0.14626949] y_conv= [[ 13.28009605]] y_real= [[0.0]]\n",
      "Epoch: 19750 cost= 16476.074218750 b= [ 0.14449507] y_conv= [[ 378.35916138]] y_real= [[250.0]]\n",
      "Epoch: 19800 cost= 9272.135742188 b= [ 0.14936167] y_conv= [[-903.70806885]] y_real= [[-1000.0]]\n",
      "Epoch: 19850 cost= 1479.534790039 b= [ 0.14996801] y_conv= [[-961.53527832]] y_real= [[-1000.0]]\n",
      "Epoch: 19900 cost= 1282.602661133 b= [ 0.14877552] y_conv= [[ 35.81344223]] y_real= [[0.0]]\n",
      "Epoch: 19950 cost= 1037.265380859 b= [ 0.15091749] y_conv= [[ 282.206604]] y_real= [[250.0]]\n",
      "Epoch: 20000 cost= 2413.177246094 b= [ 0.14957118] y_conv= [[ 49.12409973]] y_real= [[0.0]]\n",
      "Optimization Finished!\n",
      "Training cost= 2413.18 W= [[ 0.07126591]\n",
      " [ 0.1288247 ]\n",
      " [-0.12942699]\n",
      " ..., \n",
      " [-0.13766065]\n",
      " [-0.22591539]\n",
      " [-0.11271574]] b= [ 0.14957118]\n",
      "Model saved in file: /Users/il239838/Downloads/private/Thesis/Papyrus/tear_model.ckpt\n",
      "#####################################################################\n",
      "TRIANING ENDED\n",
      "#####################################################################\n",
      " \n",
      " \n"
     ]
    }
   ],
   "source": [
    "train(train_imgs, train_diagonal_delta, ROOT_FOLDER + \"tear_model.ckpt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}