AI 助理
备案控制台
开发者社区 人工智能 文章 正文

java实现人脸识别

2022-04-08 3384
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 深度学习框架jdl+javacv+向量引擎实现人脸识别

人脸识别定义

人脸识别系统主要包括四个组成部分，分别为：人脸图像采集及检测、人脸图像预处理、人脸图像特征提取以及匹配与识别。

本文图片及学习代码来源，更多可前往

实现人脸识别流程

image.png

代码结构

image.png

代码实现

一、构建springboot项目添加pom依赖

<properties>
       <jna.version>5.6.0</jna.version>
       <djl.version>0.11.0</djl.version>
       <java.version>1.8</java.version>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
       <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
   </properties>


<!-- 线性代数库 -->
       <dependency>
           <groupId>gov.nist.math</groupId>
           <artifactId>jama</artifactId>
           <version>1.0.3</version>
       </dependency>

       <dependency>
           <groupId>net.java.dev.jna</groupId>
           <artifactId>jna</artifactId>
           <version>${jna.version}</version>
       </dependency>

       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
           <scope>test</scope>
       </dependency>

       <dependency>
           <groupId>org.bytedeco</groupId>
           <artifactId>opencv-platform</artifactId>
           <version>4.5.1-1.5.5</version>
       </dependency>

       <dependency>
           <groupId>org.bytedeco</groupId>
           <artifactId>javacv</artifactId>
           <version>1.5.5</version>
       </dependency>

       <dependency>
           <groupId>org.bytedeco</groupId>
           <artifactId>javacv-platform</artifactId>
           <version>1.5.5</version>
       </dependency>

       <dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>fastjson</artifactId>
           <version>1.2.62</version>
       </dependency>



       <!-- Start DJL -->
       <dependency>
           <groupId>ai.djl</groupId>
           <artifactId>api</artifactId>
           <version>${djl.version}</version>
       </dependency>

       <!-- PyTorch -->
       <dependency>
           <groupId>ai.djl.pytorch</groupId>
           <artifactId>pytorch-model-zoo</artifactId>
           <version>${djl.version}</version>
       </dependency>
       <dependency>
           <groupId>ai.djl.pytorch</groupId>
           <artifactId>pytorch-engine</artifactId>
           <version>${djl.version}</version>
       </dependency>
       <dependency>
           <groupId>ai.djl.pytorch</groupId>
           <artifactId>pytorch-native-auto</artifactId>
           <version>1.8.1</version>
       </dependency>

二、创建转换器

package com.xgc.aideep.face.translator;

import ai.djl.modality.cv.Image;
import ai.djl.modality.cv.output.*;
import ai.djl.ndarray.NDArray;
import ai.djl.ndarray.NDArrays;
import ai.djl.ndarray.NDList;
import ai.djl.ndarray.NDManager;
import ai.djl.ndarray.types.DataType;
import ai.djl.ndarray.types.Shape;
import ai.djl.translate.Batchifier;
import ai.djl.translate.Translator;
import ai.djl.translate.TranslatorContext;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author gc.x
 * @date 2022-04
 */
public class FaceDetectionTranslator implements Translator<Image, DetectedObjects> {

    private double confThresh;
    private double nmsThresh;
    private int topK;
    private double[] variance;
    private int[][] scales;
    private int[] steps;
    private int width;
    private int height;

    public FaceDetectionTranslator(
            double confThresh,
            double nmsThresh,
            double[] variance,
            int topK,
            int[][] scales,
            int[] steps) {
        this.confThresh = confThresh;
        this.nmsThresh = nmsThresh;
        this.variance = variance;
        this.topK = topK;
        this.scales = scales;
        this.steps = steps;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public NDList processInput(TranslatorContext ctx, Image input) {
        width = input.getWidth();
        height = input.getHeight();
        NDArray array = input.toNDArray(ctx.getNDManager(), Image.Flag.COLOR);
        array = array.transpose(2, 0, 1).flip(0); // HWC -> CHW RGB -> BGR
        // The network by default takes float32
        if (!array.getDataType().equals(DataType.FLOAT32)) {
            array = array.toType(DataType.FLOAT32, false);
        }
        NDArray mean =
                ctx.getNDManager().create(new float[]{104f, 117f, 123f}, new Shape(3, 1, 1));
        array = array.sub(mean);
        return new NDList(array);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public DetectedObjects processOutput(TranslatorContext ctx, NDList list) {
        NDManager manager = ctx.getNDManager();
        double scaleXY = variance[0];
        double scaleWH = variance[1];

        NDArray prob = list.get(1).get(":, 1:");
        prob =
                NDArrays.stack(
                        new NDList(
                                prob.argMax(1).toType(DataType.FLOAT32, false),
                                prob.max(new int[]{1})));

        NDArray boxRecover = boxRecover(manager, width, height, scales, steps);
        NDArray boundingBoxes = list.get(0);
        NDArray bbWH = boundingBoxes.get(":, 2:").mul(scaleWH).exp().mul(boxRecover.get(":, 2:"));
        NDArray bbXY =
                boundingBoxes
                        .get(":, :2")
                        .mul(scaleXY)
                        .mul(boxRecover.get(":, 2:"))
                        .add(boxRecover.get(":, :2"))
                        .sub(bbWH.mul(0.5f));

        boundingBoxes = NDArrays.concat(new NDList(bbXY, bbWH), 1);

        NDArray landms = list.get(2);
        landms = decodeLandm(landms, boxRecover, scaleXY);

        // filter the result below the threshold
        NDArray cutOff = prob.get(1).gt(confThresh);
        boundingBoxes = boundingBoxes.transpose().booleanMask(cutOff, 1).transpose();
        landms = landms.transpose().booleanMask(cutOff, 1).transpose();
        prob = prob.booleanMask(cutOff, 1);

        // start categorical filtering
        long[] order = prob.get(1).argSort().get(":" + topK).toLongArray();
        prob = prob.transpose();
        List<String> retNames = new ArrayList<>();
        List<Double> retProbs = new ArrayList<>();
        List<BoundingBox> retBB = new ArrayList<>();

        Map<Integer, List<BoundingBox>> recorder = new ConcurrentHashMap<>();

        for (int i = order.length - 1; i >= 0; i--) {
            long currMaxLoc = order[i];
            float[] classProb = prob.get(currMaxLoc).toFloatArray();
            int classId = (int) classProb[0];
            double probability = classProb[1];

            double[] boxArr = boundingBoxes.get(currMaxLoc).toDoubleArray();
            double[] landmsArr = landms.get(currMaxLoc).toDoubleArray();
            Rectangle rect = new Rectangle(boxArr[0], boxArr[1], boxArr[2], boxArr[3]);
            List<BoundingBox> boxes = recorder.getOrDefault(classId, new ArrayList<>());
            boolean belowIoU = true;
            for (BoundingBox box : boxes) {
                if (box.getIoU(rect) > nmsThresh) {
                    belowIoU = false;
                    break;
                }
            }
            if (belowIoU) {
                List<Point> keyPoints = new ArrayList<>();
                for (int j = 0; j < 5; j++) { // 5 face landmarks
                    double x = landmsArr[j * 2];
                    double y = landmsArr[j * 2 + 1];
                    keyPoints.add(new Point(x * width, y * height));
                }
                Landmark landmark =
                        new Landmark(boxArr[0], boxArr[1], boxArr[2], boxArr[3], keyPoints);

                boxes.add(landmark);
                recorder.put(classId, boxes);
                String className = "Face"; // classes.get(classId)
                retNames.add(className);
                retProbs.add(probability);
                retBB.add(landmark);
            }
        }

        return new DetectedObjects(retNames, retProbs, retBB);
    }

    private NDArray boxRecover(
            NDManager manager, int width, int height, int[][] scales, int[] steps) {
        int[][] aspectRatio = new int[steps.length][2];
        for (int i = 0; i < steps.length; i++) {
            int wRatio = (int) Math.ceil((float) width / steps[i]);
            int hRatio = (int) Math.ceil((float) height / steps[i]);
            aspectRatio[i] = new int[]{hRatio, wRatio};
        }

        List<double[]> defaultBoxes = new ArrayList<>();

        for (int idx = 0; idx < steps.length; idx++) {
            int[] scale = scales[idx];
            for (int h = 0; h < aspectRatio[idx][0]; h++) {
                for (int w = 0; w < aspectRatio[idx][1]; w++) {
                    for (int i : scale) {
                        double skx = i * 1.0 / width;
                        double sky = i * 1.0 / height;
                        double cx = (w + 0.5) * steps[idx] / width;
                        double cy = (h + 0.5) * steps[idx] / height;
                        defaultBoxes.add(new double[]{cx, cy, skx, sky});
                    }
                }
            }
        }

        double[][] boxes = new double[defaultBoxes.size()][defaultBoxes.get(0).length];
        for (int i = 0; i < defaultBoxes.size(); i++) {
            boxes[i] = defaultBoxes.get(i);
        }
        return manager.create(boxes).clip(0.0, 1.0);
    }

    // decode face landmarks, 5 points per face
    private NDArray decodeLandm(NDArray pre, NDArray priors, double scaleXY) {
        NDArray point1 =
                pre.get(":, :2").mul(scaleXY).mul(priors.get(":, 2:")).add(priors.get(":, :2"));
        NDArray point2 =
                pre.get(":, 2:4").mul(scaleXY).mul(priors.get(":, 2:")).add(priors.get(":, :2"));
        NDArray point3 =
                pre.get(":, 4:6").mul(scaleXY).mul(priors.get(":, 2:")).add(priors.get(":, :2"));
        NDArray point4 =
                pre.get(":, 6:8").mul(scaleXY).mul(priors.get(":, 2:")).add(priors.get(":, :2"));
        NDArray point5 =
                pre.get(":, 8:10").mul(scaleXY).mul(priors.get(":, 2:")).add(priors.get(":, :2"));
        return NDArrays.concat(new NDList(point1, point2, point3, point4, point5), 1);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Batchifier getBatchifier() {
        return Batchifier.STACK;
    }
}

package com.xgc.aideep.face.translator;

import ai.djl.modality.cv.Image;
import ai.djl.modality.cv.transform.Normalize;
import ai.djl.modality.cv.transform.ToTensor;
import ai.djl.ndarray.NDArray;
import ai.djl.ndarray.NDList;
import ai.djl.translate.Batchifier;
import ai.djl.translate.Pipeline;
import ai.djl.translate.Translator;
import ai.djl.translate.TranslatorContext;

/**
 * @author gc.x
 * @date 2022-04
 */
public final class FaceFeatureTranslator implements Translator<Image, float[]> {

    public FaceFeatureTranslator() {
    }

    @Override
    public NDList processInput(TranslatorContext ctx, Image input) {
        NDArray array = input.toNDArray(ctx.getNDManager(), Image.Flag.COLOR);
        Pipeline pipeline = new Pipeline();
        pipeline
                // .add(new Resize(160))
                .add(new ToTensor())
                .add(
                        new Normalize(
                                new float[]{127.5f / 255.0f, 127.5f / 255.0f, 127.5f / 255.0f},
                                new float[]{128.0f / 255.0f, 128.0f / 255.0f, 128.0f / 255.0f}));

        return pipeline.transform(new NDList(array));
    }

    @Override
    public float[] processOutput(TranslatorContext ctx, NDList list) {
        NDList result = new NDList();
        long numOutputs = list.singletonOrThrow().getShape().get(0);
        for (int i = 0; i < numOutputs; i++) {
            result.add(list.singletonOrThrow().get(i));
        }
        float[][] embeddings = result.stream().map(NDArray::toFloatArray).toArray(float[][]::new);
        float[] feature = new float[embeddings.length];
        for (int i = 0; i < embeddings.length; i++) {
            feature[i] = embeddings[i][0];
        }
        return feature;
    }

    @Override
    public Batchifier getBatchifier() {
        return Batchifier.STACK;
    }
}

三、加载模型


package com.xgc.aideep.face.model;

import ai.djl.MalformedModelException;
import ai.djl.modality.cv.Image;
import ai.djl.modality.cv.output.DetectedObjects;
import ai.djl.repository.zoo.Criteria;
import ai.djl.repository.zoo.ModelNotFoundException;
import ai.djl.repository.zoo.ModelZoo;
import ai.djl.repository.zoo.ZooModel;
import ai.djl.training.util.ProgressBar;
import com.xgc.aideep.face.translator.FaceDetectionTranslator;

import java.io.IOException;

/**
 * @author gc.x
 * @date 2022-04
 */
public final class FaceDetectionModel {
    private ZooModel<Image, DetectedObjects> model;

    private static String model_path = "models/ultranet.zip";

    public void init(int topK, double confThresh, double nmsThresh) throws MalformedModelException, ModelNotFoundException, IOException {
        this.model = ModelZoo.loadModel(detectCriteria(topK, confThresh, nmsThresh));
    }

    public ZooModel<Image, DetectedObjects> getModel() {
        return model;
    }

    public void close() {
        this.model.close();
    }

    private Criteria<Image, DetectedObjects> detectCriteria(int topK, double confThresh, double nmsThresh) {
        double[] variance = {0.1f, 0.2f};

        int[][] scales = {{10, 16, 24}, {32, 48}, {64, 96}, {128, 192, 256}};
        int[] steps = {8, 16, 32, 64};

        FaceDetectionTranslator translator =
                new FaceDetectionTranslator(confThresh, nmsThresh, variance, topK, scales, steps);

        Criteria<Image, DetectedObjects> criteria =
                Criteria.builder()
                        .setTypes(Image.class, DetectedObjects.class)
                        .optModelUrls(model_path)
                        .optTranslator(translator)
                        .optEngine("PyTorch") // Use PyTorch engine
                        .optProgress(new ProgressBar())
                        .build();
        return criteria;
    }

}
package com.xgc.aideep.face.model;

import ai.djl.MalformedModelException;
import ai.djl.modality.cv.Image;
import ai.djl.repository.zoo.Criteria;
import ai.djl.repository.zoo.ModelNotFoundException;
import ai.djl.repository.zoo.ModelZoo;
import ai.djl.repository.zoo.ZooModel;
import ai.djl.training.util.ProgressBar;
import com.xgc.aideep.face.translator.FaceFeatureTranslator;

import java.io.IOException;

/**
 * @author gc.x
 * @date 2022-04
 */
public final class FaceFeatureModel {
    private ZooModel<Image, float[]> model;

    private static String model_path = "models/face_feature.zip";

    public void init() throws MalformedModelException, ModelNotFoundException, IOException {
        this.model = ModelZoo.loadModel(detectCriteria());
    }

    public ZooModel<Image, float[]> getModel() {
        return model;
    }

    public void close() {
        this.model.close();
    }

    private Criteria<Image, float[]> detectCriteria() {

        Criteria<Image, float[]> criteria =
                Criteria.builder()
                        .setTypes(Image.class, float[].class)
                        .optModelName("face_feature") // specify model file prefix
                        .optModelUrls(model_path)
                        .optTranslator(new FaceFeatureTranslator())
                        .optEngine("PyTorch") // Use PyTorch engine
                        .optProgress(new ProgressBar())
                        .build();
        return criteria;
    }

}

四、目标检测

package com.xgc.aideep.face.service.impl;

import ai.djl.ModelException;
import ai.djl.inference.Predictor;
import ai.djl.modality.cv.Image;
import ai.djl.modality.cv.ImageFactory;
import ai.djl.modality.cv.output.BoundingBox;
import ai.djl.modality.cv.output.DetectedObjects;
import ai.djl.modality.cv.output.Point;
import ai.djl.modality.cv.output.Rectangle;
import ai.djl.ndarray.NDArray;
import ai.djl.ndarray.NDManager;
import ai.djl.repository.zoo.ZooModel;
import ai.djl.translate.TranslateException;
import com.xgc.aideep.face.entity.FaceObject;
import com.xgc.aideep.face.model.FaceDetectionModel;
import com.xgc.aideep.face.service.FaceDetectService;
import com.xgc.aideep.face.service.FaceFeatureService;
import com.xgc.aideep.face.util.*;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.bytedeco.javacv.Java2DFrameUtils;
import org.bytedeco.opencv.opencv_core.Mat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * 目标检测服务
 *
 * @author gc.x
 * @date 2022-04
 */
@Slf4j
@RequiredArgsConstructor
@Service
public class DetectServiceImpl implements FaceDetectService {

    @Autowired
    private FaceFeatureService featureService;

    @Autowired
    private FaceDetectionModel faceDetectionModel;

    public List<FaceObject> faceDetect(BufferedImage image)
            throws IOException, ModelException, TranslateException {
        ZooModel<Image, DetectedObjects> model = faceDetectionModel.getModel();
        try (Predictor<Image, DetectedObjects> predictor = model.newPredictor()) {
            Image djlImg = ImageFactory.getInstance().fromImage(image);
            DetectedObjects detections = predictor.predict(djlImg);
            List<DetectedObjects.DetectedObject> list = detections.items();

            List<FaceObject> faceObjects = new ArrayList<>();
            for (DetectedObjects.DetectedObject detectedObject : list) {
                BoundingBox box = detectedObject.getBoundingBox();
                Rectangle rectangle = box.getBounds();

                // 抠人脸图
                Rectangle subImageRect =
                        FaceUtil.getSubImageRect(
                                image, rectangle, djlImg.getWidth(), djlImg.getHeight(), 0f);
                int x = (int) (subImageRect.getX());
                int y = (int) (subImageRect.getY());
                int w = (int) (subImageRect.getWidth());
                int h = (int) (subImageRect.getHeight());
                BufferedImage subImage = image.getSubimage(x, y, w, h);
                Image img = DJLImageUtil.bufferedImage2DJLImage(subImage);
                //获取特征向量
                List<Float> feature = featureService.faceFeature(img);

                FaceObject faceObject = new FaceObject();
                faceObject.setFeature(feature);
                faceObject.setBoundingBox(subImageRect);
                faceObjects.add(faceObject);
            }

            return faceObjects;
        }
    }

    public List<FaceObject> faceDetect(Image djlImg) throws TranslateException, ModelException, IOException {
        ZooModel<Image, DetectedObjects> model = faceDetectionModel.getModel();
        try (Predictor<Image, DetectedObjects> predictor = model.newPredictor()) {
            DetectedObjects detections = predictor.predict(djlImg);
            List<DetectedObjects.DetectedObject> list = detections.items();
            BufferedImage image = (BufferedImage) djlImg.getWrappedImage();
            List<FaceObject> faceObjects = new ArrayList<>();

            for (DetectedObjects.DetectedObject detectedObject : list) {
                BoundingBox box = detectedObject.getBoundingBox();
                Rectangle rectangle = box.getBounds();

                // 抠人脸图
                // factor = 0.1f, 意思是扩大10%，防止人脸仿射变换后，人脸被部分截掉
                Rectangle subImageRect =
                        FaceUtil.getSubImageRect(
                                image, rectangle, djlImg.getWidth(), djlImg.getHeight(), 1.0f);
                int x = (int) (subImageRect.getX());
                int y = (int) (subImageRect.getY());
                int w = (int) (subImageRect.getWidth());
                int h = (int) (subImageRect.getHeight());
                BufferedImage subImage = image.getSubimage(x, y, w, h);

                // 计算人脸关键点在子图中的新坐标
                List<Point> points = (List<Point>) box.getPath();
                double[][] pointsArray = FaceUtil.pointsArray(subImageRect, points);

                // 转 buffered image 图片格式
                BufferedImage converted3BGRsImg =
                        new BufferedImage(
                                subImage.getWidth(), subImage.getHeight(), BufferedImage.TYPE_3BYTE_BGR);
                converted3BGRsImg.getGraphics().drawImage(subImage, 0, 0, null);

                Mat mat = Java2DFrameUtils.toMat(converted3BGRsImg);

                try (NDManager manager = NDManager.newBaseManager()) {
                    NDArray srcPoints = manager.create(pointsArray);
                    NDArray dstPoints = SVDUtil.point112x112(manager);

                    // 定制的5点仿射变换
                    Mat svdMat = NDArrayUtil.toOpenCVMat(manager, srcPoints, dstPoints);
                    // 换仿射变换矩阵
                    mat = FaceAlignment.get5WarpAffineImg(mat, svdMat);

                    // mat转bufferedImage类型
                    BufferedImage mat2BufferedImage = OpenCVImageUtil.mat2BufferedImage(mat);
                    int width = mat2BufferedImage.getWidth() > 112 ? 112 : mat2BufferedImage.getWidth();
                    int height = mat2BufferedImage.getHeight() > 112 ? 112 : mat2BufferedImage.getHeight();
                    mat2BufferedImage = mat2BufferedImage.getSubimage(0, 0, width, height);

                    Image img = DJLImageUtil.bufferedImage2DJLImage(mat2BufferedImage);
                    //获取特征向量
                    List<Float> feature = featureService.faceFeature(img);

                    FaceObject faceObject = new FaceObject();
                    faceObject.setFeature(feature);
                    faceObject.setBoundingBox(subImageRect);
                    faceObject.setScore((float) detectedObject.getProbability());
                    faceObjects.add(faceObject);

                }
            }

            return faceObjects;
        }
    }
}

五、特征提取

package com.xgc.aideep.face.service.impl;

import ai.djl.inference.Predictor;
import ai.djl.modality.cv.Image;
import ai.djl.repository.zoo.ZooModel;
import ai.djl.translate.TranslateException;
import com.xgc.aideep.face.model.FaceFeatureModel;
import com.xgc.aideep.face.service.FaceFeatureService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * 特征提取服务
 * @author gc.x
 * @date 2022-04
 */
@Slf4j
@Service
public class FeatureServiceImpl implements FaceFeatureService {
    @Autowired
    private FaceFeatureModel faceFeatureModel;

    public List<Float> faceFeature(Image img) throws TranslateException {
        ZooModel<Image, float[]> model = faceFeatureModel.getModel();
        try (Predictor<Image, float[]> predictor = model.newPredictor()) {
            float[] embeddings = predictor.predict(img);
            List<Float> feature = new ArrayList<>();
            if (embeddings != null) {
                for (int i = 0; i < embeddings.length; i++) {
                    feature.add(embeddings[i]);
                }
            } else {
                return null;
            }
            return feature;
        }
    }
}

六、特征比对（存储）

使用向量引擎milvus存储获取的人脸特征，业务人脸识别

image.png

七、源代码开源地址

https://gitee.com/giteeClass/ai-face

文章标签：
Java
计算机视觉
机器学习/深度学习
存储
关键词：
实人认证java
java实人认证
Java人脸识别
Java实现
实人认证实现
javpower
目录
相关文章
a15034260562-24955
|
6月前
|
Java 计算机视觉
java实现人脸识别源码【含测试效果图】——前台页面层（login.jsp）
java实现人脸识别源码【含测试效果图】——前台页面层（login.jsp）
a15034260562-24955
41 0
源码世界
|
6月前
|
传感器 人工智能 前端开发
JAVA语言VUE2+Spring boot+MySQL开发的智慧校园系统源码（电子班牌可人脸识别）Saas 模式
智慧校园电子班牌，坐落于班级的门口，适合于各类型学校的场景应用，班级学校日常内容更新可由班级自行管理，也可由学校统一管理。让我们一起看看，电子班牌有哪些功能呢？
源码世界
551 4
JAVA语言VUE2+Spring boot+MySQL开发的智慧校园系统源码（电子班牌可人脸识别）Saas 模式
a15034260562-24955
|
6月前
|
Java 计算机视觉
java实现人脸识别源码【含测试效果图】——前台显示层（index.jsp）
java实现人脸识别源码【含测试效果图】——前台显示层（index.jsp）
a15034260562-24955
45 1
a15034260562-24955
|
6月前
|
Java 计算机视觉
java实现人脸识别源码【含测试效果图】——Servlet层（FaceServlet）
java实现人脸识别源码【含测试效果图】——Servlet层（FaceServlet）
a15034260562-24955
39 1
a15034260562-24955
|
6月前
|
Java 计算机视觉
java实现人脸识别源码【含测试效果图】——ServiceImpl层（UserServiceImpl）
java实现人脸识别源码【含测试效果图】——ServiceImpl层（UserServiceImpl）
a15034260562-24955
40 1
a15034260562-24955
|
6月前
|
Java 计算机视觉
java实现人脸识别源码【含测试效果图】——Service层（IUserService）
java实现人脸识别源码【含测试效果图】——Service层（IUserService）
a15034260562-24955
33 1
a15034260562-24955
|
6月前
|
Java API 计算机视觉
java实现人脸识别V3版本开发
java实现人脸识别V3版本开发
a15034260562-24955
71 0
云小弟指导上云
|
6月前
|
弹性计算 Java PHP
新手用户注册阿里云账号、实名认证、购买云服务器图文教程参考
对于初次购买阿里云产品的用户来说，第一步要做的是注册账号并完成实名认证，然后才是购买阿里云服务器或者其他云产品，本文为大家以图文形式展示一下新手用户从注册阿里云账号、实名认证到购买云服务器完整详细教程，以供参考。
云小弟指导上云
1038 1
新手用户注册阿里云账号、实名认证、购买云服务器图文教程参考
花开富贵111
|
5月前
|
文字识别 算法 API
视觉智能开放平台产品使用合集之uniapp框架如何使用阿里云金融级人脸识别
视觉智能开放平台是指提供一系列基于视觉识别技术的API和服务的平台，这些服务通常包括图像识别、人脸识别、物体检测、文字识别、场景理解等。企业或开发者可以通过调用这些API，快速将视觉智能功能集成到自己的应用或服务中，而无需从零开始研发相关算法和技术。以下是一些常见的视觉智能开放平台产品及其应用场景的概览。
花开富贵111
133 0
云安全专家
|
6月前
|
移动开发 安全 算法
首个身份认证SDK适配鸿蒙系统！阿里云金融级实人认证产品再升级
喜讯
云安全专家
601 0
首个身份认证SDK适配鸿蒙系统！阿里云金融级实人认证产品再升级

热门文章

最新文章

  • 1
    java集成opencv(不踩坑),实现人脸检测小demo(含上传人像图片识别接口),windows,IDEA,Springboot
  • 2
    java Redis工具类
  • 3
    JAVA SERVLET 属性范围样例
  • 4
    Java一分钟之-JavaMail：发送电子邮件
  • 5
    Java开发数据库设计的14个技巧，你知道几个？
  • 6
    Java的几种创建实例方法的性能对比
  • 7
    Java杂记9—NIO
  • 8
    16.2. jps - Java Virtual Machine Process Status Tool
  • 9
    Java多线程初学者指南（9）：为什么要进行数据同步
  • 10
    Java——基于java自身包实现消息系统间的通信（TCP/IP+BIO）
  • 1
    Python实现PCA降维和KNN人脸识别模型(PCA和KNeighborsClassifier算法)项目实战
    95
  • 2
    Python基于MTCNN+FaceNet+SVM进行人脸识别项目实战
    75
  • 3
    【干货分享】.NET人脸识别解决方案
    79
  • 4
    好的资源-----打卡机+Arm+Qt+OpenCV嵌入式项目-基于人脸识别的考勤系统-----B站神经网络与深度学习，商城
    79
  • 5
    视觉智能平台人脸识别页面的链接时效性
    41
  • 6
    人工智能之人脸识别技术应用场景
    330
  • 7
    视觉智能开放平台产品使用合集之人脸核身是否包含静默活体检测
    35
  • 8
    视觉智能开放平台产品使用合集之活体检测通过后，从返回结果中选择哪张图片进行人脸核身
    23
  • 9
    视觉智能开放平台产品使用合集之人脸识别客户端如何直接访问服务器进行人脸识别并传递视频流
    36
  • 10
    视觉智能开放平台产品使用合集之uniapp框架如何使用阿里云金融级人脸识别
    133

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云OSS设置跨域访问