HNU-人工智能-作业1

人工智能-作业1

计科210x 甘晴void

第1题

考虑一个实时的在线电话翻译系统，该系统实现英语与日语之间的实时在线翻译，讨论该系统的性能度量，环境，执行器，感知器，并对该环境的属性进行分析。（10分）

答：

  1. 性能度量：

    • 实时性：系统需要能够在用户说话之后的几秒内提供翻译结果，延迟应尽可能地小。

    • 准确性：翻译结果应尽可能地准确，尽可能贴近在另一种语言的原本含义，避免语义失真或误译。

    • 稳定性：系统应该在长时间运行过程中保持稳定，避免崩溃或意外中断，维持好的用户体验。

    • 并行性：系统应该能够处理多个用户同时进行的翻译请求，而不降低性能。

    • 安全性：由于涉及到用户的语音数据和个人信息，系统需要具有高度的安全性，确保数据不被泄露或被未经授权的人访问。

  2. 环境：

    • 用户动作：用户是否输入语音，以及输入日文/英文语音

    • 网络环境：系统需要可靠的网络连接，以确保语音数据能够及时传输。

    • 语音环境：用户可能在各种环境中使用系统，包括有噪音的环境或网络质量较差的地方，系统需要能够处理这些情况。

  3. 执行器：

    • （以英语翻译日语为例，日语翻译英语同理）

    • 语音识别模块：将用户说的英语语音转换为英语文本。

    • 翻译引擎：将英语文本翻译成日语文本。

    • 语音合成模块：将日语文本转换为日语语音。

  4. 感知器：

    • 语音输入：接收用户说的英语语音。

    • 文本输入：接收语音识别模块输出的英语文本。

    • 文本输出：接收翻译引擎输出的日语文本。

    • 语音输出：接收语音合成模块输出的日语语音。

    • （以上为包括内部模块的，如果只考虑将这个系统作为一个黑盒，则只有对外的一个麦克风，用于接收用户输入）

  5. 环境属性分析：

    • 完全可观察：假设传感器运作都正常，则环境（用户输入的语音、网络环境等）是完全可观察的。

    • 单Agent：显然只有一个智能体，即翻译器。

    • 随机的：环境的下一状态不取决于Agent执行的动作。

    • 静态的：Agent计算时环境不会变化，这里指已经读入的语音信息不会随着翻译的进行而随时变化，在翻译时是静态的。但若是同声传译则有可能随读入而发生变化，这个暂不考虑。

    • 连续的：读入的语音是连续的，但在解析时会转化为离散的向量（这里书上也标注过不好区分）。

    • 已知的：假定处理翻译的模型是一个预训练好的模型，那么处理翻译的规则是给定的，不会随读入而发生变化。

第2题

考虑一个医疗诊断系统的agent，讨论该agent最合适的种类(简单agent,基于模型的agent,基于目标的agent和基于效用的agent)并解释你的结论。（10分）

答：

  1. 简单反射Agent：

    简单反射Agent是一种基本的反应式Agent，它只根据当前的输入执行特定的操作，而不考虑过去或未来的状态。简单Agent适用于一些简单的诊断任务，基于单一指标或症状的诊断，例如测量体温并根据特定的阈值判断是否发烧。但对于复杂的疾病诊断，简单Agent不够灵活和智能。

  2. 基于模型的反射Agent：

    基于模型的反射Agent通过对环境的建模来进行决策，它能够考虑到环境中的动态变化以及行为的长期影响。基于模型的Agent可以利用医学知识库和患者历史数据来建立模型，以更准确地诊断疾病。它还可以学习医学知识和历史病例来不断改进自己的模型，从而提高诊断的准确性和效率。

  3. 基于目标的Agent：

    基于目标的Agent会考虑到目标的重要性和实现目标的各种可能方法，并选择最佳的行动方案以达到预期的目标。我们假设目标是尽快准确地诊断疾病，以便采取适当的治疗措施。这种Agent会根据病情的严重程度和紧急性来优先考虑诊断某些疾病，从而提高治疗的及时性和有效性。

  4. 基于效用的Agent：

    基于效用的Agent会评估不同行动的效用，并选择对整体效用最大化的行动。这里效用可能包括诊断准确性、治疗成功率、患者生存率等因素。这种Agent可以帮助医生在面临多种诊断选择时做出理性的决策，以最大程度地提高整体的医疗效果。

我认为基于效用的Agent会更好。因为不论治疗措施如何，治疗方式如何，对于病人来说，最终的治疗效果才是检验治疗的唯一标准。简单反射显然不满足医疗这种复杂情况，基于目标和可能无法很好定义目标函数从而降低效果，故我认为可能基于效用的Agent会更好。

第3题

先建立一个完整的搜索树，起点是S,终点是G,如下图,节点旁的数字表示到达目标状态的距离，然后用以下方法表示如何进行搜索，并分析这几种算法的完备性、最优性、以及时间复杂度和空间复杂度。（40分） (a).深度优先； (b).宽度优先； (c).爬山法； (d).贪婪最佳优先。

解：先给出搜索树，再分析问题，再给出几种算法的完备性、最优性、以及时间复杂度和空间复杂度。

（1）深度优先

假设在扩展节点时按照序号升序选择，若无可扩展节点就回溯。

S -> A -> B -> C(无可扩展节点，回溯回B) -> D -> G

核心代码如下：

 bool dfs_visited[N] = {0};
 void dfs(int goal, node &src, Graph &graph)
 {
     if (src.name == goal)
     {
         cout << src.cname << endl;
         return;
     }
     dfs_visited[src.name] = 1;
     cout << src.cname << " -> ";
     for (int i = 0; i < N; i++)
     {
         if (graph.getEdge(src.name, i) == 1 && !dfs_visited[i])
         {
             node des(i);
             dfs(goal, des, graph);
         }
     }
 }

（2）宽度优先

假设在扩展节点时按照序号升序选择。

S -> A/B, A -> D, B -> C, C无可扩展节点， D -> G

访问顺序应该是S -> A -> B -> D -> C -> G

核心代码如下：

 void bfs(int goal, node &src, Graph &graph)
 {
     bool bfs_visited[N] = {0};
     queue<node> q;
     q.push(src);
     while (!q.empty())
     {
         node src = q.front();
         q.pop();
         bfs_visited[src.name] = 1;
         if (src.name == goal)
         {
             cout << src.cname << endl;
             break;
         }
         cout << src.cname << " -> ";
         for (int i = 0; i < N; i++)
         {
             if (graph.getEdge(src.name, i) == 1 && !bfs_visited[i])
             {
                 node des(i);
                 bfs_visited[i] = 1;
                 q.push(des);
                 // cout << "extend" << i << endl;
             }
         }
     }
     return;
 }

（3）爬山法

爬山法总是选择邻居状态中最好的（该问题下是值最小的）节点

访问顺序S -> A -> D -> G

核心代码如下：

 bool cm_visited[N] = {0};
 const int MAXNUM = 99999;
 void climb_mountain(int goal, node &src, Graph &graph)
 {
     if (src.name == goal)
     {
         cout << src.cname << endl;
         return;
     }
     cm_visited[src.name] = 1;
     cout << src.cname << " -> ";
     int h_best = MAXNUM;
     int next_visit;
     for (int i = 0; i < N; i++)
     {
         if (graph.getEdge(src.name, i) == 1 && !cm_visited[i])
         {
             if (h[i] < h_best)
             {
                 h_best = h[i];
                 next_visit = i;
             }
         }
     }
     node des(next_visit, h_best);
     climb_mountain(goal, des, graph);
 }

（4）贪婪最佳优先

贪婪最佳优先算法总是选择h(n)最小的节点作为扩展节点，本题与爬山法类似。

访问顺序S -> A -> D -> G

核心代码如下：

 bool greedy_visited[N] = {0};
 void greedy_best_first(int goal, node &src, Graph &graph)
 {
     if (src.name == goal)
     {
         cout << src.cname << endl;
         return;
     }
     greedy_visited[src.name] = 1;
     cout << src.cname << " -> ";
     int h_best = MAXNUM;
     int next_visit = 0;
     for (int i = 0; i < N; i++)
     {
         if (graph.getEdge(src.name, i) == 1 && !greedy_visited[i])
         {
             if (h[i] < h_best)
             {
                 h_best = h[i];
                 next_visit = i;
             }
         }
     }
     node des(next_visit, h_best);
     greedy_best_first(goal, des, graph);
 }

（5）代码验证

、

（6）完备性、最优性、以及时间复杂度和空间复杂度

①深度优先；

  • 完备性：有限深度的深度优先搜索有完备性，无限深度的无完备性

  • 最优性：不具有最优性，因为在选择分支中可能错过最优解

  • 时间复杂度：O(b^n)，b为分支因子，n为最大深度

  • 空间复杂度：O(bn)，b为分支因子，n为最大深度

②宽度优先；

  • 完备性：有完备性

  • 最优性：在单位代价情况下具有最优性

  • 时间复杂度：O(b^n)，b为分支因子，n为最大深度

  • 空间复杂度：O(b^n)，b为分支因子，n为最大深度

③爬山法；

  • 完备性：无完备性

  • 最优性：不具备最优性。因为可能陷入局部最优解，而不是全局的

  • 时间复杂度：O(b^n)，b为分支因子，n为最大深度

  • 空间复杂度：O(bn)，b为分支因子，n为最大深度

④贪婪最佳优先。

  • 完备性：不具有完备性，有可能在评估函数值较小的节点终止（死胡同）

  • 最优性：不具有最优性，有可能因为不断追求较小的评估值反而走了更远的路

  • 时间复杂度：O(b^n)，b为分支因子，n为最大深度

  • 空间复杂度：O(b^n)，b为分支因子，n为最大深度

（7）完整代码

 #include <algorithm>
 #include <iostream>
 #include <memory.h>
 #include <queue>
 #include <stack>
 #include <vector>
 #define N 6
 #define S 0
 #define A 1
 #define B 2
 #define C 3
 #define D 4
 #define G 5
 ​
 using namespace std;
 ​
 int h[20] = {11, 8, 9, 10, 5, 0};
 ​
 struct node
 {
     int name;
     char cname;
     int h;
     node(int name, int h)
     {
         this->name = name;
         this->h = h;
         switch (name)
         {
         case 0:
         {
             cname = 'S';
             break;
         }
         case 1:
         {
             cname = 'A';
             break;
         }
         case 2:
         {
             cname = 'B';
             break;
         }
         case 3:
         {
             cname = 'C';
             break;
         }
         case 4:
         {
             cname = 'D';
             break;
         }
         case 5:
         {
             cname = 'G';
             break;
         }
         }
     };
 };
 ​
 class Graph
 {
 public:
     Graph()
     {
         memset(graph, -1, sizeof(graph));
     }
     int getEdge(int from, int to)
     {
         return graph[from][to];
     }
     void addEdge(int from, int to, int cost)
     {
         if (from >= N || from < 0 || to >= N || to < 0)
             return;
         graph[from][to] = cost;
     }
 ​
     void init()
     {
         addEdge(S, A, 1);
         addEdge(A, S, 1);
         addEdge(S, B, 1);
         addEdge(B, S, 1);
         addEdge(A, B, 1);
         addEdge(B, A, 1);
         addEdge(A, D, 1);
         addEdge(D, A, 1);
         addEdge(B, D, 1);
         addEdge(D, B, 1);
         addEdge(D, G, 1);
         addEdge(G, D, 1);
         addEdge(B, C, 1);
         addEdge(C, B, 1);
     }
 ​
 private:
     int graph[N][N];
 };
 ​
 bool dfs_visited[N] = {0};
 void dfs(int goal, node &src, Graph &graph)
 {
     if (src.name == goal)
     {
         cout << src.cname << endl;
         return;
     }
     dfs_visited[src.name] = 1;
     cout << src.cname << " -> ";
     for (int i = 0; i < N; i++)
     {
         if (graph.getEdge(src.name, i) == 1 && !dfs_visited[i])
         {
             node des(i, 0);
             dfs(goal, des, graph);
         }
     }
 }
 ​
 void bfs(int goal, node &src, Graph &graph)
 {
     bool bfs_visited[N] = {0};
     queue<node> q;
     q.push(src);
     while (!q.empty())
     {
         node src = q.front();
         q.pop();
         bfs_visited[src.name] = 1;
         if (src.name == goal)
         {
             cout << src.cname << endl;
             break;
         }
         cout << src.cname << " -> ";
         for (int i = 0; i < N; i++)
         {
             if (graph.getEdge(src.name, i) == 1 && !bfs_visited[i])
             {
                 node des(i, 0);
                 bfs_visited[i] = 1;
                 q.push(des);
                 // cout << "extend" << i << endl;
             }
         }
     }
     return;
 }
 ​
 bool cm_visited[N] = {0};
 const int MAXNUM = 99999;
 void climb_mountain(int goal, node &src, Graph &graph)
 {
     if (src.name == goal)
     {
         cout << src.cname << endl;
         return;
     }
     cm_visited[src.name] = 1;
     cout << src.cname << " -> ";
     int h_best = MAXNUM;
     int next_visit = 0;
     for (int i = 0; i < N; i++)
     {
         if (graph.getEdge(src.name, i) == 1 && !cm_visited[i])
         {
             if (h[i] < h_best)
             {
                 h_best = h[i];
                 next_visit = i;
             }
         }
     }
     node des(next_visit, h_best);
     climb_mountain(goal, des, graph);
 }
 ​
 bool greedy_visited[N] = {0};
 void greedy_best_first(int goal, node &src, Graph &graph)
 {
     if (src.name == goal)
     {
         cout << src.cname << endl;
         return;
     }
     greedy_visited[src.name] = 1;
     cout << src.cname << " -> ";
     int h_best = MAXNUM;
     int next_visit = 0;
     for (int i = 0; i < N; i++)
     {
         if (graph.getEdge(src.name, i) == 1 && !greedy_visited[i])
         {
             if (h[i] < h_best)
             {
                 h_best = h[i];
                 next_visit = i;
             }
         }
     }
     node des(next_visit, h_best);
     greedy_best_first(goal, des, graph);
 }
 ​
 int main()
 {
     Graph graph;
     graph.init();
     node src(S, h[S]);
     cout << "dfs:  ";
     dfs(G, src, graph);
     cout << "bfs:  ";
     bfs(G, src, graph);
     cout << "climb mountain:  ";
     climb_mountain(G, src, graph);
     cout << "greedy_best_first:  ";
     greedy_best_first(G, src, graph);
 }
 ​

第4题

图二是一棵部分展开的搜索树，其中树的边记录了对应的单步代价，叶子节点标注了到达目标结点的启发式函数的代价值，假定当前状态位于结点A。用下列的搜索方法来计算下一步需要展开的叶子节点。注意必须要有完整的计算过程，同时必须对扩展该叶子节点之前的节点顺序进行记录：（20分） （1）贪婪最佳优先搜索 （2）一致代价搜索 （3）A*树搜索 讨论以上三种算法的完备性和最优性。

解：先分析问题，再给出完备性和最优性界定。

（1）贪婪最佳优先搜索

贪婪最佳优先搜索总是选择h()值最小的节点进行扩展。

由于图中信息不足，故需要分类讨论，对于B处的h(B)值进行讨论。

  • ①若h(B)>5，则A -> C，到达叶子节点，搜索结束。答案为A -> C

  • ②若h(B)<=5，则A -> B。此时h(G)最小，故选择G节点作为扩展节点。答案为A -> B -> G

（2）一致代价搜索

一致代价搜索选择使得g()最小的节点进行扩展。

由于g(B)=3最小，故A -> B。又g(E)=6最小，故B -> E，到达叶子节点，搜索结束。答案为A -> B -> E。

（3）A*树搜索

A*树搜索结合贪婪最佳优先搜索和一致代价搜索的特点，考虑f(X)=g(X)+h(X)，选择使得评估函数f(X)最小的节点进行扩展。

由于图中信息不足，故需要分类讨论，仍然需要对于B处的h(B)值进行讨论。

  • f(B)=3+h(B)

  • f(C)=19+5=24

  • f(D)=5+13=18

①若h(B)<=15，则f(B)<=f(D)，此时选择B作为扩展节点。

  • f(E)=6+10=16

  • f(F)=8+12=20

  • f(G)=9+8=17

  • f(H)=9+10=19

此时f(E)最小，故选择E。

最终答案为A -> B -> E。

②若h(B)>15，则f(B)>f(D)，此时选择D作为扩展节点。

最终答案为A -> D。

（4）完备性与最优性

  • 贪婪最佳优先搜索：不具有完备性，不具有最优性。

  • 一致代价搜索：有完备性，有最优性

  • A*树搜索：有完备性，有最优性

第5题

给定一个启发式函数满足h(G)=0,其中G是目标状态，证明如果h是一致的，那么它是可采纳的。（20分）

解：

可采纳性与一致性定义：

  • 启发函数h(n)是可采纳的条件：对于任意结点n, h (n) < = h *(n)，其中h*(n) 是到达目标结点的真实代价

  • 启发函数h(n)是一致的条件：对于任意结点n，以及n的行为a产生的后继结点n’,满足如下公式：h(n) ≤ c(n,a,n’) + h(n’)

证明如下：

假设n为任意状态, G为某目标状态, 且从状态n到状态G的一条最优路径为n, n1, n2, ……, nm

根据一致性条件，h(n) <= c(n, a1, n1) + h(n1)

<= c(n, a1, n1) + c(n1, a2, n2) + h(n2)

<= c(n, a1, n1) + c(n1, a2, n2) + …… + c(nm, am+1, G) + h(G)

又 h(G) == 0，故 h(n) <= c(n, a1, n1) + c(n1, a2, n2) + …… + c(nm, am+1, G)

根据实际意义，h*(n) = c(n, a1, n1) + c(n1, a2, n2) + …… + c(nm, am+1, G)，因为这是从n到G的实际距离。

综上，h(n) <= h*(n)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/597766.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

革新品质检测，质构科技重塑肉类行业新篇章

革新品质检测，质构科技重塑肉类行业新篇章

革新品质检测&#xff0c;质构科技重塑肉类行业新篇章 在现代社会&#xff0c;消费者对食品安全和品质的要求日益提升&#xff0c;特别是在肉类行业。为了满足这一市场需求&#xff0c;质构科技凭借其精准、高效的优势&#xff0c;正逐渐成为肉类品质检测的新星。今天&#xf…
阅读更多...
网络安全的未来：挑战、策略与创新

网络安全的未来：挑战、策略与创新

引言&#xff1a; 在数字化时代&#xff0c;网络安全已成为个人和企业不可忽视的议题。随着网络攻击的日益频繁和复杂化&#xff0c;如何有效保护数据和隐私成为了一个全球性的挑战。 一、网络安全的现状与挑战 网络安全面临的挑战多种多样&#xff0c;包括但不限于恶意软件、…
阅读更多...
iPhone查看本机号码只需要这3招，不再为号码忘记犯愁！

iPhone查看本机号码只需要这3招，不再为号码忘记犯愁！

在日常生活中&#xff0c;我们经常需要使用手机号码进行各种通讯活动&#xff0c;但有时候会忘记自己的手机号码&#xff0c;让人感到非常尴尬。不过&#xff0c;如果您是iPhone用户&#xff0c;那么您可以放心了&#xff01;因为在iphone查看本机号码只需要简单的几个步骤&…
阅读更多...
ShardingSphere 5.x 系列【27】 数据分片原理之 SQL 改写

ShardingSphere 5.x 系列【27】 数据分片原理之 SQL 改写

有道无术，术尚可求，有术无道，止于术。 本系列Spring Boot 版本 3.1.0 本系列ShardingSphere 版本 5.4.0 源码地址：https://gitee.com/pearl-organization/study-sharding-sphere-demo 文章目录 1. 概述2. 正确性改写2.1 标识符改写2.1.1 表名称2.1.2 索引名称2.1.3 Schem…
阅读更多...
618好物节不知道买什么？快收下这份好物推荐指南！

618好物节不知道买什么？快收下这份好物推荐指南！

随着618好物节的临近&#xff0c;你是否在为选择什么产品而犹豫不决&#xff1f;不用担忧&#xff0c;我精心准备了一份购物指南&#xff0c;旨在帮助你发现那些性价比高、口碑爆棚的商品。无论是科技新品还是生活小物件&#xff0c;这份指南都能帮你快速定位到那些值得投资的好…
阅读更多...
若依前后端分离部署nginx

若依前后端分离部署nginx

1、v.sj 2、生产环境修改 3、退出登录修改 4、路由改为hash模式 5、nginx配置 location /gldhtml/ {alias D:/java/tool/nginx-1.19.6/project/jxal/html/; } location /jxal/ {proxy_pass http://localhost:8081/; }
阅读更多...
软信天成：CDMP数据管理专业人员认证9大要点【干货篇】

软信天成：CDMP数据管理专业人员认证9大要点【干货篇】

软信天成在上期文章中为大家分享了CDMP认证的基础内容。 上期文章&#xff1a;软信天成&#xff1a;CDMP数据管理专业人员认证详细介绍&#xff08;基础篇&#xff09;-CSDN博客 为方便诸位报考&#xff0c;软信根据考过CDMP的小伙伴经验分享&#xff0c;帮大家梳理了详细的考…
阅读更多...
使用Beego创建API项目并自动化文档

使用Beego创建API项目并自动化文档

最近需要使用Go写一个Web API项目&#xff0c;可以使用Beego与Gin来写此类项目&#xff0c;还是非常方便的&#xff0c;这里就介绍一下使用Beego来创建的Web API项目并自动化文档的方法。 使用Gin创建API项目并自动化文档参见&#xff1a;使用Gin编写Web API项目并自动化文档 …
阅读更多...
软考 系统架构设计师系列知识点之软件可靠性基础知识（11）

软考 系统架构设计师系列知识点之软件可靠性基础知识（11）

接前一篇文章&#xff1a;软考 系统架构设计师系列知识点之软件可靠性基础知识&#xff08;10&#xff09; 所属章节&#xff1a; 第9章. 软件可靠性基础知识 第2节 软件可靠性建模 9.2.3 软件可靠性模型模型分类 一个有效的软件可靠性模型应尽可能地将前文所述的因素在软件可…
阅读更多...
电感啸叫如何处理

电感啸叫如何处理

一&#xff0e;电感啸叫现象 电感啸叫是指在20Hz~20kHz的电流激励频率下&#xff0c;电感会发出人耳所能听见的吱吱声。周期性电流经过电感线圈产生交变磁场&#xff0c;电感现象在交变磁场作用下产生振动而发出声音&#xff0c;这种周期性频率如果落在人耳听觉范围内&#xf…
阅读更多...
syncGradle项目时报错Unknown Kotlin JVM target: 22

syncGradle项目时报错Unknown Kotlin JVM target: 22

解决方案1 定位到build.gradle.kts的出问题行&#xff0c;将其注释掉然后把sourceCompatibility行也注释掉重新sync. 这样会自动使用默认兼容的版本 你也可以根据文档手动解决兼容问题2 Configure a Gradle project | Kotlin Documentation (kotlinlang.org) ↩︎ Compatibil…
阅读更多...
MySQL动态列转行

MySQL动态列转行

介绍​​ 在实际的数据库查询中&#xff0c;有时候我们需要将表中的动态列&#xff08;即列数不固定&#xff09;转换为行&#xff0c;以便更好地进行数据分析和展示。在MySQL中&#xff0c;可以通过使用一些技巧和函数来实现动态列转行的功能。本文将介绍怎么实现MySQL动态列…
阅读更多...
Babylon.js 7.0开发入门教程

Babylon.js 7.0开发入门教程

Babylon.js 是一个功能强大的开源 3D 引擎&#xff0c;能够使用 JavaScript 渲染交互式 3D 和 2D 图形。它是为 Web 甚至 VR 创建游戏、演示、可视化和其他 3D 应用程序的绝佳选择。Babylon.js最新版本是7.0。 Babylon.js 是免费、开源和跨平台的&#xff0c;是 Unity 和 Unre…
阅读更多...
超实用|新能源汽车充电小程序开发，一键充电很简单！

超实用|新能源汽车充电小程序开发，一键充电很简单！

随着城市化的加速&#xff0c;新能源汽车用户越来越多。由于电池容量和充电时间的限制&#xff0c;新能源汽车用户通常需要在城市各处寻找充电站&#xff0c;充电过程不仅需要耗费时间&#xff0c;而且对于新能源汽车用户而言&#xff0c;充电站的位置分布是否合理、充电设施的…
阅读更多...
当下大模型的趋势以及如何让学习大模型？

当下大模型的趋势以及如何让学习大模型？

当下大模型的趋势 近年来&#xff0c;随着计算能力的提升、数据量的增加以及算法的进步&#xff0c;大模型在人工智能领域展现出了显著的发展趋势。以下是截至2024&#xff0c;大模型发展的一些关键趋势&#xff1a; 参数规模持续增长&#xff1a;从OpenAI的GPT-3的1750亿参数…
阅读更多...
如何使用 iOS系统恢复软件修复 iPhone 问题

如何使用 iOS系统恢复软件修复 iPhone 问题

苹果公司向世界推出了他们可以拥有的最智能的手机。但即使是 iPhone 也无法避免智能手机常见的损坏和问题。您将熟悉最常见的问题。屏幕黑屏或卡在 Apple 徽标上&#xff1b;冻结或卡在恢复模式的 iPhone。但这样的问题不胜枚举&#xff0c;每天都有 iOS 用户在他们的设备中遇到…
阅读更多...
第八篇：深入探索操作系统架构：从基础到前沿

第八篇：深入探索操作系统架构：从基础到前沿

深入探索操作系统架构&#xff1a;从基础到前沿 1 引言 在当今这个高速发展的数字时代&#xff0c;操作系统无疑是计算机科学领域的基石之一。它不仅是计算机硬件与最终用户之间的桥梁&#xff0c;更是实现高效计算和资源管理的关键。操作系统的架构&#xff0c;即其内部结构和…
阅读更多...
Elasticsearch：理解人工智能相似性搜索

Elasticsearch：理解人工智能相似性搜索

理解相似性搜索&#xff08;也称为语义搜索&#xff09;的指南&#xff0c;这是人工智能最新阶段的关键发现之一。 最新阶段人工智能的关键发现之一是根据相似性搜索和查找文档的能力。相似性搜索是一种比较信息的方法&#xff0c;其基于含义而非关键字。 相似性搜索也被称为语…
阅读更多...
springboot+vue+elementui实现校园互助平台大作业、毕业设计

springboot+vue+elementui实现校园互助平台大作业、毕业设计

目录 一、项目介绍 二、项目截图 管理后台 1.登录&#xff08;默认管理员账号密码均为&#xff1a;admin&#xff09; 2. 用户管理 ​编辑 3.任务管理 互助单&#xff08;学生发布&#xff09; 行政单&#xff08;教师发布&#xff09; ​编辑 审核&#xff08;退回需…
阅读更多...
如何完美解决Outlook大文件传送问题，提升办公协作效率？

如何完美解决Outlook大文件传送问题，提升办公协作效率？

在日常工作中&#xff0c;邮件是一种常用的通信方式&#xff0c;经常用来发送各类文件&#xff0c;比如报告和文档、合同和协议、财务报表、营销资料、设计文件等。但有时文件会比较大&#xff0c;因此Outlook大文件传送时&#xff0c;会遇到附件大小受限的情况。常用的解决发送…
阅读更多...
最新文章

Copyright @ 2022~2023