neat pythonで交差検定の実装について


neat pythonは交差検定が実装されていないのですが、実装コードを教えてください。以前  
Scikit-learnで可能とのアドバイスをいただきましたが、Scikit-learnではNEATは実装されていなかったかと思うので、Scikit-
learnを用いての実装についてもご教授いただけると助かります。




もうご覧になっていないかもしれませんが，`neat-python`公式ページの`xor2`を以下のように実装して動いているようです．

[code]

    from neat import nn, population
    import numpy as np
    from sklearn.base import BaseEstimator, ClassifierMixin
    from sklearn.cross_validation import cross_val_score
    
    class neatXorClassifier(BaseEstimator, ClassifierMixin):
        def __init__(self):
            self.pop = population.Population('xor2_config')
    
        @staticmethod
        def eval_fitness(genomes):
            for g in genomes:
                net = nn.create_feed_forward_phenotype(g)
                sum_square_error = 0.0
                for inputs, expected in zip(xor_inputs, xor_outputs):
                    # Serial activation propagates the inputs through the entire network.                                                                                                                                                                                                                                      
                    output = net.serial_activate(inputs)
                    sum_square_error += (output[0] - expected) ** 2
                    # When the output matches expected for all inputs, fitness will reach                                                                                                                                                                                                                                      
                    # its maximum value of 1.0.                                                                                                                                                                                                                                                                                
                    g.fitness = 1 - sum_square_error
    
        def fit(self, X, y):
            self.pop.run(self.eval_fitness, 300)
    
        def predict(self, X):
            winner = self.pop.statistics.best_genome()
            winner_net = nn.create_feed_forward_phenotype(winner)
            output = []
            for inputs in X:
                output.append(round(winner_net.serial_activate(inputs)[0]))
            return output
    
    #    def score(self, X, y):                                                                                                                                                                                                                                                                                                
    #        if len(X) == 0:                                                                                                                                                                                                                                                                                                   
    #            return 1                                                                                                                                                                                                                                                                                                      
    #        pred = self.predict(X)                                                                                                                                                                                                                                                                                            
    #        return len(list(filter(lambda x:x[0]==x[1],zip(pred,y))))/len(pred)                                                                                                                                                                                                                                               
    
    if __name__=='__main__':
        xor_inputs = [[0, 0], [0, 1], [1, 0], [1, 1]]
        xor_outputs = [0, 1, 1, 0]
    
        nxc = neatXorClassifier()
        print(cross_val_score(nxc, xor_inputs, y=xor_outputs, cv=2))
    
[/code]

