Evolving the StarCraftII Build Order Meta

from BuildRecommender import BuildRecommender

#parse, save and load build data
builder = BuildRecommender("replay_state_data",'build_orders.json')
#builder.save_all_build_orders()
all_builds = builder.load_all_build_orders()
print("%s replays collected" %(len(all_builds)))
#example build_data
all_builds[0]

25115 replays collected





[['Nexus0',
  'Probe0',
  'Pylon0',
  'Gateway0',
  'Assimilator0',
  'Hatchery1',
  'SpawningPool1',
  'Egg1',
  'Drone1',
  'Extractor1',
  'CyberneticsCore0',
  'Overlord1',
  'Stargate0',
  'Adept0',
  'AdeptPhaseShift0',
  'Zergling1',
  'Oracle0',
  'WarpGate0',
  'Queen1',
  'CreepTumor1',
  'Zealot0',
  'Larva1',
  'SporeCrawler1',
  'Sentry0',
  'TwilightCouncil0',
  'Forge0',
  'MothershipCore0',
  'Phoenix0',
  'RoboticsFacility0',
  'OracleStasisTrap0',
  'Overseer1',
  'TemplarArchive0',
  'Lair1',
  'PhotonCannon0',
  'Observer0',
  'WarpPrism0',
  'InfestationPit1',
  'HydraliskDen1',
  'ChangelingZealot1',
  'HighTemplar0',
  'Immortal0',
  'Hydralisk1',
  'Archon0',
  'WarpPrismPhasing0',
  'Mutalisk1',
  'Stalker0',
  'Baneling1',
  'EvolutionChamber1',
  'Spire1',
  'BanelingCocoon1',
  'BroodLord1',
  'CreepTumorBurrowed1',
  'Broodling1',
  'Corruptor1',
  'BroodLordCocoon1',
  'CreepTumorQueen1'],
 False,
 'Protoss',
 'Zerg',
 'Mech Depot LE',
 '0000e057beefc9b1e9da959ed921b24b9f0a31c63fedb8d94a1db78b58cf92c5.SC2Replay']

import pandas as pd
#load up static state data into dataframe
df = pd.DataFrame([build[1:] for build in all_builds],columns=['Won',"Race","EnemyRace","Map","ReplayID"])
df.sort_values(by=['Race'],inplace=True,ascending=True)
df.head()

%matplotlib inline
from collections import Counter
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
races = set(df['Race'])

hue_order = ['Protoss','Terran','Zerg']
ax = sns.countplot(df['Race'])

ax = sns.barplot(data=df,x='Race',y='Won')

map_counts = df.groupby(by='Map').count()
labels,values = zip(*sorted(map_counts['Won'].items(), key=lambda x:x[1],reverse=True))

ax = sns.barplot(x=labels, y=values)
ax = ax.set_xticklabels(rotation=90,labels = labels)

map_race_counts = df.groupby(by=['Map','Race']).count()
mr_df = map_race_counts['Won'].reset_index()
maps = set(mr_df['Map'])

ax = sns.barplot(data=mr_df,x='Map', y='Won', hue='Race',hue_order=hue_order)
ax.set(xlabel='Map', ylabel='Count')
g = plt.xticks(rotation=45)

map_race_win_counts = df.groupby(by=['Map','Race','Won']).count()
mrw_df = map_race_win_counts.reset_index()
mrw_df['Race_Won'] = mrw_df['Race'].astype(str) + mrw_df['Won'].astype(str)
mrw_df

order = ['ProtossTrue','ProtossFalse', 'TerranTrue','TerranFalse', 'ZergTrue','ZergFalse']
fg = sns.factorplot(x='Race_Won', y='ReplayID', hue='Race', 
                        col='Map', data=mrw_df, kind='bar',
                   col_wrap=3,order=order,hue_order=hue_order)
for ax in fg.axes.flat:
    for label in ax.get_xticklabels():
        label.set_rotation(45)

#grab only the firendly build order, filter out the enemies, keep won flag
all_friendly_builds = [[tuple([unit for unit in build[0] if unit[-1] == '0']),build[1]] for build in all_builds]
all_friendly_builds[0]

[('Nexus0',
  'Probe0',
  'Pylon0',
  'Gateway0',
  'Assimilator0',
  'CyberneticsCore0',
  'Stargate0',
  'Adept0',
  'AdeptPhaseShift0',
  'Oracle0',
  'WarpGate0',
  'Zealot0',
  'Sentry0',
  'TwilightCouncil0',
  'Forge0',
  'MothershipCore0',
  'Phoenix0',
  'RoboticsFacility0',
  'OracleStasisTrap0',
  'TemplarArchive0',
  'PhotonCannon0',
  'Observer0',
  'WarpPrism0',
  'HighTemplar0',
  'Immortal0',
  'Archon0',
  'WarpPrismPhasing0',
  'Stalker0'),
 False]

build_lengths = [len(bld[0]) for bld in all_friendly_builds]
max_build_len = max(build_lengths)
avg_build_len = np.mean(build_lengths)
print("Max build length = %s" %(max_build_len))
print("Average build length = %s" %int(avg_build_len))
g = sns.distplot(build_lengths,bins=50)

Max build length = 51
Average build length = 23

from collections import Counter
def common_builds(all_builds,build_start,len_build,winner=None,n_top=10):
    #build win rate sorted if winner !=None, otherwise just sort by raw counts
    if winner != None:
        winning_rates = []
        #get winning and losing build counts to obtain build win rates
        winning_builds = Counter([build[0][build_start:min(len(build[0]),build_start + len_build +1)]
                  for build in all_builds
                  if build[1] == True])
        losing_builds = Counter([build[0][build_start:min(len(build[0]),build_start + len_build +1)]
                  for build in all_builds
                  if build[1] == False])
        for build in set(winning_builds).union(set(losing_builds)):
            if build in winning_builds:
                wins = winning_builds[build]

            else:
                wins = 0
            if build in losing_builds:
                loses = losing_builds[build]
            else:
                loses = 0
            win_rate = (wins/(wins+loses))
            winning_rates.append([build,win_rate,wins])
            #sort by build count and then win rate
        return sorted(winning_rates,key=lambda x:(x[2],x[1]),reverse=winner)[0:n_top]
    else:
        #sort by build counts only
        builds = Counter([build[0][build_start:min(len(build[0]),build_start + len_build +1)]
                  for build in all_builds])
        return builds.most_common(n_top)

builds = Counter([tuple(build[0]) for build in all_friendly_builds if len(build[0]) == 12])
cmn_builds = builds.most_common(3)
for bld in cmn_builds:
    print(bld)
    print("")

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'Extractor0', 'SpawningPool0', 'Zergling0', 'Queen0', 'BanelingNest0', 'BanelingCocoon0', 'Baneling0'), 120)

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'Extractor0', 'SpawningPool0', 'Zergling0', 'BanelingNest0', 'Queen0', 'BanelingCocoon0', 'Baneling0'), 106)

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'SpawningPool0', 'Extractor0', 'Zergling0', 'Queen0', 'BanelingNest0', 'BanelingCocoon0', 'Baneling0'), 43)

cmn_builds = common_builds(all_friendly_builds,0,max_build_len,n_top=10)
for bld in cmn_builds:
    print(bld)
    print("")

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'Extractor0', 'SpawningPool0', 'Zergling0', 'Queen0', 'BanelingNest0', 'BanelingCocoon0', 'Baneling0'), 120)

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'Extractor0', 'SpawningPool0', 'Zergling0', 'Queen0'), 108)

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'Extractor0', 'SpawningPool0', 'Zergling0', 'BanelingNest0', 'Queen0', 'BanelingCocoon0', 'Baneling0'), 106)

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'SpawningPool0', 'Extractor0', 'Zergling0', 'Queen0', 'BanelingNest0', 'BanelingCocoon0', 'Baneling0'), 43)

(('Nexus0', 'Probe0', 'Pylon0', 'Forge0', 'PhotonCannon0'), 39)

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'Extractor0', 'SpawningPool0', 'BanelingNest0', 'Zergling0', 'Queen0', 'BanelingCocoon0', 'Baneling0'), 31)

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'Extractor0', 'SpawningPool0', 'Zergling0', 'Queen0', 'BanelingNest0'), 29)

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'SpawningPool0', 'Extractor0', 'Zergling0', 'Queen0'), 28)

(('CommandCenter0', 'SCV0', 'SupplyDepot0', 'Refinery0', 'Barracks0'), 28)

(('Nexus0', 'Probe0', 'Pylon0', 'Gateway0', 'Assimilator0'), 27)

cmn_builds = common_builds(all_friendly_builds,0,6,n_top=10)
for bld in cmn_builds:
    print(bld)
    print("")

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'Extractor0', 'SpawningPool0'), 6316)

(('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'SpawningPool0', 'Extractor0'), 1916)

(('Nexus0', 'Probe0', 'Pylon0', 'Gateway0', 'Assimilator0', 'CyberneticsCore0', 'MothershipCore0'), 1030)

(('Nexus0', 'Probe0', 'Pylon0', 'Gateway0', 'Assimilator0', 'CyberneticsCore0', 'Stargate0'), 998)

(('Nexus0', 'Probe0', 'Pylon0', 'Gateway0', 'Assimilator0', 'CyberneticsCore0', 'Zealot0'), 747)

(('CommandCenter0', 'SCV0', 'SupplyDepot0', 'Refinery0', 'Barracks0', 'Factory0', 'OrbitalCommand0'), 699)

(('Nexus0', 'Probe0', 'Pylon0', 'Gateway0', 'Assimilator0', 'CyberneticsCore0', 'Adept0'), 661)

(('CommandCenter0', 'SCV0', 'SupplyDepot0', 'Refinery0', 'Barracks0', 'SupplyDepotLowered0', 'Factory0'), 654)

(('CommandCenter0', 'SCV0', 'SupplyDepot0', 'Refinery0', 'SupplyDepotLowered0', 'Barracks0', 'Factory0'), 547)

(('CommandCenter0', 'SCV0', 'SupplyDepot0', 'Barracks0', 'Refinery0', 'SupplyDepotLowered0', 'OrbitalCommand0'), 509)

cmn_builds = common_builds(all_friendly_builds,0,6,winner=True, n_top=10)
for bld in cmn_builds:
    print(bld)
    print("")

[('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'Extractor0', 'SpawningPool0'), 0.4968334388853705, 3138]

[('Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0', 'SpawningPool0', 'Extractor0'), 0.49739039665970775, 953]

[('Nexus0', 'Probe0', 'Pylon0', 'Gateway0', 'Assimilator0', 'CyberneticsCore0', 'MothershipCore0'), 0.47572815533980584, 490]

[('Nexus0', 'Probe0', 'Pylon0', 'Gateway0', 'Assimilator0', 'CyberneticsCore0', 'Stargate0'), 0.48897795591182364, 488]

[('Nexus0', 'Probe0', 'Pylon0', 'Gateway0', 'Assimilator0', 'CyberneticsCore0', 'Zealot0'), 0.4819277108433735, 360]

[('CommandCenter0', 'SCV0', 'SupplyDepot0', 'Refinery0', 'Barracks0', 'SupplyDepotLowered0', 'Factory0'), 0.5229357798165137, 342]

[('CommandCenter0', 'SCV0', 'SupplyDepot0', 'Refinery0', 'Barracks0', 'Factory0', 'OrbitalCommand0'), 0.48783977110157367, 341]

[('Nexus0', 'Probe0', 'Pylon0', 'Gateway0', 'Assimilator0', 'CyberneticsCore0', 'Adept0'), 0.49319213313161875, 326]

[('CommandCenter0', 'SCV0', 'SupplyDepot0', 'Refinery0', 'SupplyDepotLowered0', 'Barracks0', 'Factory0'), 0.5191956124314442, 284]

[('CommandCenter0', 'SCV0', 'SupplyDepot0', 'Barracks0', 'Refinery0', 'SupplyDepotLowered0', 'OrbitalCommand0'), 0.5363457760314342, 273]

'''Training early stopping error handling snippet'''
# Training
early_stopping_cb = EarlyStoppingCallback(max_val_loss_delta=0.01)
#Need to catch early stopping to return model
try:
    model.fit(self.trainX, self.trainY, validation_set=(self.testX, self.testY), show_metric=False,snapshot_epoch=True,
              batch_size=128,n_epoch=self.epochs,run_id="%s-%s-%s-%s" %(arch,n_units,dropout,learning_rate),
              callbacks=early_stopping_cb)
    return model
except StopIteration:
    return model

class EarlyStoppingCallback(tflearn.callbacks.Callback):
    """
    Early stopping class to exit training when validation loss begins increasing
    """
    def __init__(self, max_val_loss_delta):
        """
        best_val_loss - stores the best epochs validation loss for current val loss compariason
                        to check if increasing. Initizalized at -inf
        max_val_loss_delta - the maximum percent the current val loss can be above the best_val_loss 
                             without exiting training
        """ 
        self.best_val_loss = math.inf
        self.max_val_loss_delta = max_val_loss_delta

    def on_epoch_end(self, training_state):
        """ 
        This is the final method called in trainer.py in the epoch loop. 
        We can stop training and leave without losing any information with a simple exception.
        On epoch end, check if validation loss has increased by more than max_val_loss_delta, if True,
        exit training  
        """
        #check if current loss better than previous best and store
        self.best_val_loss = min(training_state.val_loss,self.best_val_loss)
        if (training_state.val_loss - self.best_val_loss) >= self.best_val_loss*self.max_val_loss_delta:
            print("Terminating training at the end of epoch", training_state.epoch)
            print("Epoch loss = %s vs best loss = %s" %(training_state.val_loss, self.best_val_loss))
            raise StopIteration      

    def on_train_end(self, training_state):
        """
        Furthermore, tflearn will then immediately call this method after we terminate training, 
        (or when training ends regardless). This would be a good time to store any additional 
        information that tflearn doesn't store already.
        """
        print("Successfully left training! Final model loss:", training_state.val_loss)

def train(self, hyperparams):
        #reset graph from previously trained iterations
        tf.reset_default_graph()
        if self.X == []:
            self.make_training_data()

        self.trainX, self.testX, self.trainY, self.testY = self.preprocessing(self.X,self.y)    

        # Hyperparameters
        arch,n_units,dropout,learning_rate = hyperparams

        # Network building
        net = tflearn.input_data([None, self.max_seq_len])
        net = tflearn.embedding(net, input_dim=len(self.vocab), output_dim=128,trainable=True)

        if arch == 0:
            net = tflearn.lstm(net, n_units=n_units,
                               dropout=dropout,
                               weights_init=tflearn.initializations.xavier(),return_seq=False)
        else:
            net = tflearn.gru(net, n_units=n_units,
                              dropout=dropout,
                              weights_init=tflearn.initializations.xavier(),return_seq=False)
        net = tflearn.fully_connected(net, len(self.vocab), activation='softmax',
                                      weights_init=tflearn.initializations.xavier())
        net = tflearn.regression(net, optimizer='adam', learning_rate=learning_rate,
                                 loss='categorical_crossentropy')
        model = tflearn.DNN(net, tensorboard_verbose=2,
                            tensorboard_dir='C:/Users/macle/Desktop/Open Source Projects/autocraft/EDA/tensorboard')       

        # Training
        early_stopping_cb = EarlyStoppingCallback(max_val_loss_delta=0.01)
        #Need to catch early stopping to return model
        try:
            model.fit(self.trainX, self.trainY, validation_set=(self.testX, self.testY), show_metric=False,snapshot_epoch=True,
                      batch_size=128,n_epoch=self.epochs,run_id="%s-%s-%s-%s" %(arch,n_units,dropout,learning_rate),
                      callbacks=early_stopping_cb)
            return model
        except StopIteration:
            return model

#DEAP creator definition needs to be in global scope to parallelize
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
#Individual represented as list of 4 floats 
#(arch,n_units,dropout,learning_rate)
#arch is the cell architecture 0 = lstm, 1 = gru
#floats are later decoded to appropriate sizes
#for each hyperparamter
IND_SIZE=4
creator.create("Individual", list, fitness=creator.FitnessMax)

def evolve(builder,n_pop,co_prob,mut_prob,n_generations):
        '''Evolve the models hyperarameters (arch,n_units,dropout,learning_rate)'''

        toolbox = base.Toolbox()
        #Setup fitness (maximize val_loss)
        toolbox.register("attr_float", random.random)
        toolbox.register("individual", tools.initRepeat, creator.Individual,
                         toolbox.attr_float, n=IND_SIZE)
        toolbox.register("mate", tools.cxTwoPoint)
        toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=0.5, indpb=0.1)
        toolbox.register("select", tools.selTournament, tournsize=3)
        toolbox.register("evaluate", builder.evaluate)
        toolbox.register("population", tools.initRepeat, list, toolbox.individual)

        #assign the number of processors to run parallel fitness evaluations on
        pool = multiprocessing.Pool(16)
        toolbox.register("map", pool.map)

        pop = toolbox.population(n=n_pop)
        best_ind = pop[0]
        best_fit = -math.inf

        # Evaluate the entire population
        fitnesses = list(toolbox.map(toolbox.evaluate, pop))
        for ind, fit in zip(pop, fitnesses):
            print("Evaluating %s" %ind)
            ind.fitness.values = fit

        for g in range(n_generations):
            print("Running generation %s" %(g))
            # Select the next generation individuals
            offspring = toolbox.select(pop, len(pop))
            # Clone the selected individuals
            offspring = list(map(toolbox.clone, offspring))

            # Apply crossover and mutation on the offspring
            for child1, child2 in zip(offspring[::2], offspring[1::2]):
                if random.random() < co_prob:
                    toolbox.mate(child1, child2)
                    del child1.fitness.values
                    del child2.fitness.values

            for mutant in offspring:
                if random.random() < mut_prob:
                    toolbox.mutate(mutant)
                    del mutant.fitness.values

            # Evaluate the individuals with an invalid fitness
            invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
            fitnesses = list(toolbox.map(toolbox.evaluate, pop))
            for ind, fit in zip(invalid_ind, fitnesses):
                ind.fitness.values = fit
                #keep the single best perfoming ind through all gens
                if fit[0] > best_fit:
                    best_ind = ind
                    best_fit = fit[0]

            # The population is entirely replaced by the offspring
            pop[:] = offspring
        return best_ind

builder = BuildRecommender("replay_state_data",'build_orders.json',
                           down_sample=1)
builder.model = builder.train(hyperparams=[1,333,0.65,0.00055])

Training Step: 32009  | total loss: 2.67556 | time: 6093.463s
| Adam | epoch: 005 | loss: 2.67556 -- iter: 819328/819441
Training Step: 32010  | total loss: 2.64712 | time: 6358.537s
| Adam | epoch: 005 | loss: 2.64712 | val_loss: 2.51044 -- iter: 819441/819441
--
Successfully left training! Final model loss: 2.51044451435

model_score = builder.model.evaluate(builder.testX, builder.testY)[0]
model_score

c:\python35\lib\site-packages\dask\core.py:306: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison
  elif type_arg is type(key) and arg == key:





0.35719829542609255

builder.load_graph()
rec_build = builder.predict_build(['Hatchery0', 'Drone0', 'Overlord0', 'Larva0', 'Egg0',
                                   'Extractor0', 'SpawningPool0', 'Zergling0', 'Queen0',
                                   'BanelingNest0', 'BanelingCocoon0'],1,races=['Zerg0','Terran1'])
rec_build

['Baneling0']

builder.predict_build(['CommandCenter0'],6,races=['Terran0','Zerg1'])

['SCV0',
 'SupplyDepot0',
 'Refinery0',
 'Barracks0',
 'SupplyDepotLowered0',
 'Factory0']

builder.predict_build(['Hatchery0'],6,races=['Zerg0','Protoss1'])

['Drone0', 'Overlord0', 'Larva0', 'Egg0', 'Extractor0', 'SpawningPool0']

builder.predict_build(['Nexus0'],6,races=['Protoss0','Zerg1'])

['Probe0', 'Pylon0', 'Gateway0', 'Assimilator0', 'CyberneticsCore0', 'Zealot0']