MLP로 자동차를 평가하는 방법은 무엇입니까?

Question

자격과 가격으로 자동차 분류를 만들고 싶습니다. MLP로해야하지만 XOR 예제 외에 다른 예제는 없습니다. 나는 6 가지 조건을 가지고 있으며 그 중 하나를 vhigh와 같이 [1,0,0,0]처럼 두배로 늘리고있다. (조건은 내가 링크 된 집합이다.)

여기에 내 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/