人工智能复习期末冲刺（WUST）（大学课程）

最新推荐文章于 2023-03-01 16:01:43 发布

葛济维的博客

最新推荐文章于 2023-03-01 16:01:43 发布

阅读量2k

点赞数 19

分类专栏：大学笔记文章标签：人工智能机器学习

本文链接：https://blog.csdn.net/qq_26139541/article/details/112062623

版权

大学笔记专栏收录该内容

2 篇文章 0 订阅

订阅专栏

人工智能复习期末冲刺

补充:
元知识: 元知识是如何有效获取知识的知识

知识点总结

注意：在往年题中考过的知识点（名词解释）未整理到此博客

1.知识的表示方法

谓词逻辑、产生式、语义网络、框架

2.知识表示的可理解性和完备性

1 知识表示的可理解性：计算机中所表示的知识，人是否理解
2 完备性：智能系统中的知识表示方法是否表达全部可能出现的知识

3.归结原理

采用反证法思想，将结论取反和前提组成谓词公式并转化为子句集，在子句集中反复利用归结方法进行推理，挑选两个亲本子句，如果得到空子句则成功退出，否则得到的归结式添加到原来的子句集

4.演绎推理、归纳推理、类比推理

演绎推理：演绎推理是从已知的一般性知识出发，推理出适合于某种个别情况的结论的过程，他是一种由一般到个别的推理方法。

归纳推理：归纳推理是从大量特殊实例出发，归纳出一般性结论的推理过程，是一种由个别到一般的推理方法。

类比推理：类比推理是指在两个或两类事物有许多属性都相同或相似的基础上，推出他们在其他属性上也相同或相似的一种归纳推理。

推理的方向:

正向推理：正向推理是一种从已知事实出发、正向使用推理规则的推理方式，他是一种数据驱动的推理方式。

反向推理：反向推理是一种以某个假设目标为出发点，反向运用推理规则的推理方式。他是一种目标驱动的推理方式。

5.单调推理、非单调推理

单调推理：是指在推理过程中，由于新知识的加入和使用，是推理所得到的结论会越来越接近于最终目标，而不会出现反复情况，即不会由于新知识的加入否定了前面推出的结论，从而使推理过程又退回到前面的某一步。

非单调推理：在推理过程中，当某些新知识加入后，不但没有加强已经推出的结论，反而会否定原来已推出的结论，使推理过程要退回到先前的某一步，重新进行推理。

6.盲目搜索、启发式搜索

盲目搜索：在搜索过程中,只按预先规定的搜索控制策略进行搜索,而没有任何中间信息来改变这些控制策略.

启发式搜索：启发式搜索就是在状态空间中,对每一个搜索的状态进行评估,得到最有希望的状态,再从这个状态进行搜索直到目标

7.评估函数（估价函数）、启发函数

估价函数：用来表示节点的"希望"程度的函数，他的一般形式为f(x)=g(x)+h(x)

g(x)为初始节点 $S_0$ 到节点 $x$ 已实际付出的代价；

h(x)是从节点 $x$ 到目标节点 $S_g$ 的最优路径的估计代价，搜索的启发信息主要由h(x)来体现，称为启发函数

启发函数：从节点 $x$ 到目标节点 $S_g$ 的最优路径的估计代价

8.全局最优、局部最优

局部择优搜索：每次只在后继节点的范围内选择下一个要考察的节点，范围比较小，所以称为局部择优搜索

局部择优搜索是一种启发式搜索

全局择优搜索：在OPEN表中的全部节点中选择一个估价函数值f(x)最小的节点，作为下一个被考察的节点，因为选择的范围时OPEN表中的全部节点，所以称为全局择优搜索

9.机器学习

机器学习是研究如何使用计算机来模拟人类学习活动的一门学科。更严格地说，就是研究计算机获取新知识和新技能、识别现有知识，不断改善性能、实现自我完善的方法。

机器学习的主要策略：机械学习、传授学习、演绎学习、归纳学习、类比学习

10.图灵实验

“图灵实验”，是为了判断一台机器是否具备智能的实验。实验由三个封闭的房间组成，分别放置主持人、参与人和机器。主持人向参与人和机器提问，通过提问的结果来判断谁是人，谁是机器，如果主持人无法判断谁是人，谁是机器，则这台机器具备智能，即所谓的“智能机器”

11.状态空间法

一般把这种可能的解或解的每一个步骤表示为一个状态,这些状态的全体形成一个状态空间,然后在这个状态空间中以相应的搜索算法为基础来表示和求解问题.这种基于状态空间的问题表示和求解方法就是状态空间法.

12.A*算法

A算法是一个可采纳的最好优先算法.A算法的估价函数可表示为 $f^*(x)=g^*(x)+h^*(x)$ ,这里 $f^*(x)$ 是估价函数, $g^*(x)$ 是起点到终点的最短路径值, $h^*(x)$ 是n到目标的最短路径的启发值.

A搜索算法与A搜索算法的区别:A搜索算法中要求启发函数 $h(x)\leq h^*(x)$ ,其中h*(x)为状态n到目标状态的最小估价值.而A搜索算法对启发函数没有此要求. 或 A*搜索算法能搜索到最优解,而A搜索算法不能

二.大题公式总结

$=\frac{LS \times P(H)}{(LS-1)\times P(H)+1}$
$P(H|∽E)=\frac{LN \times P(H)}{(LN-1)\times P(H)+1}$
在这里插入图片描述

题型总结及例题

题型
一、填空题（20分）
二、名词解释（20分）
三、简答题（20分）
四、推理题（20分）
五、设计题（20分），需要用任一种代码实现。

题型一、简答题

例题一、一阶谓词逻辑表示法表示知识的步骤（简答题）

做题步骤：1.定义谓词 2.变元赋值 3.化为谓词公式
例题：
在这里插入图片描述

例题二、知识表示

例题：机器人把物体A移动到B位置，让你用合适的知识表示方法进行表示
做题步骤：
1.定义描述状态的谓词
2.写出问题的初始状态和目标状态
3.定义描述操作的谓词，每个操作需要写出条件和动作

例题在2016年习题上

例题三、归结原理（推理题）

做题步骤：
1.将题目所给信息化为谓词公式
2.将谓词公式化为子句集
3.利用归结原理进行归结
4.得出结论
例题：
在这里插入图片描述

题型二、不确定推理方法（推理题）

可信度推理方法

在这里插入图片描述

主观Bayes推理方法（不太懂）

$=\frac{LS \times P(H)}{(LS-1)\times P(H)+1}$
$P(H|∽E)=\frac{LN \times P(H)}{(LN-1)\times P(H)+1}$

课本例题很多

题型三、搜索方法（状态空间表示法）

例题1：

二阶梵塔问题设有三根柱子，在1号柱子上穿有A、B两个盘片，盘A小于盘B，盘A位于盘B的上面。要把这两个盘片全部移到另一根柱子上，而且规定每次只能移动一片，任何时刻都不能使盘B位于盘A的上面。画出二阶梵塔问题的状态空间有向图，并给出问题的解

做题步骤：

1.列出可能的状态

2.列出算符

3.写出问题的解

解：设用S=（xA, xB）表示问题的状态，
xA表示盘A所在的柱号，xB表示盘B所在的柱号。
全部可能的状态有以下9种：
S0=（1,1） S1=（1,2） S2=（1,3） S3=（2,1） S4=（2,2）
S5=（2,3） S6=（3,1） S7=（3,2） S8=（3,3）
问题的初始状态集合为S={S0}，
目标状态集合为G={S4,S8}。
算符： A(i, j)表示把盘A从柱i移到柱j上；
B(i, j)表示把盘B从柱i移到柱j上。
共有12个算符，它们分别是：
A(1,2)，A(1,3)，A(2,1)，A(2,3)，A(3,1)，A(3,2)
B(1,2)，B(1,3)，B(2,1)，B(2,3)，B(3,1)，B(3,2)

例题2:

应用状态空间的搜索策略求解最短
路径问题：求从城市A经过每个城市最多一次到
达城市E的最小交通费用的解

在这里插入图片描述

做题步骤：

（1）给出问题求解的状态定义
（2）给出问题求解的算符定义
（3）应用有代价宽度优先搜索求解或有代价深度优先搜索求解或全局优先搜索

宽度搜索和深度搜索方法可参照数据结构里面的思想

全局优先搜索在搜索时，必须选择open表中最短的路径去走，而且要写估计函数、代价函数、启发函数(这里我看不太懂)

开始：

（1）状态定义

初态：S0 = A
终态：Sg = E

（2）算符定义
go(x,y) 表示从城市x走到城市y。
使用条件：当前状态Si城市名字是x
算符操作：当前状态Si城市名字是y

FK 算符算符代价 FK 算符算符代价
F1 go(A,B) 4 F7 go(C,D) 2
F2 go(A,C) 3 F8 go(D,B) 4
F3 go(B,A) 4 F9 go(D,C) 2
F4 go(B,D) 4 F10 go(D,E) 3
F5 go(B,E) 5 F11 go(E,B) 5
F6 go(C,A) 3 F12 go(E,D) 3

（3）应用有代价深度优先搜索求解
Loop1: closed = ( A(0) )
open = ( C(3) , B(4) )
Loop2: closed = ( A(0) , C(3) )
open = (D(5) , B (4))
Loop3: closed = ( A(0) ,C(3) , D(5) )
open = ( E (8) , B (4) )
Loop4: closed = ( A (0) , C (3) , D (5) , E (8) )
E是目标状态，故算法成功终止。
open = ( B (4) )

这里解释一下：

closed表是已经走过的点集合，open表是可以到达的点集合。

上面closed表刚开始是A(0)意思是从A点开始，然后open表中是C和B因为A点可以到达C和B，C(3)是因为路径是3，然后挑一个点继续走，挑C点，然后C点从open表移动到closed表，C点可以到达D点，所以closed表中加入了D点，D(5)是因为D离起点A的距离是5，以此类推

在这里插入图片描述

题型四、设计题

例题传教士与野人代码实现

（可能会考（不确定

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
/**搜索路径**/
const int maxn=105;
int real_step;
int limit_step=25;
// Path 结构体，代表状态   path[]: answer path 上的状态序列
struct Path{
    //（左岸传教士个数，左岸野人个数，船在左岸）或者 （右岸传教士个数，右岸野人个数，船在右岸）
    int missionary,wildman,boat_loc;   
}path[maxn];//path：结构体数组，每个元素是一个Path对象即状态
// 检测 a、b、c、d 是否满足传教士不被野人吃掉的条件
// a:乘船后某岸剩余传教士数量  b:乘船后某岸剩余野人数量  c:乘船后另一岸传教士数量  d：乘船后另一岸野人数量
bool check(int a,int b,int c,int d){
 	 return (a==0||a>=b)&&(c==0||c>=d);
}

// 状态：[missionary: 某岸传教士数量  wildman: 某岸野人数量  boat_loc:船的位置]
//深度优先搜索 此处采用递归，没用栈和队列


//  step: 第step次过河     limit_step:限制的最多次数
bool dfs(int missionary,int wildman,int boat_loc,int step)
{
    path[step]=Path(missionary,wildman,boat_loc);
    // 如果满足边界条件step达到了limit_step值结束递归调用
    if(missionary==3&&wildman==3&&boat_loc==1)
       {real_step = step;
        // 返回此时状态是否满足目标状态[3,3,1]
        return true;
       }
    // 结束递归调用的另一个条件
    if(step>limit_step)
        return false;
    // a:乘船后某岸剩余传教士数量  b:乘船后某岸剩余野人数量  c:乘船后另一岸传教士数量  d：乘船后另一岸野人数量
    int a,b,c,d;
    //如果某岸传教士数量>=2 方法:(2,0)
    if(missionary>=2){
        //2:乘船传教士数量  0:乘船野人数量
        a=missionary-2,b=wildman;
		c=3-a,d=3-b;
        // 如果 a,b,c,d 满足条件
        if(check(a,b,c,d)){
           // step+1: 第step+1次  limit_step:
           if( dfs(c,d,!boat_loc,step+1) )
              return true;
        }
    }
    //如果某岸野人数量>=2 方法:(0,2)
    if(wildman>=2){
        //0:乘船传教士数量    2:乘船野人数量
        a=missionary,b=wildman-2;
	    c=3-a,d=3-b;
        // 如果 a,b,c,d 满足条件
        if(check(a,b,c,d)){
           // step+1: 第step+1次   limit_step:
           if( dfs(c,d,!boat_loc,step+1) )
              return true;
        }
    }
    // 如果某岸传教士数量>=1并且某岸野人数量>=1 方法:(1,1)
    if(missionary>=1&&wildman>=1){
        //1:乘船传教士数量   1:乘船野人数量
        a=missionary-1,b=wildman-1;
	    c=3-a,d=3-b;
        //如果 a,b,c,d 满足条件
        if(check(a,b,c,d)){
           // step+1: 第step+1次   limit_step:
           if( dfs(c,d,!boat_loc,step+1) )
              return true;
        }
    }
    // 如果某岸传教士数量>=1 方法:(1,0)
    if(missionary>=1){
        //1:乘船传教士数量    0:乘船野人数量
        a=missionary-1,b=wildman;
	    c=3-a,d=3-b;
        //如果 a,b,c,d 满足条件
        if(check(a,b,c,d)){
           //  step+1: 第step+1次   limit_step:
           if( dfs(c,d,!boat_loc,step+1) )
              return true;
        }
    }
    // 如果某岸野人数量>=1 方法:(0,1)
    if(wildman>=1){
        //0:乘船传教士数量     1:乘船野人数量
        a=missionary,b=wildman-1;
	    c=3-a,d=3-b;
        //如果 a,b,c,d 满足条件
        if(check(a,b,c,d)){
            // step+1: 第step+1次   limit_step:
           if( dfs(c,d,!boat_loc,step+1) )
              return true;
        }
    }

    return false;
}

//
int main()
{

    //如果dfs function返回真值，说明已到达目标状态，结束循环不再继续搜索;
    //如果dfs function返回假值，说明还没有到达目标状态，继续搜索.
    //missionary:左岸传教士数量：3； wildman:左岸野人数量：3； boat_loc:船的位置：0即左岸； step:深度优先搜索步骤：第0次；  limit_step:限制的最多次数
    if(dfs(3,3,0,0))
      {
       // 输出初始状态
       printf("初始状态:(3,3,0)\n");
       //循环输出每一次渡河后岸上的状态（交替输出左右两岸的情况）和每次渡河动作，即 answer path
	   for(int i=1;i<=real_step;i++)
       {   // x:乘船的传教士个数  y:乘船的野人个数 
           int x=path[i-1].missionary+path[i].missionary-3;
           int y=path[i-1].wildman+path[i].wildman-3;
           // 如果船在右岸  0：左岸  1：右岸
           if(path[i].boat_loc==1){
              printf("%d个传教士和%d个野人乘船从左岸到右岸:",x,y);
            }
           // 如果船在左岸 0：左岸  1：右岸
            else{
              printf("%d个传教士和%d个野人乘船从右岸到左岸:",x,y);
            }
            //输出状态:（左岸传教士个数，左岸野人个数，船在左岸）或者 （右岸传教士个数，右岸野人个数，船在右岸）
            printf("(%d %d %d)\n",path[i].missionary,path[i].wildman,path[i].boat_loc);
       }
      }
    else printf("no answer\n");
      return 0;
}