验证码识别系统以及人工智能总结神经网络encog图像识别入门

package svm;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

import utility.Tool;

public class InitModelData {    
    public static void main(String[] args) {
         init();
        // check();    

    }

    //训练数据存放
    static String path = "SVM/train.txt";

    private static void check() {
        String context = Tool.inputFile(path);
        System.out.println(context);
    }

    private static void init() {
        File file = new File("train");
        File[] trainList = file.listFiles();
        String identity;
        String content = "";
        for (int i = 0; i ) {
            try {
                if (!trainList[i].isFile()) {
                    continue;
                }
                BufferedImage codeImg = ImageIO.read(trainList[i]);
                identity = trainList[i].getName().split("-")[0];
                content += dataTemplate(identity, codeImg);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        Tool.outputFile(content, path);
        System.out.print(content);
        initModel();
    }
    
    /**
     * 利用训练数据模板生成模型数据
     */
    private static void initModel() {
        /*"-v","20" ,"-c","500", */
        String[] arg = {"-v","20" ,//模型参数设置
                "svm/train.txt", //存放SVM训练模型用的数据的路径
                "svm/model.txt" }; //存放SVM模型数据
        // 创建一个训练对象
        svm_train t = new svm_train();
        try {
            t.main(arg);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } // 调用
    }
    /**
     * svm数据模板
     * @param charString
     * @param codeImg
     * @return
     */
    public static String dataTemplate(String charString, BufferedImage codeImg) {
        String content = "";
        content += charString + " ";
        int width = codeImg.getWidth();
        for (int x = 0; x ) {
            for (int y = 0; y ) {
                int num = x * width + y;
                content += num + ":";
                int isBlack = Tool.isBlack(codeImg.getRGB(x, y)) ? 1 : 0;
                content += isBlack + " ";
            }
        }
        content += "\n";
        return content;
    }

}

    private static String svmProcess(List charImgs) {

        String content = "";
        for (BufferedImage bufferedImage : charImgs) {
            content += InitModelData.dataTemplate("1", bufferedImage);
        }
        System.out.println(content);
        // 输出测试文件
        Tool.outputFile(content, "SVM/test.txt");
        return svmMatch();
    }

    private static String svmMatch() {

        String[] parg = { "SVM/test.txt", // 这个是存放测试数据
                "SVM/model.txt", // 调用的是训练以后的模型
                "SVM/result.txt" }; // 生成的结果的文件的路径
        svm_predict p = new svm_predict();
        try {
            p.main(parg);
        } catch (IOException e) {
            e.printStackTrace();
        } // 调用
        String cOntent= Tool.inputFile("SVM/result.txt");
//        content把小数1.02.0 小数点和小数点后的0消除
        cOntent= content.replaceAll(".\\d", "");
        return content;
    }

import java.awt.Image;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

import javax.imageio.ImageIO;

import org.encog.ml.data.MLData;
import org.encog.ml.data.basic.BasicMLData;
import org.encog.ml.train.strategy.ResetStrategy;
import org.encog.neural.networks.BasicNetwork;
import org.encog.neural.networks.training.propagation.resilient.ResilientPropagation;
import org.encog.persist.EncogDirectoryPersistence;
import org.encog.platformspecific.j2se.TrainingDialog;
import org.encog.platformspecific.j2se.data.image.ImageMLData;
import org.encog.platformspecific.j2se.data.image.ImageMLDataSet;
import org.encog.util.downsample.SimpleIntensityDownsample;
import org.encog.util.simple.EncogUtility;

public class TrainProcess {
    private static ImgList imgList = new ImgList();
    private static ImageMLDataSet trainDataSet;
    private static BasicNetwork network;
    private static int downsampleHeight = 100;
    private static int downsampleWidth = 100;
    // RGB彩色图片
    // RGBDownsample downsample=new RGBDownsample();
    // 采样
    private static SimpleIntensityDownsample downsample = new SimpleIntensityDownsample();
    public static final String FILENAME = "encogexample.eg";

    public static void main(String[] args) {
        inputTrain();
        processNetwork();
        networkConfig();
        trainNetwork();
        System.out.println("Saving network");
        EncogDirectoryPersistence.saveObject(new File(FILENAME), network)
    }

    private static void trainNetwork() {
        // 图形界面
        String mode = "gui";
        // The number of minutes to train for.
        int minutes = 1;
        // the minimum error must achieve
        double strategyError = 0.1;
        // the number of cycles achieve the error rate
        int strategyCycles = 20;
        // Resilient弹性
        final ResilientPropagation train = new ResilientPropagation(network,
                trainDataSet);
        train.addStrategy(new ResetStrategy(strategyError, strategyCycles));
        // strategies
        // Greedy HybridStrategy ResetStrategy
        // SmartLearningRate SmartMomentum
        // StopTrainingStrategy

        // gui界面
        TrainingDialog.trainDialog(network, trainDataSet);

        // 或者 console界面
        // EncogUtility.trainConsole(train, network, training, minutes);
        System.out.println("train end");
    }

    private static void networkConfig() {
        // 第一隐藏层神经元数目
        int hidden1 = 30;
        // 第二隐藏层神经元数目
        int hidden2 = 30;
        // true:use a hyperbolic tangent activation function.
        network = EncogUtility.simpleFeedForward(trainDataSet.getInputSize(),
                hidden1, hidden2, trainDataSet.getIdealSize(), true);
        System.out.println("Created network:" + network.toString());
    }

    /**
     * 用训练数据设置网络
     */
    private static void processNetwork() {
        trainDataSet = new ImageMLDataSet(downsample, false, 1, 0);
        // processNetwork
        for (final ImagePair pair : imgList) {
            try {
                final MLData idealOutputData = returnIdealOutputData(pair);
                Image img = ImageIO.read(pair.getFile());
                final ImageMLData actualInputdata = new ImageMLData(img);
                // The ideal output should be specified when using supervised
                // 1:actual input data 2：ideal output data.
                trainDataSet.add(actualInputdata, idealOutputData);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        trainDataSet.downsample(downsampleHeight, downsampleWidth);
    }

    /**
     * 设置该标识对应输出神经元为1，其余的为0的理想数据(设置情况) ideal output data.
     * 
     * @param pair
     * @return
     */
    private static MLData returnIdealOutputData(final ImagePair pair) {
        // hold the ideal output for each output neuron
        int outputCount = ImgList.outputCount;
        final MLData ideal = new BasicMLData(outputCount);
        int indexOutputNeuron = pair.getIndexOutputNeuron();
        // corresponds to the identity of the image currently being trained
        // will be set to 1
        for (int i = 0; i ) {
            if (i == indexOutputNeuron) {
                ideal.setData(i, 1);
            } else {
                ideal.setData(i, -1);
            }
        }
        return ideal;
    }

    /**
     * 输入训练数据
     */
    private static void inputTrain() {
        File[] trainList = new File("trainData").listFiles();
        for (File file : trainList) {
            if (!file.isFile()) {
                continue;
            }
            String identity = file.getName().split("-")[0];
            imgList.add(file, identity);
            System.out.println(identity);
        }
        outputImgList();
    }

    /**
     * 序列化imgList对象保存
     */
    private static void outputImgList() {
                try {
            ObjectOutputStream outputStream = new ObjectOutputStream(
                    new FileOutputStream("imgList.object"));
            outputStream.writeObject(imgList);
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.File;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class ImgList extends ArrayList implements Serializable {
    public final Map identity2neuron = new HashMap();
    public final Map neuron2identity = new HashMap();
    public static int outputCount = 0;

    public void add(File file, String identity) {
        int indexOutputNeuron = assignIdentity(identity);
        this.add(new ImagePair(file, indexOutputNeuron));
    }

    private int assignIdentity(final String identity) {
        String lowerCase = identity.toLowerCase();
        if (identity2neuron.containsKey(lowerCase)) {
            return identity2neuron.get(lowerCase);
        }
        final int result = outputCount++;
        identity2neuron.put(lowerCase, result);
        neuron2identity.put(result, lowerCase);
        return result;
    }
}

import java.io.File;
import java.io.Serializable;

/**
 * links the image to its output neuron index number.
 * 
 * @author Administrator
 *
 */
public class ImagePair implements Serializable {
    private final File file;
    private final int indexOutputNeuron;

    public ImagePair(File file, int indexOutputNeuron) {
        super();
        this.file = file;
        this.indexOutputNeuron = indexOutputNeuron;
    }

    public File getFile() {
        return file;
    }

    public int getIndexOutputNeuron() {
        return indexOutputNeuron;
    }

}

import java.awt.Image;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

import javax.imageio.ImageIO;

import org.encog.neural.networks.BasicNetwork;
import org.encog.persist.EncogDirectoryPersistence;
import org.encog.platformspecific.j2se.data.image.ImageMLData;
import org.encog.util.downsample.SimpleIntensityDownsample;

public class RecognizeProcess {
    public static final String FILENAME = "encogexample.eg";
    private static int downsampleHeight = 20;
    private static int downsampleWidth = 20;
    private static SimpleIntensityDownsample downsample = new SimpleIntensityDownsample();

    public static void main(String[] args) {
        ImgList imgList = inputImgList();
        BasicNetwork network = (BasicNetwork) EncogDirectoryPersistence
                .loadObject(new File(FILENAME));
        File[] files = new File("recognise").listFiles();
        int num = 0;
        for (File file : files) {
            if (!file.isFile()) {
                continue;
            }
            try {
                Image img = ImageIO.read(file);
                ImageMLData input = new ImageMLData(img);
                input.downsample(downsample, false, downsampleHeight,
                        downsampleWidth, 1, -1);
                final int winner = network.winner(input);
                String name = file.getName().split("[\\.-]")[2];
                String result = imgList.neuron2identity.get(winner);
                System.out.println(name + "   " + result);
                if (name.equals(result)) {
                    num++;
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println(num);
    }

    /**
     * 反序列化imgList对象
     * 
     * @return
     */
    private static ImgList inputImgList() {
        ImgList imgList = null;
        try {
            ObjectInputStream inputStream = new ObjectInputStream(
                    new FileInputStream("imgList.object"));
            imgList = (ImgList) inputStream.readObject();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return imgList;
    }
}