ultimatetictactoe.py

@@ -6,7 +6,6 @@ from vacuumDecay import *
 from collections import Counter
 import itertools
 
-
 class TTTState(State):
     def __init__(self, curPlayer=0, generation=0, playersNum=2, board=None, lastMove=-1):
         if type(board) == type(None):
@@ -41,13 +40,13 @@ class TTTState(State):
         return "."
 
     def mutate(self, action):
-        newBoard = self.board[:action.data] + ['O',
+        newBoard = self.board[:action.data] + ['O','X'][self.curPlayer] + self.board[action.data+1:]
-                                               'X'][self.curPlayer] + self.board[action.data+1:]
         return TTTState(curPlayer=(self.curPlayer+1)%self.playersNum, playersNum=self.playersNum, board=newBoard, lastMove=action.data)
 
     def box(self, x, y):
         return index(x, y) // 9
 
+
     def next_box(self, i):
         return i % 9
 
@@ -68,8 +67,7 @@ class TTTState(State):
         box_to_play = self.next_box(self.last_move)
         idxs = self.indices_of_box(box_to_play)
         if self.box_won[box_to_play] != ".":
-            pi_2d = [self.indices_of_box(b) for b in range(
+            pi_2d = [self.indices_of_box(b) for b in range(9) if self.box_won[b] == "."]
-                9) if self.box_won[b] == "."]
             possible_indices = list(itertools.chain.from_iterable(pi_2d))
         else:
             possible_indices = idxs
@@ -132,6 +130,7 @@ class TTTState(State):
         else:
             return  1.0 - 2.0 * self.curPlayer
 
+
     def getTensor(self, player=None, phase='default'):
         if player==None:
             player = self.curPlayer
@@ -145,59 +144,50 @@ class TTTState(State):
     def getModel(cls, phase='default'):
         return Model()
 
-
 class Model(nn.Module):
     def __init__(self):
         super().__init__()
 
-        self.chansPerSmol = 24
-        self.chansPerSlot = 8
-        self.chansComp = 8
-
         self.smol = nn.Sequential(
             nn.Conv2d(
                 in_channels=1,
-                out_channels=self.chansPerSmol,
+                out_channels=16,
                 kernel_size=(3,3),
                 stride=3,
                 padding=0,
             ),
             nn.ReLU()
         )
-        self.comb = nn.Sequential(
+        #self.comb = nn.Sequential(
-            nn.Conv1d(
+        #    nn.Conv1d(
-                in_channels=self.chansPerSmol,
+        #        in_channels=24,
-                out_channels=self.chansPerSlot,
+        #        out_channels=8,
-                kernel_size=1,
+        #        kernel_size=1,
-                stride=1,
+        #        stride=1,
-                padding=0,
+        #        padding=0,
-            ),
+        #    ),
-            nn.ReLU()
+        #    nn.ReLU()
-        )
+        #)
         self.out = nn.Sequential(
-            nn.Linear(self.chansPerSlot*9, self.chansComp),
-            nn.ReLU(),
-            nn.Linear(self.chansComp, 1),
             #nn.Linear(9*8, 32),
             #nn.ReLU(),
             #nn.Linear(32, 8),
             #nn.ReLU(),
-            #nn.Linear(16*9, 12),
+            nn.Linear(16*9, 12),
-            # nn.ReLU(),
+            nn.ReLU(),
-            #nn.Linear(12, 1),
+            nn.Linear(12, 1),
             nn.Sigmoid()
         )
 
     def forward(self, x):
         x = torch.reshape(x, (1,9,9))
         x = self.smol(x)
-        x = torch.reshape(x, (self.chansPerSmol, 9))
+        #x = torch.reshape(x, (24,9))
-        x = self.comb(x)
+        #x = self.comb(x)
         x = torch.reshape(x, (-1,))
         y = self.out(x)
         return y
 
-
 def humanVsAi(train=True, remember=False, depth=3, bots=[0,1], noBg=False):
     init = TTTState()
     run = NeuralRuntime(init)
@@ -209,23 +199,19 @@ def humanVsAi(train=True, remember=False, depth=3, bots=[0, 1], noBg=False):
         trainer.saveToMemoryBank(run.head)
         print('[!] Your cognitive and strategic destinctiveness was added to my own! (Game inserted into memoryBank)')
     if train:
-        print(
+        print("[!] Your knowledge will be assimilated!!! Please stand by.... (Updating Neuristic)")
-            "[!] Your knowledge will be assimilated!!! Please stand by.... (Updating Neuristic)")
         trainer.trainFromTerm(run.head)
     print('[!] I have become smart! Destroyer of human Ultimate-TicTacToe players! (Neuristic update completed)')
     print('[!] This marks the beginning of the end of humankind!')
     print('[i] Thanks for playing! Goodbye...')
 
-
 def aiVsAiLoop():
     init = TTTState()
     trainer = Trainer(init)
     trainer.train()
 
-
 if __name__=='__main__':
-    options = ['Play Against AI',
+    options = ['Play Against AI','Play Against AI (AI begins)','Play Against AI (Fast Play)','Playground','Let AI train']
-               'Play Against AI (AI begins)', 'Play Against AI (Fast Play)', 'Playground', 'Let AI train']
     opt = choose('?', options)
     if opt == options[0]:
         humanVsAi()

vacuumDecay.py

@@ -492,7 +492,7 @@ class Runtime():
         return model, gen
 
     def getModelFileName(self):
-        return 'brains/uttt.vac'
+        return 'brains/utt.vac'
 
     def saveToMemoryBank(self, term):
         return
@@ -605,7 +605,7 @@ class Trainer(Runtime):
         self.killWorker()
         print('')
 
-    def trainModel(self, model, lr=0.000001, cut=0.01, calcDepth=4, exacity=5, terms=None, batch=16):
+    def trainModel(self, model, lr=0.00005, cut=0.01, calcDepth=4, exacity=5, terms=None, batch=16):
         loss_func = nn.MSELoss()
         optimizer = optim.Adam(model.parameters(), lr)
         if terms == None:
@@ -633,7 +633,7 @@ class Trainer(Runtime):
                         zeroLen += 1
                     if zeroLen == 5:
                         break
-            print(loss_sum/i)
+            # print(loss_sum/i)
             if r > 16 and (loss_sum/i < cut or lLoss == loss_sum):
                 return loss_sum
             lLoss = loss_sum