基于产生式规则的动物识别系统的混合推理算法

最新推荐文章于 2024-02-01 09:38:26 发布
最新推荐文章于 2024-02-01 09:38:26 发布
阅读量1.4k 收藏 12
点赞数 1
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46146755/article/details/122558083
版权
基于产生式规则的动物识别系统的混合推理算法

正向推理：使数据和产生式左部匹配，对匹配成功的产生式执行其右部。

反向推理：把子目标和GDB中的数据或产生式右部匹配。与数据匹配成功者生成叶节点；产生式右部匹配成功者，则使该产生式左部成为新的子目标。

知识库：

R1： 如果 某动物有毛发（F1） 则 该动物是哺乳动物（M1）

R2： 如果 某动物有奶（F2） 则 该动物是哺乳动物（M1）

R3： 如果 某动物有羽毛（F3） 则 该动物是鸟（M4）

R4： 如果 某动物会飞（F4），且下蛋（F5） 则 该动物是鸟（M4）

R5： 如果 某动物吃肉（F6） 则 该动物是食肉动物（M2）

R6： 如果 某动物有锋利的牙齿（F7），且有爪（F8）， 且眼睛盯着前方（F9） 则 该动物是食肉动物（M2）

R7： 如果 某动物是哺乳动物（M1），且有蹄（F10） 则 该动物是有蹄类哺乳动物（M3）

R8： 如果 某动物是哺乳动物（M1），且反刍（F11） 则 该动物是有蹄类哺乳动物（M3），且偶蹄类

R9： 如果 某动物是哺乳动物（M1），且是食肉动物（M2）, 且黄褐色（F12），且有暗班（F13） 则 该动物是豹（H1）

R10：如果 某动物是哺乳动物（M1），且是食肉动物（M2）， 且黄褐色（F12），且有黑色条纹（F14） 则 该动物是虎（H2）

R11：如果 某动物是有蹄类哺乳动物（M3），且有长脖子 （F15），且有长腿（F16），且有暗斑（F13） 则 该动物是长颈鹿（H3）

R12：如果 某动物是有蹄类哺乳动物（M3）， 且有黑条纹（F14） 则 该动物是斑马（H4）

R13：如果 某动物是鸟（M4），且不会飞（F17）， 且有长脖子（F15），且有长腿（F16）， 且是黑白色（F18） 则 该动物是鸵鸟（H5）

R14：如果 某动物是鸟（M4），且不会飞（F17）， 且会游泳（F19）， 且是黑白色（F18） 则 该动物是企鹅（H6）

R15：如果 某动物是鸟（M4），且善飞（F20） 则 该动物是信天翁（H7）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-88k4bQx6-1642483263425)(C:\Users\pumpkin\AppData\Roaming\Typora\typora-user-images\image-20210413104013980.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fy91pDMV-1642483263426)(C:\Users\pumpkin\AppData\Roaming\Typora\typora-user-images\image-20210413172448711.png)]

public static int[][] pre = {{0},{1},{2},{3,4},{5},
        {6,7,8},{20,9},{20,10},{20,21,11,12},{20,21,11,13},
        {22,14,15,12},{22,13},{23,16,14,15,17},{23,16,18,17},{23,19}};


public static int[] after = {20,20,23,23,21,21,22,22,24,25,26,27,28,29,30};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qPTKTPLm-1642483263428)(C:\Users\pumpkin\AppData\Roaming\Typora\typora-user-images\image-20210413182742487.png)]

public static List<List<Integer>> getAvailRule(List<Integer> db){
        List<List<Integer>> availRule = new ArrayList<>();
        

        for (int i = 0; i < KB.rules().size(); i++) {
            int cou = 0;
            for (int j = 0; j < KB.rules().get(i).size(); j++) {
                for (int k = 0; k < db.size(); k++) {
                    if (db.get(k) == KB.rules().get(i).get(j)){
                        cou++;
                    }
                }
            }
            if (cou==KB.rules().get(i).size()) {
                availRule.add(KB.rules().get(i));
            }
        }
        return availRule;
    }

正向推理：

infer.java

import java.util.*;

public class Infer {
    public static void forward(){
        List<Integer> db = getDB();		//将初始事实集加入数据基中
        List<List<Integer>> availRule = getAvailRule(db); 	//扫描数据基和知识库，从知识库中寻找可用规则集

        List<List<Integer>> preRule = new ArrayList<>();
        while (availRule != null) {
            for (int i = 0; i < availRule.size(); i++) {
                if (preRule.contains(availRule.get(i))) continue;
                Integer value = KB.getMatch().get(availRule.get(i));
                System.out.println("由" + availRule.get(i) + "推出：" + value);
                db.add(value);
                preRule.add(availRule.get(i));
            }
            availRule = getAvailRule(db);

            int flag = 0;
            int result = 0;
            for (int j = 0; j < db.size(); j++) {
                if (KB.animal().contains(db.get(j))){
                    flag = 1;
                    result = db.get(j);
                    break;
                }
            }
            if(flag == 1) {
                System.out.println("此时，db为：" + db);
                System.out.println("推理结果:" + KB.factsKB.get(result));
                break;
            }
        }
    }

    public static List<Integer> getDB(){
        List<Integer> db = new ArrayList<>();
        Scanner in = new Scanner(System.in);
        System.out.println("请输入初始事实集的序号：");
        String fact = in.nextLine();
        String[] arr = fact.split(" ");
        for (int i = 0; i < arr.length; i++) {
            db.add(Integer.parseInt(arr[i]));
        }
        return db;
    }

    public static List<List<Integer>> getAvailRule(List<Integer> db){
        List<List<Integer>> availRule = new ArrayList<>();


        for (int i = 0; i < KB.rules().size(); i++) {
            int cou = 0;
            for (int j = 0; j < KB.rules().get(i).size(); j++) {
                for (int k = 0; k < db.size(); k++) {
                    if (db.get(k) == KB.rules().get(i).get(j)){
                        cou++;
                    }
                }
            }
            if (cou==KB.rules().get(i).size()) {
                availRule.add(KB.rules().get(i));
            }
        }
        return availRule;
    }
}

KB.java

import java.util.*;

public class KB {
    public static String[] list = new String[]{
            /*F1*/"有毛发",/*F2*/"有奶",/*F3*/"有羽毛",/*F4*/"会飞",/*F5*/"下蛋",
            /*F6*/"吃肉",/*F7*/"犀利牙齿",/*F8*/"有爪",/*F9*/"眼睛前视",/*F10*/"有蹄",
            /*F11*/"反刍动物",/*F12*/"黄褐色",/*F13*/"暗斑",/*F14*/"黑条纹",/*F15*/"长脖子",
            /*F16*/"长腿",/*F17*/"不会飞",/*F18*/"黑白色",/*F19*/"会游泳",/*F20*/"善飞",
            /*M1*/"哺乳动物",/*M2*/"食肉动物",/*M3*/"有蹄类",/*M4*/"鸟",
            /*H1*/"豹",/*H2*/"虎",/*H3*/"长颈鹿",/*H4*/"斑马",/*H5*/"鸵鸟",/*H6*/"企鹅",/*H7*/"信天翁"
    };

    public static List<String> factsKB = Arrays.asList(list);

    public static List<List<Integer>> rules(){
        List<List<Integer>> pre = new ArrayList<>();
        List<Integer> rule1 = new ArrayList<>();
        rule1.add(0);
        pre.add(rule1);

        List<Integer> rule2 = new ArrayList<>();
        rule2.add(1);
        pre.add(rule2);

        List<Integer> rule3 = new ArrayList<>();
        rule3.add(2);
        pre.add(rule3);

        List<Integer> rule4 = new ArrayList<>();
        rule4.add(3);
        rule4.add(4);
        pre.add(rule4);

        List<Integer> rule5 = new ArrayList<>();
        rule5.add(5);
        pre.add(rule5);

        List<Integer> rule6 = new ArrayList<>();
        rule6.add(6);
        rule6.add(7);
        rule6.add(8);
        pre.add(rule6);

        List<Integer> rule7 = new ArrayList<>();
        rule7.add(20);
        rule7.add(9);
        pre.add(rule7);

        List<Integer> rule8 = new ArrayList<>();
        rule8.add(20);
        rule8.add(10);
        pre.add(rule8);

        List<Integer> rule9 = new ArrayList<>();
        rule9.add(20);
        rule9.add(21);
        rule9.add(11);
        rule9.add(12);
        pre.add(rule9);

        List<Integer> rule10 = new ArrayList<>();
        rule10.add(20);
        rule10.add(21);
        rule10.add(11);
        rule10.add(13);
        pre.add(rule10);

        List<Integer> rule11 = new ArrayList<>();
        rule11.add(22);
        rule11.add(14);
        rule11.add(15);
        rule11.add(12);
        pre.add(rule11);

        List<Integer> rule12 = new ArrayList<>();
        rule12.add(22);
        rule12.add(13);
        pre.add(rule12);

        List<Integer> rule13 = new ArrayList<>();
        rule13.add(23);
        rule13.add(16);
        rule13.add(14);
        rule13.add(15);
        rule13.add(17);
        pre.add(rule13);

        List<Integer> rule14 = new ArrayList<>();
        rule14.add(23);
        rule14.add(16);
        rule14.add(18);
        rule14.add(17);
        pre.add(rule14);

        List<Integer> rule15 = new ArrayList<>();
        rule15.add(23);
        rule15.add(19);
        pre.add(rule15);

        return pre;
    }

//    public static int[][] pre = {{0},{1},{2},{3,4},{5},
//            {6,7,8},{20,9},{20,10},{20,21,11,12},{20,21,11,13},
//            {22,14,15,12},{22,13},{23,16,14,15,17},{23,16,18,17},{23,19}};

    public static int[] after = {20,20,23,23,21,21,22,22,24,25,26,27,28,29,30};

    public static Map<List<Integer>,Integer> getMatch() {
        Map<List<Integer>,Integer> match = new HashMap<>();
        for (int i = 0; i < after.length; i++) {
            match.put(rules().get(i),after[i]);
        }
        return match;
    }

    public static List<Integer> animal(){
        List<Integer> ani = new ArrayList<>();
        ani.add(24);
        ani.add(25);
        ani.add(26);
        ani.add(27);
        ani.add(28);
        ani.add(29);
        ani.add(30);
        return ani;
    }
}

Animal.java

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

public class Animal {
    public static void main(String[] args) {
        System.out.println("事实集如下：");
        for (int i = 0; i < KB.factsKB.size()-7; i++){
            System.out.println("事实" + (i) + ":" + KB.factsKB.get(i));
        }

        Infer.forward();
    }
}

未完善的

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

public class InferBackward {
    public static void backward() {
        Scanner in = new Scanner(System.in);
        for (int i = 0; i < KB.animal().size(); i++) {
            System.out.println(i + ":" + KB.factsKB.get(KB.animal().get(i)));
        }
        System.out.println("请问你觉得你看到的动物是什么？请输入序号：");
        int s = in.nextInt();
        int g = s + 24;

        System.out.println("事实集如下：");
        for (int i = 0; i < KB.factsKB.size()-7; i++){
            System.out.println("事实" + (i) + ":" + KB.factsKB.get(i));
        }
        System.out.println("请问你看到的事实都有哪些？请输入序号：");
        Scanner in1 = new Scanner(System.in);
        String fact = in1.nextLine();
        String[] arr = fact.split(" ");
        List<Integer> facts = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            facts.add(Integer.parseInt(arr[i]));
        }

        List<Integer> ach = new ArrayList<>();          //achieve返回一个列表
        List<Integer> achieve = achieve(g, ach);

        for (int i = 0; i < facts.size(); i++) {
            if(facts.get(i) != achieve.get(i)){
                System.out.println("该动物不是" + KB.factsKB.get(g));
                break;
            }
        }
        System.out.println("该动物是" + KB.factsKB.get(g));
    }

    public static List<List<Integer>> selRules(int g) {
        List<List<Integer>> ruleSet = new ArrayList<>();
        for (List<Integer> key : KB.getMatch().keySet()) {
            if (KB.getMatch().get(key).equals(g)) {
                ruleSet.add(key);
            }
        }
        return ruleSet;
    }

    public static List<Integer> achieve(int g, List<Integer> ach){
        List<List<Integer>> ruleset = selRules(g);

        if (ruleset == null ) {
            ach.add(g);
            return ach;
        }
        else {
            for (int i = 0; i < ruleset.size(); i++) {
                for (int j = 0; j < ruleset.get(i).size(); j++) {
                    achieve(ruleset.get(i).get(j),ach);
                }
            }
        }
        return ach;
    }
}

完全版

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

public class InferBackward {
    public static void backward() {
        Scanner in = new Scanner(System.in);
        for (int i = 0; i < KB.animal().size(); i++) {
            System.out.println(i + ":" + KB.factsKB.get(KB.animal().get(i)));
        }
        System.out.println("请问你觉得你看到的动物是什么？请输入序号：");
        int s = in.nextInt();
        int g = s + 24;

        System.out.println("事实集如下：");
        for (int i = 0; i < KB.factsKB.size()-7; i++){
            System.out.println("事实" + (i) + ":" + KB.factsKB.get(i));
        }
        System.out.println("请问你看到的事实都有哪些？请输入序号：");
        Scanner in1 = new Scanner(System.in);
        String fact = in1.nextLine();
        String[] arr = fact.split(" ");
        List<Integer> facts = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            facts.add(Integer.parseInt(arr[i]));
        }

        List<Integer> ach = new ArrayList<>();          //achieve返回一个列表
        List<Integer> achieve = achieve(g, ach, facts);

        for (int i = 0; i < facts.size(); i++) {
            if(facts.get(i) != achieve.get(i)){
                System.out.println("该动物不是" + KB.factsKB.get(g));
                break;
            }
        }
        System.out.println("该动物是" + KB.factsKB.get(g));
    }

    public static List<List<Integer>> selRules(int g) {
        List<List<Integer>> ruleSet = new ArrayList<>();
        for (List<Integer> key : KB.getMatch().keySet()) {
            if (KB.getMatch().get(key).equals(g)) {
                ruleSet.add(key);
            }
        }
        return ruleSet;
    }

    public static List<Integer> achieve(int g, List<Integer> ach, List<Integer> facts){
        List<List<Integer>> ruleset = selRules(g);

        if (ruleset.isEmpty() ) {
            if (facts.contains(g)){
                ach.add(g);
                return ach;
            }
        }
        for (int i = 0; i < ruleset.size(); i++) {
            for (int j = 0; j < ruleset.get(i).size(); j++) {
                achieve(ruleset.get(i).get(j),ach,facts);
            }
        }
        return ach;
    }
}

s){
List<List> ruleset = selRules(g);

    if (ruleset.isEmpty() ) {
        if (facts.contains(g)){
            ach.add(g);
            return ach;
        }
    }
    for (int i = 0; i < ruleset.size(); i++) {
        for (int j = 0; j < ruleset.get(i).size(); j++) {
            achieve(ruleset.get(i).get(j),ach,facts);
        }
    }
    return ach;
}

}
Pumpkin-_-
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
**基于产生式规则的动物识别系统正反向混合推理（Python）**
01-20
产生式系统 把一组领域相关的产生式（或称规则）放在一起，让它们互相配合、协同动作，一个产生式生成的结论一般可供另一个（或一些）产生式作为前提或前提的一部分来使用，以这种方式求得问题之解决，这样的一组产生式被称为产生式系统 产生式系统的构成 一组规则 每条规则分为左部（或称前提、前件）和右部（或称结论、动作、后件）。通常左部表示条件，核查左部条件是否得到满足一般采用匹配方第 3 页法，即查看数据基DB（Data Base）中是否存在左部所指明的情况，若存在则认为匹配成功，否则认为匹配失败。一般说来，匹配成功则执行右部所规定的动作，例如：添加、修改和删除等。 数据基 DB 中存放的数据既是产生式作
Python 人工智能实战|产生式规则推理系统：动物识别系统、智能客服系统
最新发布
Yaoyao2024的博客
04-01 2242
实现一个简单的自动问答系统。要求系统能够实现如下功能：如果用户"询问产品"，则显示"了解您想了解的产品信息，请问您具体对哪些产品感兴趣？如果用户"询问价格"，则显示"您可以在我们的官方网站上查询到最新的产品价格信息。如果用户"询问库存"，则显示"您所感兴趣的产品目前还有货，您可以直接在官网进行购买。如果用户"投诉"，则显示"非常抱歉给您带来不便，请您提供您的订单号，我们会尽快为您解决问题。
建造一种由基于案例推理和规则推理相结合的求解系统
u012632105的博客
09-04 186
综上所述，建造一种由基于案例推理和规则推理相结合的求解系统需要收集案例和推理规则、设计结构、实现基于案例推理的求解、实现规则推理的求解、结合案例推理和规则推理以及测试和优化等步骤。对一类问题求解来说,若有部分案例(case),而有较多的推理规则(知识),试问如何建造一种由基于案例推理和规则推理相结合的求解系统,以使推理效率高又能求得问题的解。设计结构：设计基于案例推理和规则推理相结合的求解系统的结构。收集案例和推理规则：收集具有代表性的案例，并从中提取出推理规则，这些推理规则应该能够覆盖大部分情况。
产生式正向推理和逆向推理程序
langwen2048的博客
10-29 1万+
最近人工智能课程结束，本来是考试课，但老师说不用考试，交个设计就行。我就喜欢这样的老师，为我老师点赞，顺便diss一下上课念ppt，停电就没法上课，考试靠死记硬背的某些老师。扯得有点远了，先说说产生式的存储，我是用c#语言中动态数组ArrayList存储的： //规则中的每个子条件及结论都是一个结构体类型： private struct Pre { ...
神经+符号知识推理论文浅读4篇
自学小角落
06-30 2764
符号推理与神经网络方法的结合研究
产生式推理系统
qq_58894413的博客
11-04 1462
动物产生式推理系统（正向推理）
常见开源规则引擎对比分析
热门推荐
wjc133的专栏
12-30 1万+
0x00 目的背景 电商会员服务的等级、积分、权益等模块中，都使用了大量的规则判断。范式基本上是 达成xxx条件，执行xxx行为 。这很符合规则引擎那一套，因此下面选取了几个业界常见的规则引擎进行分析。 我们分别都从使用角度、原理角度两个方面进行分析。 0x01 easy-rules 项目地址：https://github.com/j-easy/easy-rules 1. 规则模型 ![image.png](https://img-blog.csdnimg.cn/img_convert/b5724b0dcd
第八章 基于规则的分类
moving
08-02 7754
1、使用IF-THEN规则分类 规则是表示信息或少量知识的好方法。基于规则的分类器使用一组IF—THEN规则进行分类。一个IF—THEN规则是一个如下的表达式： IF条件THEN结论 规则R1是一个例子： R1:IF age=youth AND student=yes THEN buys_computer=yes 也可以写作 R1:(age=youth)^(student=yes)=
sap模块有哪些_海纳易拓｜图文讲解SAP MM模块「采购价格条件」
weixin_39647458的博客
12-08 1407
MM物料管理是SAP R/3系统的一个模块，支持日常发生的业务处理功能和过程。MM系统(物料管理)的目的是满足下列各种处理，即物料需求计划、物料采购、库存管理、发票确认和物料估价。主要包括:物料需求计划、物料主数据、采购、库存管理、仓库管理、发票校验、后勤信息系统等几个组成部分。条件技术的应用条件是跟时间有关系的不同时间段会有不同的价钱定价日期控制通常，定价日期和采购订单的凭证日期相同1. 根据采...
基于C#实现的小型动物识别推理系统
毕业作品网站
07-04 2046
制作小型动物识别系统进行正向推理1 熟悉和掌握产生式系统的构成和运行机制；2 掌握基于规则推理的基本方法和技术，掌握正确的正向推理和逆向推理方法；3 熟悉在具体问题中如何实现正向推理和逆向推理的求解流程。以动物识别系统为例，用选定的编程语言建造规则库和综合数据库，并能对它们进行增加、删除和修改操作，开发能进行正确的正向推理或反向推理的推理机。1)规则采用文件记录每一条规则由“：”分割，在每一条规则中，每一个事实用空格分开，最后一个为结论，当需要加入规则时可以在文件中直接加入也可以在窗体中加入。2)在程序中所
em算法matlab代码-gmm:Matlab中的高斯混合模型和推理算法
05-26
em算法matlab代码Matlab中的高斯混合模型和推理算法 Matlab演示有关高斯混合模型（GMM）和具有EM和变分推理的推理算法 参考 克里斯托弗·毕晓普（Christopher M. Bishop）。 2006。模式识别和机器学习（信息科学与...
两种新颖的基于自组织图的混合情感学习算法
03-07
此外，我们将稀疏在线SOM（SOR-SOM）算法纳入了我们的情感神经网络学习算法，并建立了基于稀疏在线关系的基于SOM的情感神经网络（Em-SOR-SOM）混合模型，从而使SOR-可以利用SOM进一步提高模型的识别性能。...
基于轻量型卷积神经网络的交通标志识别方法.pdf
09-25
基于轻量型卷积神经网络的交通标志识别方法 本文提出了一种基于轻量型卷积神经网络的交通标志识别方法，旨在解决现有卷积神经网络模型在交通标志识别设备中的缺陷，例如内存占用高、训练速度慢、计算开销大。为了...
知识图谱推理与实践 (2) -- 基于jena实现规则推理
weixin_38168198的博客
09-06 1429
本章，介绍 基于jena的规则引擎实现推理，并通过两个例子介绍如何coding实现。 规则引擎概述 jena包含了一个通用的规则推理机，可以在RDFS和OWL推理机使用，也可以单独使用。 推理机支持在RDF图上推理，提供前向链、后向链和二者混合执行模式。包含RETE engine 和 one tabled datalog engine。可以通过GenericRuleReasoner来进行...
知识图谱推理研究综述9.3
RM_Jin的博客
09-03 322
知识图谱是以图的形式表示真实世界的实体与关系之间关系的知识库。具体来说知识图谱是通过将应用数学、图形学、信息可视化技术、信息科学等学科的理论、方法、与计量学引文分析、共现分析等方法结合，并利用可视化的图谱形象地展示其核心结构、发展历史、前沿领域以及整体知识构架，达到多学科融合目的的现代理论。
基于规则推理的知识处理方法比较
cooldream2009的博客
02-01 1125
在知识处理领域，本体推理是一种常见的方法，但其局限性在于无法支持规则型知识的推理，且推理过程缺乏自定义性。为解决这一问题，我们可以结合本体推理和规则推理，基于逻辑语言，使得知识库和数据库的推理更加灵活。本文将深入探讨基于Datalog的规则推理以及基于产生式规则的推理，比较两者的特点和应用场景。
推理计算过程_人工神经网络的泛化性和正向网络推理
weixin_42104778的博客
01-14 796
基于神经网络的知识推理实质上是在一个已经训练成熟的网络基础上对未知样本进行反应或者判断。神经网络的训练是一个网络对训练样本内在规律的学习过程，而对网络进行训练的目的主要是为了让网络模型对训练样本以外的数据具有正确的映射能力通常定义神经网络的泛化能力，也称推广能力，是指神经网络在训练完成之后输入其训练样本以外的新数据时获得正确输出的能力。它是人工神经网络的一个属性，称为泛化性能。不管是什么类型的网络...
matlab——一个简单的动物识别专家系统
行秋的博客
05-15 8148
function animal() %animal.m 动物识别专家系统 H=feature(); %输入需要进行识别动物的特征信息 clc; [A,flag]=distinguish(H); %正向推理输入信息 explain(A,flag); %对推理给出必要的解释 return; function y=feature() %inputdata.m 建立知识库，要求用户输入数据% H=zeros(20,1); %知识库，存放系统求解问题所需要的知识，T为动物特征信息的数组 disp('All th.
基于产生式规则的动物识别系统正反向混合推理 python
03-25
A：基于产生式规则的动物识别系统是一种基于规则的专家系统，利用已知的规则和先验知识对输入的数据进行处理和识别。...通过以上方法，我们可以搭建一套基于产生式规则的动物识别系统，并利用Python语言实现其算法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值