Creating a Go Bot Part V -Coordinates system-

Note: Part of this article is copied from my old blog.

Note 2: The repo is here

Now that the engine knows how to play a random valid move, there is something more that we have to do previously to make the engine play “less” randomly.

Using GTP (in next posts we will talk a little more about Go Text Protocol that will be implemented in the project) the engine sends and receives coordinates, so we need something to translate from positions to coordinates and from coordinates to positions.

Right now, this convertion will be responsability of the board class, maybe in the future it can change, but I think it is board responsability to do that translation, what do you think about that?

My first idea is this one:

def posToCoordinate(self,position):
        column=['A','B','C','D','E','F','G','H','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
        finalCoord=""
        fPositionFound = False
        for row in range(1,self.boardSize):
            for col in range(0,self.boardSize):
                if col+self.boardSize+2+(row-1)*(self.boardSize+1) == position:
                    fPositionFound = True
                    finalCoord = column[col]+str(row)
                    break

        return finalCoord

Sure it works for boards until 25×25, to make bigger boards I would need to add more letters to the list, but for now let it be like this.

Now, the program will receive a coordinate, so I need to put it as a position to update my board array.

First I need to convert from a coordinate to a number. If we look at a 6×6 board with coordinates we see this:

    A    B   C    D    E   F
00 01 02 03 04 05 06
1 07 08 09 10 11 12 13
2 14 15 16 17 18 19 20
3 21 22 23 24 25 26 27
4 28 29 30 31 32 33 34
5 35 36 37 38 39 40 41
6 42 43 44 45 46 47 48
49 50 51 52 53 54 55 56
Now, let’s think that letters have a numerical value A=0, B=1, C=2, D=3, E=4…
Using as reference: Row=r, Column=c, n=number of rows or columns
I can use:  c + n + 2 + (r-1)*(n+1) 
 
(I guess it is easy for people with good knowledge of mathematics, but for me, to get here was like hell).
For example (in 6×6 board):
  • D4 = 3 + 6 + 2 + (4-1)*(6+1) = 3 + 6 + 2 + 3*7 = 11 + 21 = 32
  • A6 = 0 + 6 + 2 + 5*7 = 8 + 35 = 43

But this position is starting in 1, but Python arrays stars in 0, so I have to rest 1 to the total:

def coordinateToPosition(self,coordinate):
        column = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U','V', 'W', 'X', 'Y', 'Z']
        return (column.index(coordinate[0])+self.boardSize+2+(int(coordinate[1])-1)*(self.boardSize+1))-1

 

 

Another thing I need to work with this is to make a better print of the board , to look like this:

Just to not loose time on this and to continue with the important part, I will make it with numbers starting from top, it is the same as it is rotated and mirrored.

This is a quick version:

class Printer:
    def printBoard(self,aBoard):
        column = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U','V', 'W', 'X', 'Y', 'Z']
        rowCounter=0
        cut=0
        line = ""
        colCounter = " "
        for i in range(0,aBoard.boardSize):
            colCounter=colCounter+column[i]
        print(colCounter)
        for i in range(0, aBoard.totalSize-1):
            if aBoard.boardList[i]==0:
                line = line+"."
            if aBoard.boardList[i]==1:
                line = line+"B"
            if aBoard.boardList[i]==2:
                line = line+"W"
            if aBoard.boardList[i]==3:
                line = line+"#"
            cut=cut+1
            if cut == aBoard.boardSize+1:
                if rowCounter>=1 and rowCounter<=aBoard.boardSize:
                    print(line+"#"+str(rowCounter))
                else:
                    print(line + "#")
                rowCounter=rowCounter+1
                line=""
                cut = 0

I changed the main script to print both convertions and this appeared:

Thanks for reading!

Creating a Go bot IV – The first move.

Well, now we have an empty board, we need to make our first move. My first approach is that every position has a value and the one with the highest value will be where our bot will play.

What is the easiest way to start doing that? Give a random number let’s say from 1 to 10 to every position, and -1000 to positions where it is forbidden to play (walls, places with stones, ko). Why -1000 and not -1 or something like that? Maybe in the near future from the first value, some things will rest points and -1 can be the place with highest value, so it is better to give an unreachable low value (I am writing as I am thinking).

So, where will be all those things? I am thinking in giving the bot a “brain” that will be a class or a bunch of classes that will receive the actual board, process it and return a move.

so, let’s create a class “Engine”. For starters I think on something like this:

import board
import random

class Engine:
    def __init__(self,color):
        self.color=color

    #Here is the process to put a stone.
    def putStone(self,aBoard):
        #Here goes all the magic.
        valuesList = self.getValues(aBoard)
        return self.returnChosenOne((valuesList))


    def getValues(self,aBoard):
        boardListValues = []
        for i in range(0,aBoard.getBoardTotalPositions()):
            if aBoard.boardList[i]!=0: #Edges, occupied spaces, ko
                boardListValues.append(-1000)
            else:
                boardListValues.append(random.randint(0,10))
        return boardListValues

    def returnChosenOne(self,valuesList):
        return valuesList.index(max(valuesList))

This class has an engine that as a parameter for the constructor it gets his color.

So everytime it is his turn we call the putStone method that receives the board, it calls getValues that will give random values and -1000 to non playable places and returns the position with the highest score. In the future it will pass through a lot more methods, but now this is simple.

Maybe in the future, while adding more things, I will separate the engine in several classes, but for now it works.

So, let’s change the main.py to create the engine, show the board, let the engine play a stone and show the board again:

from printer import Printer
from board import Board
from Engine import Engine

evilTesuji = Engine(1)
mainBoard = Board(9)
mainPrinter = Printer()
mainPrinter.printBoard(mainBoard)
move = evilTesuji.putStone(mainBoard)
mainBoard.boardList[move]=evilTesuji.color
mainPrinter.printBoard(mainBoard)

This is for a 9×9 board, so when I run this I get this:

Yes, I know it is not the best possible move, and it is not even a reasonable move playing 1-3 but as it is random, well, it is a move.

I wanted to run this again just to make sure it plays in other place, and it worked (will just paste the board with the move this time)

Next time I will add more parameters to make this play more “reasonable” openings.

Creating a Go Bot Part III – More about board representation

Note: In this post I will continue to transfer things from my old blog to this one with some new things.

Well, let’s put in practise the theory I learnt in the previous post. The board will be an array (I will use the class Vector) and in theory the size should be (n+2)*(n+1)-1. So, I will write some examples of this just to understand:

6×6 board = (6+2)*(6+1)-1 = 8*7+1 = 57 positions

Those will be the positions:

01 02 03 04 05 06 07
08 09 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35
36 37 38 39 40 41 42
43 44 45 46 47 48 49
50 51 52 53 54 55 56 57

Borders will be in positions 1, 2, 3, 4, 5, 6, 7, 8, 15, 22, 29, 36, 43, 50, 51, 52, 53, 54, 55, 56 and 57.

Another example, a 9×9 board, the minimum that is used to play frequently:

9×9 board = (9+2)*(9+1) + 1 = 11*10+1=111

 

01 02 03 04 05 06 07 08 09 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 00
01 02 03 04 05 06 07 08 09 10 11

Borders will be at 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 21, 31, 41, 51, 61, 71, 81, 91, 101, 111

So, here is another way to see where boders will be in a given board:

  • 1 to n+1
  • (n+1)*x+1 (x is a for from 1 to n)
  • (n+1)*(n+1) to (n+2)*(n+1)+1

Yes, I know that positions in my array starts in 0, not in 1, but the idea was to show positions on the board without thinking in any programming language.

Now, lets start coding!

What we need is a Board class with a constructor using the size as a parameter. That is the only parameter needed, and from that all the board can be constructed:

class Board:
    """Class for Board representation"""
    def __init__(self, size):
        self.boardList = []
        self.boardSize = size
        self.totalSize = (size + 2) * (size + 1) + 1
        for i in range(0, self.totalSize):
            self.boardList.append(0)
        #BORDERS
        for i in range(0,self.boardSize+1):
            self.boardList[i] = 3
        for i in range(0,self.boardSize):
            self.boardList[(self.boardSize+1)*(i+1)]=3
        for i in range((self.boardSize+1)*(self.boardSize+1),(self.boardSize+2)*(self.boardSize+1)+1):

Now, one thing we need now is a Printer class to print the board. I will add something for th future that is that depending on the value something is written. For example if 0 then print a point. If a border (3) print a hash a wall. if 1 is black and if 2 is white

import board
class Printer:
    def printBoard(self,aBoard):
        cut=0
        line = ""
        for i in range(0,aBoard.totalSize-1):
            if aBoard.boardList[i]==0:
                line = line+"."
            if aBoard.boardList[i]==1:
                line = line+"B"
            if aBoard.boardList[i]==2:
                line = line+"W"
            if aBoard.boardList[i]==3:
                line = line+"#"
            #line = line+str(aBoard.boardList[i])
            cut=cut+1
            if cut == aBoard.boardSize+1:
                print(line+"#")
                line=""
                cut = 0

And this completes the board representation part. Now that I have a board I can start coding the engine. Next chapter will be about an intuitive way to start putting stones.

Creating a Go bot Part II -The board-

 

Note: Lots of this material was taken from my old go blog with some new text that I am adding now because some years passed since that, I am not the same, my coding skills are not the same and my vision and ideas are not the same.

Let’s begin with the development of the bot. First, it needs to understand that there is a go board (goban) and it has positions, but what is the best way to do this?

Long, long time ago there was a document at sensei’s library that I don’t see so, I will copy from my old blog:

Board representation
The most basic of all basics. In order to have a program that can play Go, we need a representation of a Go board in computer terms. Although Go is played on a variety of board sizes, the most popular by far is 19×19. For teaching purposes or for entertainment it also is occasionally played on 13×13 or 9×9. As far as I know, smaller sizes than that are only occasionally used as testing grounds for computer programs. Also boards larger than 19×19 are so rare that I choose to ignore them completely.

For now I will only assume that the board is square so rows == columns, nothing else, the game should be able to be played in any NxN board where N > 0 (well, let’s say N>1, because 1×1 needs to enable suicide move).

Since the board is always square (with an uneven number of lines), common sense would point to using a two-dimensional array to represent the board. Unfortunately computers take much longer to access a two-dimensional array than a one-dimensional array. For this reason most serious Go playing programs will use a one-dimensional array to represent the board. The one-dimensional position z of a board-point x,y is then arrived at by the following conversion: z = x + y *19 (for a 19×19 board represented by a one-dimensional array of size 361). From now on I’ll use xy instead of z as the one-dimensional equivalent of the two-dimensional coordinate x,y. Since the program will internally only use one-dimensional arrays, it will in practice not have to do such conversion often. A computer doesn’t care whether the coordinate is represented in a one dimension or two.

Ok, so as I assumed this board will always be square it follows at some point what I was thinking I should do. For computing pourposes I think it is the same if lines are even or uneven.

Two-dimensional array is a big mistake here, I want to save all the memory I can so I think it is fair to change to a simple array.

There’s a practical difficulty with representing the board in a one dimensional array however. How can the program distinguish between the borders of the board? This is still possible by looking at the coordinate. When xy%19 equals 1 or 19, or when xy/19 equals 1 or 19 we have a point on the 1st line.

I remember when I first red this, I thought that was the end even before starting, but let’s say that after a while I get the idea of how to do this. It seems to be a lot of trouble just to replace a two dimensional array by a simple array, but it is not. Let’s check what’s next:

Next to that is the edge of the board. This is a rather cumbersome way however, and such calculation will cancel out any performance gained by using a one-dimensional representation. The common way to solve this is by usig a bigger array and use border-points around the board to indicate the board boundaries. At first you may think this would lead to a 21×21 representation, and indeed in a two-dimensional board representation this would be the case. When this gets mapped to a one-dimensional array and you’d print out the information stored, you may notice something interesting however. Whenever a border-point is reached to mark the edge of the board, you see two consecutive border-points next to each other. For this reason, the one-dimensional representation can be a little smaller. Instead of 21×21=441 points, we can make do with 20×21+1=421 points. This has one more advantage: to convert a one-dimensional coordinate to two dimensions, the division is by 20 instead of 19 or 21, which is a lot easier for humans. As said before, computers don’t care about such things, but it’s a lot easier when seeing one-dimensional coordinates in your debugger this way. Trust me, it’s a lot easier! After this you should understand the reason behind the constant values defined at the top of the class tesuji.games.go.util.GoArray.

So, you can still imagine a 2 dimensional array using a one-dimensional array, it is just to quit one border x row, because from a row to another you only need one space that will be the border. Something like this:

#########
#*********   <—The next one will be a border.
#*********
#*********
#*********
#*********
#*********
#*********
#*********
#*********
##########

This is just a 9×9 board example, but this would work on any size.

Next point is what I will put in any position of the array, so for our convenience we can use:

  • 0 = empty
  • 1 = black
  • 2 = white
  • 3 = wall
  • 4 = ko

With this I think I am covering all posibilities, if not, I can add more values later.

In my next post I will add more information about this just to not make this post too long. I know this post was a lot about theory, but believe me, next one will show the Python solution for this.

See you then!

Creating a Go bot Part I

One of my hobbies is programming (even if I work as a developer I love to program free of pressure of doing that as a job). Another hobbie I have is Go. I started to play with lots of interruptions lots of years ago. First time I watched Hikaru No Go (an excellent anime, don’t miss it).  Right now I am around 5 kyu in KGS and you can find me with the nickname “draculinio” (feel free to ask me for a game or a little chat if you see me online).

Some years ago, when nobody thoght something like Alphago would exist, I wanted to create a bot that can play go and connect it to KGS or any other server that admits go bots.  My objective was not something very big or powerfull, just something that can play coherent moves. I think that now I can begin again, I will rescue some old posts from my old go programming blog so, some part of the text will be copied from that blog. I know my programming skills are better now than then, and with some parts of those old posts and new information I will be creating the go bot and posting about updates in this blog.

Some things about the project:

  • Language: Python 3
  • Open Source, I will see in the near future what’s the best licese for this.
  • Repo in: https://github.com/Draculinio/Evil-Tesuji
  • Feel free to branch or clone.
  • Let’s see where can we go now.

Let’s put some short term first tasks

  1. Create the board representation
  2. Add a random stone
  3. Implement a mechanism to receive stones played by opponent.

Some rules for the project:

  1. Document all
  2. Push frequently
  3. Don’t hardcode (maybe some temporal hardcoding will be needed, but well documented and changed ASAP).

 

So, those three are the first things to do. Wish me luck!

 

 

 

A Counting Problem

I really love sites like Hackerrank and their programming challenges. Lately, one of them took my attention given that the simplest and standard solution didn´t work. The challenge is named “Find a String” and the idea is really simple: Count substring occurrences inside a string.

My first impression was the obvious one: “Hey, Python have this implemented”, so I tried the count method. This counts the number of times a sub string appears in a string, it is used like this:

string.count(substring)

But, the program failed. Look at this (there was another restriction, strings should have less or equal 200 characters):

def count_substring(string_to_eval, substring):
     if len(string_to_eval)&lt;201:
          return string_to_eval.count(substring)
     else:
          return 0

strint_to_eval = "ABCDCDC"
substring = "CDC"
print(count_substring(strint_to_eval,substring))

If you run this, the result is 1 but the expected result is obviously 2.

My second thought was using regex library, something like this:

 

import re
def count_substring(string_to_eval, substring):
    if len(string_to_eval)<201:
        return len(re.findall(substring, string_to_eval))
    else:
        return 0

strint_to_eval = "ABCDCDC"
substring = "CDC"
print(count_substring(strint_to_eval,substring))

But again, the result was 1.

So, times like this is when you have to stop thinking in default language methods and libraries and start thinking in algorithmic solutions.

Here is something that happens to me when something standard is not doing what I want: I do things like a craftsman, so this is a quick approach of the function:

def count_substring(string_to_eval, substring):
    counter = 0
    if len(string_to_eval)<201:
        i=0
        while i<len(string_to_eval)-len(substring)+1:
            is_equal=True
            k = i
            for j in substring:
                if j!=string_to_eval[k]:
                    is_equal=False
                k += 1
            if is_equal==True:
                counter = counter+1
            i= i+1

        return counter
    else:
        return 0

This might overkill the problem and there are many improvements in the code that can be done to make it faster, but for now, this would work.

So, the lesson is: always test your code, maybe some things that you think are OK because you are using the language standards can fail.

Testing AR XIII Conference

Once again I was invited to speak in Testing Ar meetup. This time the meetup was in Belatrix that is really a great place to do this kind of events.

This time I talked about the “Non event” of 2016, Selenium 3. Why small changes made a great change towards the future of testing automation.

Testing Ar is a great QA community from Argentina, very well organized and with superb people. Every month they do meetups in different companies.  If you want to see Testing Ar events you can see their meetup site here. If you want to see past events you can see their youtube channel.

 

Here is the conference (In spanish):

Creating a Twitter Bot II – Random Twits

 

Hello again, welcome back to this “tutorial” about creating a Twitter bot, if you missed first part, please read it here.

So, now that we can Twit, maybe we can do some interesting things with that.

Creating random Tweets

As I wrote in the last article, one problem of tweeting “Hello World” is that you can’t twit twice the same text. In the other hand, we want the program to run all the time, tweeting different things, so we will make our program twit every x seconds a random text.

First thing is to create a class that will have some common functionalities and in there create a method that will create random texts of x characters.

 

import random

class Common:
    def randomText(self,characters):
        posibleCharacters=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','ñ','o','p','q','r','s','t','u','v','w','x','y','z',' ','1','2','3','4','5','6','7','8','9']
        returnedText = ""
        for i in range(0,characters):
            returnedText = returnedText+random.choice(posibleCharacters)
        return returnedText

Even if the code is easy, here is a little explanation of how this works:

I have an array of characters that can be used for the text, and then a for from 0 to the number of desired characters it concatenates a string with new random character. In the end that string is returned.

Now that we have the functionality to send some random text, we can post tweets with a fixed delay. Here is one way to do that. Remember main file we have? Let’s work on that file and do something like this:

from Twitter import *
import time
from Common import *

starttime=time.time()
twitter = Twitter()
common = Common()
twitter.connect()

while True:
    time.sleep(30.0 - ((time.time() - starttime) % 30.0))
    twitter.tweet(common.randomText(140))

We need time library to make it post every x time. time.time() returns the time as a floating point number expressed in seconds since the epoch, in UTC. For more information about Time library look here. Next step is to make objects of class Common and Twitter and connect to our Twitter account.

Now that we are connected we enter in an infinite loop and say sleep x seconds (in the example I putted 30, but you can put what you want) and then post a random tweet of 140 characters calling the randomText method.

If you want the code, fork it, review it, do whatever you want just clone it from here

Next time we will do some changes to our profile, see who follows us, follow people, etc. so stay tuned!

 

Creating a Twitter Bot

In this series of articles I will be creating a Twitter bot in Python (because, maybe I said this before, but Python is THE language). Creating a basic bot is something really easy and at the end of this article we will have a basic bot posting tweets.

All the code up to date is in a public repository in github, so you can freely clone it from here

What we need:

  • Python (the glorious computer language) 3.X
  • Tweepy (there are other libraries, but, this one is great).
  • A Twitter account (that will be the bot’s account)
  • A Twitter app (I will explain this in the first point of the article).

Create a Twitter App

First of all you need a Twitter app, this is a way to tell Twitter guys that you will be using their API. To do that you need to go to developers link in Twitter, then search for “Manage my apps” and there you will see a “Create new App” button.

From there is just to complete a form with some basic data about the application you want to create:

  • Name of the application
  • Description
  • Website (a place where people can download, use or get info about the app).
  • Callback URL (optional, it depends if you will use it or not).

Once you save, you will have a access token, access secret token, consumer key and a secret key to access your account and do things with your bot.

Get Tweepy

Ok, now Twitter know we are going to do something with his API, so we need a library to easily access that API. We are going to use Tweepy for this tutorial but there are plenty of other libraries out there. Simply pip install it (you may need sudo on Linux)

pip install tweepy

Now we can start programming!

Basic coding

Now, lets open our favorite python (the almighty) IDE (in my case is Pycharm), and lets start

The first class I will like to create is the connector class, I will call it Twitter.py

import tweepy

class Twitter:
    def __init__(self):
        self.key="your key code"
        self.secretKey="your secret key code"
        self.access = "your access token"
        self.secretAccess = "your secret access token"
        self.auth=""
        self.api =""
    def connect(self):
        self.auth = tweepy.OAuthHandler(self.key, self.secretKey)
        self.auth.set_access_token(self.access, self.secretAccess)
        self.api = tweepy.API(self.auth)
    def tweet(self,message):
        self.api.update_status(message)

Let me explain a little what we did here:

First I imported Tweepy so this class can use it (kind of obvious but I am here for all level of developers).

In the init part of the class I added the keys I get when I created the app in Twitter and two more variables for auth and the api manager.

The first method “connect” is self descriptive 🙂  it does the OAuth part, connecting to Twitter (if you want more info about OAuth please check this website) and sets the API manager for future use.

Now that we have this class (in future articles we will update this class, but for now it is a good start) we want to tweet something, so, lets create another class to do a main class to send a tweet (it is obvious that this will be updated as the project grows).

 

from Twitter import *
twitter = Twitter()
twitter.connect()
twitter.tweet("Hello World!")

This works, but, second time you run it, it will not post your message because you cannot duplicate twits. But the idea of this first article was just to understand how you can twit something as a bot, from here you can do lots of things. For example you can do a loop to twit different things with some time in the middle.

Stay tuned, next time we will do lots of fun stuff with Tweepy!

Python Tutorial Chapter 1 -Hello World!-

python logo

 

As I said in one of my first posts, there are plenty of good reasons to program in Python and as I love this language, I will try to do tutorials, kind of  “from zero to hero”. I wish this tutorial makes you learn about Python.

 

What you will need for this tutorial:

  • Python 3
  • PyCharm (well, any other IDE will work, I just chose this one for this because I feel it is the best one).
  • Eager to learn

So, any comments, ideas, questions, whatever, just comment here or in the video I will answer.

 

P.S.: Notice that I don´t have any script for the videos, so when I press “record” I only have the idea of what I am going to talk, so I am not sure of what I am going to say at the beggining of the video.

1 2