I’ll be using a 2D convolution layer1This page is really in-depth. Search for the section on “Convolution Demo” to see an animation that sums everything up nicely. and one hidden layer to create a model. Ready? Let’s dive in!

(P.S. This tutorial assumes you know the basics about deep learning)

Imports and loading data

from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Conv2D, Dense, Flatten
from keras.utils import to_categorical
from matplotlib import pyplot as plt
import numpy as np
import seaborn as sns
from sklearn.metrics import confusion_matrix

# Load (and encode) data
(X, Y_tags), (_x, _y) = mnist.load_data()
X = X[:, :, :, np.newaxis]
Y = to_categorical(Y_tags)
print(X.shape, Y.shape)

Which outputs:

(60000, 28, 28, 1) (60000, 10)

X

Y

Let’s normalize X:

X = X/255

Making and running a model

# Define model
model = Sequential()  # Most common way to initialize a model
# Add a convolution layer.
# The first layer is the only one which needs an input shape
#   specified; everything else is calculated automatically.
model.add(Conv2D(filters=16, kernel_size=3, activation='relu', padding='same',
          input_shape=X.shape[1:]))
model.add(Flatten())  # Flatten the convolution matrix into a vector.
# Add a hidden layer with 128 nodes.
# 'Dense' is the most common layer:
model.add(Dense(units=128, activation='relu'))
model.add(Dense(units=10, activation='softmax'))  # Our output!
# Define loss function, optimizer, and any metrics:
model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

It really is that easy. We have built the entire model. Want to review it? Use 

model.summary()

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_1 (Conv2D)            (None, 28, 28, 16)        160       
_________________________________________________________________
flatten_1 (Flatten)          (None, 12544)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 128)               1605760   
_________________________________________________________________
dense_2 (Dense)              (None, 10)                1290      
=================================================================
Total params: 1,607,210
Trainable params: 1,607,210
Non-trainable params: 0
_________________________________________________________________

Want to run it? That’s easy too!

history = model.fit(X, Y, validation_split=0.15, epochs=20, batch_size=128)

And wa-bam! We have run our model! Notice how Keras will automatically do a validation split for you? No need to pre-process there! It’s also really easy to tweak how batches and epochs are used. You shouldn’t need to write your own functions or for loops!

This gives us a giant output, each line of which looks something like:

Epoch 20/20
51000/51000 [==============================] - 42s 830us/step - loss: 3.4105e-05 - acc: 1.0000 - val_loss: 0.0790 - val_acc: 0.9873

Even simpler?

Honestly, this model runs just as well without the hidden layer. We can go straight from the convolution to the output:

model = Sequential()
model.add(Conv2D(filters=16, kernel_size=3, activation='relu', padding='same',
          input_shape=X.shape[1:]))
model.add(Flatten())
model.add(Dense(units=10, activation='softmax'))
model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])
history = model.fit(X, Y, validation_split=0.15, epochs=20, batch_size=128)

This runs much faster, too (~20 seconds per epoch instead of ~40):

Epoch 20/20
51000/51000 [==============================] - 19s 364us/step - loss: 0.0065 - acc: 0.9992 - val_loss: 0.0787 - val_acc: 0.9816

Doing stuff with the model!

First up, let’s save it.

model.save('model.h5')  # You can load with keras.models.load_model()

Then why not plot the loss and accuracy over time? Keras makes this quite easy:

# Plot accuracy over time
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'])
plt.show()

# Plot loss over time
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'])
plt.show()

Predict outcomes using the model? Still very easy:

Y_pred = model.predict(X)
Y_tags_pred = np.argmax(Y_pred, axis=1)

Where did the model mess up?

We can easily see this with a confusion matrix.

cm = confusion_matrix(y_true=Y_tags, y_pred=Y_tags_pred)

This model is very very accurate, so the diagonals (correct predictions)3mean=5989 are much, much higher than the off-diagonals (incorrect predictions)4mean=1.4. So to plot this, I’m setting the diagonals to zero.

np.fill_diagonal(cm, 0)
sns.heatmap(cm, cmap='BuGn', annot=True, fmt='g')
plt.show()

As you can see, the majority of errors were converting reading as 7s, with 2 and 9 being especially confused. Also 16 5s were incorrectly read as 3s. Overall pretty good, considering there were ~6000 correct predictions per digit.

Parting Thoughts on Keras

Keras makes TensorFlow even easier. It does a lot of the tedious work for you, and feels a lot more like interacting with the theoretical framework of the model then poking at the nitty-gritty details. Sometimes you’ll need those nitty-gritty details,5And Keras generally makes it pretty easy to get at them! but most of the time something straight-forward is exactly what we want. Consider me a convert!

The post Using Keras for Deep Learning appeared first on RealThinks.

1. Determine if minorities were having a different experience in the department than their peers.
2. Try to find any interesting correlations that could give us insight into making the department a better place.6Which has all sorts of “correlation doesn’t equal causation” problems attached, so we need to be careful with any causal statements.

For the first goal, I found the best way to visualize the data was to use box and whisker plots. For the second, tables showing answer counts with a heat map behind them seemed to work the best. I tackled each of these methods very differently, so let’s cover them each one at a time.

Box and Whisker Plots

But first: A refresher

If you studied box and whisker plots in fourth grade and haven’t spared them a thought since, you are not alone. That seems to be true of the majority of people I encountered on this project. So! Let’s do a quick refresher! I made this handy-dandy graphic that should explain pretty much everything you want:Imports, imports, imports

import matplotlib.pyplot as plt
from matplotlib.backends.backend_pdf import PdfPages
import numpy as np
import pandas as pd
import seaborn as sns

Defining colors and being generally picky

When making graphics, I generally like to define my own colors. It is important to me that colors look good in a variety of circumstances, including:

• On a screen
• In print
• In print, but greyscale
• To red-green colorblind folks
• To blue-yellow colorblind folks

That’s asking a lot!! Fortunately, one of my favorite web resources gives a lot of colors to choose from that meet these goals. Paul Tol’s colorblind color schemes is a fantastic place to get color schemes. I generally use them as-is, but occasionally (like for this project) I modify them a little bit.

COLORS = {
    'blue': {'line_color': '#002255', 'face_color': '#4477AA'},
    'red': {'line_color': '#660011', 'face_color': '#CC6677'},

    'light_blue': {'line_color': '#227788', 'face_color': '#AAEEFF'},
    'med_blue': {'line_color': '#227788', 'face_color': '#88CCEE'},
    'light_turquoise': {'line_color': '#004433', 'face_color': '#66CCBB'},
    'med_turquoise': {'line_color': '#004433', 'face_color': '#44AA99'},
    'dark_turquoise': {'line_color': '#004433', 'face_color': '#228877'},
    'light_green': {'line_color': '#001100', 'face_color': '#339955'},
    'med_green': {'line_color': '#001100', 'face_color': '#117733'},
    'dark_green': {'line_color': '#001100', 'face_color': '#005511'},
    'yellow': {'line_color': '#776600', 'face_color': '#FFEE99'},
    'dark_yellow': {'line_color': '#776600', 'face_color': '#DDCC77'},
    'light_red': {'line_color': '#660011', 'face_color': '#EE8899'},
    'med_red': {'line_color': '#660011', 'face_color': '#CC6677'},
    'dark_red': {'line_color': '#660011', 'face_color': '#AA4455'},
    'light_magenta': {'line_color': '#440033', 'face_color': '#CC66BB'},
    'med_magenta': {'line_color': '#440033', 'face_color': '#AA4499'},
    'dark_magenta': {'line_color': '#440033', 'face_color': '#882277'},
    }

The box and whisker plots look exactly the way I wanted: I custom-defined each line and face, from the whiskers to the caps to fliers (aka outliers). To make this work out nicely, I wrapped it all into a function to add a single box plot to the page we’re working on:

def add_boxplot(series, ax, position=1, width=0.6, color='red', **kwargs):
    """
    Plot ONE box and whisker plot on the provided graph.

    Arguments:
        series - the data to be plotted
        ax - the graph on which to plot the data

    Optional Arguments:
        position - the x position on which to center the box and
                   whisker plot (default 1)
        width - the width of the box and whisker plot (default 0.6)
        color - the color of the box and whisker plot (default 'red')
        **kwargs - any additional arguments to pass to ax.boxplot()
    """
    # Styles
    box_style = dict(linewidth=1.5, color=COLORS[color]['line_color'],
                     facecolor=COLORS[color]['face_color'])
    whisker_style = dict(linewidth=1, color=COLORS[color]['line_color'])
    median_style = dict(linewidth=2.5, color=COLORS[color]['line_color'])
    cap_style = dict(linewidth=1.5, color=COLORS[color]['line_color'])
    flier_style = dict(marker='o', markersize=6,
                       markerfacecolor=COLORS[color]['face_color'],
                       markeredgecolor=COLORS[color]['line_color'])
    mean_style = dict(marker='d', markersize=8,
                      markerfacecolor=COLORS['red']['face_color'],
                      markeredgecolor=COLORS['red']['line_color'])

    # Plot!
    data = [x for x in series if x == x]  # Filter out NaNs.
    ax.boxplot(
        data, positions=[position], widths=width, patch_artist=True,
        boxprops=box_style, medianprops=median_style, capprops=cap_style,
        whiskerprops=whisker_style, flierprops=flier_style,
        meanprops=mean_style, **kwargs
        )

This might be a little high on the anal-retentive side of things, but beautiful graphics are important to me, and this is my blog so there.

But wait, how do we even select the data in the first place?

Well, first let’s load it.

df = pd.read_csv('dataframe_sanitized.csv')

And then let’s say we want to compare and contrast heterosexual-identified folks with LGBA+-identified folks. Well, because we cleaned up the DataFrame for easy use last week, we can easily see in a column who is heterosexual-identified:

df['orientation_hete']

Which gives us 100 values (because there were 100 respondents) of

True

False

NaN

where_hete = df['orientation_hete']
data_hete = df[where_hete]

And now we have a DataFrame with only answers from heterosexual folks! We can access each question as we did before, easy peasy:

data_hete['course_exams']

gives us a column with 673the number of people who self-identified as heterosexual on the survey integer values from 1-5.4the responses for the question We can easily ship this data to the

add_boxplot

Results!

I needed to project this multi-dimensional data down into 2- or 3-dimensions so the results are easily interpretable. What I wound up doing was making a pdf page for each question, and then printing the box plots from each individual group on the page, so you could compare and contrast answers from different demographics, like so:

Ruh roh! Looks like racial minorities and religious minorities are experiencing different expectations for when they are required to work. I’m not going to even begin to speculate on what might be causing this effect,5That’s well above my pay grade but we can see if it has anything to do sub-discipline (or other departmental identifiers):

There appear to be definite cultural differences by sub-discipline, but nothing that strikes me as, well, alarming. Tenured vs. un-tenured doesn’t seem to have much of an impact on being required to work in the evening, and the start-year of the student all seem to be within statistical significance of each other.6It’s possible the “older” students are more often required to work in the evening, but I’m not comfortable eyeballing the significance of that trend.

Combining Groups

You can note that I combined some values for “start year” on that last plot. There were too few students who had started in 2010 and 2017. I didn’t want to mess up the survey’s anonymity, so I grouped each with the nearest year. You can do that with the cunning use of

|

df['start_year_2016_17'] = df['start_year_2016'] | df['start_year_2017']

Cross-counts and Correlation

We’re in the home stretch! All that’s left to do7aside from generate social change, of course! is see if any questions correlate with one another to any degree of significance.

Kendall’s Correlation Coefficient

I chose to use Kendall’s correlation coefficient to rank the correlation between different questions. This helps capture several important aspects of the data:

• Outright examples, e.g. “I feel safe” vs “I have been harassed”8not actual wording of questions from the survey where a 5 is good in one case and very bad in the other.
• Subtle examples, e.g. an individual feels strongly about one question (1s and 5s being very extreme) and meh about another (1s and 5s being more middling).
• “Yes”/”No”/”Unsure”.  We ranked these as 1, 0, and 0.5 respectively. Is “Unsure” exactly halfway between “Yes” and “No?”

A 5 from one question doesn’t necessarily equal a 5 from another. How do you compare 1-5 scales to “Yes”/”No” scales? Does a 5 = “Yes”? With Kendall, it doesn’t matter. All that matters is the relative rank. So as long as we’re sure that a 5 is greater than a 4 (for the same question) and a “Yes” is greater than an “Unsure,” we’re good to go!

Making a Correlation Matrix

First I made a list of all of the quantitative questions we had asked, and saved it in the variable

QUANT_QS

corr_mat = df[QUANT_QS].corr(method='kendall')

Poof! We have an NxN Dataframe with each entry being Kendall’s correlation coefficient. For instance, if I want to see the correlation between “I feel that it is expected of me to work during the evening,” and “I feel that it is expected of me to work during the weekend,” all we need to do is

j = 'work_expect_evening'
k = 'work_expect_weekend'
corr_mat[j][k]

and plop! Out pops 0.64. But what does that correlation look like? Can we show this in a more visual way?

Printing Pretty Cross-Counts

tmp = pd.crosstab(df[j], df[k])
ax = sns.heatmap(tmp, cmap='BuGn', square=True, annot=True)
plt.show()

I did a little bit of my own finagling to label the axes and plot title, but it’s nothing you can’t figure out for yourself with a little Google magic. I wound up creating a .pdf file that showed all of the cross-correlation tables for anything that had a correlation higher than 0.5.9or lower than -0.5 There weren’t really any unexpected results here. Generally people who liked their advisors liked them across the board. People who worked a lot worked a lot. But it was very good to see those correlations pop up so noticeably! I’d be worried if they hadn’t!

Anyway! That’s all for now folks! I’ll see you in a couple of weeks for my next project… it’s super top secret! You’ll have to come back to find out!10Why yes, this is indeed code for “I haven’t decided myself yet.” But it will be fun, I promise!

The post Visualizing Multi-Dimensional Data Sets appeared first on RealThinks.

Trying to process all of the data into meaningful and easily-interpreted results while at the same time finishing a PhD thesis, applying for jobs, and dealing with all of the other life whirlwinds made this a very challenging project. Mostly because I didn’t quite have the time to commit to it. Once I successfully graduated, though,2yaaaay! I was able to finish this sucker up and make it look good at the same time.

Ultimately I wanted to show if different categories of people in the department (e.g. people of color, but also e.g. organic chemists) were having different experiences than their peers. We can use this data to re-shape Department policy, show areas of improvement to help retain populations vulnerable to discrimination, and get some actual statistics on department composition.

While I can’t share the data with you (privacy concerns!) I can show you what-all I did, which should be very illustrative on its own.

Social Data in the Raw

The data format coming in was a download from Google Forms, which comes as a .csv. The first line of the file has the exact text of the questions asked (separated by commas), and each subsequent line is a single person’s answers. There are numbers mixed in with strings. There are unanswered questions. There are options like “Prefer not to answer,” “Unsure,” and “Not applicable.” Some of the questions people could select multiple options (like: “With which race(s) do you identify?”).

TLDR: social data is messy.

This sounds like a job for… pandas!

Cleaning up dat Data

I identified several goals that needed to happen in order to have a workable data frame:

1. Convert the column headers to short and pithy labels, rather than using the full text of the question asked. This makes reading and processing the code much more human-friendly.
2. Convert each multiple choice question into a series of Boolean values. So if someone answers

   'Asian;White'

    , then their values for the

   race_asian

     and

   race_white

     columns should be 

   True

    , but their value for, e.g. 

   race_black

    would be 

   False

    .3It’s important to note that the demographic questions that our survey asked had much more descriptive selections for race (e.g. ‘Black or African American’) but I am abbreviating them for clarity’s sake.
3. Change questions with ‘Yes,’ ‘No,’ and ‘Unsure’ into numerical values. There is an obvious ranking here that we can show using numbers.4NOTE: There isn’t an obvious mapping to numbers. We can’t for sure say that ‘Unsure’ is exactly half of ‘Yes’, for instance. But we CAN rank them. ‘Yes’ is obviously more certain than ‘Unsure’ which is obviously more certain than ‘No’. This idea of relative rank will come up later on.
4. Identify minorities, and label them so that their answers can be pooled and compared against the majority (to see if, for instance, men, women, and trans folks have similar or dissimilar experiences across different measures).

Let’s go over the code for each goal, and show the final outcome!

Import the data and re-label the columns

import numpy as np
import pandas as pd

INFILE = 'SurveyData.csv'
df = pd.read_csv(INFILE)

Gosh, I love pandas. The data is there. POOF!5*fairy glitter sparkles*

Renaming the columns is just as easy. First, I define a (rather large) dictionary, with each key being a question asked in the survey, and each value being the short name I wanted the column to have.

column_names = {
    'Timestamp': 'timestamp',
    'I am required to work during the evening': 'work_req_evening',
    ...
    }

Then I simply ask pandas to do the renaming:

df.rename(columns=column_names, inplace=True)

As a bonus, we can turn the timestamps into pandas datetime objects, so we could do time-math on them if we so choose:

df.timestamp = pd.to_datetime(df.timestamp)

Moving right along…

Practical Parsing of Multiple Choice Answers

The first thing I did was define a function to label the multiple-choice columns in an automatic way. I didn’t want to re-label all of those by hand!

def label_maker(x, c):
    """
    Create succinct naming conventions for multiple choice options.

    If the multiple choice option has multiple words, then return an
    acroynm. Else, use the first four letters of the option. The final
    label will have the category and truncated option together.
    e.g.
        option = 'female', category = 'gender'
            -->
        label = 'gender_fema'

        option = 'Asian or Asian American', category = 'race'
            -->
        label = 'race_aoaa'

    Arguments:
        x - (string) multiple choice option to be truncated
        c - (string) category, to be prepended to label

    Returns:
        label - (string) the final, succinct column label
    """
    if len(x.split()) > 1:
        # If multiple words, then use acronym
        y = ''.join([w[0].lower() for w in x.split()])
        if y == 'p(':
            y = 'phys_%s' % x.split()[1][1:4].lower()
    else:
        y = x[:4].lower()
    return '%s_%s' % (c, y)

Note the prominent docstring. I commented the bajeezus out of this code, because I knew I’d be passing it along to someone else next year. This hypothetical next-year person might not know much about code, and it was important to me that everything I wrote be veeeeerrrrry readable.

Next I defined which questions were multiple choice questions:

mul_choice = [
    'adv_tenure',
    'gender',
    'start_year',
    ...
    ]

Now, for each question, we need to:

1. Remove ‘Prefer not to answer’ answers.
2. Turn each entry into a list, rather than a string.
3. Make new columns for each possible entry (labeled with our label_maker function above).
4. Do some clean-up.

Removing ‘Prefer not to answer’

for c in mul_choice:
    df.loc[df[c].isin(['Prefer not to answer']), c] = ''
    tmp = df[c].fillna('')

For each column, we turn blank results and ‘Prefer not to answer’ results into an empty string. We’re saving everything into a temporary 

pd.Series

tmp

Lists, not strings

This is also an easy fix!

tmp = tmp.str.split(';')

New columns for each possible entry

This gets into some tricky python-ing, but basically we’re making a new column for each multiple choice option which has a Boolean value if that option was selected by each survey participant.

tmp = tmp.apply(lambda x: pd.Series(1, index=x)).fillna(0).astype(bool)

Now we need to rename the columns using our 

label_maker

new_columns = [label_maker(x, c) for x in tmp.columns]
    tmp.rename(columns=dict(zip(tmp.columns, new_columns)), inplace=True)

Appending and clean up

Let’s add our 

tmp

df = pd.concat([df, tmp], axis=1)

That’s going to loop over all multiple choice questions and get them nice and organized. There is one last thing that we need to do, though. When we generated a new column for each multiple choice item, one of the “items” it looked at was the empty string ”. This translated to 

[Nan]

NaN

label_maker

df = df[[c for c in df.columns if not c.endswith('_')]]

Multiple choice questions: sorted!

Yes, No, Maybe So

First, let’s define a list of all of our yes/no questions:

yes_no = [
    'adv_switched',
    'harassment_observed',
    ...
]

and we’ll also make a quick dictionary that will translate words into values. Not quantitative values, mind you, but ranked values. We can’t say exactly how much ‘Unsure’ is like ‘Yes’ or like ‘No,’ but we CAN say that it’s in-between them. So the values we’re giving them are relative ranks and not absolute, got it?

yes_no_dict = {
    '': np.nan,
    'N/A': np.nan,
    'Not applicable': np.nan,
    'Prefer not to answer': np.nan,
    'No': 0,
    'Unsure': 0.5,
    'Yes': 1
    }

Also, anything that was a non-answer, we’re changing to be blank in the DataFrame. There’s just one last step, and that’s implementing the dictionary:

for c in yes_no:
    df = df.replace({c: yes_no_dict})

Aggregating minorities

For purposes of determining whether minorities have a different experience in the department than the majority, we need to be able to have a column identifying whether someone is a minority or not. Let’s use sexual orientation as the example.

First, let’s identify the options that will count as an orientation minority. In this case, it will be any answer that wasn’t “heterosexual.”

orientation_mino = [x for x in df.columns
                    if x.startswith('orientation_')
                    and x != 'orientation_hete']

Let’s turn that into a usable DataFrame:

tmp = df[orientation_mino]

In this case, my temporary DataFrame, 

tmp

tmp = tmp.sum(axis=1)

which gives us a single column that has a number in it. The number is the number of checkboxes each individual selected, other than “heterosexual.” How many options did people tend to choose?

In : tmp.unique()
Out: array([1, 0, 2])

People selected either 0, 1, or 2 check boxes from the six non-heterosexual options. Let’s turn this into a Boolean array and append it to the main DataFrame, shall we?

df['orientation_mino'] = tmp.astype(bool)

I needed to separate out each demographic differently, so if you’re doing something similar, you’ll likely want to do the same. For instance, when asking about disabled identities, so many people answered that they had mental illness that I found it important to present that demographic separately from folks with other, physical disabilities.

What’s up next?

I’m glad you asked! Next week I’m going to dive into processing this now-clean data and presenting it in a beautiful way that’s easy to parse.6Technically, I’ve already written it and you just have to wait a week to read it, because having a buffer is important for my sanity.

The post Finding Trends in Social Data: Messy, Frustrating, Important appeared first on RealThinks.

It was important to me to create a dictionary that was easily searchable, because so much out there is image-only, and you have to manually scour resources. I want this to be a resource that is easy and available!

So far the dictionary contains 674 words. I have done my best to show multiple ways of expressing words (specifically with the upward/downward ‘L’), but keep in mind that there might be a different way to write any given word that’s equally valid.

If you have any requests, suggestions, corrections, or general comments, please let me know! I would be happy to include them in the dictionary. I intend this to be a living project, and I want it to grow and evolve to be the best (and most useful) it can be.

A Searchable Teeline Dictionary

A:

Able:

About:

Above:

Accident:

Act:

After:

Aftermath:

Afternoon:

Again:

Against:

Age:

Ago:

Air:

All:

Also:

Always:

Am:

Among:

Amount:

An:

And:

Animal:

or

Announce:

Announced:

Answer:

Any:

Anything:

Appear:

April:

Are:

Area:

As:

Ask:

Astronomy:

At:

Atom:

Attention:

August:

Automatic:

Avoid:

Back:

Base:

Be:

Beaker:

Beauty:

Bed:

Been:

or

Before:

Began:

Begin:

Behind:

Best:

Better:

Between:

Big:

Biochemistry:

Biology:

Bird:

Black:

Blue:

Boat:

Body:

Book:

Both:

Box:

Boy:

Bread:

Bring:

Brought:

Build:

Bursting:

Business:

Busy:

But:

Buy:

By:

Call:

Came:

Campaign:

Can:

Car:

Care:

Carry:

Cat:

Cause:

Cell:

Center:

Centimeter:

Certain:

Change:

Chapter:

Check:

Chemical:

Chemistry:

Children:

City:

Class:

Clear:

Climate:

Close:

Cold:

Come:

Common:

Communication:

Complete:

Contain:

Control:

Convenient:

Convenience:

Correct:

Could:

Country:

Course:

Cover:

Criticism:

Cross:

Cry:

Cut:

Dark:

Data:

Datum:

Day:

or

December:

Decide:

Deep:

Deserve:

Develop:

Determined:

Did:

Differ:

Difference:

Different:

Direct:

Diversified:

Do:

Does:

Dog:

Don’t:

Done:

Door:

Down:

Draw:

Drive:

Dry:

During:

Each:

Early:

Earth:

Ease:

East:

Easy:

Eat:

Eight:

Electricity:

Electronic:

Element:

E-mail:

End:

Energy:

Engagement:

Enough:

Equal:

Even:

Ever:

Every:

Everyone:

Everything:

Evolution:

Examination:

Example:

Experiment:

Eye:

Face:

Fact:

Fall:

Family:

or

Far:

Farm:

Farther:

Fast:

Fat:

Father:

February:

Feel:

Feet:

Few:

Field:

Figure:

Fill:

Final:

or

Find:

Fine:

Fire:

Firm:

First:

Fish:

Five:

Flask:

Fly:

Follow:

Food:

Foot:

For:

Force:

Form:

Found:

Four:

Free:

Friday:

Friend:

From:

Front:

Full:

Funnel:

or

Further:

Game:

Gave:

General:

Genetics:

Geology:

Get:

Girl:

Give:

Go:

Gold:

Good:

Got:

Govern:

Government:

Gram:

Graph:

Gravity:

Great:

Green:

Grew:

Grid:

Grind:

Ground:

Group:

Grow:

Had:

or

Half:

Hand:

Happen:

Hard:

Has:

Have:

He:

Head:

Health:

Hear:

Heard:

Heat:

Held:

Help:

Her:

Here:

Hers:

Herself:

Hi:

High:

Him:

Himself:

His:

Hold:

Hole:

Home:

Horse:

Hot:

Hour:

Hundred:

or

Hypothesis:

I:

Idea:

If:

Immediate:

Implementation:

Important:

Improving:

In:

Inch:

Inconvenient:

Individual:

Interest:

Is:

Island:

It:

January:

or

Jesus:

July:

June:

Just:

Keep:

Kilogram:

Kilometer:

Kind:

King:

Knew:

Know:

Lab:

Land:

Language:

Large:

Last:

Late:

Laugh:

Law:

Lay:

Lead:

Learn:

Leave:

Left:

Less:

Let:

Letter:

Lie:

Life:

Light:

Like:

Line:

List:

Listen:

Liter:

Little:

Live:

Long:

Look:

Lost:

Lot:

Love:

Low:

Machine:

Made:

Main:

Make:

Man:

Many:

Map:

March:

Mark:

Mass:

Matter:

Maximum:

May:

Me:

Mean:

Measure:

Media:

Member:

Men:

Met:

Meter:

Microscope:

Might:

Mile:

or

Milliliter:

Millimeter:

Million:

or

Mind:

Mineral:

Minimum:

Minute:

Miss:

Molecule:

or

Monday:

Money:

Moon:

More:

Morning:

Most:

Mother:

Motion:

Mountain:

Move:

Much:

Multiply:

Multitude:

Music:

Must:

My:

Myself:

Name:

Nation:

National:

Near:

Necessary:

Need:

Never:

New:

Next:

Night:

Nine:

No:

North:

Not:

Note:

Nothing:

Notice:

Noun:

November:

Now:

Number:

Numeral:

or

Object:

Observe:

October:

Of:

Off:

Often:

Oh:

Old:

On:

Once:

One:

or

Only:

Open:

Or:

Order:

Organism:

Other:

Our:

Ourselves:

Out:

Over:

Overdue:

Overlook:

Own:

Page:

Paid:

Paleontology:

Paper:

Part:

Particle:

Pass:

Pattern:

People:

Percent:

Perhaps:

Person:

Phase:

Physics:

Picture:

Piece:

Place:

Plain:

Plan:

Plane:

Plant:

Play:

Point:

Pond:

Port:

Pose:

Possible:

Pound:

Power:

Preparation:

Prepare:

Press:

Problem:

Produce:

Product:

Public:

Pull:

Purple:

Purpose:

Put:

Question:

Quick:

Rain:

Ran:

Rank:

Reach:

Read:

Ready:

Real:

Recently:

Record:

Red:

Reference:

Remember:

Requirement:

Research:

Rest:

Retort:

Right:

River:

Road:

Rock:

Room:

Round:

Rule:

Run:

Run:

Said:

Same:

Saturday:

Saw:

Say:

Scale:

School:

Science:

Scientist:

Sea:

Second:

See:

Seem:

Self:

Semicircle:

Semiconductor:

Send:

Sent:

Sentence:

September:

Serve:

Set:

Seven:

Several:

Shall:

Shape:

She:

Ship:

Short:

Should:

Show:

Side:

Simple:

Since:

Sing:

Sir:

Sit:

Six:

Size:

Sleep:

Slow:

Small:

or

Snow:

So:

Social:

Some:

Something:

Song:

Soon:

Sound:

South:

Special:

Spell:

Stand:

Star:

Start:

State:

Stay:

Steep:

Step:

Still:

Stood:

Stop:

Story:

Street:

Strong:

Study:

Subconscious:

Success:

Such:

Sun:

Sunday:

Super:

Supermarket:

Supervise:

Sure:

Surface:

or

Survival:

Suspicious:

Table:

Tail:

Take:

Talk:

Tall:

Teach:

Teeline:

Telephone:

Telescope:

Tell:

Temperature:

Test:

Than:

Thank:

That:

The:

Their:

Them:

Then:

Theory:

There:

Therefore:

Thermometer:

These:

They:

Thing:

Think:

Thirty:

This:

Those:

Though:

Thought:

Thousand:

or

Three:

Through:

Thursday:

Time:

Tip:

Tissue:

To:

Together:

Told:

Tomorrow:

Too:

Took:

Top:

Toward:

Town:

Transport:

Travel:

Tree:

True:

Try:

Tuesday:

Turn:

Uncertainty:

Two:

Under:

Unit:

Until:

Up:

Us:

Use:

Usual:

Variable:

Very:

Voice:

Volume:

Vowel:

Wait:

Walk:

Want:

Wanted:

War:

Warm:

Was:

Watch:

Water:

Way:

We:

Weather:

Wednesday:

Week:

Weight:

Well:

Went:

Were:

West:

What:

Wheel:

When:

Where:

Whether:

Which:

While:

White:

Who:

Whole:

Why:

Will:

Wind:

Wise:

With:

Within:

Without:

Wonder:

Wood:

Word:

Work:

World:

Would:

Write:

Year:

Yes:

Yesterday:

Yet:

You:

Young:

Your:

Yourself:

Zoology:

The post A Searchable Teeline Dictionary appeared first on RealThinks.

Over the years I’ve developed a bit of a process for editing text. I have about five different websites I use to check spelling, grammar, homonyms, nominalizations… a bunch of stuff. One day it occurred to me I can aggregate most of this into its own script… where I can execute it all at once! I’m building my own grammar editor!

I’ve succeed with it (more or less), and I want to share my results with you. Some things need work, but I like where it’s headed.

Oh boy imports

This list is a doozy. We’ll explain it as we go, but it’s good practice to keep your imports at the top of a script.

# Python packages
from math import ceil
from string import punctuation

# Fun extras
import enchant  # Spell Check
import language_check  # Grammar Check
import lxml  # Needed for thesaurus
import nltk
from nltk.corpus import stopwords
from nltk.corpus import wordnet as wn
from py_thesaurus import WordAnalyzer  # Thesaurus

# Files which I define later
from cliches import cliches
from colors import Color
from filler_words import filler_words
from homophone_list import homophone_list
from nominalizations import denominalize
from weak_words import weak_adjs, weak_nouns, weak_verbs

Creating the user interface

I’m not aiming for any fancy GUIs, but I do want a fairly interactive program. I need to define a few functions to make it pretty.

First up, every time I proceed to a new section (spelling/grammar/etc), I want it to tell me in no certain terms we’re changing gears:

def now_checking_banner(word):
    '''Print a pretty banner on the output.'''
    mystr = '---  Now Checking %s!  ---' % word.title()
    dashstr = '-' * len(mystr)
    print('\n\n')
    print(dashstr)
    print(mystr)
    print(dashstr)

Nothing too fancy.7Except you may note that my print statements now have parenthesis. I’ve finally moved my curmudgeonly butt into Python3. Next, I want a function I can feed a list of words, and it will print the list out nicely into 3 (or whatever) columns. I’m also picky in that I like my columns to read down the column, and not across the row; I do a little jiggery-pokery with lists to accomplish that.

def print_rows(lis, max_rows=21, cols=3, item_width=18):
    '''
    Given a list of items, print them, numbered, in columns and rows.
    '''
    if len(lis) == 1 and lis[0] == '':
        print(' (1) <delete>')
        return

    max_items = max_rows * cols
    if len(lis) > max_items:
        lis = lis[:max_items]
    if len(lis) < 2*cols:
        cols = 1

    # Make a string template holding each column.
    mystr = '{: >4} {: <%s}' % (item_width) * cols
    nrows = ceil(len(lis)/cols)
    rows = [[]] * nrows
    r = 0
    # Order stuff to read down each column.
    # (rather than across each row).
    for i, j in enumerate(lis):
        rows[r] = rows[r] + ['(%s)' % (i+1), j]
        r = (r+1) % nrows
    while r != 0:
        rows[r] = rows[r] + ['', '']
        r = (r+1) % nrows
    for row in rows:
        print(mystr.format(*row))

Next, I wanted a built-in thesaurus for my program. Later on in the program, I check for weak words; I specifically don’t want my thesaurus to recommend those. Accomplished easily enough:

def thesaurus(word):
    '''Provide a list of synonyms that are not weak words.'''
    return [w for w in WordAnalyzer(word).get_synonym()
            if w not in filler_words
            and w not in weak_adjs
            and w not in weak_nouns
            and w not in weak_verbs]

Finally, putting these elements together, I want an input/output function. That is, I want it to print the sentence where the program catches an error (or a suggestion) with that error (or suggestion) underlined, print a list of possible replacements, and give the user a chance to input corrections.

Since I’m not using a GUI,2yet! I want to make this process as streamlined as possible. If there’s a word that needs changing, I want it to be straightforward to change that word. If I want to pick something not in the suggestions list, I should be able to do that. If I want to re-write the sentence, that should be an option too. Ultimately what I developed is a little clunky, but it gets the job done. Once I get the back-end (actual style suggestions) functioning better, I can tweak this to be a bit nicer.

def suggest(word, suggestions, sentence, underline=None,
            can_replace_sent=False):
    '''
    Ask the user to provide input on errors or style suggestions.

    Arguments:
    word - the word or phrase to be replaced
    suggestions - a list of possible suggestions
    sentence - the context surrounding the word

    Optional arguments:
    underline - a 2-element list with the start and end
        points for underlining
    can_replace_sent - should the user have the option of
        replacing the entire sentence?
    '''
    
    # Print the sentence with the underlined section underlined.
    if underline is None:
        print('\n%s' % sentence)
    else:
        Color.print('\n%s' % sentence, underline[0], underline[1])
    print('Possible suggestions for "%s":' % word)

    # Print list of suggestions, as well as custom options.
    if len(suggestions) == 0:
        suggestions += ['']  # Play nicely with print_rows.
    print_rows(suggestions)
    print(' (0) Leave be.')
    if can_replace_sent is True:
        print('(ss) Edit entire sentence.')
    print(' (?) Input your own.')

    # Get user input.
    # If a number, return listed suggestion.
    # If 0, return sentence as-is.
    # If 'ss', ask user to replace entire sentence.
    # Else: return user-input.
    ss = False  # Replace entire sentence.
    user_input = input('Your choice: ')
    try:
        n = int(user_input)
        if n == 0:
            return word, ss
        # Note: will throw an error if number doesn't exist in list
        return suggestions[n-1], ss
    except ValueError:
        if can_replace_sent is True and user_input == 'ss':
            ss = True
            sent = input('Replace entire sentence: ')
            return sent, ss
        return user_input, ss

Starting the “Text” class for our grammar editor

Everything from here on out I’m going to do within a class. I want an object to hold each set of text I’m working on, represent it in different ways (string, tokens, list of words, parts of speech, etc.). I want to be able to edit the text both by calling methods (e.g.

spelling

class Text(object):
    """
    A fancy text object which can provide style suggestions.

    Instance variables:
    string - a string of the entire text
    sentences - a list of sententces within the text
    tokens - a list of tokens
    words - a list of words
    tags - a list of words and their parts of speech tags

    Methods:
    save - save the text to a file
    spelling - check spelling
    grammar - check grammar
    homophone_check - highlight homophones
    cliches - point out overused phrases
    passive_voice - check for passive voice
    nominalizations - point out nominalizations
    weak_words - highlight weak words
    filler_words - point out words that may be unneccesary
    adverbs - highlight adverbs
    frequent_words - list the most-used words
    visualize_length - provide visual cues for sentence length
    polish - run all checks in order
    """

    def __init__(self, string, lang='en_US'):
        """
        Initialize a Text object.

        Arguments:
        string - the text string to be parsed

        Optional arguments:
        lang - the language to be used (not fully implemented)
        """
        self._string = string
        self._sentences = self._gen_sent(string)
        self._clean()
        self.lang = lang

    def save(self, filename):
        """Save the object to file."""
        with open(filename, 'w') as myfile:
            myfile.write(self._string)

Defining Properties

I’m going to be using properties to allow the in-place-type editing of sentences, words, etc. I was talking about beforehand. I’ll define the “actual” variable with a private3i.e. starting with “_” variable and the public “variable” as a property. Properties are similar to variables, except they allow function/method calls when they are assigned or called. I like using the decorator (or “@”) to define properties.

@property
    def string(self):
        return self._string

    @string.setter
    def string(self, string):
        self._string = string
        self._sentences = self._gen_sent(self._string)
        self._tokens = self._gen_tokens(self._string)
        self._words = self._gen_words(tokens=self._tokens)
        self._tags = self._gen_tags(words=self._words)

    @property
    def sentences(self):
        return self._sentences

    @sentences.setter
    def sentences(self, sents):
        self._string = ' '.join(sents)
        self._sentences = sents
        self._tokens = self._gen_tokens(self._string)
        self._words = self._gen_words(tokens=self._tokens)
        self._tags = self._gen_tags(words=self._words)

    @property
    def tokens(self):
        return self._tokens

    @tokens.setter
    def tokens(self, toks):
        self._string = ''.join(toks)
        self._sentences = self._gen_sent(self._string)
        self._tokens = toks
        self._words = self._gen_words(tokens=self._tokens)
        self._tags = self._gen_tags(words=self._words)

    @property
    def words(self):
        return self._words

    @property
    def tags(self):
        return self._tags

Defining basic cleanup

Don’t you love how I’m building a lot of foundation and we haven’t gotten into the meat and potatoes? Right now I’m showing you my “clean” method as well as the “_gen_BLAH” methods I was calling earlier. These generate4GASP! the lists of things (words, tokens, and tags) I referred to earlier.

Here I use a LOT of tools from NLTK, the Natural Language Toolkit. It easily breaks sentences with no effort on my part. I use its regular expression parser to generate tokens (like a list of words, but including punctuation and spaces). I also use it to tag the parts of speech in the text. After that, I needed a bit of clean-up (treating newlines as sentence breaks, treating contractions as ONE token/word).

def _clean(self):
        """Remove unneccesary whitespace."""
        sents = [s.strip() for s in self._sentences]
        for i in ',:;.?! ':
            sents = [s.replace(' %s' % i, i) for s in sents]

        self._string = ' '.join(sents)
        self._sentences = sents
        self._tokens = self._gen_tokens(self._string)
        self._words = self._gen_words(tokens=self._tokens)
        self._tags = self._gen_tags(words=self._words)

    def _gen_sent(self, string):
        """Generate a list of sentences."""
        sentences = nltk.tokenize.sent_tokenize(string)
        # Treat newlines as sentence breaks
        # Remove leading/trailing whitespace
        return [s.strip() for p in sentences for s in p.split('\n') if s != '']

    def _fix_contractions(self, tokens):
        """Treat contractions as one token, not three."""
        cont_list = ['d', 'll', 'm', 're', 's', 't', 've']
        conts = [i for i, tok in enumerate(tokens)
                 if tok == "'"
                 and i > 0 and i+1 < len(tokens)
                 and tokens[i+1] in cont_list]
        for c in conts:
            tokens = tokens[:c-1] + [''.join(tokens[c-1:c+2])] + tokens[c+2:]
        return tokens

    def _gen_tokens(self, string):
        """Generate a list of tokens."""
        tokens = nltk.tokenize.regexp_tokenize(string, '\w+|[^\w\s]|\s')
        return self._fix_contractions(tokens)

    def _gen_words(self, tokens=None, sent=None):
        """Generate a list of words."""
        if sent is not None:
            tokens = self._gen_tokens(sent)
        if tokens is not None:
            return [
                tok for tok in tokens if tok != ' ' and tok not in punctuation]
        raise NameError('_gen_words must be passed either tokens or sent.')

    def _gen_tags(self, words=None, sent=None):
        """Generate a list of parts of speech tags."""
        if words is not None:
            return nltk.pos_tag(words)
        if sent is not None:
            return nltk.pos_tag(self._gen_words(sent=sent))
        raise NameError('_gen_tags must be passed either words or sent.')

One more piece of business: For some of my methods, I use WordNet to lemmatize my words. It uses different parts of speech (POS) tags than does NLTK. I threw in a short method to convert from NLTK’s Penn POS tags to WordNet’s:

def _penn2morphy(self, penntag):
        """Quick 'translation' between Penn and Morphy POS tags."""
        morphy_tag = {'NN': wn.NOUN,
                      'JJ': wn.ADJ,
                      'VB': wn.VERB,
                      'RB': wn.ADV}
        try:
            return morphy_tag[penntag[:2]]
        except KeyError:
            return None

Morphy has fewer tags; if it doesn’t have a tag, the method returns

None

Two more behind-the-scenes methods.

I found my

suggest

def _replace_one_word(self, tokens, index, suggestions,
                          can_replace_sent=False):
        """
        Given tokens, an index, and suggestions:
            Determine what the replaced word should be.
            Determine where it is highlighted in the sentence.
            Ask user for input on what corrections to make.
            If they modified the entire sentence, return those tokens.
            Else replace the one token and return updated list.
        """
        tok = tokens[index]
        u_start = len(''.join(tokens[:index]))
        u_end = u_start + len(tok)
        r, ss = suggest(tok, suggestions, ''.join(tokens), (u_start, u_end),
                        can_replace_sent)
        if ss is True:  # Replace entire sentence
            tokens = self._gen_tokens(r)
        elif ss is False:
            tokens[index] = r
        return tokens

    def _replace_phrase(self, sent, phrase, suggestions,
                        can_replace_sent=True, underline=None):
        """
        Given a sentence, phrase, and suggestions:
            Determine where underline should be, if none given.
            Ask user for input on what corrections to make.
            Return sentence with corrections.
        """
        # NOTE: only highlights first instance
        if underline is None:
            u_start = sent.find(phrase)
            if u_start != -1:
                u_end = u_start + len(phrase)
                underline = (u_start, u_end)
            else:
                underline = None
        r, ss = suggest(phrase, suggestions, sent, underline, can_replace_sent)
        if ss is True:
            sent = r
        elif ss is False:
            if underline is not None:
                sent = sent[:underline[0]] + r + sent[underline[1]:]
            else:
                sent = sent.replace(phrase, r)
        return sent

Like I said, these functions are a wee bit clunky. High on my cringe list is 

_replace_phrase

The actual substance of the thing

Are you ready to actually start a grammar/style check!?!?!? Now that I’ve gotten the bones defined, we can get deep into it.

Spell check

What would a style checker be without a good ol’ spell check? I wanted my spell-checker to do two things: to check spelling, and to leave scientific words alone. Any of you who write science a lot understand my struggle. Spell checkers always pick the common lingo words and it’s frustrating. I found an online list of scientific words for spell-checkers and downloaded it into a text file called

scientific_word_list.txt

For this method, I load the enchant spell check, feed it my custom DICTIONARY OF SCIENCE, and run through each token. If the token has an error,

spelling

def spelling(self):
        """Run a spell check on the text!"""
        string = ''
        d = enchant.DictWithPWL(self.lang, 'scientific_word_list.txt')
        for sent in self._sentences:
            tokens = self._gen_tokens(sent)
            for i, tok in enumerate(tokens):
                if tok == ' ' or tok == '\n' or tok in punctuation:
                    continue
                if d.check(tok) is False:
                    tokens = self._replace_one_word(tokens, i, d.suggest(tok))
            string += ''.join(tokens) + ' '
        self.string = string.strip()

Grammar check

Why reinvent the wheel? I wanted to start with a good, basic grammar check to get this party started. I settled on

language_check

def grammar(self):
        """Run a grammar check on the text!"""
        string = ''
        d = language_check.LanguageTool(self.lang)
        d.disable_spellchecking()
        for sent in self._sentences:
            errors = d.check(sent)
            while len(errors) > 0:
                err = errors[0]
                if err.fromx < 0 or err.tox < 0:
                    errors = errors[1:]
                    continue
                sent_new = self._replace_phrase(
                    sent, sent[err.fromx:err.tox], err.replacements,
                    can_replace_sent=True, underline=[err.fromx, err.tox])
                if sent_new == sent:
                    errors = errors[1:]
                else:
                    errors = d.check(sent_new)
                sent = sent_new
            string += sent + ' '
        self.string = string.strip()

Homophone check

To be honest, I’m generally pretty good at homophones. I’m also PARANOID I’ll mix them up and look horribly uneducated and something something overreacting. I wanted something that would highlight every. single. homophone. Just to make sure. This is super overkill for some people. It’s fabulously useful for others.

def homophone_check(self):
        """Point out every single homophone, for good measure."""
        string = ''
        for sent in self._sentences:
            tokens = self._gen_tokens(sent)
            for i, tok in enumerate(tokens):
                for homophones in homophone_list:
                    for h in homophones:
                        if h == tok.lower():
                            tokens = self._replace_one_word(
                                tokens, i, homophones)
            string += ''.join(tokens) + ' '
        self.string = string.strip()

There is probably a way to do this without so many nested

for

homophone_list

Cliches!

Do you think I was born yesterday? I’m a big wig! You can’t hold a candle to me. I want to avoid cliches more than life itself! But I want it to be a no-brainer.

Barf. It pained me to write that paragraph. Let’s never talk of this again. To check for cliches, I needed to lemmatize my phrases so that my program will still catch slight variations. Never fear! NLTK is here!

def cliches(self):
        """Highlight cliches and offer suggestions."""
        string = ''
        lemmatizer = nltk.stem.WordNetLemmatizer()
        for sent in self._sentences:
            tokens = self._gen_tokens(sent)
            lem = ''.join([lemmatizer.lemmatize(t) for t in tokens]).lower()
            for k in cliches.keys():
                if k in lem:
                    sent = self._replace_phrase(sent, k, cliches[k])
                    tokens = self._gen_tokens(sent)
                    lem = ''.join([
                        lemmatizer.lemmatize(t) for t in tokens]).lower()
            string += sent + ' '
        self.string = string.strip()
        self._clean()

I compiled a huge list of cliches (and occasionally suggestions for replacing them) from the internet and saved it into a dictionary called

cliches

Passive voice

Ah the bane of my existence. I use passive voice much more than I’d like to admit. It’s also VERY difficult to check for. I searched the Interwebz for a passive voice finder, but didn’t find anything satisfactory. So I wrote my own. It works. Mostly.

The trick is finding verbs in the past-participle form (“VBN” in Penn tags) and finding other verbs that appear before them. Right now this will catch phrases like “was included” and “were substituted.” I still need to allow for an extra word (or two?) between the verbs, because it’s not catching phrases like “was not included” and “were randomly substituted.”6The good news is that almost all of these get caught later in weak_verbs, so there’s that at least. Also if there are multiple instances of passive voice in a sentence, this method does some weird things. That being said, it works on a lot of sentences with passive voice:

def passive_voice(self):
        """Point out (many) instances of passive voice."""
        string = ''
        for sent in self._sentences:
            words = self._gen_words(sent=sent)
            tags = self._gen_tags(words=words)
            vbns = [w[0] for w in tags if w[1] == 'VBN']
            if len(vbns) > 0:
                for vbn in vbns:
                    i = words.index(vbn)
                    if tags[i-1][1].startswith('V'):
                        phrase = ' '.join([words[i-1], words[i]])
                        sent = self._replace_phrase(sent, phrase, [])
            string += sent + ' '
        self.string = string.strip()

Nominalizations

It took me a long time to wrap my head around the idea of nominalizations. Once I heard the phrase “zombie nouns” it made sense, though! A nominalization is a noun hiding a verb (sometimes an adjective) in it. Good writing 101 states strong verbs are the cornerstone of strong writing. You should use them as much as possible.

Examples:
“The study was a failure.” ==> “The study failed.”
“Movement occurred in the bushes.” ==> “The bushes moved.”

I originally planned on making a list of nominalizations like I did with cliches and homonyms, but I quickly realized that was a herculean task. I changed tack. Nominalizations often possess one of several endings:

nominalization_endings = [
    'ance',
    'cy',
    'ence'
    'ing',
    'ion',
    'ment',
    'ness',
    'nt',
    'ology',
    'ry',
    'sis',
    'ty',
    'ure',
    ]

That, coupled with a short list of nominalizations without those endings (

random_nominalizations = ['belief', 'sale', 'success']

def denominalize(noun):
    """Return verb forms of noun, if it is a nominalization."""
    # Clean noun for processing.
    noun = wn.morphy(noun, wn.NOUN)
    if noun is None:
        return []

    # Determine if we should check the noun.
    should_check = False
    for ending in nominalization_endings:
        if noun.endswith(ending):
            should_check = True

    if noun in random_nominalizations:
        should_check = True

    if should_check is False:
        return []

    # Get sets of synonyms.
    synsets = wn.synsets(noun, wn.NOUN)

    # Lemmatize (get base word) of each synset.
    lemmas = []
    for syn in synsets:
        lemmas += syn.lemmas()

    # Get derivations from each lemma.
    derivs = []
    for lem in lemmas:
        derivs += lem.derivationally_related_forms()
    # Filter to only have verbs.
    derivs = [d.name() for d in derivs if d.synset().pos() == 'v']

    # Return words (no duplicates)
    return list(set(derivs))

WordNet is the powerhouse of this function. The ability to get words related to an input word is FANTASTIC. This means when asking it to denominalize “success,” you’ll see “succeed,” but you’ll also see “win” and “achieve,” which are etymologically similar. Neat!

(For those keeping track,

nominalization_endings

random_nominalizations

denominalize

nominalizations.py

Back to the

Text

nominalizations

def nominalizations(self):
        """Find many nominalizations and suggest stronger verbs."""
        string = ''
        for sent in self._sentences:
            tokens = self._gen_tokens(sent)
            nouns = [w[0] for w in self._gen_tags(sent=sent)
                     if w[1].startswith('NN')]
            for noun in nouns:
                denoms = denominalize(noun)
                if len(denoms) > 0 and noun in tokens:
                    tokens = self._replace_one_word(
                        tokens, tokens.index(noun), denoms, True)
            string += ''.join(tokens) + ' '
        self.string = string.strip()

Bonus: did anyone catch that “nominalization” is a nominalization? Thanks, English!

Weak words

There are words which are so bland you shouldn’t use them. “Beautiful”? “Amazing”? How about “radiant!” “Move”? Try “scurry” or “hustle!” Well-crafted words (especially verbs!!) can make a reading experience that much more intriguing. Again, I’m lemmatizing the words to increase the number of matches (“was” and “are” are both versions of “be” of course). I let the thesaurus do the work.

def weak_words(self):
        """Find weak words and suggest stronger ones."""
        string = ''
        lemmatizer = nltk.stem.WordNetLemmatizer()
        for sent in self._sentences:
            tokens = self._gen_tokens(sent)
            tags = self._gen_tags(sent=sent)
            for w in tags:
                pos = self._penn2morphy(w[1])
                if pos is not None:
                    lemma = lemmatizer.lemmatize(w[0], pos)
                    if (lemma in weak_verbs \
                            or lemma in weak_adjs \
                            or lemma in weak_nouns) \
                            and w[0] in tokens:
                        tokens = self._replace_one_word(
                            tokens, tokens.index(w[0]), thesaurus(w[0]), True)
            string += ''.join(tokens) + ' '
        self.string = string.strip()

weak_verbs

weak_adjs

weak_nouns

weak_words.py

Filler words

Some words don’t need to be in your text at all. Personally, “that” is a pet peeve of mine which shows up everywhere! It slows your reader for no reason. This method takes a list of filler words and suggests the user delete each one.

def filler_words(self):
        """Point out filler words and offer to delete them."""
        string = ''
        for sent in self._sentences:
            tokens = self._gen_tokens(sent)
            for i, tok in enumerate(tokens):
                if tok.lower() in filler_words:
                    tokens = self._replace_one_word(tokens, i, [], True)
            string += ''.join(tokens) + ' '
        self.string = string.strip()
        self._clean()

Adverbs

Adverbs are words (usually ending in “ly”) which modify verbs. They are almost always unnecessary. Finding a better (stronger) synonym for the verb will make your writing pop.

This is one of those methods where I was taking a DIY approach. It does catch adverbs! It, unfortunately, catches a lot of other things too (like the perfect tense). I use NLTK’s tags to find adverbs, find the verb they modify, and offer thesaurus suggestions on that verb.

def adverbs(self):
        """Find adverbs and verbs, offer better verbs."""
        string = ''
        for sent in self._sentences:
            tokens = self._gen_tokens(sent)
            words = [w for w in tokens
                     if w != ' ' and w not in punctuation]
            adverbs = [w[0] for w in self._gen_tags(words=words)
                       if w[1].startswith('RB')]
            if len(adverbs) > 0:
                verbs = [w[0] for w in self._gen_tags(words=words)
                         if w[1].startswith('V')]
                for adv in adverbs:
                    adv_i = words.index(adv)
                    v_is = [words.index(v) for v in verbs]
                    v_i = [i for i in v_is
                           if i+1 == adv_i or i-1 == adv_i]
                    if len(v_i) != 1:
                        break
                    v_i = v_i[0]
                    indices = [adv_i, v_i]
                    indices.sort()
                    phrase = ' '.join([words[i] for i in indices])
                    sent = self._replace_phrase(
                        sent, phrase, thesaurus(words[v_i]))
            string += sent + ' '
        self.string = string.strip()

Frequent words

Have you ever read something and realized they used the word “communication” like five times in one paragraph? That’s confusing, slows your reader, and is bad practice. Ideally I’d like to have this method point out not only your most frequently used words, especially those which are in proximity to another. Right now it only pulls the frequency.

def frequent_words(self, n=10):
        """Print a list of the most commonly used words."""
        lemmatizer = nltk.stem.WordNetLemmatizer()
        stopwords = nltk.corpus.stopwords.words('english')
        morphy_tags = [(x, self._penn2morphy(pos)) for x, pos in self._tags]
        lemmas = [
            lemmatizer.lemmatize(x.lower(), pos) for x, pos in morphy_tags
            if pos is not None
            and x not in stopwords
            and x != '\n']
        distr = [(k, v) for k, v in nltk.FreqDist(lemmas).items() if v > 1]
        distr.sort(key=lambda x: x[1], reverse=True)
        for i in distr[:n]:
            perc = i[1] / len(self._words) * 100
            print('{: >14}: {:}, {:}%'.format(i[0], i[1], perc))

For more on stop words, see one of my early posts on this blog.

Visualizing sentence length

We’re almost in the home stretch! We’re almost finished explaining all the code!! This last7second-to-last; it’s the last one which analyzes the text method simply visualizes each sentence by its length. Variation in sentence length is critical. The picture it prints out should be interesting, not a massive rectangle. Ultimately I’d like to opt to edit individual sentences from here; I haven’t coded that bit yet.

def visualize_length(self, char='X'):
        """Produce a visualization of sentence length."""
        for i, sent in enumerate(self._sentences):
            n = len([x for x in sent if x != ' ' and x not in punctuation])
            print('{: >6}'.format('(%s)' % (i+1)), char*n)

Tidying up

The last-last method offers the user an easy way to run through all style methods at once:

def polish(self):
        now_checking_banner('spelling')
        self.spelling()

        now_checking_banner('grammar')
        self.grammar()

        now_checking_banner('homophones')
        self.homophone_check()

        now_checking_banner('clichés')
        self.cliches()

        now_checking_banner('passive voice')
        self.passive_voice()

        now_checking_banner('nominalizations')
        self.nominalizations()

        now_checking_banner('weak words')
        self.weak_words()

        now_checking_banner('filler words')
        self.filler_words()

        now_checking_banner('adverbs')
        self.adverbs()

        now_checking_banner('frequent words')
        self.frequent_words()

        now_checking_banner('variation in sentence length')
        self.visualize_length()

A working example

I started with some crap text:

this is an example of some porely ritten text. it was ritten in a hury. i’d like too fix it up. can you help me? can you find all of the mistakes? i really want to no how to write good more then life itself. I want to insure Ive did my best work in order to feel good. Im going tward my goal to. good writers are my inspiration. They were showed to me by my mother.

And ran it through my little program. It ended with:

This remains an example of drafted text. I rushed while I wrote it. I’d relish in fixing it. Can you assist me? Can you catch the mistakes? I yearn to comprehend how to communicate. I hunger to ensure I’ve wrought my best efforts to feel worthy. I’m progressing toward my goal too. Good writers inspire me. My mother introduced them to me.

As you can see, it definitely polishes the writing. It can’t do anything for substance, though. If you start with horrible substance, this script can’t help you. A gilded turd is still a turd.

Errors and areas for improvement

Places I want to improve I didn’t explicitly mention:

• In the banner text, I want the script to explain what e.g. nominalizations are. That way the script can stand alone and not have folks scratching their head going “why in the world is this suggesting verbs where I clearly have a noun?”
• The

  _clean

    method should strip smart quotes. Curse you, smart quotes!
• Sometimes in e.g. the

  grammar

    method, the script will give you the same prompt twice if A) you decide not to change it and B) have a second grammar error in the sentence. This can lead to infinite loops.
• In the homophone checker, I want real-time working examples of each homophone, to aid in context.
• Add a pronoun-checker; sometimes if you use too many pronouns, it can confuddle the reader. (I don’t personally struggle with this; I haven’t included it yet.)
• The program gobbles newline characters. I hope you like your text in one BIG paragraph.
• The program should save as it goes. Right now one error, bug, or crash and the whole work is toast. (eek!)
• Be able to read from a LaTeX document. Right now I’m doing pretty well with the program opendetex and manual editing. It would be extra cool if I could figure out how to work this into the Python process.

Sub-scripts

Here are all the promised scripts. Please note that they are actually “.txt” files, so if you want to run them yourself please manually change the file extension.
cliches, colors, filler_words, homophone_list, nominalizations, weak_words

The post Programming a grammar and style editor appeared first on RealThinks.

Greetings!

I’ve been working on a super top secret project for several months now and it’s finally been published, so I can share it with you!

My friends, may I introduce to you Explore Stat Mech! It’s a website where you can (interactively) explore concepts directly related to statistical mechanics (and by proxy, my personal research). Go poke around! You can make movies where atoms will collide. You can change parameters around and see how they affect things in real time.

I’m going to be adding more content over the next few months; hopefully we’ll get some cool stuff about real-world applications of these simulations, the Ising Model, and using linear algebra to make everything much more efficient. Tell your friends! This should turn out to be an excellent resource for learning about this fantastic branch of chemistry!

The post Explore Statistical Mechanics: An Interactive Tutorial appeared first on RealThinks.

I’ve doing a series on creating an Othello AI that will not just play Othello with you, but will teach you how to become a better player.

So far I’ve covered:

• The rules of the game, and my motivation for this project
• Exploring basic artificial intelligence
• Reinforcement learning basics

I was planning on doing a lot more with this project, but I’ve found that I’ve really started hating it (hence the severe lack of updates). Rather than continuously put it off and let my blog wither and die, I’m going to dump all of my code and instead pick up a different project.

This is supposed to be a fun thing for me!

Quick Background (and/or Pontificating)

This code is based on my previous work with Othello (see the previous links) and on the great tutorial by Arthur Juliani about Reinforcement Learning with Tensorflow. Arthur’s stuff is great, but I found some of the naming conventions a little hard to understand. I’ve adapted my own names to a system that makes sense for me. I recommend comparing and contrasting the two bits of code to find something that works for you.

A couple of notes before I code-dump:

• The code works insomuch as it will teach the AI to play Othello. It doesn’t, however, teach it to play well. The AI learns that every move is exactly the same value (which is not true). To improve that, I would need to implement some look-ahead in the code, which is about where I gave up on this project. A great example of getting this to work is OmegaOthello by khaotik.
• I have not spent time documenting this code. Normally I’d like a lot more comments, docstrings, or at least explanations of what the crap I’m doing. If you are at all confused about what’s going on, I’ll point you again to Arthur Juliani’s Reinforcement Learning tutorial. Arthur does a fantastic job explaining all of the concepts that I’ve implemented.

More Code than You Ever Needed in a Single Block

import numpy as np
import os
import random
import tensorflow as tf
import tensorflow.contrib.slim as slim

from board import Board  # from part 1 of this series

BATCH_SIZE = 32
UPDATE_FREQ = 4
TAU = 1E-3  # Rate to update target network toward primary network.
Y = 0.99 
LOAD_MODEL = False  # Load a saved model?
PATH = './dqn'  # Path to save model.
BUFFER_SIZE = 5E4  # Num. moves to keep in buffer.
H_SIZE = 64  # Num. filters on final convolution layer.
NUM_GAMES = int(1E4)
SAVE_GAMES = int(1E3)


class QNetwork(object):
    def __init__(self, h_size=H_SIZE):
        self.current_player = 0

        self.scalar_input = tf.placeholder(shape=[None, 64], dtype=tf.int32)
        self._n_scalars = tf.shape(self.scalar_input)[0]
        self.move_mask = tf.placeholder(shape=[None, 64], dtype=tf.float32)

        self.board_onehot = tf.one_hot(self.scalar_input, 3, dtype=tf.float32)
        self._X = tf.split(self.board_onehot, 3, 2)
        self._Y = tf.transpose(
            tf.stack([
                tf.ones([self._n_scalars, 64, 1]),
                self._X[self.current_player],
                self._X[1-self.current_player],
                ])
            )
        self.pre_pad = tf.reshape(self._Y, (-1, 8, 8, 3))
        self._pads = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
        self.board_state = tf.pad(self.pre_pad, self._pads, 'CONSTANT')

        # Convolution layers decreasing board size each step
        self._conv1 = tf.tanh(slim.conv2d(
            inputs=self.board_state, num_outputs=16, kernel_size=[3, 3],
            stride=[1, 1], padding='VALID', biases_initializer=None))
        self._conv2 = tf.tanh(slim.conv2d(
            inputs=self._conv1, num_outputs=32, kernel_size=[2, 2],
            stride=[1, 1], padding='VALID', biases_initializer=None))
        self._conv3 = tf.tanh(slim.conv2d(
            inputs=self._conv2, num_outputs=32, kernel_size=[2, 2],
            stride=[1, 1], padding='VALID', biases_initializer=None))
        self._conv4 = tf.tanh(slim.conv2d(
            inputs=self._conv3, num_outputs=32, kernel_size=[2, 2],
            stride=[1, 1], padding='VALID', biases_initializer=None))
        self._conv5 = tf.tanh(slim.conv2d(
            inputs=self._conv4, num_outputs=32, kernel_size=[2, 2],
            stride=[1, 1], padding='VALID', biases_initializer=None))
        self._conv6 = tf.tanh(slim.conv2d(
            inputs=self._conv5, num_outputs=32, kernel_size=[2, 2],
            stride=[1, 1], padding='VALID', biases_initializer=None))
        self._conv7 = tf.tanh(slim.conv2d(
            inputs=self._conv6, num_outputs=32, kernel_size=[2, 2],
            stride=[1, 1], padding='VALID', biases_initializer=None))
        self._conv8 = slim.flatten(tf.tanh(slim.conv2d(
            inputs=self._conv7, num_outputs=h_size, kernel_size=[2, 2],
            stride=[1, 1], padding='VALID', biases_initializer=None)))

        # Break apart for Dueling DQN
        self._streamA, self._streamV = tf.split(self._conv8, 2, 1)
        xavier_init = tf.contrib.layers.xavier_initializer()
        self.AW = tf.Variable(xavier_init([h_size/2, 64]))
        self.VW = tf.Variable(xavier_init([h_size/2, 1]))
        self.advantage = tf.matmul(self._streamA, self.AW)
        self.value = tf.matmul(self._streamV, self.VW)

        # Combine together to get final Q-values.
        self._Q_all = self.value + tf.subtract(
            self.advantage,
            tf.reduce_mean(self.advantage, axis=1, keep_dims=True))
        self.Q_out = tf.multiply(tf.exp(self._Q_all), self.move_mask)
        self.predict = tf.multinomial(tf.log(self.Q_out), 1)[0][0]

        # Obtain loss function by taking the sum-of-squares difference
        # between the target and prediction Q-values.
        self.Q_target = tf.placeholder(shape=[None], dtype=tf.float32)
        self.actions = tf.placeholder(shape=[None], dtype=tf.int32)
        self._actions_onehot = tf.one_hot(self.actions, 64, dtype=tf.float32)

        self._Q = tf.reduce_sum(tf.multiply(
            self.Q_out, self._actions_onehot), axis=1)
        self._td_error = tf.square(self.Q_target - self._Q)
        self._loss = tf.reduce_mean(self._td_error)
        self._trainer = tf.train.AdamOptimizer(learning_rate=0.0001)
        self.update_model = self._trainer.minimize(self._loss)


class ExperienceBuffer():
    def __init__(self, buffer_size=BUFFER_SIZE):
        self.buffer = []
        self.buffer_size = buffer_size

    def add(self, experience):
        tot_len = len(self.buffer) + len(experience)
        if tot_len >= self.buffer_size:
            self.buffer = self.buffer[int(tot_len - self.buffer_size):]
        self.buffer.extend(experience)

    def sample(self, size):
        return np.reshape(
            np.array(random.sample(self.buffer, size)), [size, 6])


def move_index_to_coord(idx):
    coord_move = np.zeros(64)
    coord_move[idx] = 1
    return tuple(np.argwhere(coord_move.reshape(8, 8))[0])


def update_target_graph(tf_vars, tau=TAU):
    """
    Update parameters of target network.

    target = tau*primary + (1-tau)*target"""
    total_vars = len(tf_vars)
    op_holder = []
    for idx, var in enumerate(tf_vars[:total_vars/2]):
        op_holder.append(tf_vars[idx+total_vars/2].assign(
            (var.value()*tau) + (
                (1 - tau) * tf_vars[idx+total_vars//2].value()
                )))
    return op_holder


def update_target(op_holder, sess):
    for op in op_holder:
        sess.run(op)


tf.reset_default_graph()
main_QN = QNetwork()
Q_targetN = QNetwork()

init = tf.global_variables_initializer()
saver = tf.train.Saver()
target_ops = update_target_graph(tf.trainable_variables())
my_buffer = ExperienceBuffer()

r_list = []  # Final score of each game.
total_steps = 0


# Make a path for our model to be saved in.
if not os.path.exists(PATH):
    os.makedirs(PATH)
    
    
if __name__ == '__main__':
    with tf.Session() as sess:
        sess.run(init)
        if LOAD_MODEL is True:
            print 'Loading Model...'
            ckpt = tf.train.get_checkpoint_state(PATH)
            saver.restore(sess, ckpt.model_checkpoint_path)
        update_target(target_ops, sess)
        for i in range(NUM_GAMES):
            coin_flip = random.randint(0, 1)
            episode_buffer = ExperienceBuffer()
            b = Board(verbose=False)
            s = b.board_state_list[np.newaxis, :]
            r = 0
            while b.game_over is False:
                valid_moves = np.where(
                    [[x.is_valid_move for x in row] for row in b.board_state])
                move_mask = np.zeros_like(b.board_state, dtype='float32')
                move_mask[valid_moves] = 1
                move_mask = move_mask.flatten()[np.newaxis, :]
    
                if b.current_player == coin_flip:
                    # If my move.
                    main_QN.current_player = b.current_player
                    a = sess.run(
                        main_QN.predict,
                        feed_dict={
                           main_QN.scalar_input: s,
                           main_QN.move_mask: move_mask
                           })
                    b.coord_move(move_index_to_coord(a))
                    s1 = b.board_state_list[np.newaxis, :]
                    total_steps += 1
                    episode_buffer.add(
                        np.reshape(
                            np.array([s, a, r, s1, b.game_over, move_mask]),
                            [1, 6]))
    
                    if i > 1 and total_steps % UPDATE_FREQ == 0:
                        # Get a random batch of experiences
                        # Perform Double-DQN update to the target Q-values
                        train_batch = my_buffer.sample(BATCH_SIZE)
                        main_QN.current_player = b.current_player
                        Q_targetN.current_player = b.current_player
                        A1 = sess.run(
                            main_QN.predict,
                            feed_dict={
                                main_QN.scalar_input:
                                    np.vstack(train_batch[:, 3]),
                                main_QN.move_mask:
                                    np.vstack(train_batch[:, 5])})
                        Q2 = sess.run(
                            Q_targetN.Q_out,
                            feed_dict={
                                Q_targetN.scalar_input:
                                    np.vstack(train_batch[:, 3]),
                                Q_targetN.move_mask:
                                    np.vstack(train_batch[:, 5])})
                        doubleQ = Q2[range(BATCH_SIZE), A1]
                        Q_target = train_batch[:, 2] + Y*doubleQ
    
                        # Update the network with our target values.
                        _ = sess.run(
                            main_QN.update_model,
                            feed_dict={
                                main_QN.scalar_input: np.vstack(
                                    train_batch[:, 0]),
                                main_QN.move_mask: np.vstack(
                                    train_batch[:, 5]),
                                main_QN.Q_target: Q_target,
                                main_QN.actions: train_batch[:, 1]})
    
                        # Set target network equal to primary network.
                        update_target(target_ops, sess)
                else:
                    # If opponent's move.
                    Q_targetN.current_player = b.current_player
                    a = sess.run(Q_targetN.predict,
                                 feed_dict={
                                    Q_targetN.scalar_input: s,
                                    Q_targetN.move_mask: move_mask
                                    })
                    b.coord_move(move_index_to_coord(a))
                    s1 = b.board_state_list[np.newaxis, :]
    
                if b.game_over is True:
                    score = [b.p0_score, b.p1_score]
                    my_score = score[coin_flip]
                    their_score = score[1 - coin_flip]
                    if my_score > their_score:
                        r = 1
                    else:
                        r = -1
                s = s1
    
            my_buffer.add(episode_buffer.buffer)
            r_list += [r]
    
            # Periodically save the model.
            if i % SAVE_GAMES == 0:
                saver.save(sess, '%s/model-%s.cptk' % (PATH, i))
                print 'Saved Model'
            if len(r_list) % 10 == 0:
                print i+1, total_steps, np.mean(r_list[-10:])
    
        # Save at completion.
        saver.save(sess, '%s/model-%s.cptk' % (PATH, i))

The post Creating an Othello Tutor: Step 4, Applying a Neural Network appeared first on RealThinks.

The ultimate goal of this endeavor is to create an artificial intelligence that is a strong Othello player, and can teach you how to become stronger yourself.

I explained the rules of Othello, my motivation, and how to create a playable game in Step 1 of this series.

I created some basic artificial intelligence in Step 2 of this series.

The next thing I want to do is to use machine learning to create an even better artificial intelligence, but before I can even do that, I need to learn how to implement reinforcement learning.

Reinforcement learning is different from traditional machine learning

In many machine learning aspects, the cause/effect relationship is fairly obvious: A house with X square feet, Y bedrooms, and Z bathrooms in neighborhood Q will cost, on average N dollars. An abalone with adult characteristics that is M centimeters long and weighs P grams will have, on average, D age rings.

Some settings where we want machine learning have less obvious goals; to say it in another way, those goals might be delayed over time. Games are a prime example: a move now might be beneficial for winning, but you may not know that until much later in play. Reinforcement learning is ideal for these situations: situations where your AI has delayed rewards.

Someone like Q

First we need to introduce the idea of a Q-table. In it’s most simple form, a Q-table is an NxM matrix, where N is the number of states, and M is the number of actions you can take. If you are in the nth state, you look look at row n of your Q-table, and each column entry is your “probability” of choosing the associated action. Without jumping too far ahead of ourselves, we can summarize reinforcement learning as the process by which one generates the most accurate Q-table possible.

Big yellow taxi

Let’s create an example, shall we? I’m going to be using OpenAI Gym, a collection of toy puzzles to start folks on their machine learning journey. I’m rather partial to the taxi game example. From the documentation:

This task was introduced in [Dietterich2000] to illustrate some issues in hierarchical reinforcement learning. There are 4 locations (labeled by different letters) and your job is to pick up the passenger at one location and drop [them] off in another. You receive +20 points for a successful dropoff, and lose 1 point for every timestep it takes. There is also a 10 point penalty for illegal pick-up and drop-off actions.

So let’s initialize some Python, shall we?

import gym
import numpy as np

game = 'Taxi-v2'
env = gym.make(game)
Q = np.zeros([env.observation_space.n, env.action_space.n])

We can see what the game-state looks like with env.render():

We also have a matrix, Q, which is 500x6 because env.observation_space.n (the number of possible states of the system) is 500 and env.action_space.n (the number of actions) is 6 (up, down, left, right, pick up, drop off).

Saved by the Bellman

Now that we have a Q-table, we want it to be something other than all-zeros; we’ll be updating it with a little something called the Bellman Equation:

Which is to say, our table at state and taking action should have a value of its current reward (given to use by the game) and the maximum discounted () future reward that we expect for being in the new state, . You can imagine that if you play through many times, the winning combination will start to trickle through from end to beginning, until you have an accurate Q-table that can predict long-term rewards.

Learning point

What do you think? Do we have to tools to put this all together and create a Q-table?

# Set learning parameters.
lr = 0.85  # Learning rate
gamma = 0.99
num_episodes = 2000  # AKA number of times to play.
# Create lists to contain total rewards and steps per episode.
j_list = []
r_list = []

for i in range(num_episodes):
    # Reset environment and get first new observation.
    s = env.reset()
    r_tot = 0  # Total reward so far
    d = False  # Is the game 'done'?
    j = 0  # We have taken 'j' steps.
    # The Q-Table learning algorithm.
    while j < 99:
        j += 1
        # Choose an action by greedily (with noise) picking from Q table.
        # Note that the noise decreases with num. games played.
        a = np.argmax(Q[s] + np.random.randn(1, env.action_space.n)*(1./(i+1)))
        # Get new state, reward, 'done' from environment.
        s1, r, d, _ = env.step(a)
        # Update Q-Table with new knowledge according to Bellman.
        Q[s, a] += lr*(r + gamma*np.max(Q[s1]) - Q[s, a])
        r_tot += r
        s = s1
        if d is True:
            break
    j_list.append(j)  # Total number of steps
    r_list.append(r_tot)  # Total reward

print 'Score over time: %s' % (np.average(r_list))
print 'Score over last half: %s' % (np.average(r_list[1000:]))

Check it

Well, plotting the number of moves over time shows that the algorithm definitely started taking fewer moves right around iteration 600. That’s also about the time that the cumulative rewards start being positive instead of, I don’t know, -350! I’d say we definitely taught the algorithm to do something! But what!? Let’s watch:

# Reset environment and show a simulation.
# Essentially same code as before, but with no learning
s = env.reset()
env.render()
d = False
while d is False:
    # time.sleep(1)  # Import time.time if you want to slow it down.
    a = np.argmax(Q[s])
    s1, r, d, _ = env.step(a)
    s = s1
    env.render()

Next up: Adding a neural network

So obviously Othello is a lot more complicated than this taxi game. It has a LOT more game states (on the order of .) Next week we’re going to take the taxi example a bit further and use a neural network to generate the Q-table. If this sounds like overkill, it definitely is. But it’s a great step on our learning journey!

Standing on the shoulders of giants

I have to throw out a huge acknowledgement to Arthur Juliani, whose two posts about Q-learning tables and deep Q-learning networks were basically 100% of how I wrote this article. If you find my work at all interesting, you should definitely check out the examples and explanations over there!

The post Creating an Othello Tutor: Step 3, Learning Reinforcement Learning appeared first on RealThinks.

Importing packages

import copy  # Copy objects, don't just point to them.
import numpy as np  # Linear algebra libraries.

import board  # The code I wrote last week.

Start up the class

class AI(object):
    """
    Artificial intelligence for playing Othello.

    Instance variables:
        max_lvl - highest available level of intelligence
        strategy - int in range [0, max_lvl] indicating strategy level
            0 - take random available space
            1 - maximize number of disks taken
            2 - take square with highest available weight
            3 - maximize weights of move + all flipped disks
            4 - minimize opponent's liberties

    Methods:
        move - take a move on the given board state
    """
    _weights = np.array([[ 64, -30,  10,   5,   5,  10, -30,  64],
                         [-30, -40,   2,   2,   2,   2, -40, -30],
                         [ 10,   2,   5,   1,   1,   5,   2,  10],
                         [  5,   2,   1,   1,   1,   1,   2,   5],
                         [  5,   2,   1,   1,   1,   1,   2,   5],
                         [ 10,   2,   5,   1,   1,   5,   2,  10],
                         [-30, -40,   2,   2,   2,   2, -40, -30],
                         [ 64, -30,  10,   5,   5,  10, -30,  64]])
    max_lvl = 4

Not much to see here except documentation. I recommend always putting docstrings on things; it makes it so much easier to read your code! Future you will also thank you: give it a year and I guarantee you won’t remember what x_prime_tilde_2 means. I define a “secret” variable at this level2by putting the underscore out in front of it, the point values or weights of each square in the game. This will be used later for the point-based approach.

Also remember: any code you see after this point is still attached to the AI class as a method, hence the extra indent.

Initialize!

def __init__(self, strategy=-1):
        """
        Initialize AI.

        Optional arguments:
            strategy - a number from -1 to max_lvl; default -1 = random

        Raises:
            ValueError - if invalid strategy passed
        """
        if strategy not in range(-1, self.max_lvl+1):
            raise ValueError('strategy level must be an integer from ' \
                             '-1 to %s' % (self.max_lvl))
        if strategy == -1:
            strategy = np.randint(self.max_lvl+1)

        self.strategy = strategy

Mostly this just sets the strategy level a particular AI object would use, with a default to be random and a check that we’re actually given a valid number.

Level 0: Random Move

def _rand_move(self, possible_moves):
        """Take a random allowed move."""
        weights = np.zeros(len(possible_moves))
        return weights

There are two design choices here I want to comment on:

1. Every method tied to a strategy level I have made hidden/secret/private with an underscore before its name. Any public method is3or should be a promise from the developer that the method will stick around. I wanted my strategy methods to be more behind-the-scenes.
2. I could have had each strategy method return a move choice from the list of possible moves, but I instead decided to have it return a list of probabilities; this serves several functions:
   • I don’t need to re-write the “random choice” code over and over and over again
   • I can initialize other methods with the weights from a previous method.
   • I can future-proof this in case I want to implement multiple “choice” methods: do I always want to take the best move, or do I want to add some stochastic effects to make games a little more interesting?

Level 1: Take the most pieces

def _most_pieces(self, possible_moves):
        """Take the move which flips the largest number of disks."""
        weights = np.array([len(p[1]) for p in possible_moves])
        return weights

Recall that possible_moves comes from the board.Board class. For each entry, the first element is the move, the second element is a list of disks flipped from that move.

Levels 2-3: Use a point system to evaluate board position

def _by_weight(self, possible_moves):
        """Take the square with highest available weight."""
        weights = self._weights[zip(*[x[0] for x in possible_moves])]
        return weights

    def _by_weight_all(self, possible_moves):
        """Maximize weights of the move and all flipped disks."""
        placed_weights = self._by_weight(possible_moves)
        flipped_disks = [p[1] for p in possible_moves]
        flipped_weights = np.array([
            sum([self._weights[f] for f in fs]) for fs in flipped_disks])
        weights = flipped_weights + placed_weights
        return weights

This is just some tomfoolery to do a table-lookup on the _weights variable created earlier.

Level 4: Limit Liberties

def _liberties(self, b):
        """Decrease number of opponent's moves."""
        n_moves_remaining = 64 - (b.p0_score + b.p1_score)
        possible_moves = b.get_valid_moves()
        weights = self._by_weight(possible_moves)
        if n_moves_remaining < 25:
            weights = weights + self._most_pieces(possible_moves)
            scale = 1
        else:
            scale = 2

        for i, move in enumerate(possible_moves):
            newboard = copy.deepcopy(b)
            newboard.verbose = False
            newboard.coord_move(move[0])
            if newboard.current_player == b.current_player:
                continue
            n_opponent_moves = len(np.argwhere([
                [r.is_valid_move for r in row]
                for row in newboard.board_state]))
            weights[i] -= scale*n_opponent_moves
        return weights

As you can see, at each strategy level, I start using some methods from previous levels. It’s not enough here to just limit the number of moves (liberties) an opponent has: we also need to keep from moving to stupid places that would e.g. give the opponent a corner.

This strategy also cares a lot more about what phase of the game it’s in: early or late game. Later in the game we don’t want to minimize our opponent’s moves nearly as much as we want to start creating stable (i.e. unflippable) disks. I’ve implemented this with the scale variable.

At this point, I copy the current board state and calculate the number of moves an opponent has. Two notes:

• It is possible that taking a move means the opponent has 0 moves and it is thus our turn again. The board.Board class takes care of that, so we have to check that it is indeed our opponent’s turn before calculating the number of available moves.
• copy.deepcopy is an important part of this method. The discussion of pointers vs. copies is a bit beyond the scope of this article, but let’s boil it down to this: even if you assign a new variable name, like newboard, updating newboard will update both newboard and b unless one is a copy of the other. For copy vs deepcopy, please read the documentation.

Tying it all together

def _choice(self, weights):
        # Choose from set of best moves (weighted)
        p = np.exp(weights)
        p /= np.sum(p)
        return np.random.choice(range(len(weights)), p=p)

    def move(self, b):
        """
        Take a move on the given board state.

        Arguments:
            b - a board.Board() object

        Returns:
            move - coordinates (x, y) on which to make move
        """
        possible_moves = b.get_valid_moves()
        if self.strategy == 0:
            weights = self._rand_move(possible_moves)
        elif self.strategy == 1:
            weights = self._most_pieces(possible_moves)
        elif self.strategy == 2:
            weights = self._by_weight(possible_moves)
        elif self.strategy == 3:
            weights = self._by_weight_all(possible_moves)
        elif self.strategy == 4:
            weights = self._liberties(b)
        choice = self._choice(weights)
        return possible_moves[choice][0]

There are several ways we could make a choice here: I have chosen to use a weighted random choice, where the probabilities of choosing each move are the exponential of the weights. This means the best move will very very often be the actual move, but that some variability will happen so that games don’t get super stale.

You should play around with different _choice methods yourself! See what you like best!

Comparing strategy levels

If our strategy is worth anything, it should beat strategies “below” it in sophistication. To this end, I pitted each strategy against each other strategy, and here are the results (numbers are win-loss-tie for the first player):

As you can see, the strategies do get better with sophistication, but they’re still not… great. AI level 4 got beaten by level 0 (random moves) 31/200 times. Ideally that number would be 0.

The traditional approach to an Othello intelligence is to implement a search algorithm, e.g. “If I move here, and my opponent moves here and then I move here…” to a depth of 8 or so moves ahead. We could do that, but I’m much more interested in machine learning, and so I’m going to try to tackle this problem with that approach.

First, though, I need to learn how on earth to do that! Tune in next week to learn the basics of Reinforcement Learning.

The post Creating an Othello Tutor: Step 2, Introducing basic AI appeared first on RealThinks.

I am a board game fiend. One of my favorites is called Othello (or sometimes Reversi). Othello takes place on a 8×8 board, with disks that can be either black or white.

The rules are fairly simple, but the strategy is complex. Place a disk of your color on the board such that it flanks at least one of your opponents’ disks. All of your opponent’s flanked disks are flipped to your color. You must move if able. Once no moves remain, the winner is the person with the most disks on the board. If you want to try playing it for yourself, I recommend the Reversi game implemented at mathisfun.com.

I’ve gotten very good at playing my computer at Othello, but my forays into the online world playing against other humans I continually get crushed. I was hoping to find a computer program that could actually teach you how to play better (e.g. “A better move would have been ‘C2’ because it forces your opponent to give you the corner.”) As far as I can find, no such program exists! I have now set out to make it myself.

The basic idea: Using machine learning and TensorFlow, I will teach the computer to play Othello really well so that it can then teach me to play really well.

Outline of the plan

• Step 1: Make a playable game
  • I need to have a board state that can return a list of valid moves.
  • If I make a move, the program should flip all of the captured disks.
  • The program should determine if a player can make no moves and must be skipped.
  • If neither player can move, the program should determine a winner and end.
• Step 2: Make a basic AI that can play the game with me
  • Level 0: Move to a random available square
  • Level 1: Move to the space which flips the most disks
  • Level 2: Assign point values to different squares (e.g. corners are worth the most) and make the move which maximizes board score.
  • Level 3: Take the move which most limits your opponent’s choices.
• Step 3: Learn about Reinforcement Learning so I can actually make a strong artificial intelligence.
• Step 4: Implement the machine learning strategy to make a really good Othello AI.
• Step 5: Create a tutor.
  • The tutor will show you what would have been a better move, and tell you why (if able).
  • The tutor should be able to teach at different levels, with information about each level and what its strengths and weaknesses are
• Step 6?: Create a GUI
  • If I feel like it
  • Make it pretty
  • Mouse input
  • Disk-flipping animations

Today: Creating a playable game

The Square Class

I have implemented, for each square on the board, a container for information about that square. It contains the value of the square- 0, 1, or None. Of note: I have implemented this “variable” as a property— It acts just like a variable, except that when you assign its value, it will automatically update the other two variables: is_valid_move, and flipped_disks.

class Square(object):
    """
    Represents one square of an othello board.

    Instance variables:
        value - If a disk is placed, its value, else None
        is_valid_move - boolean if the current player can play here
        flipped_disks - if the current player plays here,
                        which disks will flip to their color
    """
    def __init__(self, value=None):
        """
        Initialize Square.

        Optional arguments:
            value - current value of square, default None
        """
        self._value = value
        self.is_valid_move = False
        self.flipped_disks = []

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        self._value = value
        self.is_valid_move = False
        self.flipped_disks = []

The Board Class

Everything from here out will be within the Board class, so all of the “functions” that you see will be methods of that class.

Initializing

This should be fairly self-explanatory, but I’ll note a few things. _human_readable_dict is something to translate from integer coordinates to alphabetical coordinates. _computer_readable_dict does the opposite. _print_row is a placeholder for displaying the board (explored later on).

current_player is also a property here, so that if it is manually set, the list of valid moves will automatically be updated. _xstr is a function that I will show in a bit; it’s used to turn row values (0/1/None) into strings, and vectorizing it at initialization makes it so we can pass the whole row at once, rather than square-by-square.

class Board(object):
    """
    8 x 8 game board which can be displayed and interacted with.

    Instance variables:
        board_state - an 8 x 8 numpy array of Square objects
        game_over - boolean: True if the game has ended
        current_player - 0/1: the player whose move it is
        p0_score - number of discs player 0 controls
        p1_score - number of discs player 1 controls
        verbose - boolean: print output on moves

    Methods:
        update_valid_moves - calculate valid moves for the current player
        get_valid_moves - return valid moves and flipped disks
        print_board - display board state in a human-readable format
        translate_move - return a coordinate move, (x, y) in
                         human-readable format
        human_move - given human-readable input (e.g. 'A4'), make move
        coord_move - given tuple (x, y), make move
    """
    _human_readable_dict = dict(enumerate('ABCDEFGH'))
    _computer_readable_dict = dict([(v, k) for k, v in enumerate('ABCDEFGH')])
    _print_row = '%s %s %s %s %s %s %s %s'.encode('utf-8')

    def __init__(self, board_state=None, verbose=True):
        """
        Initialize Board object.

        Optional arguments:
            board_state - an 8 x 8 numpy array of Square objects
                          default: starting board
            verbose - print output; default True
        """
        self._current_player = 0
        self.verbose = verbose
        if board_state is None:
            start = np.array([[Square(1), Square(0)], [Square(0), Square(1)]])
            self.board_state = np.array([
                [Square() for _ in range(8)] for _ in range(8)])
            self.board_state[3:5, 3:5] = start
        else:
            self.board_state = board_state
        self.update_valid_moves()
        self.game_over = False
        self._score()
        self._xstr = np.vectorize(self._xstr)
        if self.verbose is True:
            self.print_board()

    @property
    def current_player(self):
        return self._current_player

    @current_player.setter
    def current_player(self, value):
        if value not in [0, 1]:
            raise ValueError('Player can only be 0 or 1.')
        self._current_player = value
        self.update_valid_moves()

Get valid moves

A function to make the Square values more accessible.

def get_valid_moves(self):
        """
        Return all valid moves and accompanying flipped disks.

        Returns:
            vms - a list of tuples where
                tuple[0] is a valid move and
                tuple[1] is a list of flipped disks
        """
        flipped_disks = np.array([
            [r.flipped_disks for r in row] for row in self.board_state])
        valid_moves = [tuple(r) for r in np.argwhere(flipped_disks)]
        flipped_moves = list(flipped_disks[np.where(flipped_disks)])
        return zip(valid_moves, flipped_moves)

Update valid moves

This is easily the part of the code I struggled with the most. All the other code I found to run Othello programs would search each square with your piece in it, and then find all moves that could be made using that square as the flanking piece. A separate function determined which disks were flipped once a move was made.

That strategy is slow, and can lead to ridiculous happenings like if there’s only one place on the board you can move it could still take a looong time to find it. I also see no reason to find valid moves and flipped disks in separate calls. So, breaking this down into its most basic form: if fed a 1-D array, _valid_moves_in_array will return the indices of each available move and the indices of the resulting flipped disks.

def _valid_moves_in_array(self, array):
        """
        Given a 1-D array, find valid moves and disks flipped.

        Called by update_valid_moves()

        Arguments:
            array - a 1-D numpy array

        Returns:
            valid_moves - list of tuples:
                tuple[0] is index of valid move
                tuple[1] is list of indices of flipped disks
        """
        valid_moves = []
        # If array doesn't have both 0 and 1, there are no valid moves.
        if not ((array == 0).any() and (array == 1).any()):
            return valid_moves
        opponent = 1 - self._current_player
        pos_list = np.where(array == self._current_player)[0]

        for pos in pos_list:
            i = pos - 1
            flipped_disks = []
            if i >= 0 and array[i] == opponent:
                flipped_disks += [i]
                i -= 1
                while i >= 0 and array[i] == opponent:
                    flipped_disks += [i]
                    i -= 1
                if i >= 0 and array[i] is None:
                    valid_moves += [(i, flipped_disks)]

            i = pos + 1
            flipped_disks = []
            if i < len(array) and array[i] == opponent:
                flipped_disks += [i]
                i += 1
                while i < len(array) and array[i] == opponent:
                    flipped_disks += [i]
                    i += 1
                if i < len(array) and array[i] is None:
                    valid_moves += [(i, flipped_disks)]
        return valid_moves

Once we have that, it’s as simple as looking at each row, column, and diagonal:

def update_valid_moves(self):
        """
        Update valid moves for the current player, save to board_state.
        """
        # Reset all cells to 'invalid move'
        for row in self.board_state:
            for cell in row:
                cell.is_valid_move = False
                cell.flipped_disks = []

        # Horizontal
        for i, row in enumerate(self.board_state):
            array = np.array([cell.value for cell in row])
            vms = self._valid_moves_in_array(array)
            for index, flipped in vms:
                flipped_ids = zip([i]*len(flipped), flipped)
                self.board_state[i, index].is_valid_move = True
                self.board_state[i, index].flipped_disks += flipped_ids

        # Vertical
        for i, col in enumerate(self.board_state.T):
            array = np.array([cell.value for cell in col])
            vms = self._valid_moves_in_array(array)
            for index, flipped in vms:
                flipped_ids = zip(flipped, [i]*len(flipped))
                self.board_state[index, i].is_valid_move = True
                self.board_state[index, i].flipped_disks += flipped_ids

        # Diagonal NW--SE
        for i in range(-7, 8):
            array = np.array([
                cell.value for cell in self.board_state.diagonal(i)])
            vms = self._valid_moves_in_array(array)
            for index, flipped in vms:
                flipped_ids = [self._diag_coords(i, f, 'NW') for f in flipped]
                coords = self._diag_coords(i, index, 'NW')
                self.board_state[coords].is_valid_move = True
                self.board_state[coords].flipped_disks += flipped_ids

        # Diagonal NE--SW
        for i in range(-7, 8):
            array = np.array([cell.value for cell in np.diag(
                np.fliplr(self.board_state), i)])
            vms = self._valid_moves_in_array(array)
            for index, flipped in vms:
                flipped_ids = [self._diag_coords(i, f, 'NE') for f in flipped]
                coords = self._diag_coords(i, index, 'NE')
                self.board_state[coords].is_valid_move = True
                self.board_state[coords].flipped_disks += flipped_ids

The very last thing to consider is that there is a bit of shenanigans with diagonal arrays. We need to take the index of the diagonal array and turn that back into 8×8 coordinates. I wrote a function to do just that.

def _diag_coords(self, i, index, NW_NE):
        """
        Translate from diagonal indices to array coordinates.

        Called by update_valid_moves()

        Arguments:
            i - i'th slice of matrix
            index - index of the diagonal array
            NW_NE - can be 'NW' or 'NE'; direction of slice

        Returns:
            row - index of numpy row
            col - index of numpy column

        Exceptions Raised:
            AssertionError - if NW_NE is neither 'NW' nor 'NE'
        """
        assert NW_NE in ['NW', 'NE'], 'NW_NE must be either "NW" or "NE"'
        if i >= 0:
            row = index
        else:
            row = index - i

        if NW_NE == 'NW':
            col = row + i
        else:
            if i > 0:
                col = 7 - index - i
            else:
                col = 7 - index
        return row, col

Printing the board in an intelligible manner

The values in my Squares are 0, 1, or None. I’d like to print them as a little more user-friendly. I’ve chosen the unicode characters u25CF (●), u25CB (○), and u25E6(◦). print_board translates each row into these characters and makes it all nice and easy to read.

def print_board(self):
        """Display board state in a human-readable format."""
        row_num = 1
        for row in self.board_state:
            vals = tuple(self._xstr([cell.value for cell in row]))
            print row_num, self._print_row % vals
            row_num += 1
        print '  A B C D E F G H'

    def _xstr(self, s):
        """For printing human-readable board: convert None to ' '."""
        if s is None:
            return u'\u25E6'  # bullet
        elif s == 0:
            return u'\u25CF'  # filled circle
        elif s == 1:
            return u'\u25CB'  # empty circle
        else:
            raise ValueError('Invalid value for square.')

Taking moves- both as a human and with numpy coordinates

At this point we’re just interacting with all of the framework we’ve already made… almost home free!

def translate_move(self, move):
        """
        Translate coordinate move (x, y) into human-readable format.

        Arguments:
            move - an (x, y) tuple

        Returns:
            a length-2 string e.g. 'A4'
        """
        return self._human_readable_dict[move[1]], move[0]+1

    def human_move(self, s):
        """
        Make move on board.

        Arguments:
            s - Human-readable string of length-2 e.g. 'A4'

        Effects:
            take move
            flip relevent disks
            update current_player
            update valid moves
            print message if player skipped
            check if game has ended; print final score if so
            print board

        Exceptions raised:
            AssertionError - if s is incorrect length
            RuntimeError - if invalid move provided
        """
        assert len(s) == 2, 's must be 2 characters'
        s1, s2 = list(s)
        s1 = self._computer_readable_dict[s1]
        s2 = int(s2) - 1
        self.coord_move((s2, s1))

    def coord_move(self, move):
        """
        Make move on board.

        Called by human_move()

        Arguments:
            move - tuple of array coordinates (x, y)

        Effects:
            take move
            flip relevent disks
            update current_player
            update valid moves
            print message if player skipped
            check if game has ended; print final score if so
            print board

        Exceptions raised:
            RuntimeError - if invalid move provided
        """

        cell = self.board_state[move]
        if cell.is_valid_move is False:
            raise RuntimeError('Invalid move.')
        flipped_disks = cell.flipped_disks

        self.board_state[move].value = self._current_player
        for d in flipped_disks:
            self.board_state[d].value = self._current_player

        self._current_player = 1 - self._current_player
        self.update_valid_moves()
        self._score()
        if self.verbose:
            self.print_board()

Scoring the game and tracking its conclusion

def _score(self):
        """
        Tracks if players have moves and if game has ended

        Called by coord_move()

        Effects:
            update current player scores
            if current player has no valid moves, skip player
            print 'skipped player' message
            update valid moves
            if current player has no valid moves
                set game_over to True
                print 'game over' message
                print final scores
        """
        vals = np.array([[r.value for r in row] for row in self.board_state])
        self.p0_score = len(np.where(vals == 0)[0])
        self.p1_score = len(np.where(vals == 1)[0])
        n_moves = len(self.get_valid_moves())
        if n_moves == 0:
            self._current_player = 1 - self._current_player
            self.update_valid_moves()
            n_moves = len(self.get_valid_moves())
            if n_moves == 0:
                self.game_over = True
                if self.verbose:
                    print 'Game over.'
                    print u'\u25CF : %s\t\u25CB : %s'.encode('utf-8') % (
                        self.p0_score, self.p1_score)

Playing the Game

In [3]: b = Board()
1 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
2 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
3 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
4 ◦ ◦ ◦ ○ ● ◦ ◦ ◦
5 ◦ ◦ ◦ ● ○ ◦ ◦ ◦
6 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
7 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
8 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
  A B C D E F G H

In [4]: b.human_move('E6')
1 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
2 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
3 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
4 ◦ ◦ ◦ ○ ● ◦ ◦ ◦
5 ◦ ◦ ◦ ● ● ◦ ◦ ◦
6 ◦ ◦ ◦ ◦ ● ◦ ◦ ◦
7 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
8 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
  A B C D E F G H

In [5]: b.human_move('F6')
1 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
2 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
3 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
4 ◦ ◦ ◦ ○ ● ◦ ◦ ◦
5 ◦ ◦ ◦ ● ○ ◦ ◦ ◦
6 ◦ ◦ ◦ ◦ ● ○ ◦ ◦
7 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
8 ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦
  A B C D E F G H

That’s all for now!

Tune in next week, for creating an AI that will play the game with us!

The post Creating an Othello Tutor: Step 1, Making a Playable Game appeared first on RealThinks.