开放式简历人脸识别不准确


13

在我的应用程序中,我尝试使用Open CV在特定图像上进行人脸识别,这里我首先训练一个图像,然后在训练该图像后,如果我在该图像上进行人脸识别,则它成功地识别出该训练过的人脸。但是,当我转向同一个人的另一张照片时,识别不起作用。它仅适用于经过训练的图像,所以我的问题是如何纠正它?

更新:我要做的是用户应该从存储中选择一个人的图像,然后在训练了所选图像之后,我想从存储中获取与我训练过的图像相匹配的所有图像。

这是我的活动课:

public class MainActivity extends AppCompatActivity {
    private Mat rgba,gray;
    private CascadeClassifier classifier;
    private MatOfRect faces;
    private ArrayList<Mat> images;
    private ArrayList<String> imagesLabels;
    private Storage local;
    ImageView mimage;
    Button prev,next;
    ArrayList<Integer> imgs;
    private int label[] = new int[1];
    private double predict[] = new double[1];
    Integer pos = 0;
    private String[] uniqueLabels;
    FaceRecognizer recognize;
    private boolean trainfaces() {
        if(images.isEmpty())
            return false;
        List<Mat> imagesMatrix = new ArrayList<>();
        for (int i = 0; i < images.size(); i++)
            imagesMatrix.add(images.get(i));
        Set<String> uniqueLabelsSet = new HashSet<>(imagesLabels); // Get all unique labels
        uniqueLabels = uniqueLabelsSet.toArray(new String[uniqueLabelsSet.size()]); // Convert to String array, so we can read the values from the indices

        int[] classesNumbers = new int[uniqueLabels.length];
        for (int i = 0; i < classesNumbers.length; i++)
            classesNumbers[i] = i + 1; // Create incrementing list for each unique label starting at 1
        int[] classes = new int[imagesLabels.size()];
        for (int i = 0; i < imagesLabels.size(); i++) {
            String label = imagesLabels.get(i);
            for (int j = 0; j < uniqueLabels.length; j++) {
                if (label.equals(uniqueLabels[j])) {
                    classes[i] = classesNumbers[j]; // Insert corresponding number
                    break;
                }
            }
        }
        Mat vectorClasses = new Mat(classes.length, 1, CvType.CV_32SC1); // CV_32S == int
        vectorClasses.put(0, 0, classes); // Copy int array into a vector

        recognize = LBPHFaceRecognizer.create(3,8,8,8,200);
        recognize.train(imagesMatrix, vectorClasses);
        if(SaveImage())
            return true;

        return false;
    }
    public void cropedImages(Mat mat) {
        Rect rect_Crop=null;
        for(Rect face: faces.toArray()) {
            rect_Crop = new Rect(face.x, face.y, face.width, face.height);
        }
        Mat croped = new Mat(mat, rect_Crop);
        images.add(croped);
    }
    public boolean SaveImage() {
        File path = new File(Environment.getExternalStorageDirectory(), "TrainedData");
        path.mkdirs();
        String filename = "lbph_trained_data.xml";
        File file = new File(path, filename);
        recognize.save(file.toString());
        if(file.exists())
            return true;
        return false;
    }

    private BaseLoaderCallback callbackLoader = new BaseLoaderCallback(this) {
        @Override
        public void onManagerConnected(int status) {
            switch(status) {
                case BaseLoaderCallback.SUCCESS:
                    faces = new MatOfRect();

                    //reset
                    images = new ArrayList<Mat>();
                    imagesLabels = new ArrayList<String>();
                    local.putListMat("images", images);
                    local.putListString("imagesLabels", imagesLabels);

                    images = local.getListMat("images");
                    imagesLabels = local.getListString("imagesLabels");

                    break;
                default:
                    super.onManagerConnected(status);
                    break;
            }
        }
    };

    @Override
    protected void onResume() {
        super.onResume();
        if(OpenCVLoader.initDebug()) {
            Log.i("hmm", "System Library Loaded Successfully");
            callbackLoader.onManagerConnected(BaseLoaderCallback.SUCCESS);
        } else {
            Log.i("hmm", "Unable To Load System Library");
            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION, this, callbackLoader);
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        prev = findViewById(R.id.btprev);
        next = findViewById(R.id.btnext);
        mimage = findViewById(R.id.mimage);
       local = new Storage(this);
       imgs = new ArrayList();
       imgs.add(R.drawable.jonc);
       imgs.add(R.drawable.jonc2);
       imgs.add(R.drawable.randy1);
       imgs.add(R.drawable.randy2);
       imgs.add(R.drawable.imgone);
       imgs.add(R.drawable.imagetwo);
       mimage.setBackgroundResource(imgs.get(pos));
        prev.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if(pos!=0){
                  pos--;
                  mimage.setBackgroundResource(imgs.get(pos));
                }
            }
        });
        next.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if(pos<5){
                    pos++;
                    mimage.setBackgroundResource(imgs.get(pos));
                }
            }
        });
        Button train = (Button)findViewById(R.id.btn_train);
        train.setOnClickListener(new View.OnClickListener() {
            @RequiresApi(api = Build.VERSION_CODES.KITKAT)
            @Override
            public void onClick(View view) {
                rgba = new Mat();
                gray = new Mat();
                Mat mGrayTmp = new Mat();
                Mat mRgbaTmp = new Mat();
                classifier = FileUtils.loadXMLS(MainActivity.this);
                Bitmap icon = BitmapFactory.decodeResource(getResources(),
                        imgs.get(pos));
                Bitmap bmp32 = icon.copy(Bitmap.Config.ARGB_8888, true);
                Utils.bitmapToMat(bmp32, mGrayTmp);
                Utils.bitmapToMat(bmp32, mRgbaTmp);
                Imgproc.cvtColor(mGrayTmp, mGrayTmp, Imgproc.COLOR_BGR2GRAY);
                Imgproc.cvtColor(mRgbaTmp, mRgbaTmp, Imgproc.COLOR_BGRA2RGBA);
                /*Core.transpose(mGrayTmp, mGrayTmp); // Rotate image
                Core.flip(mGrayTmp, mGrayTmp, -1); // Flip along both*/
                gray = mGrayTmp;
                rgba = mRgbaTmp;
                Imgproc.resize(gray, gray, new Size(200,200.0f/ ((float)gray.width()/ (float)gray.height())));
                if(gray.total() == 0)
                    Toast.makeText(getApplicationContext(), "Can't Detect Faces", Toast.LENGTH_SHORT).show();
                classifier.detectMultiScale(gray,faces,1.1,3,0|CASCADE_SCALE_IMAGE, new Size(30,30));
                if(!faces.empty()) {
                    if(faces.toArray().length > 1)
                        Toast.makeText(getApplicationContext(), "Mutliple Faces Are not allowed", Toast.LENGTH_SHORT).show();
                    else {
                        if(gray.total() == 0) {
                            Log.i("hmm", "Empty gray image");
                            return;
                        }
                        cropedImages(gray);
                        imagesLabels.add("Baby");
                        Toast.makeText(getApplicationContext(), "Picture Set As Baby", Toast.LENGTH_LONG).show();
                        if (images != null && imagesLabels != null) {
                            local.putListMat("images", images);
                            local.putListString("imagesLabels", imagesLabels);
                            Log.i("hmm", "Images have been saved");
                            if(trainfaces()) {
                                images.clear();
                                imagesLabels.clear();
                            }
                        }
                    }
                }else {
                   /* Bitmap bmp = null;
                    Mat tmp = new Mat(250, 250, CvType.CV_8U, new Scalar(4));
                    try {
                        //Imgproc.cvtColor(seedsImage, tmp, Imgproc.COLOR_RGB2BGRA);
                        Imgproc.cvtColor(gray, tmp, Imgproc.COLOR_GRAY2RGBA, 4);
                        bmp = Bitmap.createBitmap(tmp.cols(), tmp.rows(), Bitmap.Config.ARGB_8888);
                        Utils.matToBitmap(tmp, bmp);
                    } catch (CvException e) {
                        Log.d("Exception", e.getMessage());
                    }*/
                    /*    mimage.setImageBitmap(bmp);*/
                    Toast.makeText(getApplicationContext(), "Unknown Face", Toast.LENGTH_SHORT).show();
                }
            }
        });
        Button recognize = (Button)findViewById(R.id.btn_recognize);
        recognize.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if(loadData())
                    Log.i("hmm", "Trained data loaded successfully");
                rgba = new Mat();
                gray = new Mat();
                faces = new MatOfRect();
                Mat mGrayTmp = new Mat();
                Mat mRgbaTmp = new Mat();
                classifier = FileUtils.loadXMLS(MainActivity.this);
                Bitmap icon = BitmapFactory.decodeResource(getResources(),
                        imgs.get(pos));
                Bitmap bmp32 = icon.copy(Bitmap.Config.ARGB_8888, true);
                Utils.bitmapToMat(bmp32, mGrayTmp);
                Utils.bitmapToMat(bmp32, mRgbaTmp);
                Imgproc.cvtColor(mGrayTmp, mGrayTmp, Imgproc.COLOR_BGR2GRAY);
                Imgproc.cvtColor(mRgbaTmp, mRgbaTmp, Imgproc.COLOR_BGRA2RGBA);
                /*Core.transpose(mGrayTmp, mGrayTmp); // Rotate image
                Core.flip(mGrayTmp, mGrayTmp, -1); // Flip along both*/
                gray = mGrayTmp;
                rgba = mRgbaTmp;
                Imgproc.resize(gray, gray, new Size(200,200.0f/ ((float)gray.width()/ (float)gray.height())));
                if(gray.total() == 0)
                    Toast.makeText(getApplicationContext(), "Can't Detect Faces", Toast.LENGTH_SHORT).show();
                classifier.detectMultiScale(gray,faces,1.1,3,0|CASCADE_SCALE_IMAGE, new Size(30,30));
                if(!faces.empty()) {
                    if(faces.toArray().length > 1)
                        Toast.makeText(getApplicationContext(), "Mutliple Faces Are not allowed", Toast.LENGTH_SHORT).show();
                    else {
                        if(gray.total() == 0) {
                            Log.i("hmm", "Empty gray image");
                            return;
                        }
                        recognizeImage(gray);
                    }
                }else {
                    Toast.makeText(getApplicationContext(), "Unknown Face", Toast.LENGTH_SHORT).show();
                }
            }
        });


    }
    private void recognizeImage(Mat mat) {
        Rect rect_Crop=null;
        for(Rect face: faces.toArray()) {
            rect_Crop = new Rect(face.x, face.y, face.width, face.height);
        }
        Mat croped = new Mat(mat, rect_Crop);
        recognize.predict(croped, label, predict);
        int indice = (int)predict[0];
        Log.i("hmmcheck:",String.valueOf(label[0])+" : "+String.valueOf(indice));
        if(label[0] != -1 && indice < 125)
            Toast.makeText(getApplicationContext(), "Welcome "+uniqueLabels[label[0]-1]+"", Toast.LENGTH_SHORT).show();
        else
            Toast.makeText(getApplicationContext(), "You're not the right person", Toast.LENGTH_SHORT).show();
    }
    private boolean loadData() {
        String filename = FileUtils.loadTrained();
        if(filename.isEmpty())
            return false;
        else
        {
            recognize.read(filename);
            return true;
        }
    }
}

我的文件实用程序类:

   public class FileUtils {
        private static String TAG = FileUtils.class.getSimpleName();
        private static boolean loadFile(Context context, String cascadeName) {
            InputStream inp = null;
            OutputStream out = null;
            boolean completed = false;
            try {
                inp = context.getResources().getAssets().open(cascadeName);
                File outFile = new File(context.getCacheDir(), cascadeName);
                out = new FileOutputStream(outFile);

                byte[] buffer = new byte[4096];
                int bytesread;
                while((bytesread = inp.read(buffer)) != -1) {
                    out.write(buffer, 0, bytesread);
                }

                completed = true;
                inp.close();
                out.flush();
                out.close();
            } catch (IOException e) {
                Log.i(TAG, "Unable to load cascade file" + e);
            }
            return completed;
        }
        public static CascadeClassifier loadXMLS(Activity activity) {


            InputStream is = activity.getResources().openRawResource(R.raw.lbpcascade_frontalface);
            File cascadeDir = activity.getDir("cascade", Context.MODE_PRIVATE);
            File mCascadeFile = new File(cascadeDir, "lbpcascade_frontalface_improved.xml");
            FileOutputStream os = null;
            try {
                os = new FileOutputStream(mCascadeFile);
                byte[] buffer = new byte[4096];
                int bytesRead;
                while ((bytesRead = is.read(buffer)) != -1) {
                    os.write(buffer, 0, bytesRead);
                }
                is.close();
                os.close();

            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }


            return new CascadeClassifier(mCascadeFile.getAbsolutePath());
        }
        public static String loadTrained() {
            File file = new File(Environment.getExternalStorageDirectory(), "TrainedData/lbph_trained_data.xml");

            return file.toString();
        }
    }

这些是我要在此处比较的图像,人的脸还是一样,因为它不匹配! 图片1 图片2


当我为自动考勤系统建立最后一年的作业时,我使用了8-10张自己的图像(姿势和光照条件略有不同)来训练分类器。
ZdaR

您可以水平翻转训练图像垫来满足该要求。
nfl-x

@ nfl-x翻转图像无法解决准确性问题,我们需要更好的关于tensorflow的最新答案似乎还可以,但没有足够的信息或教程可用于android系统,因此我们最好的猜测是继续投票这样专家可以干预并为android提供适当的解决方案
Patel先生,

Answers:


5

更新资料

根据问题中的新编辑,您需要一种方法来快速识别在模型的训练阶段可能无法获得照片的新人员。这些任务称为少量射击学习。这类似于情报/警察机构使用CCTV摄像机镜头找到目标的要求。由于通常没有足够的特定目标图像,因此在训练期间,他们使用诸如FaceNet之类的模型。我确实建议阅读该论文,但是,我在这里解释了它的一些要点:

  • 通常,分类器的最后一层是一个* 1向量,其中n-1个元素几乎等于零,一个元素接近1。接近1的元素确定有关输入标签的分类器预测。 典型的CNN架构
  • 作者发现,如果他们在庞大的人脸数据集上训练具有特定损失函数的分类器网络,则可以使用半决赛图层输出来表示任何人脸,无论其是否在训练集中,作者称此向量为“ 面部嵌入”
  • 先前的结果意味着,使用训练有素的FaceNet模型,您可以将任何面孔汇总为向量。这种方法的一个非常有趣的属性是,特定角度的人在不同角度/位置/状态下的矢量在欧氏空间中最接近(此属性由作者选择的损失函数来强制执行)。在此处输入图片说明
  • 总而言之,您有一个模型来获取人脸作为输入并返回向量。彼此接近的向量很可能属于同一个人(用于检查您是否可以使用KNN或仅使用简单的欧氏距离)。

FaceNet的一种实现可以在这里找到。我建议您尝试在计算机上运行它以了解实际处理的内容。之后,最好执行以下操作:

  1. 将存储库中提到的F​​aceNet模型转换为其tflite版本(博客文章可能会有所帮助)
  2. 对于用户提交的每张照片,请使用Face API提取面部
  3. 在您的应用程序中使用缩小的模型来获取提取的面部的面部嵌入。
  4. 处理用户画廊中的所有图像,获取照片中人脸的矢量。
  5. 然后将在步骤4中找到的每个向量与在步骤3中找到的每个向量进行比较以获得匹配项。

原始答案

您遇到了机器学习最普遍的挑战之一:过度拟合。人脸检测和识别本身就是一个巨大的研究领域,几乎所有合理准确的模型都在使用某种深度学习。请注意,即使准确地检测人脸也并不像看上去那样容易,但是,就像您在android上一样,您可以使用Face API来完成此任务。(其他更高级的技术(例如MTCNN)太慢/难以部署在手机上)。已经显示,仅给模型提供背景噪声很大或内部有多个人的面部照片是行不通的。因此,您真的不能跳过此步骤。

从背景中获得候选目标的良好修剪面孔后,您需要克服识别检测到的面孔的难题。同样,据我所知,所有有能力的模型都在使用某种深度学习/卷积神经网络。在手机上使用它们是一个挑战,但是由于Tensorflow Lite,您可以缩小它们并在应用程序中运行它们。我曾经研究过的有关Android手机上人脸识别的项目在这里可以检查。请记住,任何好的模型都应在大量标记数据实例上进行训练,但是已经有大量的人脸或其他图像识别任务的大型数据集已经对模型进行过训练,以对其进行调整并利用其现有知识,我们可以采用迁移学习,有关对象检测和迁移学习的快速入门与您的案例密切相关,请查看博客文章。

总体而言,您必须获取要检测的面孔的大量实例以及您不关心的人的大量面孔图片,然后需要基于上述资源训练模型,然后您需要使用TensorFlow lite减小其大小并将其嵌入到您的应用程序中。然后,对于每个帧,您调用android Face API并将Feed(可能是检测到的脸部)供入模型中并标识人物。

根据延迟的容忍度以及训练集大小和目标数的数量,您可以获得各种结果,但是,如果您只有几个目标人员,则可以轻松实现%90 +精度。


我不想在我的应用程序中使用网络连接,因此Google Cloud愿景毫无疑问,但张量流精简版似乎很有趣,它免费吗?如果您能提供一个可行的示例,我将不胜感激!谢谢
R.Coder

好的答案!
R.Coder

免费。检查示例。尽管用户体验方面存在一些故障,但我们能够在不使用网络连接的情况下以非常高的准确性识别225个人的面孔。但这应该是一个好的开始。
Farzad Vertigo,

好吧,我会尝试一下
R.Coder

1
有效!!!!我最终提取了该面部网络模型tflite,并在一张训练有素的图像上获得了80%以上的准确性。但是时间复杂度确实是非常巨大的!,比较两个图像至少需要5到6秒,如何减小它呢?
R.Coder

2

如果我理解正确,那么您正在用单个图像训练分类器。在这种情况下,分类器将能够识别的所有特定图像。您将需要一组训练有素的更大图片来显示同一个人,至少要有5到10张不同的图像。


您有关于如何执行此操作的示例吗?
R.Coder

是的,我正在单个静态图像上进行人脸识别
R.Coder

看到这里例如如何使用train()docs.opencv.org/3.4/dd/d65/...
弗洛里安Echtler

如果您可以提供一些与android有关的编码示例,则此答案无济于事!
R.Coder

0

1)在将LBPHrecognizer初始化为-> LBPHFaceRecognizer(1、8、8、8、100)时更改阈值

2)用至少2-3张图片训练每张脸,因为这些识别器主要用于比较

3)在识别时设置准确度阈值。做这样的事情:

//predicting result
// LoadData is a static class that contains trained recognizer
// _result is the gray frame image captured by the camera
LBPHFaceRecognizer.PredictionResult ER = LoadData.recog.Predict(_result);
int temp_result = ER.Label;

imageBox1.SizeMode = PictureBoxSizeMode.StretchImage;
imageBox1.Image = _result.Mat;

//Displaying predicted result on screen
// LBPH returns -1 if face is recognized
if ((temp_result != -1) && (ER.Distance < 55)){  
     //I get best accuracy at 55, you should try different values to determine best results
     // Do something with detected image
}

好了,您可以编辑我当前的代码并提供一个有效的示例来用Java做到这一点吗?
R.Coder
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.