MLPで車を評価する方法は？

Question

私は資格と価格で車の分類をしたいと思います。私はMLPでそれを行うべきですが、XORの例以外に他の例はありません。私は6つの条件があり、それらをvhighの[1,0,0,0]のように倍にしています（条件はUICIのリンクにあります）。

ここに私のMLPコードがあります。 uciデータセットでトレーニングするDatasetこのコードにどのように適応させることができますか？

編集：私はXORの問題以外の他の例はないと言っているわけではありません。私は入力セットの例が必要であることを意味します。[1,0]のようにではなく、2つ以上の入力が必要です。

import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 



public class MultiLayerPerceptron implements Cloneable 
{ 
protected double   fLearningRate = 0.6; 
protected Layer[]   fLayers; 
protected TransferFunction fTransferFunction; 


public MultiLayerPerceptron(int[] layers, double learningRate, TransferFunction fun) 
{ 
    fLearningRate = learningRate; 
    fTransferFunction = fun; 

    fLayers = new Layer[layers.length]; 

    for(int i = 0; i < layers.length; i++) 
    {   
     if(i != 0) 
     { 
      fLayers[i] = new Layer(layers[i], layers[i - 1]); 
     } 
     else 
     { 
      fLayers[i] = new Layer(layers[i], 0); 
     } 
    } 
} 



public double[] execute(double[] input) 
{ 
    int i; 
    int j; 
    int k; 
    double new_value; 

    double output[] = new double[fLayers[fLayers.length - 1].Length]; 

    // Put input 
    for(i = 0; i < fLayers[0].Length; i++) 
    { 
     fLayers[0].Neurons[i].Value = input[i]; 
    } 

    // Execute - hiddens + output 
    for(k = 1; k < fLayers.length; k++) 
    { 
     for(i = 0; i < fLayers[k].Length; i++) 
     { 
      new_value = 0.0; 
      for(j = 0; j < fLayers[k - 1].Length; j++) 
       new_value += fLayers[k].Neurons[i].Weights[j] * fLayers[k - 1].Neurons[j].Value; 

      new_value += fLayers[k].Neurons[i].Bias; 

      fLayers[k].Neurons[i].Value = fTransferFunction.evalute(new_value); 
     } 
    } 


    // Get output 
    for(i = 0; i < fLayers[fLayers.length - 1].Length; i++) 
    { 
     output[i] = fLayers[fLayers.length - 1].Neurons[i].Value; 
    } 

    return output; 
} 




public double backPropagateMultiThread(double[] input, double[] output, int nthread) 
{ 
    return 0.0; 
} 




public double backPropagate(double[] input, double[] output) 
{ 
    double new_output[] = execute(input); 
    double error; 
    int i; 
    int j; 
    int k; 

    /* doutput = correct output (output) */ 

    for(i = 0; i < fLayers[fLayers.length - 1].Length; i++) 
    { 
     error = output[i] - new_output[i]; 
     fLayers[fLayers.length - 1].Neurons[i].Delta = error * fTransferFunction.evaluteDerivate(new_output[i]); 
    } 


    for(k = fLayers.length - 2; k >= 0; k--) 
    { 
     //delta 
     for(i = 0; i < fLayers[k].Length; i++) 
     { 
      error = 0.0; 
      for(j = 0; j < fLayers[k + 1].Length; j++) 
       error += fLayers[k + 1].Neurons[j].Delta * fLayers[k + 1].Neurons[j].Weights[i]; 

      fLayers[k].Neurons[i].Delta = error * fTransferFunction.evaluteDerivate(fLayers[k].Neurons[i].Value);    
     } 

     // success 
     for(i = 0; i < fLayers[k + 1].Length; i++) 
     { 
      for(j = 0; j < fLayers[k].Length; j++) 
       fLayers[k + 1].Neurons[i].Weights[j] += fLearningRate * fLayers[k + 1].Neurons[i].Delta * 
         fLayers[k].Neurons[j].Value; 
      fLayers[k + 1].Neurons[i].Bias += fLearningRate * fLayers[k + 1].Neurons[i].Delta; 
     } 
    } 

    // error 
    error = 0.0; 

    for(i = 0; i < output.length; i++) 
    { 
     error += Math.abs(new_output[i] - output[i]); 

     //System.out.println(output[i]+" "+new_output[i]); 
    } 

    error = error/output.length; 
    return error; 
} 

public boolean save(String path) 
{ 
    try 
    { 
     FileOutputStream fout = new FileOutputStream(path); 
     ObjectOutputStream oos = new ObjectOutputStream(fout); 
     oos.writeObject(this); 
     oos.close(); 
    } 
    catch (Exception e) 
    { 
     return false; 
    } 

    return true; 
} 



public static MultiLayerPerceptron load(String path) 
{ 
    try 
    { 
     MultiLayerPerceptron net; 

     FileInputStream fin = new FileInputStream(path); 
     ObjectInputStream oos = new ObjectInputStream(fin); 
     net = (MultiLayerPerceptron) oos.readObject(); 
     oos.close(); 

     return net; 
    } 
    catch (Exception e) 
    { 
     return null; 
    } 
} 


public double getLearningRate() 
{ 
    return fLearningRate; 
} 

public void setLearningRate(double rate) 
{ 
    fLearningRate = rate; 
} 


public void setTransferFunction(TransferFunction fun) 
{ 
    fTransferFunction = fun; 
} 



public int getInputLayerSize() 
{ 
    return fLayers[0].Length; 
} 


public int getOutputLayerSize() 
{ 
    return fLayers[fLayers.length - 1].Length; 
} 
} 

Answer 1

XORはANNを使用した非線形分類の簡単なベンチマークです。 2つの入力と1つの出力（例：[0,1] => [1]）を持ち、それだけではありません。あなたの質問のために

は、簡単な答えは

違いは、5入力1出力を必要とすることで、XORのためのニューラルネットワーク（MLP）を実装するなどと同じ扱いです。（あなたのUCIデータセットを参照）

また、これらのリンクを試してみることができます。

http://scikit-learn.org/dev/modules/neural_networks_supervised.html

http://neuroph.sourceforge.net/