图书信息
图书目录

计算思维与人工智能导论




本书是面向高等学校非计算机专业学生开设的通识教育课程教材,尤其适合民航类院校学生使用。全书共11章,内容包括计算基础、基本数据类型、基本控制结构、模块(函数)化、组合数据类型、面向对象编程、算法与数据结构、软件开发、数据基础、人工智能基础、人工智能技术的应用与实践等。

本书由浅入深地讲解了计算机的基础知识、Python的基本语法、程序设计思想和问题的求解方法,以及人工智能的基础技术和应用实践,并结合大量的实际案例,帮助读者更好地掌握知识点。

本书可以作为高等学校非计算机专业的大学计算机和人工智能通识课程的教材,也可以作为相关技术人员自学的参考书。



作者:
王宏伟 鲁亮 黄睿 主编

定价:
56.00 元

出版时间:
2026-07-31

ISBN:
978-7-04-067302-9

物料号:
67302-00

读者对象:
高等教育

一级分类:
计算机/教育技术类

二级分类:
计算机基础课程

三级分类:
大学计算机基础

重点项目:
暂无

版面字数:
500千字

开本:
16开

装帧形式:
平装

页数:
暂无

最新
印次时间:
2026年01月
  • 目录
    • 前辅文
      • 第1章 计算基础
        • 1.1 信息与数据的数字化表达
          • 1.1.1 信息时代的核心命题
            • 1.1.2 信息与数据的辩证关系
              • 1.1.3 从模拟到数字
                • 1.1.4 数字化表达的核心
                  • 1.1.5 数字化的深远影响
                  • 1.2 数制与编码
                    • 1.2.1 二进制的基石:逢二进一的逻辑
                      • 1.2.2 进制的相互转换
                        • 1.2.3 整数的二进制编码
                          • 1.2.4 实数的二进制编码
                          • 1.3 字符、图像与语音的编码方法
                            • 1.3.1 字符编码
                              • 1.3.2 图像编码:从像素到视觉信息
                                • 1.3.3 语音编码:从声波到数字信号
                                  • 1.3.4 编码方法的共性与启示
                                  • 1.4 图灵机与可计算性理论
                                    • 1.4.1 计算理论的起源
                                      • 1.4.2 图灵机的基本模型
                                        • 1.4.3 图灵机的工作原理
                                          • 1.4.4 通用图灵机
                                            • 1.4.5 图灵机与现代计算机
                                            • 1.5 冯·诺依曼结构与现代计算机系统
                                              • 1.5.1 冯·诺依曼结构的诞生
                                                • 1.5.2 冯·诺依曼结构的五大组成部分
                                                  • 1.5.3 存储程序思想
                                                    • 1.5.4 现代计算机系统对冯·诺依曼结构的继承与发展
                                                      • 1.5.5 程序的执行过程:冯·诺依曼结构的动态视角
                                                        • 1.5.6 冯·诺依曼瓶颈与突破尝试
                                                          • 1.5.7 冯·诺依曼结构与图灵机的关联
                                                            • 1.5.8 冯·诺依曼结构的历史地位与未来
                                                            • 1.6 云计算与资源共享架构
                                                              • 1.6.1 从单机到云端:计算资源的共享革命
                                                                • 1.6.2 云计算的核心特征:超越传统IT模式
                                                                  • 1.6.3 云计算的服务架构:三层服务模型
                                                                    • 1.6.4 云计算的部署模型:按需选择的资源边界
                                                                      • 1.6.5 虚拟化与分布式系统
                                                                        • 1.6.6 典型案例:云计算如何重塑行业应用
                                                                          • 1.6.7 云计算的挑战与未来趋势
                                                                          • 1.7 本章小结
                                                                            • 习题
                                                                            • 第2章 基本数据类型
                                                                              • 2.1 Python语言与开发环境简介
                                                                                • 2.1.1 Python语言的发展
                                                                                  • 2.1.2 Python语言的特点
                                                                                    • 2.1.3 安装Python解释器
                                                                                      • 2.1.4 运行Python小程序
                                                                                      • 2.2 数据与变量的基本概念
                                                                                        • 2.2.1 内置数据类型
                                                                                          • 2.2.2 常量、变量和标识符
                                                                                          • 2.3 整数与浮点数
                                                                                            • 2.3.1 整数的表示与操作
                                                                                              • 2.3.2 浮点数的表示与操作
                                                                                              • 2.4 布尔型与逻辑运算
                                                                                                • 2.4.1 关系表达式
                                                                                                  • 2.4.2 逻辑表达式
                                                                                                  • 2.5 字符串类型与字符串操作
                                                                                                    • 2.5.1 字符串类型数据
                                                                                                      • 2.5.2 字符串的处理
                                                                                                      • 2.6 类型转换与输入输出
                                                                                                        • 2.6.1 类型转换
                                                                                                          • 2.6.2 数据的输入
                                                                                                            • 2.6.3 数据的输出
                                                                                                              • 2.6.4 格式化输出
                                                                                                              • 2.7 本章小结
                                                                                                                • 习题
                                                                                                                • 第3章 基本控制结构
                                                                                                                  • 3.1 结构化程序设计
                                                                                                                    • 3.1.1 程序流程图
                                                                                                                      • 3.1.2 程序运行的基本结构
                                                                                                                      • 3.2 顺序结构
                                                                                                                        • 3.3 选择结构
                                                                                                                          • 3.3.1 单分支选择结构
                                                                                                                            • 3.3.2 双分支选择结构
                                                                                                                              • 3.3.3 多分支选择结构
                                                                                                                                • 3.3.4 if语句嵌套结构
                                                                                                                                • 3.4 循环结构
                                                                                                                                  • 3.4.1 遍历循环(有限循环):for语句
                                                                                                                                    • 3.4.2 条件循环(非确定次数循环):while语句
                                                                                                                                      • 3.4.3 循环辅助语句:break和continue语句
                                                                                                                                        • 3.4.4 pass语句
                                                                                                                                          • 3.4.5 try-except语句
                                                                                                                                          • 3.5 综合应用实例
                                                                                                                                            • 3.6 本章小结
                                                                                                                                              • 习题
                                                                                                                                              • 第4章 模块(函数)化
                                                                                                                                                • 4.1 函数的作用
                                                                                                                                                  • 4.2 函数的定义与调用
                                                                                                                                                    • 4.2.1 函数的定义
                                                                                                                                                      • 4.2.2 函数的调用
                                                                                                                                                      • 4.3 参数传递
                                                                                                                                                        • 4.3.1 形参和实参
                                                                                                                                                          • 4.3.2 可变对象与不可变对象
                                                                                                                                                            • 4.3.3 位置参数
                                                                                                                                                              • 4.3.4 关键字参数
                                                                                                                                                                • 4.3.5 默认参数
                                                                                                                                                                  • 4.3.6 可变参数
                                                                                                                                                                    • 4.3.7 参数组合
                                                                                                                                                                    • 4.4 lambda函数
                                                                                                                                                                      • 4.5 函数嵌套与递归
                                                                                                                                                                        • 4.5.1 函数的嵌套调用
                                                                                                                                                                          • 4.5.2 递归
                                                                                                                                                                          • 4.6 变量作用域
                                                                                                                                                                            • 4.6.1 不同变量作用域
                                                                                                                                                                              • 4.6.2 变量名解析
                                                                                                                                                                                • 4.6.3 global关键字
                                                                                                                                                                                • 4.7 综合应用
                                                                                                                                                                                  • 4.8 本章小结
                                                                                                                                                                                    • 习题
                                                                                                                                                                                    • 第5章 组合数据类型
                                                                                                                                                                                      • 5.1 引言:当数据不再是“一个”
                                                                                                                                                                                        • 5.1.1 民航数据的真实世界
                                                                                                                                                                                          • 5.1.2 基本数据类型的局限
                                                                                                                                                                                            • 5.1.3 四大核心“容器”的直觉模型
                                                                                                                                                                                            • 5.2 列表:有序的数据队列
                                                                                                                                                                                              • 5.2.1 列表的概念与特点
                                                                                                                                                                                                • 5.2.2 列表的创建与初始化
                                                                                                                                                                                                  • 5.2.3 列表的访问与切片
                                                                                                                                                                                                    • 5.2.4 列表的增删改操作
                                                                                                                                                                                                      • 5.2.5 列表的排序与常用方法
                                                                                                                                                                                                        • 5.2.6 民航应用案例:当日航班表管理
                                                                                                                                                                                                        • 5.3 元组:不可变的记录
                                                                                                                                                                                                          • 5.3.1 元组的概念与特点
                                                                                                                                                                                                            • 5.3.2 元组的创建与访问
                                                                                                                                                                                                              • 5.3.3 元组的不可变性:为何重要?
                                                                                                                                                                                                                • 5.3.4 元组解包与函数多返回值
                                                                                                                                                                                                                  • 5.3.5 民航应用案例:作为“钥匙”的唯一标识
                                                                                                                                                                                                                  • 5.4 字典:高效的索引目录
                                                                                                                                                                                                                    • 5.4.1 字典的概念与特点
                                                                                                                                                                                                                      • 5.4.2 字典的创建与基本操作
                                                                                                                                                                                                                        • 5.4.3 遍历字典
                                                                                                                                                                                                                          • 5.4.4 民航应用案例:构建航班信息索引
                                                                                                                                                                                                                          • 5.5 集合:专注去重与关系
                                                                                                                                                                                                                            • 5.5.1 集合的概念与特点
                                                                                                                                                                                                                              • 5.5.2 集合的创建与核心功能:自动去重
                                                                                                                                                                                                                                • 5.5.3 集合的核心功能:数学运算
                                                                                                                                                                                                                                  • 5.5.4 民航应用案例:延误与国际航班的交集分析
                                                                                                                                                                                                                                  • 5.6 综合案例:搭建内存中的航班数据分析框架
                                                                                                                                                                                                                                    • 5.6.1 任务重述:我们需要什么?
                                                                                                                                                                                                                                      • 5.6.2 结构选型:为任务匹配最佳“容器”
                                                                                                                                                                                                                                        • 5.6.3 落地代码:协同作战
                                                                                                                                                                                                                                          • 5.6.4 性能的直觉:为什么这样选是高效的?
                                                                                                                                                                                                                                          • 5.7 总结与结构选型
                                                                                                                                                                                                                                            • 5.7.1 四大组合数据类型特点总览
                                                                                                                                                                                                                                              • 5.7.2 如何选择合适的数据结构:一个决策树
                                                                                                                                                                                                                                                • 5.7.3 类型间的灵活转换
                                                                                                                                                                                                                                                • 5.8 本章小结
                                                                                                                                                                                                                                                  • 习题
                                                                                                                                                                                                                                                  • 第6章 面向对象编程
                                                                                                                                                                                                                                                    • 6.1 引言:从分散的数据到统一的“对象”
                                                                                                                                                                                                                                                      • 6.1.1 模块化的局限:当数据与动作分离
                                                                                                                                                                                                                                                        • 6.1.2 真实世界的启发:“对象”思维
                                                                                                                                                                                                                                                          • 6.1.3 面向对象的解决方案
                                                                                                                                                                                                                                                          • 6.2 类与对象:创建你的第一个“航班”蓝图
                                                                                                                                                                                                                                                            • 6.2.1 类是“蓝图”,对象是“实例”
                                                                                                                                                                                                                                                              • 6.2.2 定义一个最简单的类
                                                                                                                                                                                                                                                                • 6.2.3 使用_ init_ 方法为对象绑定数据
                                                                                                                                                                                                                                                                  • 6.2.4 多个实例,数据各自独立
                                                                                                                                                                                                                                                                  • 6.3 封装:为“航班”对象装上“保护壳”
                                                                                                                                                                                                                                                                    • 6.3.1 为什么需要“保护壳”
                                                                                                                                                                                                                                                                      • 6.3.2 实现封装:使用私有属性
                                                                                                                                                                                                                                                                        • 6.3.3 开设“窗口”:getter和setter方法
                                                                                                                                                                                                                                                                          • 6.3.4 民航领域案例:飞机维护系统
                                                                                                                                                                                                                                                                          • 6.4 继承:创造不同类型航班
                                                                                                                                                                                                                                                                            • 6.4.1 问题的出现:相似的“蓝图”
                                                                                                                                                                                                                                                                              • 6.4.2 解决方案:提取“父类”,实现继承
                                                                                                                                                                                                                                                                                • 6.4.3 方法重写
                                                                                                                                                                                                                                                                                • 6.5 多态:统一指挥,各自行动
                                                                                                                                                                                                                                                                                  • 6.5.1 问题的出现:需要为每种飞机单独下指令吗?
                                                                                                                                                                                                                                                                                    • 6.5.2 解决方案:约定统一接口,实现多态
                                                                                                                                                                                                                                                                                      • 6.5.3 “鸭子类型”:Python中的多态精髓
                                                                                                                                                                                                                                                                                      • 6.6 组合:当“航班”拥有一个“飞机”
                                                                                                                                                                                                                                                                                        • 6.6.1 继承的误区:所有东西都应该继承吗?
                                                                                                                                                                                                                                                                                          • 6.6.2 解决方案:将对象作为属性,实现组合
                                                                                                                                                                                                                                                                                            • 6.6.3 继承与组合:如何做出正确选择
                                                                                                                                                                                                                                                                                            • 6.7 综合案例:搭建一个微型航班管理系统
                                                                                                                                                                                                                                                                                              • 6.7.1 案例背景与目标
                                                                                                                                                                                                                                                                                                • 6.7.2 系统蓝图:类设计与关系分析
                                                                                                                                                                                                                                                                                                  • 6.7.3 Python实现:将蓝图变为代码
                                                                                                                                                                                                                                                                                                    • 6.7.4 运行结果与分析
                                                                                                                                                                                                                                                                                                    • 6.8 本章小结
                                                                                                                                                                                                                                                                                                      • 习题
                                                                                                                                                                                                                                                                                                      • 第7章 算法与数据结构
                                                                                                                                                                                                                                                                                                        • 7.1 算法:解决问题的“食谱”
                                                                                                                                                                                                                                                                                                          • 7.1.1 引入案例:登机口分配的“秘密”
                                                                                                                                                                                                                                                                                                            • 7.1.2 算法的定义:一份好的“食谱”
                                                                                                                                                                                                                                                                                                              • 7.1.3 算法与程序的区别
                                                                                                                                                                                                                                                                                                                • 7.1.4 算法的表示方式
                                                                                                                                                                                                                                                                                                                • 7.2 查找算法:从大海捞针到按图索骥
                                                                                                                                                                                                                                                                                                                  • 7.2.1 问题的出现:如何找到指定的航班?
                                                                                                                                                                                                                                                                                                                    • 7.2.2 方案一:线性查找
                                                                                                                                                                                                                                                                                                                      • 7.2.3 性能瓶颈与算法的“快慢”
                                                                                                                                                                                                                                                                                                                        • 7.2.4 方案二:二分查找
                                                                                                                                                                                                                                                                                                                          • 7.2.5 终极方案?回顾字典的力量
                                                                                                                                                                                                                                                                                                                            • 7.2.6 查找效率金字塔:思想的总结
                                                                                                                                                                                                                                                                                                                            • 7.3 排序算法:让航班信息井然有序
                                                                                                                                                                                                                                                                                                                              • 7.3.1 问题的出现:如何展示有序的航班列表?
                                                                                                                                                                                                                                                                                                                                • 7.3.2 方案一:选择排序
                                                                                                                                                                                                                                                                                                                                  • 7.3.3 方案二:使用Python内置排序
                                                                                                                                                                                                                                                                                                                                  • 7.4 时间与空间复杂度:算法的“跑分”
                                                                                                                                                                                                                                                                                                                                    • 7.4.1 为什么不能用“秒”来衡量算法
                                                                                                                                                                                                                                                                                                                                      • 7.4.2 时间复杂度:操作次数的增长趋势
                                                                                                                                                                                                                                                                                                                                        • 7.4.3 空间复杂度:需要多少“草稿纸”
                                                                                                                                                                                                                                                                                                                                          • 7.4.4 时间与空间的权衡
                                                                                                                                                                                                                                                                                                                                          • 7.5 超越线性:树与图的世界
                                                                                                                                                                                                                                                                                                                                            • 7.5.1 树:描述“层级”与“归属”的关系
                                                                                                                                                                                                                                                                                                                                              • 7.5.2 图:描述“网络”与“连接”的关系
                                                                                                                                                                                                                                                                                                                                                • 7.5.3 基于树和图的强大算法
                                                                                                                                                                                                                                                                                                                                                • 7.6 综合案例:高效的航班查询系统
                                                                                                                                                                                                                                                                                                                                                  • 7.6.1 任务描述:从混乱到高效
                                                                                                                                                                                                                                                                                                                                                    • 7.6.2 系统设计:两步走的策略
                                                                                                                                                                                                                                                                                                                                                      • 7.6.3 代码实现:将思想化为现实
                                                                                                                                                                                                                                                                                                                                                        • 7.6.4 案例分析与方案权衡
                                                                                                                                                                                                                                                                                                                                                        • 7.7 本章小结
                                                                                                                                                                                                                                                                                                                                                          • 习题
                                                                                                                                                                                                                                                                                                                                                          • 第8章 软件开发
                                                                                                                                                                                                                                                                                                                                                            • 8.1 从“我有一个想法”到产品:软件的生命周期与团队角色
                                                                                                                                                                                                                                                                                                                                                              • 8.1.1 软件的生命周期:一场精心策划的校园活动
                                                                                                                                                                                                                                                                                                                                                                • 8.1.2 团队角色:软件开发的幕后英雄们
                                                                                                                                                                                                                                                                                                                                                                • 8.2 蓝图与探索:不同的软件开发模型
                                                                                                                                                                                                                                                                                                                                                                  • 8.2.1 瀑布模型:按图纸施工的“建筑师”
                                                                                                                                                                                                                                                                                                                                                                    • 8.2.2 敏捷模型:持续探索的“航海家”
                                                                                                                                                                                                                                                                                                                                                                    • 8.3 软件开发的“工坊”:开发环境与版本控制
                                                                                                                                                                                                                                                                                                                                                                      • 8.3.1 再探“智能工坊”:集成开发环境
                                                                                                                                                                                                                                                                                                                                                                        • 8.3.2 版本控制系统:项目的“时间机器”与“协作契约”
                                                                                                                                                                                                                                                                                                                                                                          • 8.3.3 完美结合:在VS Code中直观地使用Git
                                                                                                                                                                                                                                                                                                                                                                          • 8.4 “千锤百炼”:软件测试与质量保证
                                                                                                                                                                                                                                                                                                                                                                            • 8.4.1 测试的必要性:为什么软件里总有缺陷
                                                                                                                                                                                                                                                                                                                                                                              • 8.4.2 测试金字塔:从“零件”到“整车”的检验体系
                                                                                                                                                                                                                                                                                                                                                                                • 8.4.3 测试的两种视角:黑盒测试与白盒测试
                                                                                                                                                                                                                                                                                                                                                                                  • 8.4.4 像测试工程师一样思考:ATM取款的艺术
                                                                                                                                                                                                                                                                                                                                                                                    • 8.4.5 超越测试:质量保证的宏观视角
                                                                                                                                                                                                                                                                                                                                                                                    • 8.5 从“我”到“我们”:高效协作与项目管理
                                                                                                                                                                                                                                                                                                                                                                                      • 8.5.1 可视化工作流:一张让任务“活”起来的看板
                                                                                                                                                                                                                                                                                                                                                                                        • 8.5.2 协作的节奏:每日站会与沟通的艺术
                                                                                                                                                                                                                                                                                                                                                                                          • 8.5.3 协作的基石:执行共同的规范
                                                                                                                                                                                                                                                                                                                                                                                          • 8.6 软件工程师的职业伦理与社会责任
                                                                                                                                                                                                                                                                                                                                                                                            • 8.6.1 为什么软件工程师需要懂伦理
                                                                                                                                                                                                                                                                                                                                                                                              • 8.6.2 软件工程师的核心伦理准则
                                                                                                                                                                                                                                                                                                                                                                                                • 8.6.3 灰色地带的思考
                                                                                                                                                                                                                                                                                                                                                                                                • 8.7 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                  • 习题
                                                                                                                                                                                                                                                                                                                                                                                                  • 第9章 数据基础
                                                                                                                                                                                                                                                                                                                                                                                                    • 9.1 数据的“前世今生”:数据的类型、来源与获取
                                                                                                                                                                                                                                                                                                                                                                                                      • 9.1.1 数据的类型:信息的“收纳盒”
                                                                                                                                                                                                                                                                                                                                                                                                        • 9.1.2 数据的来源与获取:去哪里“淘金”?
                                                                                                                                                                                                                                                                                                                                                                                                        • 9.2 数据的“身份证”:常见格式(CSV、JSON)与读取方法
                                                                                                                                                                                                                                                                                                                                                                                                          • 9.2.1 CSV:朴实无华的电子表格
                                                                                                                                                                                                                                                                                                                                                                                                            • 9.2.2 JSON:灵活自由的嵌套清单
                                                                                                                                                                                                                                                                                                                                                                                                            • 9.3 去伪存真:数据清洗
                                                                                                                                                                                                                                                                                                                                                                                                              • 9.3.1 缺失值处理
                                                                                                                                                                                                                                                                                                                                                                                                                • 9.3.2 重复数据处理
                                                                                                                                                                                                                                                                                                                                                                                                                  • 9.3.3 格式不一致处理
                                                                                                                                                                                                                                                                                                                                                                                                                    • 9.3.4 异常值/离群点处理
                                                                                                                                                                                                                                                                                                                                                                                                                    • 9.4 让数据“说话”:描述性统计与数据可视化
                                                                                                                                                                                                                                                                                                                                                                                                                      • 9.4.1 描述性统计:给数据画一张“数字素描”
                                                                                                                                                                                                                                                                                                                                                                                                                        • 9.4.2 数据可视化:“一图胜千言”的艺术
                                                                                                                                                                                                                                                                                                                                                                                                                        • 9.5 发现数据间的“秘密”:简单建模与相关性分析
                                                                                                                                                                                                                                                                                                                                                                                                                          • 9.5.1 相关性分析:衡量同步变化的程度
                                                                                                                                                                                                                                                                                                                                                                                                                            • 9.5.2 相关性计算
                                                                                                                                                                                                                                                                                                                                                                                                                              • 9.5.3 关键警告:相关不等于因果!
                                                                                                                                                                                                                                                                                                                                                                                                                                • 9.5.4 简单建模:画一条最佳拟合线
                                                                                                                                                                                                                                                                                                                                                                                                                                • 9.6 从数据到决策:数据驱动的思维方式
                                                                                                                                                                                                                                                                                                                                                                                                                                  • 9.6.1 数据驱动决策的闭环流程
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 9.6.2 案例研究:如何提升航班准点率?
                                                                                                                                                                                                                                                                                                                                                                                                                                      • 9.6.3 从公司决策到个人学习和生活
                                                                                                                                                                                                                                                                                                                                                                                                                                      • 9.7 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                                        • 习题
                                                                                                                                                                                                                                                                                                                                                                                                                                        • 第10章 人工智能基础
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 10.1 人工智能的定义与发展路径
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 10.1.1 人工智能的发展路径
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 10.1.2 未来方向
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 10.2 机器学习原理与流程
                                                                                                                                                                                                                                                                                                                                                                                                                                                • 10.2.1 机器学习的定义
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 10.2.2 机器学习的发展历程
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 10.2.3 机器学习的方法分类
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 10.3 机器学习问题
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 10.3.1 分类问题
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 10.3.2 回归问题
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 10.3.3 聚类问题
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 10.3.4 其他问题
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 10.4 深度学习
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 10.4.1 卷积神经网络
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 10.4.2 Transformer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 10.4.3 学习策略
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 10.4.4 损失函数
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 10.5 大模型与生成式AI初探
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 10.5.1 大模型的定义
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 10.5.2 大模型的核心技术
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 10.6 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 习题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 第11章 人工智能技术的应用与实践
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 11.1 “智能+”产业与多模态AI的深度融合
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 11.1.1 多模态AI的技术突破与核心能力
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 11.1.2 产业融合的典型应用场景
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 11.1.3 技术挑战与发展前景
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 11.2 自然语言处理
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 11.2.1 自然语言处理在现实生活中的广泛应用
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 11.2.2 自然语言处理在民航业的应用
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 11.2.3 自然语言处理的未来发展趋势和技术挑战
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 11.3 计算机视觉
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 11.3.1 计算机视觉在生活场景中的应用
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 11.3.2 计算机视觉在民航业的专业应用
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 11.3.3 计算机视觉的未来发展趋势和面临的技术挑战
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 11.4 推荐算法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 11.4.1 推荐算法的日常生活应用场景
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 11.4.2 推荐算法在民航业的创新应用实践
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 11.4.3 推荐算法的未来发展趋势和面临的技术挑战
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 11.5 机器人系统与人机交互
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 11.5.1 机器人系统架构与核心技术
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 11.5.2 人机交互的演进与创新
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 11.5.3 应用场景的深度融合
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 11.5.4 机器人技术的未来发展趋势和面临的技术挑战
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 11.6 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 习题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1