neat pythonは交差検定が実装されていないのですが、実装コードを教えてください。以前  
Scikit-learnで可能とのアドバイスをいただきましたが、Scikit-learnではNEATは実装されていなかったかと思うので、Scikit-
learnを用いての実装についてもご教授いただけると助かります。
CC BY-SA 3.0
2016-02-17T09:00:02.153
22204
2016-11-08T23:59:44.073
14079
question
python
neat pythonで交差検定の実装について
ご質問は一般に交差検定の実装ですか，それともNeat特有の問題ですか?  
scikit-learnでK分割の交差検定をするだけなら

```

    from sklearn import cross_validation
    import numpy
    X = numpy.array([[1,2],[0,4],[4,5],[2,3]]) # feature
    y = numpy.array([0.9,-0.1,1.2,15.3])       # answer
    kf = cross_validation.KFold(len(X), n_folds=2) # 2-validation
    for train_index, test_index in kf:
         X_train, X_test = X[train_index], X[test_index]
         y_train, y_test = y[train_index], y[test_index]
    
```

これでできるはずです．ループの中で学習データ(x_train,y_train)とテストデータ(x_test,y_test)に分割されるので．学習データで学習して，テストデータでスコアを測ればよいです．  
個人的な疑問ですが，Neatで評価するスコアは何ですか? 少しNeat
Pythonのページを見たかんじではテストデータから予測する方法がわからないからです.
CC BY-SA 3.0
2016-02-23T04:06:03.907
22420
2016-02-23T04:06:03.907
14418
22204
answer
もうご覧になっていないかもしれませんが，`neat-python`公式ページの`xor2`を以下のように実装して動いているようです．

```

    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))
    
```
CC BY-SA 3.0
2016-03-07T05:01:25.543
22878
2016-03-07T05:01:25.543
14418
22204
answer