Ch12 (Neural Network dict): Programming Collective Intel

""" Chapter 12 Programming Collective Intelligence: Neural networks.

    As the chapter has no exercises in it I thought I would get to know the neural network
    a bit better by rewriting it to use saved dictionaries instead of a sql database.
    It works the same way outputting three files:
       "hiddennode.json", "wordhidden.json" and "hiddenurl.json."
    These files are loaded/created on initialization, and updated during training etc.
    I could have probably saved the dictionaries as pickles but I felt like json :)
"""

from math import tanh
import json

def dtanh(y):
    return 1.0-y*y

class searchnet:
    def __init__(self):
        try:
            f = open('hiddennode.json', 'r')
            self.hiddennode={}
            for line in f:
                self.hiddennode = json.loads(line)           # json saves keys as strings so...
            for a in self.hiddennode.keys():
                self.hiddennode[int(a)]=self.hiddennode[a]   # ...for keeping track of hiddenid.
                del self.hiddennode[a]
            f = open('wordhidden.json', 'r')
            self.wordhidden={}
            for line in f:
                self.wordhidden = json.loads(line)
            f = open('hiddenurl.json', 'r')
            self.hiddenurl={}
            for line in f:
                self.hiddenurl = json.loads(line)
        except:
            print "The required dictionaries don't exist in this folder."
            shall=str(raw_input('Shall I create them for you? (y/n) >'))
            if shall=='y' or shall=='Y':
                self.create_dics()
                print"-"*44
                print '"hiddennode.json", "wordhidden.json" and "hiddenurl.json" created.'

    def create_dics(self):
        self.hiddennode={}
        self.wordhidden={}
        self.hiddenurl={}
        f = open('hiddennode.json', 'w')
        f.write(json.dumps(self.hiddennode))
        f.close()
        f = open('wordhidden.json', 'w')
        f.write(json.dumps(self.wordhidden))
        f.close()
        f = open('hiddenurl.json', 'w')
        f.write(json.dumps(self.hiddenurl))
        f.close()

    def save_dics(self):
        f = open('hiddennode.json', 'w')
        f.write(json.dumps(self.hiddennode))
        f.close()
        f = open('wordhidden.json', 'w')
        f.write(json.dumps(self.wordhidden))
        f.close()
        f = open('hiddenurl.json', 'w')
        f.write(json.dumps(self.hiddenurl))
        f.close()

    def getstrength(self,fromid1,toid1,layer):
        fromid=str(fromid1)  # json saves as strings
        toid=str(toid1)
        if layer==0:
            try: res=self.wordhidden[fromid][toid]
            except: res=-0.2
        else:
            try: res=self.hiddenurl[fromid][toid]
            except: res=0
        return float(res)

    def setstrength(self,fromid1,toid1,layer,strength):
        fromid=str(fromid1)  # json saves as strings
        toid=str(toid1)
        if layer==0:
            if str(fromid) in self.wordhidden:
                self.wordhidden[fromid][toid]=strength
            else:
                self.wordhidden[fromid]={}
                self.wordhidden[fromid][toid]=strength
        else:
            if fromid in self.hiddenurl:
                self.hiddenurl[fromid][toid]=strength
            else:
                self.hiddenurl[fromid]={}
                self.hiddenurl[fromid][toid]=strength

    def generatehiddennode(self,wordids,urls):
        if len(wordids)>3: return None
        createkey='_'.join(sorted([str(wi) for wi in wordids]))
        hiddenid=0
        notin=0
        if len(self.hiddennode)==0:
            self.hiddennode[0]=createkey
            notin=1
        else:
            for a in self.hiddennode:
                if self.hiddennode[a]==createkey:
                    hiddenid=a
                    notin=1
        if notin==0:
            hiddenid=int(max(self.hiddennode))+1
            self.hiddennode[hiddenid]=createkey
        for wordid in wordids:
            self.setstrength(wordid,hiddenid,0,1.0/len(wordids))
        for urlid in urls:
            self.setstrength(hiddenid,urlid,1,0.1)
        self.save_dics()

    def getallhiddenids(self,wordids,urlids):
        l1={}
        for wordid in wordids:
            if str(wordid) in self.wordhidden:
                a=self.wordhidden[str(wordid)].keys()
                for row in a: l1[row]=1
        for urlid in urlids:
            for a in self.hiddenurl:
                if str(urlid) in self.hiddenurl[a]:
                    l1[a]=1
        return l1.keys()

    def setupnetwork(self,wordids,urlids):
        # Value lists
        self.wordids=wordids
        self.hiddenids=self.getallhiddenids(wordids,urlids)
        self.urlids=urlids

        # Node outputs         strengths set to default values
        self.ai = [1.0]*len(self.wordids)
        self.ah = [1.0]*len(self.hiddenids)
        self.ao = [1.0]*len(self.urlids)

        # Create weights matrix
        self.wi =[[self.getstrength(wordid,hiddenid,0) for hiddenid in self.hiddenids] for wordid in self.wordids]
        self.wo =[[self.getstrength(hiddenid,urlid,1) for urlid in self.urlids] for hiddenid in self.hiddenids]

    def feedforward(self):
        # the only inputs are the query words
        for i in range(len(self.wordids)):
            self.ai[i] = 1.0

        # hidden activations
        for j in range(len(self.hiddenids)):
            sum = 0.0
            for i in range(len(self.wordids)):
                sum = sum + self.ai[i] * self.wi[i][j]
            self.ah[j] = tanh(sum)

        # output activations
        for k in range(len(self.urlids)):
            sum = 0.0
            for j in range(len(self.hiddenids)):
                sum = sum + self.ah[j] * self.wo[j][k]
            self.ao[k] = tanh(sum)

        return self.ao[:]

    def getresult(self,wordids,urlids):
        self.setupnetwork(wordids,urlids)
        return self.feedforward()

    def backPropagate(self,targets, N=0.5):
        # calculate errors for output
        output_deltas = [0.0]*len(self.urlids)
        for k in range(len(self.urlids)):
            error = targets[k]-self.ao[k]
            output_deltas[k] = dtanh(self.ao[k])*error

        # calculate errors for hidden layer
        hidden_deltas = [0.0]*len(self.hiddenids)
        for j in range(len(self.hiddenids)):
            error = 0.0
            for k in range(len(self.urlids)):
                error = error+output_deltas[k]*self.wo[j][k]
            hidden_deltas[j] = dtanh(self.ah[j])*error

        # update output weights
        for j in range(len(self.hiddenids)):
            for k in range(len(self.urlids)):
                change=output_deltas[k]*self.ah[j]
                self.wo[j][k] = self.wo[j][k] + N*change

        # update input weights
        for i in range(len(self.wordids)):
            for j in range(len(self.hiddenids)):
                change = hidden_deltas[j]*self.ai[i]
                self.wi[i][j] = self.wi[i][j] + N*change

    def trainquery(self,wordids,urlids,selectedurl):
        # generate a hiddennode if neccessary
        self.generatehiddennode(wordids,urlids)

        self.setupnetwork(wordids,urlids)
        self.feedforward()
        targets=[0.0]*len(urlids)
        targets[urlids.index(selectedurl)]=1.0
        error = self.backPropagate(targets)
        self.updatedatabase()

    def updatedatabase(self):
        # set them to database values
        for i in range(len(self.wordids)):
            for j in range(len(self.hiddenids)):
                self.setstrength(self.wordids[i],self.hiddenids[j],0,self.wi[i][j])
        for j in range(len(self.hiddenids)):
            for k in range(len(self.urlids)):
                self.setstrength(self.hiddenids[j],self.urlids[k],1,self.wo[j][k])
        self.save_dics()

"""
Usage: The same as nn.py but without the database references.

import nn_rewrite1 as nn
wWorld,wRiver,wBank,wFrog=101,102,103,104
uWorldBank,uRiver,uEarth=201,202,203

mynet=nn.searchnet()

mynet.generatehiddennode([wWorld,wRiver],[uRiver,uEarth])
mynet.hiddennode
mynet.hiddenurl
mynet.wordhidden

mynet.trainquery([wWorld,wBank],[uWorldBank,uRiver,uEarth],uWorldBank)
mynet.getresult([wWorld,wBank],[uWorldBank,uRiver,uEarth])

allurls=[uWorldBank,uRiver,uEarth]
for i in range(30):
    mynet.trainquery([wWorld,wBank],allurls,uWorldBank)
    mynet.trainquery([wRiver,wBank],allurls,uRiver)
    mynet.trainquery([wWorld],allurls,uEarth)

mynet.getresult([wWorld,wBank],[uWorldBank,uRiver,uEarth])
mynet.getresult([wWorld,wFrog],[uWorldBank,uRiver,uEarth])
"""