Как сделать оценку автомобиля с помощью MLP?

Question

Я хочу сделать классификацию для автомобилей с их квалификацией и их ценами. Я должен сделать это с помощью MLP, но кроме примера XOR нет другого примера. У меня 6 условий, и я поворачиваю их к удвоениям, как [1,0,0,0] для vhigh (условия находятся в наборе uci, который я связал.)

Вот мой код MLP, и я хочу тренировать его с помощью uci dataset 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 входа и один выход (например, [0,1] => [1]), и также это не только пример.

Для вашего вопроса, простой ответ для лечения такой же, как реализации нейронной сети (MLP) для XOR,

Разница заключается в том, что вам нужно 5 вход и 1 выход. (Со ссылкой на свой Uci набор данных)

Вы также можете попробовать эти ссылки:

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

http://neuroph.sourceforge.net/