使用Java和PostgreSQL存储向量数据的实现指南

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.2.5</version>
</dependency>

spring.datasource.url=jdbc:postgresql://localhost:5432/yourdatabase
spring.datasource.username=yourusername
spring.datasource.password=yourpassword
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

import javax.persistence.*;
import java.util.Arrays;

@Entity
public class VectorData {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column
    private String name;

    @Column
    private double[] vector;

    // Getters and Setters
    // toString() 方法
}

import org.springframework.data.jpa.repository.JpaRepository;

public interface VectorDataRepository extends JpaRepository<VectorData, Long> {
    // 可以在这里定义自定义查询方法
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class VectorDataService {

    @Autowired
    private VectorDataRepository vectorDataRepository;

    public VectorData saveVectorData(String name, double[] vector) {
        VectorData vectorData = new VectorData();
        vectorData.setName(name);
        vectorData.setVector(vector);
        return vectorDataRepository.save(vectorData);
    }

    // 其他增删改查方法
}

public List<VectorData> getAllVectorData() {
    return vectorDataRepository.findAll();
}

public Optional<VectorData> getVectorDataById(Long id) {
    return vectorDataRepository.findById(id);
}

public VectorData updateVectorData(Long id, String name, double[] vector) {
    Optional<VectorData> optionalVectorData = vectorDataRepository.findById(id);
    if (optionalVectorData.isPresent()) {
        VectorData vectorData = optionalVectorData.get();
        vectorData.setName(name);
        vectorData.setVector(vector);
        return vectorDataRepository.save(vectorData);
    }
    return null;
}

public void deleteVectorData(Long id) {
    vectorDataRepository.deleteById(id);
}

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface VectorDataRepository extends JpaRepository<VectorData, Long> {

    @Query("SELECT v FROM VectorData v WHERE sqrt(power(v.vector[1] - :vector1, 2) + power(v.vector[2] - :vector2, 2) + power(v.vector[3] - :vector3, 2)) < :threshold")
    List<VectorData> findSimilarVectors(@Param("vector1") double vector1,
                                        @Param("vector2") double vector2,
                                        @Param("vector3") double vector3,
                                        @Param("threshold") double threshold);
}

public List<VectorData> findSimilarVectors(double[] vector, double threshold) {
    return vectorDataRepository.findSimilarVectors(vector[0], vector[1], vector[2], threshold);
}

import tensorflow as tf
import numpy as np

# 加载预训练模型
model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False, pooling='avg')

# 加载图像并预处理
img_path = 'path_to_your_image.jpg'
img = tf.keras.preprocessing.image.load_img(img_path, target_size=(224, 224))
img_array = tf.keras.preprocessing.image.img_to_array(img)
img_array = np.expand_dims(img_array, axis=0)
img_array = tf.keras.applications.resnet50.preprocess_input(img_array)

# 提取特征向量
features = model.predict(img_array)

double[] features = ...; // 从特征提取模型获得的特征向量
String imageName = "example.jpg";
vectorDataService.saveVectorData(imageName, features);

double[] queryVector = ...; // 输入图像的特征向量
double threshold = 0.5;
List<VectorData> similarImages = vectorDataService.findSimilarVectors(queryVector, threshold);

// 输出相似图像
similarImages.forEach(image -> System.out.println(image.getName()));