跳到正文
阿里雲開發者社區 AI·· 32 分鐘前AI 評分18

AI奇門遁甲開發實戰:基於多維特徵提取的盤局對比分析引擎架構

AI奇门遁甲开发实战:基于多维特征提取的盘局对比分析引擎架构

AI 導讀

AI奇門遁甲 App 的盤局對比分析引擎,透過結構化盤局資料、提取多維特徵及計算相似度,支援盤局對比分析。文章説明引擎採用數據解析層、特徵工程層和計算引擎層,並以餘弦相似度比較特徵向量。

正文

2026-11-22 9

版权

版权声明:

本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写 侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

简介: 本文介绍AI奇门遁甲App中盘局对比分析引擎的设计与实现,聚焦数据结构化、多维特征提取(九宫、星门、干支五行等)、余弦/Jaccard相似度计算及高性能对比架构,提升传统术数分析的效率与量化水平。

奇门遁甲1.jpg 奇门遁甲2.jpg 奇门遁甲3.jpg

在传统文化数字化与智能化应用中,AI奇门遁甲App的核心挑战在于盘局数据的结构化处理与多维度对比分析。传统人工对比盘局不仅效率低下,且难以量化分析不同盘局之间的差异与关联;而盘局对比分析涉及九宫数据解析、特征向量构建、相似度计算等复杂逻辑,若处理不当会导致分析结果偏差与性能瓶颈。本文从算法设计与架构视角,探讨AI奇门遁甲盘局对比分析引擎的设计与实现,重点解决盘局数据结构化、多维特征提取、相似度算法以及高性能对比引擎等技术难点。

一、 业务背景与架构设计

AI奇门遁甲盘局对比分析通常包含:盘局数据解析、特征提取、相似度计算、对比结果可视化等功能。在系统架构上,需要解决三个核心问题:一是盘局数据结构化,需将非结构化的盘局信息(九宫、星门神仪)转化为结构化的数据模型,便于后续计算;二是多维特征提取,需从盘局中提取干支五行、星门旺衰、格局组合等多维特征,构建特征向量;三是高效相似度计算,需通过余弦相似度、欧氏距离等算法,快速计算盘局之间的相似度,支持大规模盘局的实时对比。推荐采用“数据解析层+特征工程层+计算引擎层”的架构,通过数据解析层将盘局转化为结构化对象,利用特征工程层提取多维特征向量,结合计算引擎层实现高效的相似度计算与对比分析。

二、 核心代码实现

1. 盘局数据结构化与多维特征提取

通过结构化解析与特征工程,将盘局信息转化为多维特征向量,为对比分析提供数据基础。


@Service
public class BoardFeatureExtractor {
    
    
    public FeatureVector extractFeatures(BoardData board) {
        FeatureVector vector = new FeatureVector();
        vector.setBoardId(board.getBoardId());
        
        
        List<PalaceFeature> palaceFeatures = new ArrayList<>();
        for (Palace palace : board.getPalaces()) {
            PalaceFeature feature = extractPalaceFeatures(palace);
            palaceFeatures.add(feature);
        }
        vector.setPalaceFeatures(palaceFeatures);
        
        
        GlobalFeature globalFeature = extractGlobalFeatures(board);
        vector.setGlobalFeature(globalFeature);
        
        
        double[] featureArray = buildFeatureArray(vector);
        vector.setFeatureArray(featureArray);
        
        return vector;
    }
    
    
    private PalaceFeature extractPalaceFeatures(Palace palace) {
        PalaceFeature feature = new PalaceFeature();
        feature.setPalaceNum(palace.getPalaceNum());
        
        
        feature.setDiPanWuxing(getWuxing(palace.getDiPan()));
        feature.setTianPanWuxing(getWuxing(palace.getTianPan()));
        
        
        feature.setStarStrength(calculateStarStrength(palace.getStar(), palace.getPalaceNum()));
        feature.setDoorStrength(calculateDoorStrength(palace.getDoor(), palace.getPalaceNum()));
        
        
        feature.setPatterns(detectPatterns(palace));
        
        return feature;
    }
    
    
    private GlobalFeature extractGlobalFeatures(BoardData board) {
        GlobalFeature feature = new GlobalFeature();
        
        
        Map<String, Integer> wuxingCount = new HashMap<>();
        for (Palace palace : board.getPalaces()) {
            String diPanWuxing = getWuxing(palace.getDiPan());
            wuxingCount.merge(diPanWuxing, 1, Integer::sum);
        }
        feature.setWuxingDistribution(wuxingCount);
        
        
        int auspiciousCount = 0;
        int inauspiciousCount = 0;
        for (Palace palace : board.getPalaces()) {
            List<String> patterns = detectPatterns(palace);
            for (String pattern : patterns) {
                if (isAuspicious(pattern)) auspiciousCount++;
                if (isInauspicious(pattern)) inauspiciousCount++;
            }
        }
        feature.setAuspiciousCount(auspiciousCount);
        feature.setInauspiciousCount(inauspiciousCount);
        
        return feature;
    }
    
    
    private double[] buildFeatureArray(FeatureVector vector) {
        List<Double> features = new ArrayList<>();
        
        
        for (PalaceFeature palaceFeature : vector.getPalaceFeatures()) {
            features.add(palaceFeature.getStarStrength());
            features.add(palaceFeature.getDoorStrength());
            features.add((double) palaceFeature.getPatterns().size());
        }
        
        
        features.add((double) vector.getGlobalFeature().getAuspiciousCount());
        features.add((double) vector.getGlobalFeature().getInauspiciousCount());
        
        
        double[] array = new double[features.size()];
        for (int i = 0; i < features.size(); i++) {
            array[i] = features.get(i);
        }
        
        return array;
    }
    
    
    private String getWuxing(String ganZhi) {
        
        if (ganZhi == null || ganZhi.isEmpty()) return "未知";
        char first = ganZhi.charAt(0);
        switch (first) {
            case '甲': case '乙': return "木";
            case '丙': case '丁': return "火";
            case '戊': case '己': return "土";
            case '庚': case '辛': return "金";
            case '壬': case '癸': return "水";
            default: return "未知";
        }
    }
    
    
    private double calculateStarStrength(String star, int palaceNum) {
        
        return Math.random();
    }
    
    
    private double calculateDoorStrength(String door, int palaceNum) {
        
        return Math.random();
    }
    
    
    private List<String> detectPatterns(Palace palace) {
        List<String> patterns = new ArrayList<>();
        
        if (palace.getStar() != null && palace.getDoor() != null) {
            patterns.add("测试格局");
        }
        return patterns;
    }
    
    
    private boolean isAuspicious(String pattern) {
        
        return pattern.contains("吉");
    }
    
    
    private boolean isInauspicious(String pattern) {
        
        return pattern.contains("凶");
    }
}

2. 基于余弦相似度的盘局对比引擎

通过余弦相似度算法计算盘局之间的相似度,实现高效的盘局对比分析。


@Service
public class BoardComparisonEngine {
    
    @Autowired
    private BoardFeatureExtractor featureExtractor;
    
    
    public ComparisonResult compareBoards(BoardData board1, BoardData board2) {
        ComparisonResult result = new ComparisonResult();
        result.setBoardId1(board1.getBoardId());
        result.setBoardId2(board2.getBoardId());
        
        
        FeatureVector vector1 = featureExtractor.extractFeatures(board1);
        FeatureVector vector2 = featureExtractor.extractFeatures(board2);
        
        
        double overallSimilarity = calculateCosineSimilarity(
            vector1.getFeatureArray(), 
            vector2.getFeatureArray()
        );
        result.setOverallSimilarity(overallSimilarity);
        
        
        List<PalaceComparison> palaceComparisons = new ArrayList<>();
        for (int i = 0; i < 9; i++) {
            PalaceFeature pf1 = vector1.getPalaceFeatures().get(i);
            PalaceFeature pf2 = vector2.getPalaceFeatures().get(i);
            
            PalaceComparison comparison = new PalaceComparison();
            comparison.setPalaceNum(i + 1);
            
            
            double starSimilarity = 1.0 - Math.abs(pf1.getStarStrength() - pf2.getStarStrength());
            comparison.setStarSimilarity(starSimilarity);
            
            
            double doorSimilarity = 1.0 - Math.abs(pf1.getDoorStrength() - pf2.getDoorStrength());
            comparison.setDoorSimilarity(doorSimilarity);
            
            
            Set<String> patterns1 = new HashSet<>(pf1.getPatterns());
            Set<String> patterns2 = new HashSet<>(pf2.getPatterns());
            double patternSimilarity = calculateJaccardSimilarity(patterns1, patterns2);
            comparison.setPatternSimilarity(patternSimilarity);
            
            
            double palaceSimilarity = (starSimilarity + doorSimilarity + patternSimilarity) / 3.0;
            comparison.setOverallSimilarity(palaceSimilarity);
            
            palaceComparisons.add(comparison);
        }
        result.setPalaceComparisons(palaceComparisons);
        
        
        String conclusion = generateConclusion(overallSimilarity, palaceComparisons);
        result.setConclusion(conclusion);
        
        return result;
    }
    
    
    private double calculateCosineSimilarity(double[] v1, double[] v2) {
        if (v1.length != v2.length) {
            throw new IllegalArgumentException("特征向量维度不一致");
        }
        
        double dotProduct = 0.0;
        double norm1 = 0.0;
        double norm2 = 0.0;
        
        for (int i = 0; i < v1.length; i++) {
            dotProduct += v1[i] * v2[i];
            norm1 += v1[i] * v1[i];
            norm2 += v2[i] * v2[i];
        }
        
        if (norm1 == 0 || norm2 == 0) {
            return 0.0;
        }
        
        return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
    }
    
    
    private double calculateJaccardSimilarity(Set<String> set1, Set<String> set2) {
        if (set1.isEmpty() && set2.isEmpty()) {
            return 1.0;
        }
        
        Set<String> intersection = new HashSet<>(set1);
        intersection.retainAll(set2);
        
        Set<String> union = new HashSet<>(set1);
        union.addAll(set2);
        
        return (double) intersection.size() / union.size();
    }
    
    
    private String generateConclusion(double overallSimilarity, List<PalaceComparison> palaceComparisons) {
        StringBuilder conclusion = new StringBuilder();
        
        if (overallSimilarity > 0.8) {
            conclusion.append("两个盘局整体高度相似,");
        } else if (overallSimilarity > 0.5) {
            conclusion.append("两个盘局整体中等相似,");
        } else {
            conclusion.append("两个盘局整体差异较大,");
        }
        
        
        PalaceComparison mostSimilar = palaceComparisons.stream()
            .max(Comparator.comparingDouble(PalaceComparison::getOverallSimilarity))
            .orElse(null);
        
        if (mostSimilar != null) {
            conclusion.append("其中第").append(mostSimilar.getPalaceNum()).append("宫最为相似;");
        }
        
        
        PalaceComparison leastSimilar = palaceComparisons.stream()
            .min(Comparator.comparingDouble(PalaceComparison::getOverallSimilarity))
            .orElse(null);
        
        if (leastSimilar != null) {
            conclusion.append("第").append(leastSimilar.getPalaceNum()).append("宫差异最大。");
        }
        
        return conclusion.toString();
    }
    
    
    @Data
    public static class ComparisonResult {
        private String boardId1;
        private String boardId2;
        private double overallSimilarity;
        private List<PalaceComparison> palaceComparisons;
        private String conclusion;
    }
    
    
    @Data
    public static class PalaceComparison {
        private int palaceNum;
        private double starSimilarity;
        private double doorSimilarity;
        private double patternSimilarity;
        private double overallSimilarity;
    }
}

三、 总结

AI奇门遁甲盘局对比分析的技术核心在于盘局数据的结构化处理与多维特征的量化计算。通过结构化解析与特征工程,将盘局信息转化为多维特征向量,为对比分析提供数据基础;结合余弦相似度与Jaccard相似度算法,实现盘局整体与宫位级别的精准对比,支持大规模盘局的实时分析;通过特征向量与相似度计算,将传统的人工对比转化为可量化的算法模型,提升分析效率与准确性。这种架构不仅适用于奇门遁甲盘局对比,也可推广至其他需要结构化数据对比与相似度计算的应用中,为高性能、高可用的传统文化智能化系统提供通用解决方案。

文章标签:

目录

相关文章

|

8天前

|

Linux Go 开发工具

手机上跑 DeepSeek 智能体:开源安卓客户端 DSH Go 安装与使用指南

DSH Go 是一款开源安卓客户端,将 DeepSeek Harness 智能体引擎装进手机:免 Root、免 Termux,一键安装即用;支持本机运行(内置 Ubuntu+Node.js)或远程接管电脑会话;具备插话打断、过程折叠、屏幕操控、端到端加密分享等特色功能,真正实现智能体“口袋化”。

9171 24 73

|

3天前

|

人工智能 安全 应用服务中间件

NGINX 爆出两处高危漏洞 可导致未经身份验证的远程代码执行

NGINX曝出两个高危漏洞(CVE-2026-123633和CVE-2026-123007),CVSS 9.2分,均属HTTP/2内存安全缺陷,无需认证即可远程执行代码。影响自2015年起的多个版本,静态站点亦受威胁。修复版本为开源版1.30.7/1.31.9。(239字)

1298 0 0

NGINX 爆出两处高危漏洞 可导致未经身份验证的远程代码执行

|

10天前

|

人工智能 前端开发 API

阿里云Qwen4-Max 大模型详解:定位、特征、能力、适用场景与相对Qwen3-Max差异解析

2026年11月11日,阿里发布第四代旗舰模型Qwen4-Max预览版,首发千问AI平台Token Plan并接入千问办公、Qoder等入口。该版本聚焦知识理解、世界感知、编程与Agentic四项升级,主打复杂编程、专业办公、前端设计与专业软件操作等真实任务。预览期为11月11日10:00至11月25日24:00,仅支持Token Plan调用,到期后模型标识下线;限时2折、新用户再享5折,最低1折可体验。

1970 2 3

|

10天前

|

JSON 前端开发 API

阿里云最新Qwen4-Max大模型介绍:模型定位、特征、能力、适用场景解析

2026 年 11 月 11 日,阿里发布第四代旗舰模型Qwen4-Max预览版,首发千问 AI 平台 Token Plan,并同步接入千问办公、Qoder 等入口。该版本聚焦知识理解、世界感知、编程与 Agentic 四项升级,主打复杂编程、专业办公、前端设计与专业软件操作。预览期至 11 月 25 日 24:00,到期后模型标识下线;限时 2 折、新用户再享 5 折,最低 1 折可体验。

2032 4 6

|

4天前

|

人工智能 弹性计算 IDE

Codex超详细入门指南(下载·安装·登录·上手,全版本覆盖,2026最新版)

适合团队落地代码规范,每次提交自动生成评审报告,降低人工CR工作量。同时支持自定义技能脚本,接入团队内部SDK说明文档,让Codex生成符合团队编码规范的代码。Codex三大客户端覆盖本地开发、服务器远程编码、自动化流水线场景,搭配阿里云百炼的Token Plan、Coding Plan,能够低成本搭建稳定可控的AI编码助手。新手建议先从IDE插件入手,熟悉交互逻辑,再尝试CLI版本部署在阿里云ECS,实现云上项目远程编码、批量脚本处理。只要按照步骤完成环境准备、版本选型、密钥对接、项目初始化,就可以把Codex融入日常开发流程,大幅提升代码编写、问题排查、项目重构的效率。

951 0 0

|

6天前

|

人工智能 弹性计算 开发工具

零成本玩各大模型!DeepSeek Harness dsh-our-free-model 插件,13 个厂商模型直接用

总结一下:装这个插件,你不用注册、不用绑卡、不用填一个 Key,就能在 DeepSeek Harness 里用上 DeepSeek V4.1 Flash、Kimi K3 这一批前沿模型,而且是白嫖的、还不限量。三步搞定:下载插件,复制包含 `package.json` 的插件目录路径,在「添加插件」里粘贴路径安装并重启。无论是在阿里云 ECS 上通过命令行部署的 Web 版,还是本地的 Electron 桌面端,都能顺利跑通,快速搭建一套零成本的免费模型使用环境。

1330 1 2

热门文章

最新文章

來源:阿里雲開發者社區 AI · developer.aliyun.com