Wie man Auto Bewertung mit MLP machen?

Question

Ich möchte eine Klassifizierung für Autos mit ihren Qualifikationen und ihren Preisen machen. Ich sollte es mit MLP machen, aber außer XOR gibt es kein anderes Beispiel. Ich habe 6 Bedingungen und ich mache sie zu Doppeln wie [1,0,0,0] für vhigh. (Bedingungen sind in der UCI-Set, dass ich verknüpft.)

Hier ist mein MLP-Code und ich möchte trainiere es mit uci datensatz Dataset wie kann ich es für diesen code anpassen?

edit: lassen Sie mich klarer sein, ich sage nicht, es gibt kein anderes Beispiel neben XOR-Problem. Ich meine, dass ich ein Beispiel für einen Eingabesatz brauche, nicht wie [1,0] ich brauche mehr als 2 Eingaben.

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 ist ein einfacher Benchmark für nichtlineare Klassifizierung mit ANN. Es hat 2 Eingänge und einen Ausgang (z. B. [0,1] => [1]), Und es ist nicht nur ein Beispiel.

Für Ihre Frage, einfache Antwort ist die gleiche wie die Umsetzung Neural Network (MLP) für XOR, ist

Der Unterschied zu behandeln, dass Sie 5 Eingang und 1 Ausgang benötigen. (In Bezug auf Ihre uci Datensatz)

Sie können auch versuchen, diese Links:

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

http://neuroph.sourceforge.net/