ND4j大矩阵做相识度计算实现1:N计算

「爱情、让人受尽委屈。」 2022-02-09 20:11 166阅读 0赞

现在很多做人脸识别的技术都是基于C++，python；但是java也是有自己的深度学习的库，Deeplearning4j就是java自己的深度学习库，ND4j就是dp4j里面专门做向量计算的库，现在就用ND4j实现1:N矩阵计算功能：

pom：

<dependency>
                <groupId>org.nd4j</groupId>
                <artifactId>nd4j-native</artifactId>
                <version>${dp4j-version}</version>
            </dependency>

1:N计算的核心就是，用矩阵和一个大矩阵做内积乘法

业务功能：就是用一张人脸的特征和数据库里面有的特征做内积乘法，快速在数据库里面找到这张人脸对应的人；

现实方法：

由于每次都在数据库里面去查询特征数据会消耗时间，所以我把特征数据初始化加载到内存里面来维护；做完内积计算以后需要找到相识度最大的对应的那条数据，opencv里面有一个sortIndex函数可以将数组的值排序以后返回对应的索引地址，java可以自己实现一个排序；

将查出来的特征值进行缓存：

@Component
    public class NDCache {
    
    
        public static List<BasisFeature> basisFeatures = Lists.newArrayList();
    
        public static INDArray zeros = null;
    
        public static void load(List<BasisFeature> features){
            basisFeatures = features;
            List<INDArray> INDArrays = features.stream().map(basisFeature -> Nd4j.create(basisFeature.getBasis())).collect(Collectors.toList());
             zeros = Nd4j.vstack(INDArrays);
        }
    
    }

实现矩阵计算，更新矩阵：

@Slf4j
    @Service
    public class NDService {
    
        @Autowired
        private MongoTemplate mongoTemplate;
    
        private static double forecastValues = 0.65D;
    
        private INDArray creArry(List<Double> features) {
            INDArray array = Nd4j.create(features.size(), 1);
            features.forEach(item -> array.putRow(features.indexOf(item), Nd4j.create(new double[]{item})));
            return array;
        }
    
        public BasisFeature comparRes(List<Double> features){
            INDArray resArr =  NDCache.zeros.mmul(creArry(features));
            Point[] points = Point.sortPoint(resArr.toDoubleVector());
            Point point = points[0];
            if (point.getValue() < forecastValues){
                return  null;
            }
            log.info("1比N第一位结果："+point);
            return NDCache.basisFeatures.get(point.getIndex());
        }
    
        public void updateArr(BasisFeature basisFeature){
            for (int i=0;i<NDCache.basisFeatures.size();i++){
                BasisFeature feature = NDCache.basisFeatures.get(i);
                if (feature.getObjectId().equals(basisFeature.getObjectId())){
                    NDCache.basisFeatures.set(i,basisFeature);
                    NDCache.zeros.put(i,Nd4j.create(basisFeature.getBasis()));
                    log.info("矩阵更新："+NDCache.zeros.length());
                }
            }
        }
    
        public void loadNDarr(){
            Query query = new Query();
        
            List<BasisFeature> features = mongoTemplate.find(query,BasisFeature.class);
            NDCache.basisFeatures = features;
            List<INDArray> INDArrays = features.stream().map(basisFeature -> Nd4j.create(basisFeature.getBasis())).collect(Collectors.toList());
            NDCache.zeros = Nd4j.vstack(INDArrays);
            log.info("初始化矩阵大小："+NDCache.zeros.length()+":数据源大小："+features.size());
        }
    
        public void add(BasisFeature ... basisFeatures){
            if (ObjectUtils.isEmpty(NDCache.zeros)){
                loadNDarr();
            }else {
                List<INDArray> indArrays = Lists.newArrayList(NDCache.zeros);
                Arrays.asList(basisFeatures).stream().forEach(basisFeature -> indArrays.add(Nd4j.create(basisFeature.getBasis())));
                NDCache.zeros = Nd4j.vstack(indArrays);
                log.info("矩阵扩张："+NDCache.zeros.length());
            }
        }
    
    }

自定义sortIndex：

public class SortComprator implements Comparator {
    
        @Override
        public int compare(Object arg0, Object arg1) {
            Point t1=(Point)arg0;
            Point t2=(Point)arg1;
            return t2.getValue().compareTo(t1.getValue());
        }
    
    }

自定义数据结构:

@Data
    public class Point{
    
        private Double value;
    
        private int index;
    
       public  static Point[] sortPoint(double[] doubleVector){
            Point[] points = new Point[doubleVector.length];
            for (int i=0;i<doubleVector.length;i++){
                Point point = new Point();
                point.setValue(doubleVector[i]);
                point.setIndex(i);
                points[i] = point;
            }
            Arrays.sort(points,new SortComprator());
            return points;
        }
    
    }

整个计算流程只是把其他语言的实现方法实现了一遍，但是java在计算方便的速度也是很快的，一百万的矩阵差不多也就141ms,

这个只是基于cpu的计算，当然nd4j也是可以基于cuda的GPU计算的。