在Mari / O中保存神经网络池

如何解决在Mari / O中保存神经网络池

因此，我正在尝试使用此AI通过NEAT训练和清除超级马里奥世界的AI。 应用，一切正常，但是我在保存培训结果方面遇到麻烦-游泳池。

我得到了错误

Loading pool from C:\Download\biz\Lua\Snes\neat-mario\pool\DP1.state.pool
NLua.Exceptions.LuaScriptException: [string "main"]:923: 'for' limit must be a number

这似乎是由于保存numGenomes的某些问题而发生的，但我不知道为什么。 代码如下：

config = require "config"
spritelist = require "spritelist"
game = require "game"
mathFunctions = require "mathFunctions"

Inputs = config.InputSize+1
Outputs = #config.ButtonNames

function newInnovation()
    pool.innovation = pool.innovation + 1
    return pool.innovation
end

function newPool()
    local pool = {}
    pool.species = {}
    pool.generation = 0
    pool.innovation = Outputs
    pool.currentSpecies = 1
    pool.currentGenome = 1
    pool.currentFrame = 0
    pool.maxfitness = 0
    
    return pool
end

function newSpecies()
    local species = {}
    species.topfitness = 0
    species.staleness = 0
    species.genomes = {}
    species.averagefitness = 0
    
    return species
end

function newGenome()
    local genome = {}
    genome.genes = {}
    genome.fitness = 0
    genome.adjustedfitness = 0
    genome.network = {}
    genome.maxneuron = 0
    genome.globalRank = 0
    genome.mutationRates = {}
    genome.mutationRates["connections"] = config.NeatConfig.MutateConnectionsChance
    genome.mutationRates["link"] = config.NeatConfig.LinkMutationChance
    genome.mutationRates["bias"] = config.NeatConfig.BiasMutationChance
    genome.mutationRates["node"] = config.NeatConfig.NodeMutationChance
    genome.mutationRates["enable"] = config.NeatConfig.EnableMutationChance
    genome.mutationRates["disable"] = config.NeatConfig.disableMutationChance
    genome.mutationRates["step"] = config.NeatConfig.StepSize
    
    return genome
end

function copyGenome(genome)
    local genome2 = newGenome()
    for g=1,#genome.genes do
        table.insert(genome2.genes,copyGene(genome.genes[g]))
    end
    genome2.maxneuron = genome.maxneuron
    genome2.mutationRates["connections"] = genome.mutationRates["connections"]
    genome2.mutationRates["link"] = genome.mutationRates["link"]
    genome2.mutationRates["bias"] = genome.mutationRates["bias"]
    genome2.mutationRates["node"] = genome.mutationRates["node"]
    genome2.mutationRates["enable"] = genome.mutationRates["enable"]
    genome2.mutationRates["disable"] = genome.mutationRates["disable"]
    
    return genome2
end

function basicGenome()
    local genome = newGenome()
    local innovation = 1

    genome.maxneuron = Inputs
    mutate(genome)
    
    return genome
end

function newGene()
    local gene = {}
    gene.into = 0
    gene.out = 0
    gene.weight = 0.0
    gene.enabled = true
    gene.innovation = 0
    
    return gene
end


function newNeuron()
    local neuron = {}
    neuron.incoming = {}
    neuron.value = 0.0
    --neuron.dw = 1
    return neuron
end

function generateNetwork(genome)
    local network = {}
    network.neurons = {}
    
    for i=1,Inputs do
        network.neurons[i] = newNeuron()
    end
    
    for o=1,Outputs do
        network.neurons[config.NeatConfig.MaxNodes+o] = newNeuron()
    end
    
    table.sort(genome.genes,function (a,b)
        return (a.out < b.out)
    end)
    for i=1,#genome.genes do
        local gene = genome.genes[i]
        if gene.enabled then
            if network.neurons[gene.out] == nil then
                network.neurons[gene.out] = newNeuron()
            end
            local neuron = network.neurons[gene.out]
            table.insert(neuron.incoming,gene)
            if network.neurons[gene.into] == nil then
                network.neurons[gene.into] = newNeuron()
            end
        end
    end
    
    genome.network = network
end

function evaluateNetwork(network,inputs,inputDeltas)
    table.insert(inputs,1)
    table.insert(inputDeltas,99)
    if #inputs ~= Inputs then
        console.writeline("Incorrect number of neural network inputs.")
        return {}
    end
    

    for i=1,Inputs do
        network.neurons[i].value = inputs[i] * inputDeltas[i]
        --network.neurons[i].value = inputs[i]
    end
    
    for _,neuron in pairs(network.neurons) do
        local sum = 0
        for j = 1,#neuron.incoming do
            local incoming = neuron.incoming[j]
            local other = network.neurons[incoming.into]
            sum = sum + incoming.weight * other.value
        end
        
        if #neuron.incoming > 0 then
            neuron.value = mathFunctions.sigmoid(sum)
        end
    end
    
    local outputs = {}
    for o=1,Outputs do
        local button = "P1 " .. config.ButtonNames[o]
        if network.neurons[config.NeatConfig.MaxNodes+o].value > 0 then
            outputs[button] = true
        else
            outputs[button] = false
        end
    end
    
    return outputs
end


    local count = 0
    for _,_ in pairs(neurons) do
        count = count + 1
    end
    local n = math.random(1,count)
    
    for k,v in pairs(neurons) do
        n = n-1
        if n == 0 then
            return k
        end
    end
    
    return 0
end

function containsLink(genes,link)
    for i=1,#genes do
        local gene = genes[i]
        if gene.into == link.into and gene.out == link.out then
            return true
        end
    end
end

function pointMutate(genome)
    local step = genome.mutationRates["step"]
    
    for i=1,#genome.genes do
        local gene = genome.genes[i]
        if math.random() < config.NeatConfig.PerturbChance then
            gene.weight = gene.weight + math.random() * steP*2 - step
        else
            gene.weight = math.random()*4-2
        end
    end
end

function linkMutate(genome,forceBias)
    local neuron1 = randomNeuron(genome.genes,false)
    local neuron2 = randomNeuron(genome.genes,true)
     
    local newLink = newGene()
    if neuron1 <= Inputs and neuron2 <= Inputs then
        --Both input nodes
        return
    end
    if neuron2 <= Inputs then
        -- Swap output and input
        local temp = neuron1
        neuron1 = neuron2
        neuron2 = temp
    end

    newLink.into = neuron1
    newLink.out = neuron2
    if forceBias then
        newLink.into = Inputs
    end
    
    if containsLink(genome.genes,newLink) then
        return
    end
    newLink.innovation = newInnovation()
    newLink.weight = math.random()*4-2
    
    table.insert(genome.genes,newLink)
end

function nodeMutate(genome)
    if #genome.genes == 0 then
        return
    end

    genome.maxneuron = genome.maxneuron + 1

    local gene = genome.genes[math.random(1,#genome.genes)]
    if not gene.enabled then
        return
    end
    gene.enabled = false
    
    local gene1 = copyGene(gene)
    gene1.out = genome.maxneuron
    gene1.weight = 1.0
    gene1.innovation = newInnovation()
    gene1.enabled = true
    table.insert(genome.genes,gene1)
    
    local gene2 = copyGene(gene)
    gene2.into = genome.maxneuron
    gene2.innovation = newInnovation()
    gene2.enabled = true
    table.insert(genome.genes,gene2)
end

function enabledisableMutate(genome,enable)
    local candidates = {}
    for _,gene in pairs(genome.genes) do
        if gene.enabled == not enable then
            table.insert(candidates,gene)
        end
    end
    
    if #candidates == 0 then
        return
    end
    
    local gene = candidates[math.random(1,#candidates)]
    gene.enabled = not gene.enabled
end

function mutate(genome)
    for mutation,rate in pairs(genome.mutationRates) do
        if math.random(1,2) == 1 then
            genome.mutationRates[mutation] = 0.95*rate
        else
            genome.mutationRates[mutation] = 1.05263*rate
        end
    end

    if math.random() < genome.mutationRates["connections"] then
        pointMutate(genome)
    end
    
    local p = genome.mutationRates["link"]
    while p > 0 do
        if math.random() < p then
            linkMutate(genome,false)
        end
        p = p - 1
    end

    p = genome.mutationRates["bias"]
    while p > 0 do
        if math.random() < p then
            linkMutate(genome,true)
        end
        p = p - 1
    end
    
    p = genome.mutationRates["node"]
    while p > 0 do
        if math.random() < p then
            nodeMutate(genome)
        end
        p = p - 1
    end
    
    p = genome.mutationRates["enable"]
    while p > 0 do
        if math.random() < p then
            enabledisableMutate(genome,true)
        end
        p = p - 1
    end

    p = genome.mutationRates["disable"]
    while p > 0 do
        if math.random() < p then
            enabledisableMutate(genome,false)
        end
        p = p - 1
    end
end

function disjoint(genes1,genes2)
    local i1 = {}
    for i = 1,#genes1 do
        local gene = genes1[i]
        i1[gene.innovation] = true
    end

    local i2 = {}
    for i = 1,#genes2 do
        local gene = genes2[i]
        i2[gene.innovation] = true
    end
    
    local disjointGenes = 0
    for i = 1,#genes1 do
        local gene = genes1[i]
        if not i2[gene.innovation] then
            disjointGenes = disjointGenes+1
        end
    end
    
    for i = 1,#genes2 do
        local gene = genes2[i]
        if not i1[gene.innovation] then
            disjointGenes = disjointGenes+1
        end
    end
    
    local n = math.max(#genes1,#genes2)
    
    return disjointGenes / n
end

function weights(genes1,genes2)
    local i2 = {}
    for i = 1,#genes2 do
        local gene = genes2[i]
        i2[gene.innovation] = gene
    end

    local sum = 0
    local coincident = 0
    for i = 1,#genes1 do
        local gene = genes1[i]
        if i2[gene.innovation] ~= nil then
            local gene2 = i2[gene.innovation]
            sum = sum + math.abs(gene.weight - gene2.weight)
            coincident = coincident + 1
        end
    end
    
    return sum / coincident
end
    
function sameSpecies(genome1,genome2)
    local dd = config.NeatConfig.Deltadisjoint*disjoint(genome1.genes,genome2.genes)
    local dw = config.NeatConfig.DeltaWeights*weights(genome1.genes,genome2.genes) 
    return dd + dw < config.NeatConfig.DeltaThreshold
end

function rankGlobally()
    local global = {}
    for s = 1,#pool.species do
        local species = pool.species[s]
        for g = 1,#species.genomes do
            table.insert(global,species.genomes[g])
        end
    end
    table.sort(global,b)
        return (a.fitness < b.fitness)
    end)
    
    for g=1,#global do
        global[g].globalRank = g
    end
end

function calculateAveragefitness(species)
    local total = 0
    
    for g=1,#species.genomes do
        local genome = species.genomes[g]
        total = total + genome.globalRank
    end
    
    species.averagefitness = total / #species.genomes
end

function totalAveragefitness()
    local total = 0
    for s = 1,#pool.species do
        local species = pool.species[s]
        total = total + species.averagefitness
    end

    return total
end

function cullSpecies(cutToOne)
    for s = 1,#pool.species do
        local species = pool.species[s]
        
        table.sort(species.genomes,b)
            return (a.fitness > b.fitness)
        end)
        
        local remaining = math.ceil(#species.genomes/2)
        if cutToOne then
            remaining = 1
        end
        while #species.genomes > remaining do
            table.remove(species.genomes)
        end
    end
end

function breedChild(species)
    local child = {}
    if math.random() < config.NeatConfig.CrossoverChance then
        g1 = species.genomes[math.random(1,#species.genomes)]
        g2 = species.genomes[math.random(1,#species.genomes)]
        child = crossover(g1,g2)
    else
        g = species.genomes[math.random(1,#species.genomes)]
        child = copyGenome(g)
    end
    
    mutate(child)
    
    return child
end

function removeStaleSpecies()
    local survived = {}

    for s = 1,b)
            return (a.fitness > b.fitness)
        end)
        
        if species.genomes[1].fitness > species.topfitness then
            species.topfitness = species.genomes[1].fitness
            species.staleness = 0
        else
            species.staleness = species.staleness + 1
        end
        if species.staleness < config.NeatConfig.StaleSpecies or species.topfitness >= pool.maxfitness then
            table.insert(survived,species)
        end
    end

    pool.species = survived
end

function removeWeakSpecies()
    local survived = {}

    local sum = totalAveragefitness()
    for s = 1,#pool.species do
        local species = pool.species[s]
        breed = math.floor(species.averagefitness / sum * config.NeatConfig.Population)
        if breed >= 1 then
            table.insert(survived,species)
        end
    end

    pool.species = survived
end


function addToSpecies(child)
    local foundSpecies = false
    for s=1,#pool.species do
        local species = pool.species[s]
        if not foundSpecies and sameSpecies(child,species.genomes[1]) then
            table.insert(species.genomes,child)
            foundSpecies = true
        end
    end
    
    if not foundSpecies then
        local childSpecies = newSpecies()
        table.insert(childSpecies.genomes,child)
        table.insert(pool.species,childSpecies)
    end
end

function newGeneration()
    cullSpecies(false) -- Cull the bottom half of each species
    rankGlobally()
    removeStaleSpecies()
    rankGlobally()
    for s = 1,#pool.species do
        local species = pool.species[s]
        calculateAveragefitness(species)
    end
    removeWeakSpecies()
    local sum = totalAveragefitness()
    local children = {}
    for s = 1,#pool.species do
        local species = pool.species[s]
        breed = math.floor(species.averagefitness / sum * config.NeatConfig.Population) - 1
        for i=1,breed do
            table.insert(children,breedChild(species))
        end
    end
    cullSpecies(true) -- Cull all but the top member of each species
    while #children + #pool.species < config.NeatConfig.Population do
        local species = pool.species[math.random(1,#pool.species)]
        table.insert(children,breedChild(species))
    end
    for c=1,#children do
        local child = children[c]
        addToSpecies(child)
    end
    
    pool.generation = pool.generation + 1
    
    --writeFile("backup." .. pool.generation .. "." .. forms.gettext(saveLoadFile))
    writeFile(forms.gettext(saveLoadFile) .. ".gen" .. pool.generation .. ".pool")
end
    
function initializePool()
    pool = newPool()

    for i=1,config.NeatConfig.Population do
        basic = basicGenome()
        addToSpecies(basic)
    end

    initializeRun()
end

function initializeRun()
    savestate.load(config.NeatConfig.Filename);
    if config.StartPowerup ~= NIL then
        game.writePowerup(config.StartPowerup)
    end
    rightmost = 0
    pool.currentFrame = 0
    timeout = config.NeatConfig.TimeoutConstant
    game.clearJoypad()
    startCoins = game.getCoins()
    startscore = game.getscore()
    startLives = game.getLives()
    checkMarioCollision = true
    marioHitCounter = 0
    powerUpCounter = 0
    powerUpBefore = game.getPowerup()
    local species = pool.species[pool.currentSpecies]
    local genome = species.genomes[pool.currentGenome]
    generateNetwork(genome)
    evaluateCurrent()
end

function evaluateCurrent()
    local species = pool.species[pool.currentSpecies]
    local genome = species.genomes[pool.currentGenome]
    
    local inputDeltas = {}
    inputs,inputDeltas = game.getInputs()
    
    controller = evaluateNetwork(genome.network,inputDeltas)
    
    if controller["P1 Left"] and controller["P1 Right"] then
        controller["P1 Left"] = false
        controller["P1 Right"] = false
    end
    if controller["P1 Up"] and controller["P1 Down"] then
        controller["P1 Up"] = false
        controller["P1 Down"] = false
    end

    joypad.set(controller)
end

if pool == nil then
    initializePool()
end


function nextGenome()
    pool.currentGenome = pool.currentGenome + 1
    if pool.currentGenome > #pool.species[pool.currentSpecies].genomes then
        pool.currentGenome = 1
        pool.currentSpecies = pool.currentSpecies+1
        if pool.currentSpecies > #pool.species then
            newGeneration()
            pool.currentSpecies = 1
        end
    end
end

function fitnessAlreadyMeasured()
    local species = pool.species[pool.currentSpecies]
    local genome = species.genomes[pool.currentGenome]
    
    return genome.fitness ~= 0
end

form = forms.newform(500,500,"Mario-Neat")
netPicture = forms.pictureBox(form,5,250,470,200)


--int forms.pictureBox(int formhandle,[int? x = null],[int? y = null],[int? width = null],[int? height = null]) 

function displayGenome(genome)
    forms.clear(netPicture,0x80808080)
    local network = genome.network
    local cells = {}
    local i = 1
    local cell = {}
    for dy=-config.BoxRadius,config.BoxRadius do
        for dx=-config.BoxRadius,config.BoxRadius do
            cell = {}
            cell.x = 50+5*dx
            cell.y = 70+5*dy
            cell.value = network.neurons[i].value
            cells[i] = cell
            i = i + 1
        end
    end
    local biasCell = {}
    biasCell.x = 80
    biasCell.y = 110
    biasCell.value = network.neurons[Inputs].value
    cells[Inputs] = biasCell
    
    for o = 1,Outputs do
        cell = {}
        cell.x = 220
        cell.y = 30 + 8 * o
        cell.value = network.neurons[config.NeatConfig.MaxNodes + o].value
        cells[config.NeatConfig.MaxNodes+o] = cell
        local color
        if cell.value > 0 then
            color = 0xFF0000FF
        else
            color = 0xFF000000
        end
        --gui.drawText(223,24+8*o,config.ButtonNames[o],color,9)
        forms.drawText(netPicture,223,9)
    end
    
    for n,neuron in pairs(network.neurons) do
        cell = {}
        if n > Inputs and n <= config.NeatConfig.MaxNodes then
            cell.x = 140
            cell.y = 40
            cell.value = neuron.value
            cells[n] = cell
        end
    end
    
    for n=1,4 do
        for _,gene in pairs(genome.genes) do
            if gene.enabled then
                local c1 = cells[gene.into]
                local c2 = cells[gene.out]
                if gene.into > Inputs and gene.into <= config.NeatConfig.MaxNodes then
                    c1.x = 0.75*c1.x + 0.25*c2.x
                    if c1.x >= c2.x then
                        c1.x = c1.x - 40
                    end
                    if c1.x < 90 then
                        c1.x = 90
                    end
                    
                    if c1.x > 220 then
                        c1.x = 220
                    end
                    c1.y = 0.75*c1.y + 0.25*c2.y
                    
                end
                if gene.out > Inputs and gene.out <= config.NeatConfig.MaxNodes then
                    c2.x = 0.25*c1.x + 0.75*c2.x
                    if c1.x >= c2.x then
                        c2.x = c2.x + 40
                    end
                    if c2.x < 90 then
                        c2.x = 90
                    end
                    if c2.x > 220 then
                        c2.x = 220
                    end
                    c2.y = 0.25*c1.y + 0.75*c2.y
                end
            end
        end
    end
    
    --gui.drawBox(50-config.BoxRadius*5-3,70-config.BoxRadius*5-3,50+config.BoxRadius*5+2,70+config.BoxRadius*5+2,0xFF000000,0x80808080)
    forms.drawBox(netPicture,50-config.BoxRadius*5-3,0x80808080)
    --oid forms.drawBox(int componenthandle,int x,int y,int x2,int y2,[color? line = null],[color? background = null]) 
    for n,cell in pairs(cells) do
        if n > Inputs or cell.value ~= 0 then
            local color = math.floor((cell.value+1)/2*256)
            if color > 255 then color = 255 end
            if color < 0 then color = 0 end
            local opacity = 0xFF000000
            if cell.value == 0 then
                opacity = 0x50000000
            end
            color = opacity + color*0x10000 + color*0x100 + color
            forms.drawBox(netPicture,cell.x-2,cell.y-2,cell.x+2,cell.y+2,opacity,color)
            --gui.drawBox(cell.x-2,color)
        end
    end
    for _,gene in pairs(genome.genes) do
        if gene.enabled then
            local c1 = cells[gene.into]
            local c2 = cells[gene.out]
            local opacity = 0xA0000000
            if c1.value == 0 then
                opacity = 0x20000000
            end
            
            local color = 0x80-math.floor(math.abs(mathFunctions.sigmoid(gene.weight))*0x80)
            if gene.weight > 0 then 
                color = opacity + 0x8000 + 0x10000*color
            else
                color = opacity + 0x800000 + 0x100*color
            end
            --gui.drawLine(c1.x+1,c1.y,c2.x-3,c2.y,color)
            forms.drawLine(netPicture,c1.x+1,color)
        end
    end
    
    --gui.drawBox(49,71,51,78,0x00000000,0x80FF0000)
    forms.drawBox(netPicture,49,0x80FF0000)
    --if forms.ischecked(showMutationRates) then
        local pos = 100
        for mutation,rate in pairs(genome.mutationRates) do
            --gui.drawText(100,pos,mutation .. ": " .. rate,10)
            forms.drawText(netPicture,100,10)
            --forms.drawText(pictureBox,400,mutation .. ": " .. rate)
            
            --void forms.drawText(int componenthandle,string message,[color? forecolor = null],[color? backcolor = null],[int? fontsize = null],[string fontfamily = null],[string fontstyle = null],[string horizalign = null],[string vertalign = null]) 

            pos = pos + 8
        end
    --end
    forms.refresh(netPicture)
end

function writeFile(filename)
        local file = io.open(filename,"w")
        file:write(pool.generation .. "\n")
        file:write(pool.maxfitness .. "\n")
        file:write(#pool.species .. "\n")
        for n,species in pairs(pool.species) do
                file:write(species.topfitness .. "\n")
                file:write(species.staleness .. "\n")
                file:write(#species.genomes .. "\n")
                for m,genome in pairs(species.genomes) do
                        file:write(genome.fitness .. "\n")
                        file:write(genome.maxneuron .. "\n")
                        for mutation,rate in pairs(genome.mutationRates) do
                                file:write(mutation .. "\n")
                                file:write(rate .. "\n")
                        end
                        file:write("done\n")
                        
                        file:write(#genome.genes .. "\n")
                        for l,gene in pairs(genome.genes) do
                                file:write(gene.into .. " ")
                                file:write(gene.out .. " ")
                                file:write(gene.weight .. " ")
                                file:write(gene.innovation .. " ")
                                if(gene.enabled) then
                                        file:write("1\n")
                                else
                                        file:write("0\n")
                                end
                        end
                end
        end
        file:close()
end

function savePool()
    local filename = forms.gettext(saveLoadFile)
    print(filename)
    writeFile(filename)
end

function mysplit(inputstr,sep)
        if sep == nil then
                sep = "%s"
        end
        local t={} ; i=1
        for str in string.gmatch(inputstr,"([^"..sep.."]+)") do
                t[i] = str
                i = i + 1
        end
        return t
end

function loadFile(filename)
        print("Loading pool from " .. filename)
        local file = io.open(filename,"r")
        pool = newPool()
        pool.generation = file:read("*number")
        pool.maxfitness = file:read("*number")
        forms.settext(MaxLabel,"Max fitness: " .. math.floor(pool.maxfitness))
        local numSpecies = file:read("*number")
        for s=1,numSpecies do
                local species = newSpecies()
                table.insert(pool.species,species)
                species.topfitness = file:read("*number")
                species.staleness = file:read("*number")

• 这里是代码中的错误*

                local numGenomes = file:read("*number")
                for g=1,numGenomes do
                        local genome = newGenome()
                        table.insert(species.genomes,genome)
                        genome.fitness = file:read("*number")
                        genome.maxneuron = file:read("*number")
                        local line = file:read("*line")
                        while line ~= "done" do
  
                                genome.mutationRates[line] = file:read("*number")
                                line = file:read("*line")
                        end
                        local numGenes = file:read("*number")
                        for n=1,numGenes do
  
                                local gene = newGene()
                                local enabled
  
                                local genestr = file:read("*line")
                                local geneArr = mysplit(genestr)
                                gene.into = tonumber(geneArr[1])
                                gene.out = tonumber(geneArr[2])
                                gene.weight = tonumber(geneArr[3])
                                gene.innovation = tonumber(geneArr[4])
                                enabled = tonumber(geneArr[5])
  
  
                                if enabled == 0 then
                                        gene.enabled = false
                                else
                                        gene.enabled = true
                                end
  
                                table.insert(genome.genes,gene)
                        end
                end
        end
        file:close()
  
        while fitnessAlreadyMeasured() do
                nextGenome()
        end
        initializeRun()
        pool.currentFrame = pool.currentFrame + 1
        print("Pool loaded.")
  
  
  end
  
    function flipState()
        if config.Running == true then
            config.Running = false
            forms.settext(startButton,"Start")
        else
            config.Running = true
            forms.settext(startButton,"Stop")
        end
    end
  
    function loadPool()
        filename = forms.openfile("DP1.state.pool",config.PoolDir) 
        --local filename = forms.gettext(saveLoadFile)
        forms.settext(saveLoadFile,filename)
        loadFile(filename)
    end
  
    function playTop()
        local maxfitness = 0
        local maxs,maxg
        for s,species in pairs(pool.species) do
            for g,genome in pairs(species.genomes) do
                if genome.fitness > maxfitness then
                    maxfitness = genome.fitness
                    maxs = s
                    maxg = g
                end
            end
        end
  
        pool.currentSpecies = maxs
        pool.currentGenome = maxg
        pool.maxfitness = maxfitness
        forms.settext(MaxLabel,"Max fitness: " .. math.floor(pool.maxfitness))
        initializeRun()
        pool.currentFrame = pool.currentFrame + 1
        return
    end
  

谢谢！ 由于字符限制，省略了一些无关的部分