v1 of chess space

README.md

@@ -1,12 +1,4 @@
----
-title: Chess
-emoji: 🦀
-colorFrom: blue
-colorTo: gray
-sdk: gradio
-sdk_version: 3.0.19
-app_file: app.py
-pinned: false
----
+# Working on setting up a HuggingFace space for chess, using Gradio
+
+Step 1: deploy a model to predict the position from an image (using https://github.com/Elucidation/tensorflow_chessbot)
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,57 @@
+import re
+import gradio as gr
+
+from chessfenbot.chessboard_finder import findGrayscaleTilesInImage
+from chessfenbot.tensorflow_chessbot import ChessboardPredictor
+from chessfenbot.helper_functions import shortenFEN
+
+
+def predict(img, active="w"):
+    """
+    main predict function for gradio.
+    Predict a chessboard FEN.
+    Wraps model from https://github.com/Elucidation/tensorflow_chessbot/tree/chessfenbot
+
+    Args:
+        img (PIL image): input image of a chess board
+        active (str): defaults to "w"
+    """
+
+    # Look for chessboard in image, get corners and split chessboard into tiles
+    tiles, corners = findGrayscaleTilesInImage(img)
+
+    # Initialize predictor, takes a while, but only needed once
+    predictor = ChessboardPredictor(frozen_graph_path='chessfenbot/saved_models/frozen_graph.pb')
+    fen, tile_certainties = predictor.getPrediction(tiles)
+    predictor.close()
+    short_fen = shortenFEN(fen)
+    # Use the worst case certainty as our final uncertainty score
+    certainty = tile_certainties.min()
+
+    print('Per-tile certainty:')
+    print(tile_certainties)
+    print("Certainty range [%g - %g], Avg: %g" % (
+    tile_certainties.min(), tile_certainties.max(), tile_certainties.mean()))
+
+    # predicted FEN
+    fen_out = f"{short_fen} {active} - - 0 1"
+    # certainty
+    certainty = "%.1f%%" % (certainty*100)
+    # link to analysis board on Lichess
+    lichess_link = f'https://lichess.org/analysis/standard/{re.sub(" ", "_", fen_out)}'
+     
+    return fen_out, certainty, lichess_link
+
+
+gr.Interface(
+    predict,
+    inputs=gr.inputs.Image(label="Upload chess board", type="pil"),
+    outputs=[
+        gr.Textbox(label="FEN"), 
+        gr.Textbox(label="certainty"), 
+        gr.Textbox(label="Link to Lichess analysis board (copy and paste into URL)"), 
+        ],
+    title="Chess FEN bot",
+    examples=["chessfenbot/example_input.png"],
+    description="Simple wrapper around TensorFlow Chessbot (https://github.com/Elucidation/tensorflow_chessbot)"
+).launch()

chessfenbot/.gitignore

@@ -0,0 +1,21 @@
+.ipynb_checkpoints
+*.pyc
+*.png
+*.jpg
+*.gif
+
+!example_input.png
+
+# Ignore chessboard input images and tile outputs
+chessboards/
+tiles/
+
+# Ignore reddit username/password config file
+auth_config.py
+praw.ini
+
+# Ignore tracking files
+*.txt
+!requirements.txt
+
+!readme_images/*

chessfenbot/Dockerfile

@@ -0,0 +1,31 @@
+FROM tensorflow/tensorflow
+MAINTAINER Sam <elucidation@gmail.com>
+
+# Install python and pip and use pip to install the python reddit api PRAW
+RUN apt-get -y update && apt-get install -y \
+  python-dev \
+  libxml2-dev \
+  libxslt1-dev \
+  libjpeg-dev \
+  vim \
+   && apt-get clean
+
+# Install python reddit api related files
+RUN pip install praw==4.3.0 beautifulsoup4==4.4.1 lxml==3.3.3 Pillow==4.0.0 html5lib==1.0b8
+
+# Clean up APT when done.
+RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+# Remove jupyter related files
+RUN rm -rf /notebooks /run_jupyter.sh
+
+# Copy code over
+COPY . /tcb/
+
+WORKDIR /tcb
+
+# Run chessbot by default
+CMD ["/tcb/run_chessbot.sh"]
+
+# Start up the docker instance with the proper auth file using
+# <machine>$ docker run -dt --rm --name cfb -v <local_auth_file>:/tcb/auth_config.py elucidation/tensorflow_chessbot

chessfenbot/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sameer Ansari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chessfenbot/cfb_helpers.py

@@ -0,0 +1,22 @@
+import time
+from datetime import datetime
+
+# Check if submission has a comment by this bot already
+def previouslyRepliedTo(submission, me):
+  for comment in submission.comments:
+    if comment.author == me:
+      return True
+  return False
+
+
+def waitWithComments(sleep_time, segment=60):
+  """Sleep for sleep_time seconds, printing to stdout every segment of time"""
+  print("\t%s - %s seconds to go..." % (datetime.now(), sleep_time))
+  while sleep_time > segment:
+    time.sleep(segment) # sleep in increments of 1 minute
+    sleep_time -= segment
+    print("\t%s - %s seconds to go..." % (datetime.now(), sleep_time))
+  time.sleep(sleep_time)
+
+def logMessage(submission, status=""):
+  print("{} | {} {}: {}".format(datetime.now(), submission.id, status, submission.title.encode('utf-8')))

chessfenbot/chessboard_finder.py

@@ -0,0 +1,426 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Pass in image of online chessboard screenshot, returns corners of chessboard
+# usage: chessboard_finder.py [-h] urls [urls ...]
+
+# Find orthorectified chessboard corners in image
+
+# positional arguments:
+#   urls        Input image urls
+
+# optional arguments:
+#   -h, --help  show this help message and exit
+
+
+# sudo apt-get install libatlas-base-dev for numpy error, see https://github.com/Kitt-AI/snowboy/issues/262
+import numpy as np
+# sudo apt-get install libopenjp2-7 libtiff5
+import PIL.Image
+import argparse
+from time import time
+from .helper_image_loading import *
+
+
+def nonmax_suppress_1d(arr, winsize=5):
+  """Return 1d array with only peaks, use neighborhood window of winsize px"""
+  _arr = arr.copy()
+
+  for i in range(_arr.size):
+    if i == 0:
+      left_neighborhood = 0
+    else:
+      left_neighborhood = arr[max(0,i-winsize):i]
+    if i >= _arr.size-2:
+      right_neighborhood = 0
+    else:
+      right_neighborhood = arr[i+1:min(arr.size-1,i+winsize)]
+
+    if arr[i] < np.max(left_neighborhood) or arr[i] <= np.max(right_neighborhood):
+      _arr[i] = 0
+  return _arr
+
+def findChessboardCorners(img_arr_gray, noise_threshold = 8000):
+  # Load image grayscale as an numpy array
+  # Return None on failure to find a chessboard
+  #
+  # noise_threshold: Ratio of standard deviation of hough values along an axis
+  # versus the number of pixels, manually measured  bad trigger images
+  # at < 5,000 and good  chessboards values at > 10,000
+
+  # Get gradients, split into positive and inverted negative components 
+  gx, gy = np.gradient(img_arr_gray)
+  gx_pos = gx.copy()
+  gx_pos[gx_pos<0] = 0
+  gx_neg = -gx.copy()
+  gx_neg[gx_neg<0] = 0
+
+  gy_pos = gy.copy()
+  gy_pos[gy_pos<0] = 0
+  gy_neg = -gy.copy()
+  gy_neg[gy_neg<0] = 0
+
+  # 1-D ampltitude of hough transform of gradients about X & Y axes
+  num_px = img_arr_gray.shape[0] * img_arr_gray.shape[1]
+  hough_gx = gx_pos.sum(axis=1) * gx_neg.sum(axis=1)
+  hough_gy = gy_pos.sum(axis=0) * gy_neg.sum(axis=0)
+
+  # Check that gradient peak signal is strong enough by
+  # comparing normalized standard deviation to threshold
+  if min(hough_gx.std() / hough_gx.size,
+         hough_gy.std() / hough_gy.size) < noise_threshold:
+    return None
+  
+  # Normalize and skeletonize to just local peaks
+  hough_gx = nonmax_suppress_1d(hough_gx) / hough_gx.max()
+  hough_gy = nonmax_suppress_1d(hough_gy) / hough_gy.max()
+
+  # Arbitrary threshold of 20% of max
+  hough_gx[hough_gx<0.2] = 0
+  hough_gy[hough_gy<0.2] = 0
+
+  # Now we have a set of potential vertical and horizontal lines that
+  # may contain some noisy readings, try different subsets of them with
+  # consistent spacing until we get a set of 7, choose strongest set of 7
+  pot_lines_x = np.where(hough_gx)[0]
+  pot_lines_y = np.where(hough_gy)[0]
+  pot_lines_x_vals = hough_gx[pot_lines_x]
+  pot_lines_y_vals = hough_gy[pot_lines_y]
+
+  # Get all possible length 7+ sequences
+  seqs_x = getAllSequences(pot_lines_x)
+  seqs_y = getAllSequences(pot_lines_y)
+  
+  if len(seqs_x) == 0 or len(seqs_y) == 0:
+    return None
+  
+  # Score sequences by the strength of their hough peaks
+  seqs_x_vals = [pot_lines_x_vals[[v in seq for v in pot_lines_x]] for seq in seqs_x]
+  seqs_y_vals = [pot_lines_y_vals[[v in seq for v in pot_lines_y]] for seq in seqs_y]
+
+  # shorten sequences to up to 9 values based on score
+  # X sequences
+  for i in range(len(seqs_x)):
+    seq = seqs_x[i]
+    seq_val = seqs_x_vals[i]
+
+    # if the length of sequence is more than 7 + edges = 9
+    # strip weakest edges 
+    if len(seq) > 9:
+      # while not inner 7 chess lines, strip weakest edges
+      while len(seq) > 7:
+        if seq_val[0] > seq_val[-1]:
+          seq = seq[:-1]
+          seq_val = seq_val[:-1]
+        else:
+          seq = seq[1:]
+          seq_val = seq_val[1:]
+
+    seqs_x[i] = seq
+    seqs_x_vals[i] = seq_val
+
+  # Y sequences
+  for i in range(len(seqs_y)):
+    seq = seqs_y[i]
+    seq_val = seqs_y_vals[i]
+
+    while len(seq) > 9:
+      if seq_val[0] > seq_val[-1]:
+        seq = seq[:-1]
+        seq_val = seq_val[:-1]
+      else:
+        seq = seq[1:]
+        seq_val = seq_val[1:]
+
+    seqs_y[i] = seq
+    seqs_y_vals[i] = seq_val
+
+  # Now that we only have length 7-9 sequences, score and choose the best one
+  scores_x = np.array([np.mean(v) for v in seqs_x_vals])
+  scores_y = np.array([np.mean(v) for v in seqs_y_vals])
+
+  # Keep first sequence with the largest step size
+  # scores_x = np.array([np.median(np.diff(s)) for s in seqs_x])
+  # scores_y = np.array([np.median(np.diff(s)) for s in seqs_y])
+
+  #TODO(elucidation): Choose heuristic score between step size and hough response
+
+  best_seq_x = seqs_x[scores_x.argmax()]
+  best_seq_y = seqs_y[scores_y.argmax()]
+  # print(best_seq_x, best_seq_y)
+
+  # Now if we have sequences greater than length 7, (up to 9),
+  # that means we have up to 9 possible combinations of sets of 7 sequences
+  # We try all of them and see which has the best checkerboard response
+  sub_seqs_x = [best_seq_x[k:k+7] for k in range(len(best_seq_x) - 7 + 1)]
+  sub_seqs_y = [best_seq_y[k:k+7] for k in range(len(best_seq_y) - 7 + 1)]
+
+  dx = np.median(np.diff(best_seq_x))
+  dy = np.median(np.diff(best_seq_y))
+  corners = np.zeros(4, dtype=int)
+  
+  # Add 1 buffer to include the outer tiles, since sequences are only using
+  # inner chessboard lines
+  corners[0] = int(best_seq_y[0]-dy)
+  corners[1] = int(best_seq_x[0]-dx)
+  corners[2] = int(best_seq_y[-1]+dy)
+  corners[3] = int(best_seq_x[-1]+dx)
+
+  # Generate crop image with on full sequence, which may be wider than a normal
+  # chessboard by an extra 2 tiles, we'll iterate over all combinations
+  # (up to 9) and choose the one that correlates best with a chessboard
+  gray_img_crop = PIL.Image.fromarray(img_arr_gray).crop(corners)
+
+  # Build a kernel image of an idea chessboard to correlate against
+  k = 8 # Arbitrarily chose 8x8 pixel tiles for correlation image
+  quad = np.ones([k,k])
+  kernel = np.vstack([np.hstack([quad,-quad]), np.hstack([-quad,quad])])
+  kernel = np.tile(kernel,(4,4)) # Becomes an 8x8 alternating grid (chessboard)
+  kernel = kernel/np.linalg.norm(kernel) # normalize
+  # 8*8 = 64x64 pixel ideal chessboard
+
+  k = 0
+  n = max(len(sub_seqs_x), len(sub_seqs_y))
+  final_corners = None
+  best_score = None
+
+  # Iterate over all possible combinations of sub sequences and keep the corners
+  # with the best correlation response to the ideal 64x64px chessboard
+  for i in range(len(sub_seqs_x)):
+    for j in range(len(sub_seqs_y)):
+      k = k + 1
+      
+      # [y, x, y, x]
+      sub_corners = np.array([
+        sub_seqs_y[j][0]-corners[0]-dy, sub_seqs_x[i][0]-corners[1]-dx,
+        sub_seqs_y[j][-1]-corners[0]+dy, sub_seqs_x[i][-1]-corners[1]+dx],
+        dtype=np.int)
+
+      # Generate crop candidate, nearest pixel is fine for correlation check
+      sub_img = gray_img_crop.crop(sub_corners).resize((64,64)) 
+
+      # Perform correlation score, keep running best corners as our final output
+      # Use absolute since it's possible board is rotated 90 deg
+      score = np.abs(np.sum(kernel * sub_img))
+      if best_score is None or score > best_score:
+        best_score = score
+        final_corners = sub_corners + [corners[0], corners[1], corners[0], corners[1]]
+
+  return final_corners
+
+def getAllSequences(seq, min_seq_len=7, err_px=5):
+  """Given sequence of increasing numbers, get all sequences with common
+  spacing (within err_px) that contain at least min_seq_len values"""
+
+  # Sanity check that there are enough values to satisfy
+  if len(seq) < min_seq_len:
+    return []
+
+  # For every value, take the next value and see how many times we can step
+  # that falls on another value within err_px points
+  seqs = []
+  for i in range(len(seq)-1):
+    for j in range(i+1, len(seq)):
+      # Check that seq[i], seq[j] not already in previous sequences
+      duplicate = False
+      for prev_seq in seqs:
+        for k in range(len(prev_seq)-1):
+          if seq[i] == prev_seq[k] and seq[j] == prev_seq[k+1]:
+            duplicate = True
+      if duplicate:
+        continue
+      d = seq[j] - seq[i]
+      
+      # Ignore two points that are within error bounds of each other
+      if d < err_px:
+        continue
+
+      s = [seq[i], seq[j]]
+      n = s[-1] + d
+      while np.abs((seq-n)).min() < err_px:
+        n = seq[np.abs((seq-n)).argmin()]
+        s.append(n)
+        n = s[-1] + d
+
+      if len(s) >= min_seq_len:
+        s = np.array(s)
+        seqs.append(s)
+  return seqs
+
+def getChessTilesColor(img, corners):
+  # img is a color RGB image
+  # corners = (x0, y0, x1, y1) for top-left corner to bot-right corner of board
+  height, width, depth = img.shape
+  if depth !=3:
+    print("Need RGB color image input")
+    return None
+
+  # corners could be outside image bounds, pad image as needed
+  padl_x = max(0, -corners[0])
+  padl_y = max(0, -corners[1])
+  padr_x = max(0, corners[2] - width)
+  padr_y = max(0, corners[3] - height)
+
+  img_padded = np.pad(img, ((padl_y,padr_y),(padl_x,padr_x), (0,0)), mode='edge')
+
+  chessboard_img = img_padded[
+    (padl_y + corners[1]):(padl_y + corners[3]), 
+    (padl_x + corners[0]):(padl_x + corners[2]), :]
+
+  # 256x256 px RGB image, 32x32px individual RGB tiles, normalized 0-1 floats
+  chessboard_img_resized = np.asarray( \
+        PIL.Image.fromarray(chessboard_img) \
+        .resize([256,256], PIL.Image.BILINEAR), dtype=np.float32) / 255.0
+
+  # stack deep 64 tiles with 3 channesl RGB each
+  # so, first 3 slabs are RGB for tile A1, then next 3 slabs for tile A2 etc.
+  tiles = np.zeros([32,32,3*64], dtype=np.float32) # color
+  # Assume A1 is bottom left of image, need to reverse rank since images start
+  # with origin in top left
+  for rank in range(8): # rows (numbers)
+    for file in range(8): # columns (letters)
+      # color
+      tiles[:,:,3*(rank*8+file):3*(rank*8+file+1)] = \
+        chessboard_img_resized[(7-rank)*32:((7-rank)+1)*32,file*32:(file+1)*32]
+
+  return tiles
+
+def getChessBoardGray(img, corners):
+  # img is a grayscale image
+  # corners = (x0, y0, x1, y1) for top-left corner to bot-right corner of board
+  height, width = img.shape
+
+  # corners could be outside image bounds, pad image as needed
+  padl_x = max(0, -corners[0])
+  padl_y = max(0, -corners[1])
+  padr_x = max(0, corners[2] - width)
+  padr_y = max(0, corners[3] - height)
+
+  img_padded = np.pad(img, ((padl_y,padr_y),(padl_x,padr_x)), mode='edge')
+
+  chessboard_img = img_padded[
+    (padl_y + corners[1]):(padl_y + corners[3]), 
+    (padl_x + corners[0]):(padl_x + corners[2])]
+
+  # 256x256 px image, 32x32px individual tiles
+  # Normalized
+  chessboard_img_resized = np.asarray( \
+        PIL.Image.fromarray(chessboard_img) \
+        .resize([256,256], PIL.Image.BILINEAR), dtype=np.uint8) / 255.0
+  return chessboard_img_resized
+
+def getChessTilesGray(img, corners):
+  chessboard_img_resized = getChessBoardGray(img, corners)
+  return getTiles(chessboard_img_resized)
+
+
+def getTiles(processed_gray_img):
+  # Given 256x256 px normalized grayscale image of a chessboard (32x32px per tile)
+  # NOTE (values must be in range 0-1)
+  # Return a 32x32x64 tile array
+  # 
+  # stack deep 64 tiles
+  # so, first slab is tile A1, then A2 etc.
+  tiles = np.zeros([32,32,64], dtype=np.float32) # grayscale
+  # Assume A1 is bottom left of image, need to reverse rank since images start
+  # with origin in top left
+  for rank in range(8): # rows (numbers)
+    for file in range(8): # columns (letters)
+      tiles[:,:,(rank*8+file)] = \
+        processed_gray_img[(7-rank)*32:((7-rank)+1)*32,file*32:(file+1)*32]
+
+  return tiles
+
+def findGrayscaleTilesInImage(img):
+  """ Find chessboard and convert into input tiles for CNN """
+  if img is None:
+    return None, None
+
+  # Convert to grayscale numpy array 
+  img_arr = np.asarray(img.convert("L"), dtype=np.float32)
+  
+  # Use computer vision to find orthorectified chessboard corners in image
+  corners = findChessboardCorners(img_arr)
+  if corners is None:
+    return None, None
+
+  # Pull grayscale tiles out given image and chessboard corners
+  tiles = getChessTilesGray(img_arr, corners)
+
+  # Return both the tiles as well as chessboard corner locations in the image
+  return tiles, corners
+
+# DEBUG
+# from matplotlib import pyplot as plt
+# def plotTiles(tiles):
+#   """Plot color or grayscale tiles as 8x8 subplots"""
+#   plt.figure(figsize=(6,6))
+#   files = "ABCDEFGH"
+#   for rank in range(8): # rows (numbers)
+#     for file in range(8): # columns (letters)
+#       plt.subplot(8,8,(7-rank)*8 + file + 1) # Plot rank reverse order to match image
+      
+#       if tiles.shape[2] == 64:
+#         # Grayscale
+#         tile = tiles[:,:,(rank*8+file)] # grayscale
+#         plt.imshow(tile, interpolation='None', cmap='gray', vmin = 0, vmax = 1)
+#       else:
+#         #Color
+#         tile = tiles[:,:,3*(rank*8+file):3*(rank*8+file+1)] # color
+#         plt.imshow(tile, interpolation='None',)
+      
+#       plt.axis('off')
+#       plt.title('%s %d' % (files[file], rank+1), fontsize=6)
+#   plt.show()
+
+def main(url):
+  print("Loading url %s..." % url)
+  color_img, url = loadImageFromURL(url)
+  
+  # Fail if can't load image
+  if color_img is None:
+    print('Couldn\'t load url: %s' % url)
+    return
+
+  if color_img.mode != 'RGB':
+    color_img = color_img.convert('RGB')
+  print("Processing...")
+  a = time()
+  img_arr = np.asarray(color_img.convert("L"), dtype=np.float32)
+  corners = findChessboardCorners(img_arr)
+  print("Took %.4fs" % (time()-a))
+  # corners = [x0, y0, x1, y1] where (x0,y0) 
+  # is top left and (x1,y1) is bot right
+
+  if corners is not None:
+    print("\tFound corners for %s: %s" % (url, corners))
+    link = getVisualizeLink(corners, url)
+    print(link)
+
+    # tiles = getChessTilesColor(np.array(color_img), corners)
+    # tiles = getChessTilesGray(img_arr, corners)
+    # plotTiles(tiles)
+
+    # plt.imshow(color_img, interpolation='none')
+    # plt.plot(corners[[0,0,2,2,0]]-0.5, corners[[1,3,3,1,1]]-0.5, color='red', linewidth=1)
+    # plt.show()
+  else:
+    print('\tNo corners found in image')
+
+if __name__ == '__main__':
+  np.set_printoptions(suppress=True, precision=2)
+  parser = argparse.ArgumentParser(description='Find orthorectified chessboard corners in image')
+  parser.add_argument('urls', default=['https://i.redd.it/1uw3h772r0fy.png'],
+    metavar='urls', type=str,  nargs='*', help='Input image urls')
+  # main('http://www.chessanytime.com/img/jeudirect/simplechess.png')
+  # main('https://i.imgur.com/JpzfV3y.jpg')
+  # main('https://i.imgur.com/jsCKzU9.jpg')
+  # main('https://i.imgur.com/49htmMA.png')
+  # main('https://i.imgur.com/HHdHGBX.png')
+  # main('http://imgur.com/By2xJkO')
+  # main('http://imgur.com/p8DJMly')
+  # main('https://i.imgur.com/Ns0iBrw.jpg')
+  # main('https://i.imgur.com/KLcCiuk.jpg')
+  args = parser.parse_args()
+  for url in args.urls:
+    main(url)
+

chessfenbot/chessbot.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python
+# ChessFenBot daemon
+# Finds submissions with chessboard images in them,
+# use a tensorflow convolutional neural network to predict pieces and return
+# a lichess analysis link and FEN diagram of chessboard
+# Run with --dry to dry run without actual submissions
+from __future__ import print_function
+import praw
+import requests
+import socket
+import time
+from datetime import datetime
+import argparse
+
+import tensorflow_chessbot # For neural network model
+from helper_functions_chessbot import *
+from helper_functions import shortenFEN
+from cfb_helpers import * # logging, comment waiting and self-reply helpers
+
+def generateResponseMessage(submission, predictor):
+  print("\n---\nImage URL: %s" % submission.url)
+  
+  # Use CNN to make a prediction
+  fen, certainty, visualize_link = predictor.makePrediction(submission.url)
+
+  if fen is None:
+    print("> %s - Couldn't generate FEN, skipping..." % datetime.now())
+    print("\n---\n")
+    return None
+  
+  fen = shortenFEN(fen) # ex. '111pq11r' -> '3pq2r'
+  print("Predicted FEN: %s" % fen)
+  print("Certainty: %.4f%%" % (certainty*100))
+
+  # Get side from title or fen
+  side = getSideToPlay(submission.title, fen)
+  # Generate response message
+  msg = generateMessage(fen, certainty, side, visualize_link)
+  print("fen: %s\nside: %s\n" % (fen, side))
+  return msg
+
+
+def processSubmission(submission, cfb, predictor, args, reply_wait_time=10):
+  # Check if submission passes requirements and wasn't already replied to
+  if isPotentialChessboardTopic(submission):
+    if not previouslyRepliedTo(submission, cfb):
+      # Generate response
+      response = generateResponseMessage(submission, predictor)
+      if response is None:
+        logMessage(submission,"[NO-FEN]") # Skip since couldn't generate FEN
+        return
+
+      # Reply to submission with response
+      if not args.dry:
+        logMessage(submission,"[REPLIED]")
+        submission.reply(response)
+      else:
+        logMessage(submission,"[DRY-RUN-REPLIED]")
+
+      # Wait after submitting to not overload
+      waitWithComments(reply_wait_time)
+    else:
+      logMessage(submission,"[SKIP]") # Skip since replied to already
+
+  else:
+    logMessage(submission)
+    time.sleep(1) # Wait a second between normal submissions
+
+def main(args):
+  resetTensorflowGraph()
+  running = True
+  reddit = praw.Reddit('CFB') # client credentials set up in local praw.ini file
+  cfb = reddit.user.me() # ChessFenBot object
+  subreddit = reddit.subreddit('chess+chessbeginners+AnarchyChess+betterchess+chesspuzzles')
+  predictor = tensorflow_chessbot.ChessboardPredictor()
+
+  while running:
+    # Start live stream on all submissions in the subreddit
+    stream = subreddit.stream.submissions()
+    try:
+      for submission in stream:
+        processSubmission(submission, cfb, predictor, args)
+    except (socket.error, requests.exceptions.ReadTimeout,
+            requests.packages.urllib3.exceptions.ReadTimeoutError,
+            requests.exceptions.ConnectionError) as e:
+      print(
+        "> %s - Connection error, skipping and continuing in 30 seconds: %s" % (
+        datetime.now(), e))
+      time.sleep(30)
+      continue
+    except Exception as e:
+      print("Unknown Error, skipping and continuing in 30 seconds:",e)
+      time.sleep(30)
+      continue
+    except KeyboardInterrupt:
+      print("Keyboard Interrupt: Exiting...")
+      running = False
+      break
+
+  predictor.close()
+  print('Finished')
+
+def resetTensorflowGraph():
+  """WIP needed to restart predictor after an error"""
+  import tensorflow as tf
+  print('Reset TF graph')
+  tf.reset_default_graph() # clear out graph
+
+def runSpecificSubmission(args):
+  resetTensorflowGraph()
+  reddit = praw.Reddit('CFB') # client credentials set up in local praw.ini file
+  cfb = reddit.user.me() # ChessFenBot object
+  predictor = tensorflow_chessbot.ChessboardPredictor()
+
+  submission = reddit.submission(args.sub)
+  print("URL: ", submission.url)
+  if submission:
+    print('Processing...')
+    processSubmission(submission, cfb, predictor, args)
+
+  predictor.close()
+  print('Done')
+
+def dryRunTest(submission='5tuerh'):
+  resetTensorflowGraph()
+  reddit = praw.Reddit('CFB') # client credentials set up in local praw.ini file
+  predictor = tensorflow_chessbot.ChessboardPredictor()
+
+  # Use a specific submission
+  submission = reddit.submission(submission)
+  print('Loading %s' % submission.id)
+  # Check if submission passes requirements and wasn't already replied to
+  if isPotentialChessboardTopic(submission):
+    # Generate response
+    response = generateResponseMessage(submission, predictor)
+    print("RESPONSE:\n")
+    print('-----------------------------')
+    print(response)
+    print('-----------------------------')
+  else:
+    print('Submission not considered chessboard topic')
+
+  predictor.close()
+  print('Finished')
+
+  
+
+if __name__ == '__main__':
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--dry', help='dry run (don\'t actually submit replies)',
+                      action="store_true", default=False)
+  parser.add_argument('--test', help='Dry run test on pre-existing comment)',
+                      action="store_true", default=False)
+  parser.add_argument('--sub', help='Pass submission string to process')
+  args = parser.parse_args()
+  if args.test:
+    print('Doing dry run test on submission')
+    if args.sub:
+      dryRunTest(args.sub)
+    else:
+      dryRunTest()
+  elif args.sub is not None:
+    runSpecificSubmission(args)
+  else:
+    main(args)

chessfenbot/dataset.py

@@ -0,0 +1,61 @@
+import tensorflow as tf
+# From https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/examples/tutorials/mnist/input_data.py
+class DataSet(object):
+  def __init__(self, images, labels, dtype=tf.float32):
+    """Construct a DataSet. 
+    `dtype` can be either
+    `uint8` to leave the input as `[0, 255]`, or `float32` to rescale into
+    `[0, 1]`.
+    """
+    dtype = tf.as_dtype(dtype).base_dtype
+    
+    if dtype not in (tf.uint8, tf.float32):
+      raise TypeError('Invalid image dtype %r, expected uint8 or float32' %
+              dtype)
+    assert images.shape[0] == labels.shape[0], (
+      'images.shape: %s labels.shape: %s' % (images.shape,
+                           labels.shape))
+    self._num_examples = images.shape[0]
+    # Convert shape from [num examples, rows, columns, depth]
+    # to [num examples, rows*columns] (assuming depth == 1)
+    assert images.shape[3] == 1
+    images = images.reshape(images.shape[0], images.shape[1] * images.shape[2])
+    if dtype == tf.float32:
+      # Convert from [0, 255] -> [0.0, 1.0].
+      images = images.astype(np.float32)
+      images = np.multiply(images, 1.0 / 255.0)
+    
+    self._images = images
+    self._labels = labels
+    self._epochs_completed = 0
+    self._index_in_epoch = 0
+  @property
+  def images(self):
+    return self._images
+  @property
+  def labels(self):
+    return self._labels
+  @property
+  def num_examples(self):
+    return self._num_examples
+  @property
+  def epochs_completed(self):
+    return self._epochs_completed
+  def next_batch(self, batch_size):
+    """Return the next `batch_size` examples from this data set."""
+    start = self._index_in_epoch
+    self._index_in_epoch += batch_size
+    if self._index_in_epoch > self._num_examples:
+      # Finished epoch
+      self._epochs_completed += 1
+      # Shuffle the data
+      perm = np.arange(self._num_examples)
+      np.random.shuffle(perm)
+      self._images = self._images[perm]
+      self._labels = self._labels[perm]
+      # Start next epoch
+      start = 0
+      self._index_in_epoch = batch_size
+      assert batch_size <= self._num_examples
+    end = self._index_in_epoch
+    return self._images[start:end], self._labels[start:end]

chessfenbot/helper_functions.py

@@ -0,0 +1,172 @@
+import numpy as np
+
+# Imports for visualization
+import PIL.Image
+
+# DEBUG for ipython notebook visualizations.
+# from IPython.display import clear_output, Image, display
+
+# def display_array(a, fmt='jpeg', rng=[0,1]):
+#   """Display an array as a picture."""
+#   a = (a - rng[0])/float(rng[1] - rng[0]) # normalized float value
+#   a = np.uint8(np.clip(a*255, 0, 255))
+#   f = StringIO()
+
+#   PIL.Image.fromarray(np.asarray(a, dtype=np.uint8)).save(f, fmt)
+#   display(Image(data=f.getvalue()))
+
+# def display_weight(a, fmt='jpeg', rng=[0,1]):
+#   """Display an array as a color picture."""
+#   a = (a - rng[0])/float(rng[1] - rng[0]) # normalized float value
+#   a = np.uint8(np.clip(a*255, 0, 255))
+#   f = StringIO()
+
+#   v = np.asarray(a, dtype=np.uint8)
+
+#   # blue is high intensity, red is low
+#   # Negative
+#   r = 255-v.copy()
+#   r[r<127] = 0
+#   r[r>=127] = 255
+  
+#   # None
+#   g = np.zeros_like(v)
+  
+#   # Positive
+#   b = v.copy()
+#   b[b<127] = 0
+#   b[b>=127] = 255
+  
+#   #np.clip((v-127)/2,0,127)*2
+
+#   #-1 to 1
+#   intensity = np.abs(2.*a-1)
+
+#   rgb = np.uint8(np.dstack([r,g,b]*intensity))
+
+#   PIL.Image.fromarray(rgb).save(f, fmt)
+#   display(Image(data=f.getvalue(), width=100))
+
+# def display_image(a, fmt='png'):
+#   """Display an image as a picture in-line."""
+#   f = StringIO()
+
+#   PIL.Image.fromarray(np.asarray(a, dtype=np.uint8)).save(f, fmt)
+#   display(Image(data=f.getvalue()))
+
+# FEN related
+def getFENtileLabel(fen,letter,number):
+  """Given a fen string and a rank (number) and file (letter), return label vector"""
+  l2i = lambda l:  ord(l)-ord('A') # letter to index
+  number = 8-number # FEN has order backwards
+  piece_letter = fen[number*8+number + l2i(letter)]
+  label = np.zeros(13, dtype=np.uint8)
+  label['1KQRBNPkqrbnp'.find(piece_letter)] = 1 # note the 1 instead of ' ' due to FEN notation
+  # We ignore shorter FENs with numbers > 1 because we generate the FENs ourselves
+  return label
+
+# We'll define the 12 pieces and 1 spacewith single characters 
+#  KQRBNPkqrbnp
+def getLabelForSquare(letter,number):
+  """Given letter and number (say 'B3'), return one-hot label vector
+     (12 pieces + 1 space == no piece, so 13-long vector)"""
+  l2i = lambda l:  ord(l)-ord('A') # letter to index
+  piece2Label = lambda piece: ' KQRBNPkqrbnp'.find(piece)
+  # build mapping to index
+  # Starter position
+  starter_mapping = np.zeros([8,8], dtype=np.uint8)
+  starter_mapping[0, [l2i('A'), l2i('H')]] = piece2Label('R')
+  starter_mapping[0, [l2i('B'), l2i('G')]] = piece2Label('N')
+  starter_mapping[0, [l2i('C'), l2i('F')]] = piece2Label('B')
+  starter_mapping[0, l2i('D')] = piece2Label('Q')
+  starter_mapping[0, l2i('E')] = piece2Label('K')
+  starter_mapping[1, :] = piece2Label('P')
+
+  starter_mapping[7, [l2i('A'), l2i('H')]] = piece2Label('r')
+  starter_mapping[7, [l2i('B'), l2i('G')]] = piece2Label('n')
+  starter_mapping[7, [l2i('C'), l2i('F')]] = piece2Label('b')
+  starter_mapping[7, l2i('D')] = piece2Label('q')
+  starter_mapping[7, l2i('E')] = piece2Label('k')
+  starter_mapping[6, :] = piece2Label('p')
+  # Note: if we display the array, the first row is white,
+  # normally bottom, but arrays show it as top
+  
+  # Generate one-hot label
+  label = np.zeros(13, dtype=np.uint8)
+  label[starter_mapping[number-1, l2i(letter), ]] = 1
+  return label
+
+def name2Label(name):
+  """Convert label vector into name of piece"""
+  return ' KQRBNPkqrbnp'.find(name)
+
+def labelIndex2Name(label_index):
+  """Convert label index into name of piece"""
+  return ' KQRBNPkqrbnp'[label_index]
+
+def label2Name(label):
+  """Convert label vector into name of piece"""
+  return labelIndex2Name(label.argmax())
+
+def shortenFEN(fen):
+  """Reduce FEN to shortest form (ex. '111p11Q' becomes '3p2Q')"""
+  return fen.replace('11111111','8').replace('1111111','7') \
+            .replace('111111','6').replace('11111','5') \
+            .replace('1111','4').replace('111','3').replace('11','2')
+
+def lengthenFEN(fen):
+  """Lengthen FEN to 71-character form (ex. '3p2Q' becomes '111p11Q')"""
+  return fen.replace('8','11111111').replace('7','1111111') \
+            .replace('6','111111').replace('5','11111') \
+            .replace('4','1111').replace('3','111').replace('2','11')
+
+def unflipFEN(fen):
+    if len(fen) < 71:
+        fen = lengthenFEN(FEN)
+    return '/'.join([ r[::-1] for r in fen.split('/') ][::-1])
+
+
+# For Training in IPython Notebooks
+def loadFENtiles(image_filepaths):
+  """Load Tiles with FEN string in filename for labels.
+  return both images and labels"""
+  # Each tile is a 32x32 grayscale image, add extra axis for working with MNIST Data format
+  images = np.zeros([image_filepaths.size, 32, 32, 1], dtype=np.uint8)
+  labels = np.zeros([image_filepaths.size, 13], dtype=np.float64)
+
+  for i, image_filepath in enumerate(image_filepaths):
+    if i % 1000 == 0:
+      #print("On #%d/%d : %s" % (i,image_filepaths.size, image_filepath))
+      print(".",)
+    
+    # Image
+    images[i,:,:,0] = np.asarray(PIL.Image.open(image_filepath), dtype=np.uint8)
+
+    # Label
+    fen = image_filepath[-78:-7]
+    _rank = image_filepath[-6]
+    _file = int(image_filepath[-5])
+    labels[i,:] = getFENtileLabel(fen, _rank, _file)
+  print("Done")
+  return images, labels
+
+def loadLabels(image_filepaths):
+  """Load label vectors from list of image filepaths"""
+  # Each filepath contains which square we're looking at, 
+  # since we're in starter position, we know which
+  # square has which piece, 12 distinct pieces 
+  # (6 white and 6 black) and 1 as empty = 13 labels
+  training_data = np.zeros([image_filepaths.size, 13], dtype=np.float64)
+  for i, image_filepath in enumerate(image_filepaths):
+    training_data[i,:] = getLabelForSquare(image_filepath[-6],int(image_filepath[-5]))
+  return training_data
+
+def loadImages(image_filepaths):
+  # Each tile is a 32x32 grayscale image, add extra axis for working with MNIST Data format
+  training_data = np.zeros([image_filepaths.size, 32, 32, 1], dtype=np.uint8)
+  for i, image_filepath in enumerate(image_filepaths):
+    if i % 100 == 0:
+      print("On #%d/%d : %s" % (i,image_filepaths.size, image_filepath))
+    img = PIL.Image.open(image_filepath)
+    training_data[i,:,:,0] = np.asarray(img, dtype=np.uint8)
+  return training_data

chessfenbot/helper_functions_chessbot.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+# 
+# Helper functions for the reddit chessbot
+# Includes functions to parse FEN strings and get pithy quotes
+import re
+from helper_functions import lengthenFEN
+from message_template import *
+
+#########################################################
+# ChessBot Message Generation Functions
+
+def isPotentialChessboardTopic(sub):
+  """if url is imgur link, or url ends in .png/.jpg/.gif"""
+  if sub.url == None:
+    return False
+  return ('imgur' in sub.url
+          or any([sub.url.lower().endswith(ending) for ending in ['.png', '.jpg', 'jpeg', '.gif']]))
+
+def invert(fen):
+  return ''.join(reversed(fen))
+
+def generateMessage(fen, certainty, side, visualize_link):
+  """Generate response message using FEN, certainty and side for flipping link order"""
+  vals = {} # Holds template responses
+
+  # Things that don't rely on black/white to play 
+  # FEN image link is aligned with screenshot, not side to play
+  if fen == '8/8/8/8/8/8/8/8':
+    # Empty chessboard link, fen-to-image doesn't correctly identify those
+    vals['unaligned_fen_img_link'] = 'http://i.stack.imgur.com/YxP53.gif'
+  else:
+    vals['unaligned_fen_img_link'] = 'http://www.fen-to-image.com/image/60/%s.png' % fen
+  vals['certainty'] = certainty*100.0 # to percentage
+  vals['pithy_message'] = getPithyMessage(certainty)
+  
+  if side == 'b':
+    # Flip FEN if black to play, assumes image is flipped
+    fen = invert(fen)
+  
+  inverted_fen = invert(fen)
+
+  # Get castling status based on pieces being in initial positions or not
+  castle_status = getCastlingStatus(fen)
+  inverted_castle_status = getCastlingStatus(inverted_fen)
+
+  # Fill out template and return
+  vals['fen_w'] = "%s w %s -" % (fen, castle_status)
+  vals['fen_b'] = "%s b %s -" % (fen, castle_status)
+  vals['inverted_fen_w'] = "%s w %s -" % (inverted_fen, inverted_castle_status)
+  vals['inverted_fen_b'] = "%s b %s -" % (inverted_fen, inverted_castle_status)
+
+  vals['lichess_analysis_w'] = 'https://www.lichess.org/analysis/%s_w_%s' % (fen, castle_status)
+  vals['lichess_analysis_b'] = 'https://www.lichess.org/analysis/%s_b_%s' % (fen, castle_status)
+  vals['lichess_editor_w'] = 'https://www.lichess.org/editor/%s_w_%s' % (fen, castle_status)
+  vals['lichess_editor_b'] = 'https://www.lichess.org/editor/%s_b_%s' % (fen, castle_status)
+
+  vals['inverted_lichess_analysis_w'] = 'https://www.lichess.org/analysis/%s_w_%s' % (inverted_fen, inverted_castle_status)
+  vals['inverted_lichess_analysis_b'] = 'https://www.lichess.org/analysis/%s_b_%s' % (inverted_fen, inverted_castle_status)
+  vals['inverted_lichess_editor_w'] = 'https://www.lichess.org/editor/%s_w_%s' % (inverted_fen, inverted_castle_status)
+  vals['inverted_lichess_editor_b'] = 'https://www.lichess.org/editor/%s_b_%s' % (inverted_fen, inverted_castle_status)
+
+  vals['visualize_link'] = visualize_link
+  
+  return MESSAGE_TEMPLATE.format(**vals)
+
+
+
+# Add a little message based on certainty of response
+def getPithyMessage(certainty):
+  pithy_messages = [
+    '*[\[ ◕ _ ◕\]^*> ... \[⌐■ _ ■\]^*](http://i.imgur.com/yaVftzT.jpg)*',
+    'A+ ✓',
+    '✓',
+    '[Close.](http://i.imgur.com/SwKKZlD.jpg)',
+    '[WAI](http://gfycat.com/RightHalfIndianglassfish)',
+    '[:(](http://i.imgur.com/BNwca4R.gifv)',
+    '[I tried.](http://i.imgur.com/kmmp0lc.png)',
+    '[Wow.](http://i.imgur.com/67fZDh9.webm)']
+  pithy_messages_cutoffs = [0.999995, 0.99, 0.9, 0.8, 0.7, 0.5, 0.2, 0.0]
+
+  for cuttoff, pithy_message in zip(pithy_messages_cutoffs, pithy_messages):
+    if certainty >= cuttoff:
+      return pithy_message
+  
+  return ""
+
+def getSideToPlay(title, fen):
+  """Based on post title return 'w', 'b', or predict from FEN"""
+  title = title.lower()
+  # Return if 'black' in title unless 'white to' is, and vice versa, or predict if neither
+  if 'black' in title:
+    if 'white to' in title:
+      return 'w'
+    return 'b'
+  elif 'white' in title:
+    if 'black to' in title:
+      return 'b'
+    return 'w'
+  else:
+    # Predict side from fen (always returns 'w' or 'b', default 'w')
+    return predictSideFromFEN(fen)
+
+def predictSideFromFEN(fen):
+  """Returns which side it thinks FEN is looking from.
+     Checks number of white and black pieces on either side to determine
+     i.e if more black pieces are on 1-4th ranks, then black to play"""
+
+  # remove spaces values (numbers) from fen
+  fen = re.sub('\d','',fen)
+  
+  #split fen to top half and bottom half (top half first)
+  parts = fen.split('/')
+  top = list(''.join(parts[:4]))
+  bottom = list(''.join(parts[4:]))
+  
+  # If screenshot is aligned from POV of white to play, we'd expect
+  # top to be mostly black pieces (lowercase)
+  # and bottom to be mostly white pieces (uppercase), so lets count
+  top_count_white = sum(list(map(lambda x: ord(x) <= ord('Z'), top)))
+  bottom_count_white = sum(list(map(lambda x: ord(x) <= ord('Z'), bottom)))
+
+  top_count_black = sum(list(map(lambda x: ord(x) >= ord('a'), top)))
+  bottom_count_black = sum(list(map(lambda x: ord(x) >= ord('a'), bottom)))
+
+  # If more white pieces on top side, or more black pieces on bottom side, black to play
+  if (top_count_white > bottom_count_white or top_count_black < bottom_count_black):
+    return 'b'
+
+  # Otherwise white
+  return 'w'
+
+def getCastlingStatus(fen):
+  """Check FEN to see if castling is allowed based on initial positions.
+     Returns 'KQkq' variants or '-' if no castling."""
+  
+  fen = lengthenFEN(fen) # 71-char long fen
+  # rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR : initial position
+  # 01234567                           01234567 +63
+
+  status = ['','','',''] # KQkq
+  # Check if black king can castle
+  if fen[4] == 'k':
+    # long (q)
+    if fen[0] == 'r':
+      status[3] = 'q'
+    if fen[7] == 'r':
+      status[2] = 'k'
+  # Check if white king can castle
+  if fen[63+4] == 'K':
+    # long (Q)
+    if fen[63+0] == 'R':
+      status[1] = 'Q'
+    if fen[63+7] == 'R':
+      status[0] = 'K'
+  
+  status = ''.join(status)
+  return status if status else '-'
+
+def getFENtileLetter(fen,letter,number):
+  """Given a fen string and a rank (number) and file (letter), return piece letter"""
+  l2i = lambda l:  ord(l)-ord('A') # letter to index
+  piece_letter = fen[(8-number)*8+(8-number) + l2i(letter)]
+  return ' KQRBNPkqrbnp'.find(piece_letter)

chessfenbot/helper_image_loading.py

@@ -0,0 +1,109 @@
+import numpy as np
+
+# Imports for visualization
+import PIL.Image
+from io import BytesIO
+try:
+  # Python 3
+  from urllib.request import urlopen, Request
+  from urllib.parse import quote
+except ImportError:
+  # Python 2
+  from urllib2 import urlopen, Request
+  from urllib2 import quote
+
+
+# Imports for pulling metadata from imgur url
+import requests
+from bs4 import BeautifulSoup
+
+# All images are returned as PIL images, not numpy arrays
+def loadImageGrayscale(img_file):
+  """Load image from file, convert to grayscale float32 numpy array"""
+  img = PIL.Image.open(img_file)
+
+  # Convert to grayscale and return
+  return img.convert("L")
+
+def loadImageFromURL(url, max_size_bytes=4000000):
+  """Load image from url.
+
+  If the url has more data than max_size_bytes, fail out
+  Try and update with metadata url link if an imgur link"""
+  
+  # If imgur try to load from metadata
+  url = tryUpdateImgurURL(url)
+
+  # Try loading image from url directly
+  try:
+    req = Request(url, headers={'User-Agent' : "TensorFlow Chessbot"})
+    con = urlopen(req)
+    # Load up to max_size_bytes of data from url
+    data = con.read(max_size_bytes)
+    # If there is more, image is too big, skip
+    if len(con.read(1)) != 0:
+      print("Skipping, url data larger than %d bytes" % max_size_bytes)
+      return None, url
+
+    # Process into PIL image
+    img = PIL.Image.open(BytesIO(data))
+    # Return PIL image and url used
+    return img, url
+  except IOError as e:
+    # Return None on failure to load image from url
+    return None, url
+
+def tryUpdateImgurURL(url):
+  """Try to get actual image url from imgur metadata"""
+  if 'imgur' not in url: # Only attempt on urls that have imgur in it
+    return url
+
+  soup = BeautifulSoup(requests.get(url).content, "lxml")
+  
+  # Get metadata tags
+  meta = soup.find_all('meta')
+  # Get the specific tag, ex.
+  # <meta content="https://i.imgur.com/bStt0Fuh.jpg" name="twitter:image"/>
+  tags = list(filter(lambda tag: 'name' in tag.attrs and tag.attrs['name'] == "twitter:image", meta))
+  
+  if tags:
+    # Replace url with metadata url
+    url = tags[0]['content']
+  
+  return url
+
+def loadImageFromPath(img_path):
+  """Load PIL image from image filepath, keep as color"""
+  return PIL.Image.open(open(img_path,'rb'))
+
+
+def resizeAsNeeded(img, max_size=(2000,2000), max_fail_size=(2000,2000)):
+  if not PIL.Image.isImageType(img):
+    img = PIL.Image.fromarray(img) # Convert to PIL Image if not already
+
+  # If image is larger than fail size, don't try resizing and give up
+  if img.size[0] > max_fail_size[0] or img.size[1] > max_fail_size[1]:
+    return None
+
+  """Resize if image larger than max size"""
+  if img.size[0] > max_size[0] or img.size[1] > max_size[1]:
+    print("Image too big (%d x %d)" % (img.size[0], img.size[1]))
+    new_size = np.min(max_size) # px
+    if img.size[0] > img.size[1]:
+      # resize by width to new limit
+      ratio = np.float(new_size) / img.size[0]
+    else:
+      # resize by height
+      ratio = np.float(new_size) / img.size[1]
+    print("Reducing by factor of %.2g" % (1./ratio))
+    new_size = (np.array(img.size) * ratio).astype(int)
+    print("New size: (%d x %d)" % (new_size[0], new_size[1]))
+    img = img.resize(new_size, PIL.Image.BILINEAR)
+  return img
+
+def getVisualizeLink(corners, url):
+  """Return online link to visualize found corners for url"""
+  encoded_url = quote(url, safe='')
+  
+  return ("http://tetration.xyz/tensorflow_chessbot/overlay_chessboard.html?%d,%d,%d,%d,%s" % 
+    (corners[0], corners[1], corners[2], corners[3], encoded_url))

chessfenbot/helper_webkit2png.py

@@ -0,0 +1,76 @@
+# Wrapper on webkit2png to render chessboard layouts from lichess
+
+import sys
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+from PyQt4.QtWebKit import *
+from PyQt4.QtNetwork import *
+
+# Download webkit2png from here and place in same directory
+# https://github.com/adamn/python-webkit2png/tree/master/webkit2png
+# 
+import webkit2png
+
+######################################################3
+# For scraping website screenshots
+class Options():
+  url = None
+  output_filename = None
+  cookie = None
+
+
+class ChessScreenshotServer():
+  """docstring for ChessScreenshotServer"""
+  def __init__(self, url=None, output_filename=None):
+    self.options = Options()
+    self.options.url = url
+    self.options.output_filename = output_filename
+
+    self.app = self.init_qtgui()
+
+  def init_qtgui(self, display=None, style=None, qtargs=None):
+    """Initiates the QApplication environment using the given args."""
+    if QApplication.instance():
+      print ("QApplication has already been instantiated.\n"
+         "Ignoring given arguments and returning existing QApplication.")
+      return QApplication.instance()
+
+    qtargs2 = [sys.argv[0]]
+    qtargs2.extend(qtargs or [])
+
+    return QApplication(qtargs2)
+
+  def renderScreenshotToFile(self):
+    """This is run within QT"""
+    try:
+      renderer = webkit2png.WebkitRenderer()
+      # renderer.wait = 5
+      renderer.qWebSettings[QWebSettings.JavascriptEnabled] = True # Enable javascript
+      if self.options.cookie:
+        renderer.cookies = [self.options.cookie]
+      with open(self.options.output_filename, 'w') as f:
+        renderer.render_to_file(res=self.options.url, file_object=f)
+        print "\tSaved screenshot to '%s'" % f.name
+      QApplication.exit(0)
+    except RuntimeError, e:
+      print "Error:", e
+      print >> sys.stderr, e
+      QApplication.exit(1)
+
+
+  def takeScreenshot(self, url=None, output_filename=None):
+    if url:
+      self.options.url = url
+    if output_filename:
+      self.options.output_filename = output_filename
+    
+    QTimer.singleShot(0, self.renderScreenshotToFile)
+    return self.app.exec_()
+
+  def takeChessScreenshot(self, fen_string=None, output_filename=None, 
+                          cookie=None): 
+    """Take uncropped screenshot of lichess board of FEN string and save to file"""
+    url_template = "http://en.lichess.org/editor/%s"
+    if cookie:
+      self.options.cookie = cookie
+    return self.takeScreenshot(url_template % fen_string, output_filename)

chessfenbot/message_template.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# Response message template
+MESSAGE_TEMPLATE = """[◕ _ ◕]^*
+
+I attempted to generate a [chessboard layout]({unaligned_fen_img_link}) from the posted image[^(what I saw)]({visualize_link}),
+with a certainty of **{certainty:.3f}%**. *{pithy_message}*
+
+-
+
+◇ White to play : [Analysis]({lichess_analysis_w}) | [Editor]({lichess_editor_w}) 
+`{fen_w}`
+
+-
+
+◆ Black to play : [Analysis]({lichess_analysis_b}) | [Editor]({lichess_editor_b})
+`{fen_b}`
+
+-
+
+> ▾ Links for when pieces are inverted on the board:
+> 
+> White to play : [Analysis]({inverted_lichess_analysis_w}) | [Editor]({inverted_lichess_editor_w})
+> `{inverted_fen_w}`
+>
+> Black to play : [Analysis]({inverted_lichess_analysis_b}) | [Editor]({inverted_lichess_editor_b})
+> `{inverted_fen_b}`
+
+-
+
+
+---
+
+^(Yes I am a machine learning bot | )
+[^(`How I work`)](http://github.com/Elucidation/tensorflow_chessbot 'Must go deeper')
+^( | )[^(`Try your own images`)](http://tetration.xyz/ChessboardFenTensorflowJs/)
+^( | Reply with a corrected FEN to add to my next training dataset)
+
+"""

chessfenbot/readme.md

@@ -0,0 +1,127 @@
+## Cloned from: https://github.com/Elucidation/tensorflow_chessbot/tree/chessfenbot
+
+TensorFlow Chessbot - /u/ChessFenBot [◕ _ ◕]<sup>\* *I make FENs*</sup>
+---
+## Command Line Interface (CLI)
+
+### Setting up the virtual environment
+
+This uses Python 3, pip3 and virtualenv, if you don't have these installed you can use:
+
+```
+sudo apt-get install python3-pip
+sudo pip3 install virtualenv
+```
+
+Then, create a new virtual environment, source it, and install the dependencies from `requirements.txt`.
+
+```
+virtualenv venv
+source venv/bin/activate
+pip3 install -r requirements.txt 
+```
+
+### Running the CLI
+
+`tensorflow_chessbot.py` contains the library and script for running predictions on images passed by file or url.
+
+```
+$ ./tensorflow_chessbot.py -h
+usage: tensorflow_chessbot.py [-h] [--url URL] [--filepath FILEPATH]
+ 
+ Predict a chessboard FEN from supplied local image link or URL
+ 
+ optional arguments:
+   -h, --help           show this help message and exit
+   --url URL            URL of image (ex. http://imgur.com/u4zF5Hj.png)
+  --filepath FILEPATH  filepath to image (ex. u4zF5Hj.png)
+```
+
+For example to run on the provided `example_input.png` ![example_input](example_input.png)
+
+```
+./tensorflow_chessbot.py --filepath example_input.png
+```
+
+Should output something like:
+
+```
+(venv) $ ./tensorflow_chessbot.py --filepath example_input.png
+
+--- Prediction on file example_input.png ---
+   Loading model 'saved_models/frozen_model.pb'
+   Model restored.
+Closing session.
+Per-tile certainty:
+[[1. 1. 1. 1. 1. 1. 1. 1.]
+ [1. 1. 1. 1. 1. 1. 1. 1.]
+ [1. 1. 1. 1. 1. 1. 1. 1.]
+ [1. 1. 1. 1. 1. 1. 1. 1.]
+ [1. 1. 1. 1. 1. 1. 1. 1.]
+ [1. 1. 1. 1. 1. 1. 1. 1.]
+ [1. 1. 1. 1. 1. 1. 1. 1.]
+ [1. 1. 1. 1. 1. 1. 1. 1.]]
+Certainty range [0.999975 - 1], Avg: 0.999997
+---
+Predicted FEN: bn4kN/p5bp/1p3npB/3p4/8/5Q2/PPP2PPP/R3R1K1
+Final Certainty: 100.0%
+```
+
+Which would be ![predicted](http://www.fen-to-image.com/image/60/bn4kN/p5bp/1p3npB/3p4/8/5Q2/PPP2PPP/R3R1K1.png)
+
+
+## Reddit Bot
+
+[/u/ChessFenBot](https://www.reddit.com/user/ChessFenBot) will automatically reply to [reddit /r/chess](https://www.reddit.com/r/) new topic image posts that contain detectable online chessboard screenshots. A screenshot either ends in `.png`, `.jpg`, `.gif`, or is an `imgur` link. 
+
+It replies with a [lichess](http://www.lichess.org) analysis link for that layout and a predicted [FEN](https://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation).
+
+```py
+predictor = ChessboardPredictor()
+fen, certainty = predictor.makePrediction('http://imgur.com/u4zF5Hj.png')
+print "Predicted FEN: %s" % fen
+print "Certainty: %.1f%%" % (certainty*100)
+```
+
+```
+Certainty range [0.999545 - 1], Avg: 0.999977, Overall: 0.998546
+Predicted FEN: 8/5p2/5k1P/2p4P/1p1p4/8/3K4/8
+Certainty: 99.9%
+Done
+[Finished in 1.8s]
+```
+
+ChessFenBot automatically replied to [this reddit post](https://www.reddit.com/r/chess/comments/45osos/very_difficult_find_the_best_move_for_white/d004cg6?context=3), it processed the [screenshot link url](http://i.imgur.com/HnWYt8A.png) and responded with:
+
+> ChessFenBot [◕ _ ◕]<sup>\* *I make FENs*</sup>
+> 
+> ---
+> 
+> I attempted to generate a chessboard layout from the posted image, with an overall certainty of **99.9916%**.
+> 
+> FEN: [1nkr4/1p3q1p/pP4pn/P1r5/3N1p2/2b2B1P/5PPB/2RQ1RK1](http://www.fen-to-image.com/image/30/1nkr1111/1p111q1p/pP1111pn/P1r11111/111N1p11/11b11B1P/11111PPB/11RQ1RK1.png)
+> 
+> Here is a link to a [Lichess Analysis](http://www.lichess.org/analysis/1nkr4/1p3q1p/pP4pn/P1r5/3N1p2/2b2B1P/5PPB/2RQ1RK1_w) - White to play
+> 
+> ---
+> 
+> <sup>Yes I am a machine learning bot | [`How I work`](https://github.com/Elucidation/tensorflow_chessbot 'Must go deeper') | Reply with a corrected FEN or [Editor link)](http://www.lichess.org/editor/r1b1r1k1/5pp1/p1pR1nNp/8/2B5/2q5/P1P1Q1PP/5R1K) to add to my next training dataset</sup>
+
+## Running with Docker
+
+Automated build on Docker available at `elucidation/tensorflow_chessbot`
+
+Populate your own `auth_config.py` which has the form
+
+```py
+USERNAME='<NAME>'
+PASSWORD='<PASSWORD>'
+USER_AGENT='<AGENT INFO>'
+```
+
+
+Then you can download and run the docker image passing this config file using:
+
+```
+docker run -dt --rm --name cfb -v <local_auth_file>:/tcb/auth_config.py elucidation/tensorflow_chessbot
+```

chessfenbot/requirements.txt

@@ -0,0 +1,7 @@
+python=3.7
+beautifulsoup4>=4.6.3,<5
+lxml>=4.2.4,<5
+Pillow>=5.2.0,<6
+tensorflow>=1.5.0,<2
+requests<3,>=2.21.0
+gradio==3.0.19

chessfenbot/run_chessbot.sh

@@ -0,0 +1,4 @@
+#!/bin/bash 
+echo "Currently in `pwd`"
+log_name=`date +"%F_%H-%M-%S"`
+python -u ./chessbot.py > ./out_$log_name.log 2> ./error_$log_name.log

chessfenbot/save_graph.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Generate graph.pb and graph.pbtxt
+
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1' # Ignore Tensorflow INFO debug messages
+import tensorflow as tf
+import numpy as np
+
+# Output graph to the same directory as the checkpoint.
+output_graph = "saved_models/graph.pb"
+output_graphtxt = ('saved_models', 'graph.pbtxt')
+
+# Set up a fresh session and create the model and load it from the saved checkpoint.
+tf.reset_default_graph() # clear out graph.
+sess = tf.Session()
+
+model_path='saved_models/model_10000.ckpt'
+
+def weight_variable(shape, name=""):
+    initial = tf.truncated_normal(shape, stddev=0.1)
+    return tf.Variable(initial, name)
+
+def bias_variable(shape, name=""):
+    initial = tf.constant(0.1, shape=shape)
+    return tf.Variable(initial, name)
+
+def conv2d(x, W):
+    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
+
+def max_pool_2x2(x, name=""):
+    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
+                        strides=[1, 2, 2, 1], padding='SAME', name=name)
+
+x = tf.placeholder(tf.float32, [None, 32*32], 'Input')
+
+# First layer : 32 features
+W_conv1 = weight_variable([5, 5, 1, 32], name='W1')
+b_conv1 = bias_variable([32], name='B1')
+
+x_image = tf.reshape(x, [-1,32,32,1])
+
+h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1, name='Conv1')
+h_pool1 = max_pool_2x2(h_conv1, name='Pool1')
+
+# Second convolutional layer : 64 features
+W_conv2 = weight_variable([5, 5, 32, 64], name='W2')
+b_conv2 = bias_variable([64], name='B2')
+
+h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2, name='Conv2')
+h_pool2 = max_pool_2x2(h_conv2, name='Pool2')
+
+# Densely connected layer : 1024 neurons, image size now 8x8
+W_fc1 = weight_variable([8 * 8 * 64, 1024], name='W3')
+b_fc1 = bias_variable([1024], name='B3')
+
+h_pool2_flat = tf.reshape(h_pool2, [-1, 8*8*64], name='Pool3')
+h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1, 'MatMult3')
+
+# Dropout
+keep_prob = tf.placeholder("float", name='KeepProb')
+h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob, name='Drop4')
+
+# Readout layer : softmax, 13 features
+W_fc2 = weight_variable([1024, 13], name='W5')
+b_fc2 = bias_variable([13], name='B5')
+
+# Probabilities
+y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2, name='probabilities')
+
+# Final prediction
+prediction = tf.argmax(y_conv,1, name='prediction')
+
+# Ground truth labels if exist 
+y_ = tf.placeholder(tf.float32, [None, 13], name='Ytruth')
+actual_answer = tf.argmax(y_,1, name='actual')
+
+cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv), name='CrossEntropy')
+
+# train_step = tf.train.GradientDescentOptimizer(0.001).minimize(cross_entropy)
+train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
+
+correct_prediction = tf.equal(prediction, actual_answer, name='CorrectPrediction')
+accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"), name='Accuracy')
+
+# Add ops to save and restore all the variables.
+saver = tf.train.Saver()
+
+# Restore model from checkpoint
+print("\t Loading model '%s'" % model_path)
+saver.restore(sess, model_path)
+print("\t Model restored.")
+
+# Write graph in text format
+tf.train.write_graph(sess.graph_def,output_graphtxt[0], output_graphtxt[1])
+
+# To freeze graph then use:
+# python3 -m tensorflow.python.tools.freeze_graph --input_graph graph.pbtxt --input_checkpoint=model_10000.ckpt  --input_binary=false --output_graph=actual_frozen.pb --output_node_names=prediction,probabilities
+
+# We also save the binary-encoded graph that may or may not be frozen (TBD) below.
+# We use a built-in TF helper to export variables to constants
+output_graph_def = tf.graph_util.convert_variables_to_constants(
+    sess, # The session is used to retrieve the weights
+    tf.get_default_graph().as_graph_def(), # The graph_def is used to retrieve the nodes 
+    ["prediction", "probabilities"] # The output node names are used to select the useful nodes
+) 
+
+# Finally we serialize and dump the output graph to the filesystem
+with tf.gfile.GFile(output_graph, "wb") as f:
+    f.write(output_graph_def.SerializeToString())
+print("%d ops in the final graph." % len(output_graph_def.node))

chessfenbot/saved_models/checkpoint

@@ -0,0 +1,2 @@
+model_checkpoint_path: "saved_models/model_10000.ckpt"
+all_model_checkpoint_paths: "saved_models/model_10000.ckpt"

chessfenbot/saved_models/frozen_graph.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4dd6247d76600d3a686ce67ebea0aef382a8feed94a7f5c968feb5eac4add7cf
+size 17046610

chessfenbot/saved_models/graph.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f17d70feda7e2c549fc1af23adab6fbb56e57e70583ed1ad855e4bf8e47d1c6b
+size 17046610

chessfenbot/saved_models/model_10000.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b7fa9a030353a743cdcf4fee1a8834fc62f11414464ae8dd474bea0dd804de1
+size 51131512

chessfenbot/tensorflow_chessbot.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# TensorFlow Chessbot
+# This contains ChessboardPredictor, the class responsible for loading and
+# running a trained CNN on chessboard screenshots. Used by chessbot.py.
+# A CLI interface is provided as well.
+#
+#   $ ./tensorflow_chessbot.py -h
+#   usage: tensorflow_chessbot.py [-h] [--url URL] [--filepath FILEPATH]
+# 
+#    Predict a chessboard FEN from supplied local image link or URL
+# 
+#    optional arguments:
+#      -h, --help           show this help message and exit
+#      --url URL            URL of image (ex. http://imgur.com/u4zF5Hj.png)
+#     --filepath FILEPATH  filepath to image (ex. u4zF5Hj.png)
+# 
+# This file is used by chessbot.py, a Reddit bot that listens on /r/chess for 
+# posts with an image in it (perhaps checking also for a statement 
+# "white/black to play" and an image link)
+# 
+# It then takes the image, uses some CV to find a chessboard on it, splits it up
+# into a set of images of squares. These are the inputs to the tensorflow CNN
+# which will return probability of which piece is on it (or empty)
+# 
+# Dataset will include chessboard squares from chess.com, lichess
+# Different styles of each, all the pieces
+# 
+# Generate synthetic data via added noise:
+#  * change in coloration
+#  * highlighting
+#  * occlusion from lines etc.
+# 
+# Take most probable set from TF response, use that to generate a FEN of the
+# board, and bot comments on thread with FEN and link to lichess analysis.
+# 
+# A lot of tensorflow code here is heavily adopted from the 
+# [tensorflow tutorials](https://www.tensorflow.org/versions/0.6.0/tutorials/pdes/index.html)
+
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1' # Ignore Tensorflow INFO debug messages
+import tensorflow as tf
+import numpy as np
+
+from .helper_functions import *
+from .helper_image_loading import *
+from .chessboard_finder import *
+
+def load_graph(frozen_graph_filepath):
+    # Load and parse the protobuf file to retrieve the unserialized graph_def.
+    with tf.io.gfile.GFile(frozen_graph_filepath, "rb") as f:
+        graph_def = tf.compat.v1.GraphDef()
+        graph_def.ParseFromString(f.read())
+
+    # Import graph def and return.
+    with tf.Graph().as_default() as graph:
+        # Prefix every op/nodes in the graph.
+        tf.import_graph_def(graph_def, name="tcb")
+    return graph
+
+class ChessboardPredictor(object):
+  """ChessboardPredictor using saved model"""
+  def __init__(self, frozen_graph_path='./saved_models/frozen_graph.pb'):
+    # Restore model using a frozen graph.
+    print("\t Loading model '%s'" % frozen_graph_path)
+    graph = load_graph(frozen_graph_path)
+    self.sess = tf.compat.v1.Session(graph=graph)
+
+    # Connect input/output pipes to model.
+    self.x = graph.get_tensor_by_name('tcb/Input:0')
+    self.keep_prob = graph.get_tensor_by_name('tcb/KeepProb:0')
+    self.prediction = graph.get_tensor_by_name('tcb/prediction:0')
+    self.probabilities = graph.get_tensor_by_name('tcb/probabilities:0')
+    print("\t Model restored.")
+
+  def getPrediction(self, tiles):
+    """Run trained neural network on tiles generated from image"""
+    if tiles is None or len(tiles) == 0:
+      print("Couldn't parse chessboard")
+      return None, 0.0
+    
+    # Reshape into Nx1024 rows of input data, format used by neural network
+    validation_set = np.swapaxes(np.reshape(tiles, [32*32, 64]),0,1)
+
+    # Run neural network on data
+    guess_prob, guessed = self.sess.run(
+      [self.probabilities, self.prediction], 
+      feed_dict={self.x: validation_set, self.keep_prob: 1.0})
+    
+    # Prediction bounds
+    a = np.array(list(map(lambda x: x[0][x[1]], zip(guess_prob, guessed))))
+    tile_certainties = a.reshape([8,8])[::-1,:]
+
+    # Convert guess into FEN string
+    # guessed is tiles A1-H8 rank-order, so to make a FEN we just need to flip the files from 1-8 to 8-1
+    labelIndex2Name = lambda label_index: ' KQRBNPkqrbnp'[label_index]
+    pieceNames = list(map(lambda k: '1' if k == 0 else labelIndex2Name(k), guessed)) # exchange ' ' for '1' for FEN
+    fen = '/'.join([''.join(pieceNames[i*8:(i+1)*8]) for i in reversed(range(8))])
+    return fen, tile_certainties
+
+  ## Wrapper for chessbot
+  def makePrediction(self, url):
+    """Try and return a FEN prediction and certainty for URL, return Nones otherwise"""
+    img, url = helper_image_loading.loadImageFromURL(url, max_size_bytes=2000000)
+    result = [None, None, None]
+    
+    # Exit on failure to load image
+    if img is None:
+      print('Couldn\'t load URL: "%s"' % url)
+      return result
+
+    # Resize image if too large
+    img = helper_image_loading.resizeAsNeeded(img)
+
+    # Exit on failure if image was too large teo resize
+    if img is None:
+      print('Image too large to resize: "%s"' % url)
+      return result
+
+    # Look for chessboard in image, get corners and split chessboard into tiles
+    tiles, corners = chessboard_finder.findGrayscaleTilesInImage(img)
+
+    # Exit on failure to find chessboard in image
+    if tiles is None:
+      print('Couldn\'t find chessboard in image')
+      return result
+    
+    # Make prediction on input tiles
+    fen, tile_certainties = self.getPrediction(tiles)
+    
+    # Use the worst case certainty as our final uncertainty score
+    certainty = tile_certainties.min()
+
+    # Get visualize link
+    visualize_link = helper_image_loading.getVisualizeLink(corners, url)
+
+    # Update result and return
+    result = [fen, certainty, visualize_link]
+    return result
+
+  def close(self):
+    print("Closing session.")
+    self.sess.close()
+
+###########################################################
+# MAIN CLI
+
+def main(args):
+  # Load image from filepath or URL
+  if args.filepath:
+    # Load image from file
+    img = helper_image_loading.loadImageFromPath(args.filepath)
+    args.url = None # Using filepath.
+  else:
+    img, args.url = helper_image_loading.loadImageFromURL(args.url)
+
+  # Exit on failure to load image
+  if img is None:
+    raise Exception('Couldn\'t load URL: "%s"' % args.url)
+    
+  # Resize image if too large
+  # img = helper_image_loading.resizeAsNeeded(img)
+
+  # Look for chessboard in image, get corners and split chessboard into tiles
+  tiles, corners = chessboard_finder.findGrayscaleTilesInImage(img)
+
+  # Exit on failure to find chessboard in image
+  if tiles is None:
+    raise Exception('Couldn\'t find chessboard in image')
+
+  # Create Visualizer url link
+  if args.url:
+    viz_link = helper_image_loading.getVisualizeLink(corners, args.url)
+    print('---\nVisualize tiles link:\n %s\n---' % viz_link)
+
+  if args.url:
+    print("\n--- Prediction on url %s ---" % args.url)
+  else:
+    print("\n--- Prediction on file %s ---" % args.filepath)
+  
+  # Initialize predictor, takes a while, but only needed once
+  predictor = ChessboardPredictor()
+  fen, tile_certainties = predictor.getPrediction(tiles)
+  predictor.close()
+  if args.unflip:
+      fen = unflipFEN(fen)
+  short_fen = shortenFEN(fen)
+  # Use the worst case certainty as our final uncertainty score
+  certainty = tile_certainties.min()
+
+  print('Per-tile certainty:')
+  print(tile_certainties)
+  print("Certainty range [%g - %g], Avg: %g" % (
+    tile_certainties.min(), tile_certainties.max(), tile_certainties.mean()))
+
+  active = args.active
+  print("---\nPredicted FEN:\n%s %s - - 0 1" % (short_fen, active))
+  print("Final Certainty: %.1f%%" % (certainty*100))
+
+if __name__ == '__main__':
+  np.set_printoptions(suppress=True, precision=3)
+  import argparse
+  parser = argparse.ArgumentParser(description='Predict a chessboard FEN from supplied local image link or URL')
+  parser.add_argument('--url', default='http://imgur.com/u4zF5Hj.png', help='URL of image (ex. http://imgur.com/u4zF5Hj.png)')
+  parser.add_argument('--filepath', help='filepath to image (ex. u4zF5Hj.png)')
+  parser.add_argument('--unflip', default=False, action='store_true', help='revert the image of a flipped chessboard')
+  parser.add_argument('--active', default='w')
+  args = parser.parse_args()
+  main(args)
+
+  

chessfenbot/tileset_generator.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+#
+# usage: tileset_generator.py [-h] input_folder output_folder
+
+# Generate tile images for alll chessboard images in input folder
+
+# positional arguments:
+#   input_folder   Input image folder
+#   output_folder  Output tile folder
+
+# optional arguments:
+#   -h, --help     show this help message and exit
+
+# Pass an input folder and output folder
+# Builds tile images for each chessboard image in input folder and puts
+# in the output folder
+# Used for building training datasets
+from chessboard_finder import *
+import os
+import glob
+
+def saveTiles(tiles, img_save_dir, img_file):
+  letters = 'ABCDEFGH'
+  if not os.path.exists(img_save_dir):
+    os.makedirs(img_save_dir)
+  
+  for i in range(64):
+    sqr_filename = "%s/%s_%s%d.png" % (img_save_dir, img_file, letters[i%8], i/8+1)
+    
+    # Make resized 32x32 image from matrix and save
+    if tiles.shape != (32,32,64):
+      PIL.Image.fromarray(tiles[:,:,i]) \
+          .resize([32,32], PIL.Image.ADAPTIVE) \
+          .save(sqr_filename)
+    else:
+      # Possibly saving floats 0-1 needs to change fromarray settings
+      PIL.Image.fromarray((tiles[:,:,i]*255).astype(np.uint8)) \
+          .save(sqr_filename)
+
+def generateTileset(input_chessboard_folder, output_tile_folder):
+  # Create output folder as needed
+  if not os.path.exists(output_tile_folder):
+    os.makedirs(output_tile_folder)
+
+  # Get all image files of type png/jpg/gif
+  img_files = set(glob.glob("%s/*.png" % input_chessboard_folder))\
+    .union(set(glob.glob("%s/*.jpg" % input_chessboard_folder)))\
+    .union(set(glob.glob("%s/*.gif" % input_chessboard_folder)))
+
+  num_success = 0
+  num_failed = 0
+  num_skipped = 0
+
+  for i, img_path in enumerate(img_files):
+    print("#% 3d/%d : %s" % (i+1, len(img_files), img_path))
+    # Strip to just filename
+    img_file = img_path[len(input_chessboard_folder):-4]
+
+    # Create output save directory or skip this image if it exists
+    img_save_dir = "%s/tiles_%s" % (output_tile_folder, img_file)
+    
+    if os.path.exists(img_save_dir):
+      print("\tSkipping existing")
+      num_skipped += 1
+      continue
+    
+    # Load image
+    print("---")
+    print("Loading %s..." % img_path)
+    img_arr = np.array(loadImageGrayscale(img_path), dtype=np.float32)
+
+    # Get tiles
+    print("\tGenerating tiles for %s..." % img_file)
+    corners = findChessboardCorners(img_arr)
+    tiles = getChessTilesGray(img_arr, corners)
+
+    # Save tiles
+    if len(tiles) > 0:
+      print("\tSaving tiles %s" % img_file)
+      saveTiles(tiles, img_save_dir, img_file)
+      num_success += 1
+    else:
+      print("\tNo Match, skipping")
+      num_failed += 1
+
+  print("\t%d/%d generated, %d failures, %d skipped." % (num_success,
+    len(img_files) - num_skipped, num_failed, num_skipped))
+
+if __name__ == '__main__':
+  np.set_printoptions(suppress=True, precision=2)
+  parser = argparse.ArgumentParser(description='Generate tile images for alll chessboard images in input folder')
+  parser.add_argument('input_folder', metavar='input_folder', type=str,
+                      help='Input image folder')
+  parser.add_argument('output_folder', metavar='output_folder', type=str,
+                      help='Output tile folder')
+  args = parser.parse_args()
+  generateTileset(args.input_folder, args.output_folder)

chessfenbot/webkit2png.py

@@ -0,0 +1,414 @@
+#
+# webkit2png.py
+#
+# Creates screenshots of webpages using by QtWebkit.
+#
+# Copyright (c) 2014 Roland Tapken <roland@dau-sicher.de>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+#
+# Nice ideas "todo":
+#  - Add QTcpSocket support to create a "screenshot daemon" that
+#    can handle multiple requests at the same time.
+
+import time
+import os
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+from PyQt4.QtWebKit import *
+from PyQt4.QtNetwork import *
+
+# Class for Website-Rendering. Uses QWebPage, which
+# requires a running QtGui to work.
+class WebkitRenderer(QObject):
+    """
+    A class that helps to create 'screenshots' of webpages using
+    Qt's QWebkit. Requires PyQt4 library.
+
+    Use "render()" to get a 'QImage' object, render_to_bytes() to get the
+    resulting image as 'str' object or render_to_file() to write the image
+    directly into a 'file' resource.
+    """
+    def __init__(self,**kwargs):
+        """
+        Sets default values for the properties.
+        """
+
+        if not QApplication.instance():
+            raise RuntimeError(self.__class__.__name__ + " requires a running QApplication instance")
+        QObject.__init__(self)
+
+        # Initialize default properties
+        self.width = kwargs.get('width', 0)
+        self.height = kwargs.get('height', 0)
+        self.timeout = kwargs.get('timeout', 0)
+        self.wait = kwargs.get('wait', 0)
+        self.scaleToWidth = kwargs.get('scaleToWidth', 0)
+        self.scaleToHeight = kwargs.get('scaleToHeight', 0)
+        self.scaleRatio = kwargs.get('scaleRatio', 'keep')
+        self.format = kwargs.get('format', 'png')
+        self.logger = kwargs.get('logger', None)
+        
+        # Set this to true if you want to capture flash.
+        # Not that your desktop must be large enough for
+        # fitting the whole window.
+        self.grabWholeWindow = kwargs.get('grabWholeWindow', False)
+        self.renderTransparentBackground = kwargs.get('renderTransparentBackground', False)
+        self.ignoreAlert = kwargs.get('ignoreAlert', True)
+        self.ignoreConfirm = kwargs.get('ignoreConfirm', True)
+        self.ignorePrompt = kwargs.get('ignorePrompt', True)
+        self.interruptJavaScript = kwargs.get('interruptJavaScript', True)
+        self.encodedUrl = kwargs.get('encodedUrl', False)
+        self.cookies = kwargs.get('cookies', [])
+
+        # Set some default options for QWebPage
+        self.qWebSettings = {
+            QWebSettings.JavascriptEnabled : False,
+            QWebSettings.PluginsEnabled : False,
+            QWebSettings.PrivateBrowsingEnabled : True,
+            QWebSettings.JavascriptCanOpenWindows : False
+        }
+
+
+    def render(self, res):
+        """
+        Renders the given URL into a QImage object
+        """
+        # We have to use this helper object because
+        # QApplication.processEvents may be called, causing
+        # this method to get called while it has not returned yet.
+        helper = _WebkitRendererHelper(self)
+        helper._window.resize( self.width, self.height )
+        image = helper.render(res)
+
+        # Bind helper instance to this image to prevent the
+        # object from being cleaned up (and with it the QWebPage, etc)
+        # before the data has been used.
+        image.helper = helper
+
+        return image
+
+    def render_to_file(self, res, file_object):
+        """
+        Renders the image into a File resource.
+        Returns the size of the data that has been written.
+        """
+        format = self.format # this may not be constant due to processEvents()
+        image = self.render(res)
+        qBuffer = QBuffer()
+        image.save(qBuffer, format)
+        file_object.write(qBuffer.buffer().data())
+        return qBuffer.size()
+
+    def render_to_bytes(self, res):
+        """Renders the image into an object of type 'str'"""
+        format = self.format # this may not be constant due to processEvents()
+        image = self.render(res)
+        qBuffer = QBuffer()
+        image.save(qBuffer, format)
+        return qBuffer.buffer().data()
+
+## @brief The CookieJar class inherits QNetworkCookieJar to make a couple of functions public.
+class CookieJar(QNetworkCookieJar):
+    def __init__(self, cookies, qtUrl, parent=None):
+        QNetworkCookieJar.__init__(self, parent)
+        for cookie in cookies:
+            QNetworkCookieJar.setCookiesFromUrl(self, QNetworkCookie.parseCookies(QByteArray(cookie)), qtUrl)
+
+    def allCookies(self):
+        return QNetworkCookieJar.allCookies(self)
+    
+    def setAllCookies(self, cookieList):
+        QNetworkCookieJar.setAllCookies(self, cookieList)
+
+class _WebkitRendererHelper(QObject):
+    """
+    This helper class is doing the real work. It is required to
+    allow WebkitRenderer.render() to be called "asynchronously"
+    (but always from Qt's GUI thread).
+    """
+
+    def __init__(self, parent):
+        """
+        Copies the properties from the parent (WebkitRenderer) object,
+        creates the required instances of QWebPage, QWebView and QMainWindow
+        and registers some Slots.
+        """
+        QObject.__init__(self)
+
+        # Copy properties from parent
+        for key,value in parent.__dict__.items():
+            setattr(self,key,value)
+
+        # Determine Proxy settings
+        proxy = QNetworkProxy(QNetworkProxy.NoProxy)
+        if 'http_proxy' in os.environ:
+            proxy_url = QUrl(os.environ['http_proxy'])
+            if unicode(proxy_url.scheme()).startswith('http'):
+                protocol = QNetworkProxy.HttpProxy
+            else:
+                protocol = QNetworkProxy.Socks5Proxy
+
+            proxy = QNetworkProxy(
+                protocol,
+                proxy_url.host(),
+                proxy_url.port(),
+                proxy_url.userName(),
+                proxy_url.password()
+            )
+
+        # Create and connect required PyQt4 objects
+        self._page = CustomWebPage(logger=self.logger, ignore_alert=self.ignoreAlert,
+            ignore_confirm=self.ignoreConfirm, ignore_prompt=self.ignorePrompt,
+            interrupt_js=self.interruptJavaScript)
+        self._page.networkAccessManager().setProxy(proxy)
+        self._view = QWebView()
+        self._view.setPage(self._page)
+        self._window = QMainWindow()
+        self._window.setCentralWidget(self._view)
+
+        # Import QWebSettings
+        for key, value in self.qWebSettings.iteritems():
+            self._page.settings().setAttribute(key, value)
+
+        # Connect required event listeners
+        self.connect(self._page, SIGNAL("loadFinished(bool)"), self._on_load_finished)
+        self.connect(self._page, SIGNAL("loadStarted()"), self._on_load_started)
+        self.connect(self._page.networkAccessManager(), SIGNAL("sslErrors(QNetworkReply *,const QList<QSslError>&)"), self._on_ssl_errors)
+        self.connect(self._page.networkAccessManager(), SIGNAL("finished(QNetworkReply *)"), self._on_each_reply)
+
+        # The way we will use this, it seems to be unesseccary to have Scrollbars enabled
+        self._page.mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
+        self._page.mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
+        self._page.settings().setUserStyleSheetUrl(QUrl("data:text/css,html,body{overflow-y:hidden !important;}"))
+
+        # Show this widget
+        self._window.show()
+
+    def __del__(self):
+        """
+        Clean up Qt4 objects.
+        """
+        self._window.close()
+        del self._window
+        del self._view
+        del self._page
+
+    def render(self, res):
+        """
+        The real worker. Loads the page (_load_page) and awaits
+        the end of the given 'delay'. While it is waiting outstanding
+        QApplication events are processed.
+        After the given delay, the Window or Widget (depends
+        on the value of 'grabWholeWindow' is drawn into a QPixmap
+        and postprocessed (_post_process_image).
+        """
+        self._load_page(res, self.width, self.height, self.timeout)
+        # Wait for end of timer. In this time, process
+        # other outstanding Qt events.
+        if self.wait > 0:
+            if self.logger: self.logger.debug("Waiting %d seconds " % self.wait)
+            waitToTime = time.time() + self.wait
+            while time.time() < waitToTime:
+                if QApplication.hasPendingEvents():
+                    QApplication.processEvents()
+
+        if self.renderTransparentBackground:
+            # Another possible drawing solution
+            image = QImage(self._page.viewportSize(), QImage.Format_ARGB32)
+            image.fill(QColor(255,0,0,0).rgba())
+
+            # http://ariya.blogspot.com/2009/04/transparent-qwebview-and-qwebpage.html
+            palette = self._view.palette()
+            palette.setBrush(QPalette.Base, Qt.transparent)
+            self._page.setPalette(palette)
+            self._view.setAttribute(Qt.WA_OpaquePaintEvent, False)
+
+            painter = QPainter(image)
+            painter.setBackgroundMode(Qt.TransparentMode)
+            self._page.mainFrame().render(painter)
+            painter.end()
+        else:
+            if self.grabWholeWindow:
+                # Note that this does not fully ensure that the
+                # window still has the focus when the screen is
+                # grabbed. This might result in a race condition.
+                self._view.activateWindow()
+                image = QPixmap.grabWindow(self._window.winId())
+            else:
+                image = QPixmap.grabWidget(self._window)
+
+        return self._post_process_image(image)
+
+    def _load_page(self, res, width, height, timeout):
+        """
+        This method implements the logic for retrieving and displaying
+        the requested page.
+        """
+
+        # This is an event-based application. So we have to wait until
+        # "loadFinished(bool)" raised.
+        cancelAt = time.time() + timeout
+        self.__loading = True
+        self.__loadingResult = False # Default
+
+        # When "res" is of type tuple, it has two elements where the first
+        # element is the HTML code to render and the second element is a string
+        # setting the base URL for the interpreted HTML code.
+        # When resource is of type str or unicode, it is handled as URL which
+        # shal be loaded
+        if type(res) == tuple:
+            url = res[1]
+        else:
+            url = res
+
+        if self.encodedUrl:
+            qtUrl = QUrl.fromEncoded(url)
+        else:
+            qtUrl = QUrl(url)
+
+        # Set the required cookies, if any
+        self.cookieJar = CookieJar(self.cookies, qtUrl)
+        self._page.networkAccessManager().setCookieJar(self.cookieJar)
+
+        # Load the page
+        if type(res) == tuple:
+            self._page.mainFrame().setHtml(res[0], qtUrl) # HTML, baseUrl
+        else:
+            self._page.mainFrame().load(qtUrl)
+
+        while self.__loading:
+            if timeout > 0 and time.time() >= cancelAt:
+                raise RuntimeError("Request timed out on %s" % res)
+            while QApplication.hasPendingEvents() and self.__loading:
+                QCoreApplication.processEvents()
+
+        if self.logger: self.logger.debug("Processing result")
+
+        if self.__loading_result == False:
+            if self.logger: self.logger.warning("Failed to load %s" % res)
+
+        # Set initial viewport (the size of the "window")
+        size = self._page.mainFrame().contentsSize()
+        if self.logger: self.logger.debug("contentsSize: %s", size)
+        if width > 0:
+            size.setWidth(width)
+        if height > 0:
+            size.setHeight(height)
+
+        self._window.resize(size)
+
+    def _post_process_image(self, qImage):
+        """
+        If 'scaleToWidth' or 'scaleToHeight' are set to a value
+        greater than zero this method will scale the image
+        using the method defined in 'scaleRatio'.
+        """
+        if self.scaleToWidth > 0 or self.scaleToHeight > 0:
+            # Scale this image
+            if self.scaleRatio == 'keep':
+                ratio = Qt.KeepAspectRatio
+            elif self.scaleRatio in ['expand', 'crop']:
+                ratio = Qt.KeepAspectRatioByExpanding
+            else: # 'ignore'
+                ratio = Qt.IgnoreAspectRatio
+            qImage = qImage.scaled(self.scaleToWidth, self.scaleToHeight, ratio, Qt.SmoothTransformation)
+            if self.scaleRatio == 'crop':
+                qImage = qImage.copy(0, 0, self.scaleToWidth, self.scaleToHeight)
+        return qImage
+
+    def _on_each_reply(self,reply):
+      """
+      Logs each requested uri
+      """
+      # print "Received %s" % (reply.url().toString())
+      # self.logger.debug("Received %s" % (reply.url().toString()))
+
+    # Eventhandler for "loadStarted()" signal
+    def _on_load_started(self):
+        """
+        Slot that sets the '__loading' property to true
+        """
+        if self.logger: self.logger.debug("loading started")
+        self.__loading = True
+
+    # Eventhandler for "loadFinished(bool)" signal
+    def _on_load_finished(self, result):
+        """Slot that sets the '__loading' property to false and stores
+        the result code in '__loading_result'.
+        """
+        if self.logger: self.logger.debug("loading finished with result %s", result)
+        self.__loading = False
+        self.__loading_result = result
+
+    # Eventhandler for "sslErrors(QNetworkReply *,const QList<QSslError>&)" signal
+    def _on_ssl_errors(self, reply, errors):
+        """
+        Slot that writes SSL warnings into the log but ignores them.
+        """
+        for e in errors:
+            if self.logger: self.logger.warn("SSL: " + e.errorString())
+        reply.ignoreSslErrors()
+
+
+class CustomWebPage(QWebPage):
+    def __init__(self, **kwargs):
+        """
+        Class Initializer
+        """
+        super(CustomWebPage, self).__init__()
+        self.logger = kwargs.get('logger', None)
+        self.ignore_alert = kwargs.get('ignore_alert', True)
+        self.ignore_confirm = kwargs.get('ignore_confirm', True)
+        self.ignore_prompt = kwargs.get('ignore_prompt', True)
+        self.interrupt_js = kwargs.get('interrupt_js', True)
+
+    def javaScriptAlert(self, frame, message):
+        if self.logger: self.logger.debug('Alert: %s', message)
+        if not self.ignore_alert:
+            return super(CustomWebPage, self).javaScriptAlert(frame, message)
+
+    def javaScriptConfirm(self, frame, message):
+        if self.logger: self.logger.debug('Confirm: %s', message)
+        if not self.ignore_confirm:
+            return super(CustomWebPage, self).javaScriptConfirm(frame, message)
+        else:
+            return False
+
+    def javaScriptPrompt(self, frame, message, default, result):
+        """
+        This function is called whenever a JavaScript program running inside frame tries to prompt
+        the user for input. The program may provide an optional message, msg, as well as a default value
+        for the input in defaultValue.
+
+        If the prompt was cancelled by the user the implementation should return false;
+        otherwise the result should be written to result and true should be returned.
+        If the prompt was not cancelled by the user, the implementation should return true and
+        the result string must not be null.
+        """
+        if self.logger: self.logger.debug('Prompt: %s (%s)' % (message, default))
+        if not self.ignore_prompt:
+            return super(CustomWebPage, self).javaScriptPrompt(frame, message, default, result)
+        else:
+            return False
+
+    def shouldInterruptJavaScript(self):
+        """
+        This function is called when a JavaScript program is running for a long period of time.
+        If the user wanted to stop the JavaScript the implementation should return true; otherwise false.
+        """
+        if self.logger: self.logger.debug("WebKit ask to interrupt JavaScript")
+        return self.interrupt_js

requirements.txt

@@ -0,0 +1,4 @@
+python=3.7
+-r tensorflow_chessbot-chessfenbot/requirements.txt
+gradio==3.0.19
+