本文详细介绍如何结合蒙特卡罗树搜索（MCTS）与深度残差网络，从零实现一个能够通过自我对弈持续提升棋力的五子棋AI 系统。

项目概述

本项目是一个基于 AlphaZero 思想实现的五子棋 AI 系统。与传统的博弈AI（如 Minimax + Alpha-Beta剪枝）不同，本系统不依赖人类专家知识或手工设计的评估函数，而是让 AI通过自我对弈从零开始学习五子棋策略。

项目特点

技术栈

后端： Python 3.10+ / PyTorch 2.1.0 / FastAPI0.104.1

前端： Vue 3.3 / TypeScript 5.3 / Vite 5.0 / Pinia2.1

核心原理

AlphaZero 算法思想

2017年，DeepMind 发布了AlphaZero，仅通过自我对弈就在围棋、国际象棋、日本将棋上超越了所有前任冠军程序。其核心思想包括：

1. 深度神经网络：用一个网络同时预测当前局面的价值（谁更可能赢）和策略（下一步应该走哪里）
2. 蒙特卡罗树搜索：利用神经网络的预测来指导搜索，而非传统的随机模拟
3. 自我对弈：AI与自己对弈产生训练数据，不断迭代提升

┌────────────────────────────────────────────────────────────┐│                    AlphaZero 训练循环                       ││                                                            ││   ┌─────────┐     ┌─────────┐     ┌─────────┐            ││   │  自我对弈 │ ──▶ │ 收集数据 │ ──▶ │ 训练网络 │ ──┐       ││   └─────────┘     └─────────┘     └─────────┘   │        ││        ▲                                          │        ││        └──────────────────────────────────────────┘        ││                        更新模型                             │└────────────────────────────────────────────────────────────┘

蒙特卡罗树搜索 (MCTS)

MCTS 是一种启发式搜索算法，通过模拟来评估局面的好坏。AlphaZero使用神经网络改进了传统 MCTS：

四个阶段

选择 (Selection)          扩展 (Expansion)     │                         │     ▼                         ▼┌─────────┐               ┌─────────┐│  根节点  │               │ 新节点   ││    ●    │──────────────▶│    ○    ││   / \   │               │         ││  ●   ●  │               └─────────┘└─────────┘                    │                               ▼回溯 (Backpropagation)    评估 (Evaluation)     │                         │     ▼                         ▼┌─────────┐               ┌─────────┐│ 更新统计 │               │神经网络  ││  V, N   │◀──────────────│ (P, V)  ││ 向上传播 │               │         │└─────────┘               └─────────┘

1. 选择 (Selection)：从根节点开始，根据 UCB公式选择子节点，直到到达叶子节点
2. 扩展 (Expansion)：在叶子节点扩展可能的子节点
3. 评估(Evaluation)：使用神经网络评估新节点的价值
4. 回溯(Backpropagation)：将评估结果向上传播，更新路径上所有节点的统计信息

UCB 公式

节点选择使用 PUCT (Predictor Upper Confidence bounds applied toTrees) 公式：

其中： - $Q(s, a)$：动作 $a$ 的平均价值（累计价值 /访问次数） - $P(s, a)$：策略网络给出的先验概率 -$N(s, a)$：动作 $a$ 的访问次数 -$c_{puct}$：探索常数（本项目使用 0.8）

这个公式巧妙地平衡了利用（选择高价值动作）和探索（尝试访问较少的动作）。

Dirichlet 噪声

为了增加探索性，训练时在根节点添加 Dirichlet 噪声：

本项目使用 $\epsilon = 0.01$, $\alpha = 0.3$。

策略价值网络

网络采用双头架构，共享特征提取层，分别输出策略和价值：

输入: (batch, 3, 15, 15)  ├── 通道0: 当前玩家棋子位置  ├── 通道1: 对手棋子位置  └── 通道2: 空位位置        │        ▼┌─────────────────────────────────┐│  Conv2d(3→32, 3×3) + BN + ReLU  │  初始卷积层└─────────────────────────────────┘        │        ▼┌─────────────────────────────────┐│        ResBlock × 5             │  5个残差块│  ┌─────────────────────────┐    ││  │ Conv(32,32) → BN → ReLU │    ││  │ Conv(32,32) → BN        │    ││  │      + skip connection  │    ││  └─────────────────────────┘    │└─────────────────────────────────┘        │        ├───────────────────────────┐        ▼                           ▼┌─────────────────┐         ┌─────────────────┐│     价值头       │         │     策略头       ││   Conv(32→1)    │         │  Conv(32→16)    ││   Flatten       │         │  Conv(16→1)     ││   Linear(128)   │         │  Flatten        ││   Linear(1)     │         │  Softmax        ││   Tanh          │         │                 │└─────────────────┘         └─────────────────┘        │                           │        ▼                           ▼  局面价值 ∈ [-1, 1]        落子概率 ∈ [0, 1]^225

系统架构

Gomoku-AI/├── backend/                    # 后端服务│   ├── main.py                 # FastAPI 入口│   ├── game/│   │   └── board.py            # 棋盘逻辑│   ├── ai/│   │   ├── network.py          # 神经网络定义│   │   ├── mcts.py             # MCTS 算法│   │   └── train.py            # 训练脚本│   └── models/│       └── best_model.pth      # 训练好的模型│├── frontend/                   # Vue 前端│   └── src/│       ├── components/         # 组件 (棋盘、控制面板等)│       ├── stores/             # Pinia 状态管理│       └── api/                # API 调用│└── deploy/                     # 部署配置    ├── deploy.sh    └── nginx.conf

前后端交互流程

┌─────────────┐                    ┌─────────────┐│   前端 Vue   │                    │  后端 FastAPI ││             │                    │             ││  1. 点击落子 │ ─── POST /move ──▶ │             ││             │                    │  2. 执行MCTS ││             │                    │     搜索     ││  4. 显示结果 │ ◀── AI落子+胜率 ─── │  3. 返回结果 ││             │                    │             │└─────────────┘                    └─────────────┘

代码实现详解

神经网络设计

残差块

残差连接使得网络可以更深，同时避免梯度消失：

class ResidualBlock(nn.Module):    """残差块"""        def __init__(self, channels: int):        super().__init__()        self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)        self.bn1 = nn.BatchNorm2d(channels)        self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)        self.bn2 = nn.BatchNorm2d(channels)        self.relu = nn.ReLU()    def forward(self, x: torch.Tensor) -> torch.Tensor:        residual = x        out = self.relu(self.bn1(self.conv1(x)))        out = self.bn2(self.conv2(out))        out += residual  # 残差连接        out = self.relu(out)        return out

策略价值网络

class PolicyValueNetwork(nn.Module):    """策略-价值网络"""        def __init__(self, in_channels=3, hidden_channels=32, num_blocks=5):        super().__init__()                # 初始卷积层        self.conv_init = nn.Conv2d(in_channels, hidden_channels, 3, padding=1)        self.bn_init = nn.BatchNorm2d(hidden_channels)                # 残差块        self.res_blocks = nn.ModuleList([            ResidualBlock(hidden_channels) for _ in range(num_blocks)        ])                # 策略头：输出每个位置的落子概率        self.policy_conv = nn.Conv2d(hidden_channels, 1, kernel_size=3, padding=1)                # 价值头：输出当前局面的胜率评估        self.value_conv = nn.Conv2d(hidden_channels, 1, kernel_size=1)        self.value_fc1 = nn.Linear(225, 128)        self.value_fc2 = nn.Linear(128, 1)    def forward(self, x):        # 特征提取        x = F.relu(self.bn_init(self.conv_init(x)))        for block in self.res_blocks:            x = block(x)                # 策略头        policy = self.policy_conv(x).view(x.size(0), -1)                # 价值头        value = F.relu(self.value_conv(x)).view(x.size(0), -1)        value = torch.tanh(self.value_fc2(F.relu(self.value_fc1(value))))                return value, policy

棋盘状态编码

将棋盘转换为神经网络输入的三通道张量：

def board_to_tensor(board: list) -> torch.Tensor:    """    将棋盘转换为神经网络输入        输入 board: 15x15 矩阵，1=当前方，-1=对方，0=空    输出: (3, 15, 15) 张量    """    board_arr = np.array(board)        current_player = (board_arr == 1).astype(np.float32)   # 当前玩家棋子    opponent = (board_arr == -1).astype(np.float32)        # 对手棋子    empty = (board_arr == 0).astype(np.float32)            # 空位        return torch.FloatTensor(np.stack([current_player, opponent, empty]))

MCTS 实现

节点定义

class Node:    """MCTS 树节点"""        def __init__(self, board, parent=None, move=None):        self.board = board           # 当前局面        self.parent = parent         # 父节点        self.move = move             # 到达该节点的动作        self.children = {}           # 子节点字典 {move: (child, prior)}        self.visit_count = 0         # 访问次数 N        self.value_sum = 0.0         # 累计价值 W        self.value = None            # 神经网络评估值        @property    def q_value(self):        """平均价值 Q = W / N"""        if self.visit_count == 0:            return 0.0        return self.value_sum / self.visit_count

UCB 子节点选择

def _select_child(self, node: Node) -> Node:    """根据 UCB 公式选择子节点"""    total_visits = sum(        (child.visit_count if child else 0)         for child, _ in node.children.values()    )    sqrt_total = math.sqrt(total_visits + 1)        best_score = -float('inf')    best_move = None        for move, (child, prior) in node.children.items():        if child and child.visit_count > 0:            # 已访问节点：使用实际 Q 值            exploit = child.q_value            explore = self.c_puct * prior * sqrt_total / (child.visit_count + 1)        else:            # 未访问节点：使用平均值估计            exploit = avg_value            explore = self.c_puct * prior * sqrt_total                score = explore - exploit  # 注意：这里取负是因为子节点视角相反        if score > best_score:            best_score = score            best_move = move        return self._get_or_create_child(node, best_move)

完整搜索流程

def search(self, root_board, num_simulations):    """执行 MCTS 搜索"""    root = Node(root_board)        for _ in range(num_simulations):        node = root        search_path = [node]                # 1. 选择：沿树下降到叶子节点        while node.children:            node = self._select_child(node)            search_path.append(node)                # 2. 扩展与评估        if not self._is_terminal(node.board):            self._expand_node(node)  # 使用神经网络扩展        else:            node.value = self._evaluate_terminal(node.board)                # 3. 回溯：更新路径上所有节点        value = node.value        for n in reversed(search_path):            n.visit_count += 1            n.value_sum += value            value = -value  # 翻转视角        return self._get_results(root), root

自我对弈训练

训练数据生成

每局自对弈结束后，收集所有经历的局面作为训练数据：

def generate_single_game(model_state_dict, num_simulations):    """生成单局自对弈数据"""    model = PolicyValueNetwork()    model.load_state_dict(model_state_dict)        board = [[0] * 15 for _ in range(15)]    mcts = MCTS(model=model)        for move_num in range(225):        # MCTS 搜索        (value, action_probs), root = mcts.search(board, num_simulations)                # 根据概率选择动作        action = select_action(action_probs, temperature=0.1)        x, y = action        board[x][y] = 1                if is_game_over(board):            break                # 翻转视角（双方交替）        flip_board(board)        # 返回训练数据：(局面, 策略, 价值)    return mcts.get_train_data()

数据增强

五子棋棋盘具有 D4 对称性（4次旋转 × 2次翻转 = 8倍数据增强）：

def augment_data(boards, policies, values, weights):    """D4 对称变换数据增强"""    augmented = []        for board, policy, value, weight in zip(boards, policies, values, weights):        for k in range(4):  # 0°, 90°, 180°, 270° 旋转            for flip in [False, True]:  # 是否水平翻转                new_board = torch.rot90(board, k, [1, 2])                new_policy = torch.rot90(policy, k, [0, 1])                                if flip:                    new_board = torch.flip(new_board, [2])                    new_policy = torch.flip(new_policy, [1])                                augmented.append((new_board, new_policy, value, weight))        return augmented

训练损失函数

使用组合损失：价值损失（MSE）+ 策略损失（KL散度）

def train_step(model, batch):    boards, target_policies, target_values = batch        pred_values, pred_policies = model(boards)        # 价值损失：均方误差    value_loss = F.mse_loss(pred_values, target_values)        # 策略损失：KL散度    policy_loss = F.kl_div(        F.log_softmax(pred_policies, dim=1),        target_policies,        reduction='batchmean'    )        # 总损失（价值损失权重更高）    total_loss = 2 * value_loss + policy_loss        return total_loss

模型选择策略

采用 AlphaZero 风格的模型选择，确保模型持续进步：

def evaluate_and_update(new_model, best_model, num_games=20):    """评估新模型并决定是否更新"""    wins = 0        for game in range(num_games):        # 新模型 vs 最佳模型对弈        winner = play_game(new_model, best_model)        if winner == 1:  # 新模型获胜            wins += 1        win_rate = wins / num_games        # 胜率超过 55% 才更新最佳模型    if win_rate > 0.55:        save_model(new_model, 'best_model.pth')        return True    return False

项目部署与使用

环境配置

# 1. 克隆项目git clone https://github.com/fallingnight131/Gomoku-AI.gitcd Gomoku-AI# 2. 创建 Conda 环境conda create -n gomoku python=3.10 -yconda activate gomoku# 3. 安装后端依赖cd backendpip install -r requirements.txt# 4. 安装前端依赖cd ../frontendnpm install

启动服务

# 终端1：启动后端cd backenduvicorn main:app --reload --host 0.0.0.0 --port 8000# 终端2：启动前端cd frontendnpm run dev

访问 http://localhost:5173 开始游戏！

训练模型

cd backend# 快速测试（5-10分钟）python -m ai.train -n 5 --samples 10 --simulations 30 --workers 4# 标准训练（2-4小时）python -m ai.train -n 50 --samples 100 --simulations 30 --workers 10# 完整训练（8-24小时）python -m ai.train -n 200 --samples 100 --simulations 30 --workers 10

训练参数说明

参考资料

1. Mastering theGame of Go without Human Knowledge - AlphaGo Zero 论文
2. Mastering Chess and Shogiby Self-Play - AlphaZero 论文
3. Monte CarloTree Search - 蒙特卡罗树搜索介绍
4. Deep ResidualLearning - ResNet 论文

代码仓库： GitHub -Gomoku-AI

临时部署： 五子棋AI

如果这篇文章对你有帮助，欢迎 Star ⭐ 支持！

HBase 的相关信息

HBase 是什么

HBase 是一种分布式的、面向列（Column-oriented）的 NoSQL 数据库，是Hadoop 生态系统 的重要组成部分。

它的全称是：

Hadoop Database (HBase)

起源于 Google 的 Bigtable 论文，HBase 是 Bigtable 在开源界的实现，由Apache 基金会维护。

HBase 与 Hadoop 的关系

HBase 是 Hadoop 的上层应用之一，它依赖 Hadoop的组件实现底层存储与分布式管理。

可以这样理解它们的关系：

🗂 HDFS 管数据的“存放位置”

🧮 MapReduce 管数据的“计算任务”

🏗 HBase 管数据的“存储结构与访问方式”

或者一句话概括：

Hadoop 负责“存+算”，HBase 负责“查+改”。

HBase的数据模型（类比关系型数据库）

举个例子：

Table: StudentRowKey: 2015001Column Family: Info, ScoreData:RowKey | Info:Name | Info:Sex | Info:Age | Score:Math | Score:English2015001 | Zhangsan  | male     | 23       | 86          | 69

可以看到：

• Info 是一个列族（存放学生基本信息）

• Score 是另一个列族（存放成绩信息）

• 每行由一个唯一的 RowKey（学号）标识

HBase 和 Mysql 的区别

HBase 和 Mysql都是数据库，但他们适用的领域不一样，可以把它们想象成两种不同的交通工具：

• MySQL像一辆精密的轿车：适合在结构化的道路（固定表结构）上快速、安全、准确地运送少量贵重物品（结构化数据）。它强调事务安全和数据一致性。

• HBase像一列重载的火车：适合在粗糙的轨道（松散结构）上运输海量的、各种形态的货物（半/非结构化数据）。它追求的是吞吐量和大容量，而不是每件货物的精确摆放。

✅ HBase 适合的场景有：

• 数据量非常大（TB级以上）

• 数据是稀疏表（不是每行都有所有列）

• 需要高吞吐随机读写

• 需要按时间或主键快速检索

• 例如：

  • 用户行为日志系统

  • 传感器 IoT 数据

  • 社交关系存储

  • 推荐系统用户画像

  • 搜索引擎索引数据

❌ 不适合的场景：

• 小数据量项目（几GB以内）

• 需要复杂SQL、多表关联、事务支持

• 表结构频繁变化

对于这些场景用 Mysql 会更合适。

环境准备

在使用 HBase 前需要先搭好HDFS 环境

安装 HBase

下载安装包：

wget https://archive.apache.org/dist/hbase/1.4.13/hbase-1.4.13-bin.tar.gz

解压并移动到/usr/local/目录下：

sudo tar -zxvf hbase-1.4.13-bin.tar.gz -C /usr/local/

配置环境变量

打开Bash配置文件：

sudo nano ~/.bashrc

如果你按照之前搭HDFS环境的那篇文章配置过.bashrc文件，把之前加在文集末尾的内容改成：

export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64export HADOOP_HOME=/usr/local/hadoopexport HBASE_HOME=/usr/local/hbaseexport PATH=$PATH:$JAVA_HOME/bin:$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$HBASE_HOME/bin:$HBASE_HOME/sbin

之后执行：

source ~/.bashrc

随后打开 HBase 的配置文件：

sudo nano /usr/local/hbase/conf/hbase-site.xml

找到：

<property><property>

将<property>和中间夹着的内容改成：

<configuration>  <property>    <name>hbase.rootdir</name>    <value>hdfs://localhost:9000/hbase</value>  </property>  <property>    <name>hbase.zookeeper.property.dataDir</name>    <value>/usr/local/hbase/zookeeper</value>  </property>  <property>    <name>hbase.cluster.distributed</name>    <value>true</value>  </property></configuration>

启动 HBase

在 HDFS 已经启动的前提下，执行：

start-hbase.sh

如果想要关闭 HBase，可以执行：

stop-hbase.sh

启动完以后执行：

jps

如果输出包含：

HMasterHRegionServer

使用 HBase 命令

打开和退出 HBase Shell

成功启动 HBase 以后可以执行：

hbase shell

进入成功会出现提示符：

hbase(main):001:0>

HBase Shell 类似 mysql命令行，在这里可以通过命令对数据和表进行操作管理。

想要退出 HBase Shell 可以直接执行：

exit

HBase Shell 常用命令

HBase 的命令不像 SQL，而是类 Ruby 语法。 命令格式大多是：

command '参数1', '参数2', ...

表管理命令

创建表例子：

create 'student', 'info'

数据操作命令

插入和读取示例：

put 'student', 'row1', 'info:name', 'Alice'put 'student', 'row1', 'info:age', '21'get 'student', 'row1'

输出类似：

COLUMN                  CELL info:age               timestamp=..., value=21 info:name              timestamp=..., value=Alice

扫描查询

scan 'student'

输出示例：

ROW                        COLUMN+CELL row1                      column=info:age, timestamp=..., value=21                           column=info:name, timestamp=..., value=Alice

你还可以加过滤条件，比如：

scan 'student', {STARTROW => 'row1', STOPROW => 'row9'}

删除表数据

disable 'student'drop 'student'

或清空但保留表结构：

truncate 'student'

管理命令（系统级）

示例

例如要建的表叫 student，结构如下：

在 HBase 中：

• 表名：student

• 列族（Column Family）有两个：

  • info

  • score

• 每个列族下有多个“列限定符”（Qualifier）：

  • info:name、info:sex、info:age

  • score:math、score:english

具体步骤如下：

创建表：

命令：

create 'student', 'info', 'score'

说明：

• student 是表名；

• info 和 score 是列族。

插入数据

依次插入每一列数据：

put 'student', '2015001', 'info:name', 'Zhangsan'put 'student', '2015001', 'info:sex', 'male'put 'student', '2015001', 'info:age', '23'put 'student', '2015001', 'score:math', '86'put 'student', '2015001', 'score:english', '69'

查看表数据

查看单行:

get 'student', '2015001'

输出类似：

COLUMN                    CELLinfo:age                 timestamp=..., value=23info:name                timestamp=..., value=Zhangsaninfo:sex                 timestamp=..., value=malescore:english            timestamp=..., value=69score:math               timestamp=..., value=86

查看整张表:

scan 'student'

输出类似：

ROW                        COLUMN+CELL 2015001                   column=info:age, value=23                           column=info:name, value=Zhangsan                           column=info:sex, value=male                           column=score:english, value=69                           column=score:math, value=86

删除与清空操作

如果想删除整行：

deleteall 'student', '2015001'

如果想清空表（但保留结构）：

truncate 'student'

如果想彻底删除表：

disable 'student'drop 'student'

通过脚本使用 HBase

实际开发中肯定会通过编程实现与数据库的交互，而 HBase 提供了 Java客户端接口，使得我们可以通过 Java 脚本使用 HBase 。

准备工作

确保已经启动 HDFS 和 HBase：

start-dfs.shstart-hbase.sh

检查进程：

jps

确定输出包括：

NameNodeDataNodeSecondaryNameNodeHMasterHRegionServer

编写 Java 脚本

在一个方便的目录下创建一个项目目录：

mkdir -p ~/hbase-java-apicd ~/hbase-java-api

在该目录下创建一个 Java 文件：

nano HBaseExample.java

在这个 Java 文件里写入如下代码：

import java.io.IOException;import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.hbase.HBaseConfiguration;import org.apache.hadoop.hbase.TableName;import org.apache.hadoop.hbase.client.*;import org.apache.hadoop.hbase.util.Bytes;public class HBaseExample {    public static void main(String[] args) throws IOException {        // 1. 创建HBase配置        Configuration config = HBaseConfiguration.create();        config.set("hbase.zookeeper.quorum", "localhost");        config.set("hbase.zookeeper.property.clientPort", "2181");        config.set("hbase.rootdir", "hdfs://localhost:9000/hbase");        // 2. 建立连接        Connection connection = ConnectionFactory.createConnection(config);        Admin admin = connection.getAdmin();        // 3. 创建表        TableName tableName = TableName.valueOf("student");        if (!admin.tableExists(tableName)) {            TableDescriptorBuilder tableDesc = TableDescriptorBuilder.newBuilder(tableName);            ColumnFamilyDescriptor family = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes("info")).build();            tableDesc.setColumnFamily(family);            admin.createTable(tableDesc.build());            System.out.println("✅ 表 'student' 已创建");        } else {            System.out.println("ℹ️ 表 'student' 已存在");        }        // 4. 插入数据        Table table = connection.getTable(tableName);        Put put = new Put(Bytes.toBytes("row1"));        put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("name"), Bytes.toBytes("Alice"));        put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("age"), Bytes.toBytes("21"));        table.put(put);        System.out.println("✅ 插入成功");        // 5. 读取数据        Get get = new Get(Bytes.toBytes("row1"));        Result result = table.get(get);        byte[] value = result.getValue(Bytes.toBytes("info"), Bytes.toBytes("name"));        System.out.println("查询结果: " + Bytes.toString(value));        // 6. 扫描整张表        Scan scan = new Scan();        ResultScanner scanner = table.getScanner(scan);        for (Result res : scanner) {            System.out.println(res);        }        scanner.close();        // 7. 关闭资源        table.close();        admin.close();        connection.close();    }}

配置环境

设置 HBase 的依赖路径：

export HBASE_CLASSPATH=$(hbase classpath)

如果图方便，希望下次打开终端不用再输入如上命令，也可以把这行命令写进.bashrc文件，不过未来可能有冲突风险，需谨慎考虑。

编译运行

编译：

javac -cp $HBASE_CLASSPATH:. HBaseExample.java

运行:

java -cp $HBASE_CLASSPATH:. HBaseExample

在 Shell 验证结果

运行完 Java 程序后，打开 HBase shell：

hbase shelllistscan 'student'

预期输出：

ROW           COLUMN+CELL row1         column=info:age, timestamp=..., value=21 row1         column=info:name, timestamp=..., value=Alice1 row(s)

HDFS和Hadoop的关系和用处

什么是 Hadoop

Hadoop 是一个开源的大数据处理框架，由 Apache 基金会维护。它的目标是：

让“成千上万台普通计算机”能像“一台超级计算机”一样处理海量数据。

一句话总结：

Hadoop = 分布式存储（HDFS） + 分布式计算（MapReduce） +调度管理（YARN）

什么是 HDFS

HDFS（Hadoop Distributed File System） 是 Hadoop 的分布式文件系统。它是 Hadoop 存储数据的底层基础。

你可以把它理解为：

一个“把多台机器的硬盘组合在一起”的虚拟超大硬盘。

HDFS 的核心思想

假设你有一个 10TB 的文件，而你的电脑只有 1TB 硬盘， 那你可以用 HDFS把它分成若干个块（block），分别存到多台机器上。

HDFS 由两个主要角色组成：

HDFS和Hadoop的关系

Hadoop负责大数据计算框架（存储+计算），是总系统；HDFS负责分布式文件存储，是Hadoop 的底层存储模块。

环境准备

Linux系统

本文的所有命令是Ubuntu环境下运行的，可以买一个云服务器初始化的时候选择ubuntu系统，或者下载一个ubuntu镜像在虚拟机上跑。

安装 JDK（建议 Java 8）

本文使用Java对文件进行操作，所以需要安装JDK。建议安装Java8，用其他版本可能有起冲突的风险。

sudo apt updatesudo apt install openjdk-8-jdk -yjava -version

安装 Hadoop（建议使用 Hadoop3.3.x）

下载并解压

wget https://downloads.apache.org/hadoop/common/hadoop-3.3.6/hadoop-3.3.6.tar.gztar -zxvf hadoop-3.3.6.tar.gzsudo mv hadoop-3.3.6 /usr/local/hadoop

如果你没有安装 wget，可以先安装：

sudo apt updatesudo apt install wget -y

配置环境变量

打开配置文件：

sudo nano ~/.bashrc

在文件末尾加上：

export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64export HADOOP_HOME=/usr/local/hadoopexport PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin

然后执行：

source ~/.bashrc

验证安装

执行：

hadoop version

由于HDFS是Hadoop的子模块，所以安装完Hadoop以后系统就自带了HDFS。

启动 Hadoop单机模式（或伪分布式）

建立ssh连接

本文是单机模式，所以只需要和自己（localhost）建立ssh免密登录就行。如果是正常情况下多台机器实现分布式，则需要和本机以及每台机器都配置免密登录。

安装并启动 SSH 服务

执行：

sudo apt updatesudo apt install openssh-server -y

安装好后启动 SSH 服务：

sudo systemctl enable sshsudo systemctl start ssh

确认 SSH 正在运行：

sudo systemctl status ssh

应看到状态为：

Active: active (running)

配置本机免密登录（localhost）

让 Hadoop 在执行脚本时能自动 SSH 登录自己而不用密码。

生成 SSH 密钥：

ssh-keygen -t rsa -P ""

把公钥加到本机授权文件（多机器的话则是把本机公钥加到每台机器的授权文件）：

cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys

测试免密登录：

ssh localhost

第一次可能会提示：

Are you sure you want to continue connecting (yes/no)?

输入：

yes

然后如果能直接进入（没有要求输入密码），说明成功。

退出：

exit

在 Hadoop的配置文件中显式设置 JAVA_HOME

由于SSH 默认启动的是 非登录 shell，不会加载 ~/.bashrc，所以.bashrc中的 JAVA_HOME 虽然在 .bashrc 里，但 Hadoop 的脚本看不到。

因此需要编辑：

$HADOOP_HOME/etc/hadoop/hadoop-env.sh

执行命令：

nano /usr/local/hadoop/etc/hadoop/hadoop-env.sh

找到这一行（大概在文件中间位置）：

# export JAVA_HOME=

把注释去掉并改成你系统真实的 Java 路径，例如（以 Java 8 为例）：

export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64

保存后重新加载环境

source ~/.bashrc

定义NameNode所在地址

打开配置文件

sudo nano /usr/local/hadoop/etc/hadoop/core-site.xml

找到：

<property><property>

将<property>和中间夹着的内容改成：

<property>  <name>fs.defaultFS</name>  <value>hdfs://localhost:9000</value></property>

这样系统就能知道 NameNode 所在主机的主机名或 IP（localhost）。

启动

启动前需格式化 NameNode（必须重新格式化）。

hdfs namenode -format

输入启动 HDFS 的命令：

start-dfs.sh

确认启动结果：

jps

输出应当包含：

NameNodeDataNodeSecondaryNameNodeJps

可以尝试在浏览器输入：

http://localhost:9870

大部分情况下ubuntu系统没有图形界面，只有纯终端，如果用的是虚拟机，可以通过：

hostname -I

假设输出：

192.168.56.101

http://192.168.56.101:9870

如果用的是云服务器，则在本地电脑执行：

ssh -L 9870:localhost:9870 username@<你的服务器IP>

然后在本地浏览器打开：

http://localhost:9870

通过脚本实现HDFS文件操作

准备工作

确保以下前提都满足：

1. Hadoop 已经正确安装并能启动：

   start-dfs.shjps

   能看到NameNode、DataNode、SecondaryNameNode。

2. Java 环境配置正确：

   java -versionjavac -version

3. HDFS 运行正常：

   hdfs dfs -mkdir /testhdfs dfs -ls /

编写 Java 脚本

在一个方便的目录下创建一个项目目录：

mkdir -p ~/hdfs-java-apicd ~/hdfs-java-api

创建一个 Java 文件：

nano HdfsClient.java

在这个 Java 文件里写入如下代码：

import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.fs.FileSystem;import org.apache.hadoop.fs.Path;import org.apache.hadoop.fs.FSDataInputStream;import org.apache.hadoop.fs.FileStatus;import java.io.BufferedReader;import java.io.InputStreamReader;import java.net.URI;public class HdfsClient {    public static void main(String[] args) throws Exception {        // 1. 设置 Hadoop 配置信息        Configuration conf = new Configuration();        conf.set("fs.defaultFS", "hdfs://localhost:9000"); // 如果配置了 hostname 就写 hdfs://CivilightEterna:9000        // 2. 获取文件系统对象        FileSystem fs = FileSystem.get(new URI("hdfs://localhost:9000"), conf, "username");        // 3. 创建目录        Path dir = new Path("/experiment");        if (!fs.exists(dir)) {            fs.mkdirs(dir);            System.out.println("✅ 目录 /experiment 创建成功！");        }        // 4. 上传文件        Path localFile = new Path("/home/username/test.txt");        Path hdfsFile = new Path("/experiment/test.txt");        fs.copyFromLocalFile(localFile, hdfsFile);        System.out.println("✅ 文件上传成功！");        // 5. 读取文件        FSDataInputStream inputStream = fs.open(hdfsFile);        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));        String line;        System.out.println("✅ 文件内容：");        while ((line = reader.readLine()) != null) {            System.out.println(line);        }        reader.close();        // 6. 查看文件信息        FileStatus status = fs.getFileStatus(hdfsFile);        System.out.println("✅ 文件路径：" + status.getPath());        System.out.println("✅ 文件大小：" + status.getLen() + " bytes");        // 7. 删除文件        fs.delete(hdfsFile, true);        System.out.println("✅ 文件已删除。");        // 8. 关闭文件系统        fs.close();    }}

然后在本地ubuntu用户目录创建一个名test.txt的文件：

echo "Hello HDFS from Java API!" > /home/username/test.txt

编译并运行

设置 Hadoop 的依赖路径：

export HADOOP_CLASSPATH=$(hadoop classpath)

编译：

javac -cp $HADOOP_CLASSPATH HdfsClient.java

如果编译成功，会生成：

HdfsClient.class

运行程序：

java -cp $HADOOP_CLASSPATH:. HdfsClient

运行效果示例

如果一切正常，你会看到输出：

✅ 目录 /experiment 创建成功！✅ 文件上传成功！✅ 文件内容：Hello HDFS from Java API!✅ 文件路径：hdfs://localhost:9000/experiment/test.txt✅ 文件大小：26 bytes✅ 文件已删除。

同时你可以验证：

hdfs dfs -ls /experiment

如果想要直接使用成品，可以点击>这里。(因为部署在了streamlit，所以可能需要唤醒一下程序)

原理

本文介绍的方法是通过输入视频在b站的网址，然后通过api爬取视频。

虽然视频的播放地址有时候就在html文件中，但是对于拜年庆等视频，地址在html文件中的位置有变化，并不能稳定爬到，而aid、cid等api信息参数的位置相对稳定，所以用api的方法爬成功的概率更高。

获取api参数

b站视频的api有三个参数，分别是aid、bvid、cid。

由于b站视频的url中是包含bvid的，所以我们实际要收集的参数是aid和cid。

在html文件中，aid和cid一般就在bvid的上下，可以通过正则化找到相应的bvid，然后再获取另外两个参数。

获取视频数据

通过api参数，就可以访问视频的json数据了。api接口是https://api.bilibili.com/x/player/playurl。

返回的json数据如下：

可以看到，视频的播放地址就在返回的json数据里。b站视频的视频流和音频流是分开的。视频的播放地址在video下，音频的播放地址在audio下,baseUrl和base_url都可能是有效的播放地址。vidio和audio下都有很多个子数据，一般越靠前的品质越好，例如0下的视频数据比1下的视频数据分辨率高。

爬取到视频和音频文件以后，将两个文件合并一下，一个完整的视频就得到了。

代码实现

下面是用python写的示例代码：

import requestsimport osfrom moviepy.editor import VideoFileClip, AudioFileClipimport re# 视频页面 URLurl = input("请输入 Bilibili 视频的网址:\n ")def extract_bv(url):    """    从给定的 URL 中提取 Bilibili 的 BV 号。​    参数:​        url (str): 包含 BV 号的 URL。​    返回:​        str: 提取到的 BV 号，如果未找到则返回 None。​    """​    # 定义匹配 BV 号的正则表达式​    bv_pattern = r"BV[0-9A-Za-z]+"​    ​    # 使用正则表达式在 URL 中查找​    match = re.search(bv_pattern, url)​    ​    if match:​        return match.group(0)  # 返回匹配到的 BV 号​    else:​        return None  # 如果没有匹配到 BV 号，则返回 None​    bvid = extract_bv(url)def find_api_inf(url, bvid, headers):    # 获取api信息​    response = requests.get(url, headers=headers)​    if response.status_code == 200:​        html_content = response.text        # 匹配包含 aid、bvid 和 cid 的字段​        matches = re.findall(r'"aid":(\d+),"bvid":"(BV[0-9A-Za-z]+)","cid":(\d+)', html_content)        # 查找指定 bvid 的 aid 和 cid​        for aid, matched_bvid, cid in matches:​            if matched_bvid == bvid:​                return aid, cid​        else:​            print(f"未找到指定的 bvid: {bvid}")​    else:​        print(f"请求失败，状态码：{response.status_code}")# 设置请求头，模拟浏览器headers = {    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36"}aid, cid = find_api_inf(url, bvid, headers)params = {"fnver": "0","fnval": "4048","fourk": "1","aid": aid,"bvid": bvid,"cid": cid,}# 请求 B站 APIresponse = requests.get("https://api.bilibili.com/x/player/playurl", params=params, headers=headers)data = response.json()# 提取视频和音频 URLvideo_base_urls = []audio_base_urls = []# 提取视频 URLfor video_data in data['data']['dash']['video']:    if 'baseUrl' in video_data:        video_base_urls.append(video_data['baseUrl'])    if 'base_url' in video_data:        video_base_urls.append(video_data['base_url'])# 提取音频 URLfor audio_data in data['data']['dash']['audio']:    if 'baseUrl' in audio_data:        audio_base_urls.append(audio_data['baseUrl'])    if 'base_url' in audio_data:        audio_base_urls.append(audio_data['base_url'])# 定义下载函数def download_file(url, filename):    try:        print(f"正在下载: {url}")        response = requests.get(url, stream=True)        response.raise_for_status()        with open(filename, "wb") as f:            for chunk in response.iter_content(chunk_size=8192):                f.write(chunk)        print(f"下载完成: {filename}")        return True    except Exception as e:        print(f"下载失败: {url}, 错误: {e}")        return False# 下载视频和音频video_file = "video.mp4"audio_file = "audio.m4a"video_downloaded = Falseaudio_downloaded = Falsefor video_url in video_base_urls:    if download_file(video_url, video_file):        video_downloaded = True        breakfor audio_url in audio_base_urls:    if download_file(audio_url, audio_file):        audio_downloaded = True        break# 合并音频和视频if video_downloaded and audio_downloaded:    output_file = "output.mp4"    print("正在合并音频和视频...")    try:        # 加载视频和音频文件​        video = VideoFileClip(video_file)​        audio = AudioFileClip(audio_file)        # 将音频添加到视频​        video = video.set_audio(audio)        # 导出合并后的视频​        video.write_videofile(output_file, codec="libx264", audio_codec="aac")​        print(f"合并完成: {output_file}")​    except Exception as e:​        print(f"合并失败: {e}")​    finally:​        # 清理 MoviePy 的缓存文件​        video.close()​        audio.close()else:​    print("视频或音频下载失败，无法合并。")# 清理临时文件if os.path.exists(video_file):    os.remove(video_file)if os.path.exists(audio_file):    os.remove(audio_file)

问题描述

用cmake加MSVC工具链编译C++程序的时候出现了C2065：未声明的标识符的报错。此前使用minGW的时候没有过这样的报错。

报错原因

问题是由于源文件的字符编码不兼容导致的。MSVC默认使用ANSI 编码（如 GB2312 或Shift-JIS）解析源文件，而源代码可能是UTF-8编码的，这就导致了C2065（未声明的标识符）等错误，特别是当代码中包含非 ASCII字符（如中文注释、字符串常量等）时。

解决方法

在CmakeLists增加：

if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")​add_compile_options(/source-charset:utf-8 /execution-charset:utf-8)endif()

这样就能强制 MSVC 以 UTF-8解析代码，避免了字符编码问题引起的未声明标识符错误。

众所周知，学习通因为反作弊机制不允许黏贴文本到答题框，但是学习通的答题框太小了，在这玩意里面一个一个打字会很不方便，但是想要在记事本上把答案写完再黏上去是不被允许的。

本文讲述一种办法使得答案可以被黏贴进答题框。

打开检查

如果你使用的是Chrome或者MicrosoftEdge，在答题页面右键打开菜单选择检测。

找到答题框部分

打开检查以后，选择元素菜单。

然后点击左上角的箭头。

选择了这个箭头以后，点击任何网页中的元素都会自动跳转到其对应的html代码部分。

随后我们选择答题框。

可以看到右边检查已经选中了答题框区域。

修改答题框文本

我们点开标签<body>。

看到标签<p>。我们再点开这个<p>标签。

这时我们看到"​" == $0。这就是答题框文本部分，接下来只需要将这个​黏贴成答案就行了。

之后再回车，左边的答题框里就有了我们需要的答案。

基础表格绘制

画一张表

表格的基本语法如下，第一行是表格的标题行，第二行固定以--- 做分隔，列通过使用 |來添加。宽度是自动分配的，如果第二行和第一行列数不一样也会自动对齐（但是会不美观）。空格会被忽视掉。|没有对齐也没有关系，最后形成的表格都是会自动对齐的。

| Column 1 | Column 2 | Column 3 || -------- | -------- | -------- || Text1    | Text2    | Text3    || Text4    | Text5    | Text6    |

效果如下：

对齐方法

默认是左对齐，但是如果希望自定义对齐方法也是可以的.

| 预设对齐 | 靠左对齐 | 靠右对齐 | 置中对齐 || ----- | :----- | -----: | :-----: || Text1 | Text2 | Text3 | Text4 || Text5 | Text6 | Text7 | Text8 || Text9 | Text10 | Text11 | Text12 |

效果如下：

表内换行

可以使用html标签<br>实现换行。

| Column 1 | Column 2 | Column 3 || -------- | -------- | -------- || Text1    | Text2    | Text3    || Text4    | Text5    | Text6<br>Text7    |

效果如下：

特殊符号绘制

由于|有特殊意义，所以不能直接在表内使用。可以使用&#124来绘制|。

| Column 1 | Column 2 | Column 3 || -------- | -------- | -------- || Text1    | Text2    | Text3    || Text4    | Text5    | Text6|Text7   |

效果如下：

当你希望表中有空行的时候，直接不填东西是不行的。

例如：

| Column 1 | Column 2 | Column 3 || -------- | -------- | -------- || Text1    | Text2    | Text 3   ||          |          |          || Text4    | Text5    | Text6    |

效果如下：

可以看到，中间一行直接凭空消失了。因为markdown会忽视没有填任何东西的行。

正确的写法是用 占位。

| Column 1 | Column 2 | Column 3 || -------- | -------- | -------- || Text1    | Text2    | Text 3   ||     |          |          || Text4    | Text5    | Text6    |

效果如下：

这样一来，原本没有内容的一行就不会被忽视了。

复杂符号绘制

例如$a_{j}$、$x^{n}$这样有上标下标的符号；以及$\theta$这样的希腊符号，可以通过Latex实现，表格内部是支持Latex的。

在表格里面通过

$具体Latex语句$

可以插入复杂符号。

例如:

| $a_{j}$ | $x^{n}$ | $\theta$ || :-------: | :-------: | :--------: ||   Text1   |   Text2   |   Text3    ||   Text4   |   Text5   |   Text6    |

效果如下：

复杂表格绘制

如果要画更加复杂的表格，例如要合并单元格的话，markdown自带的表格绘制方法就不适用了。

需要通过html的方法实现单元格合并。

画一张表

首先用html画一个简单的表格：

<table border="1" width="600px" cellspacing="10">    <tr>        <th>Column 1</th>         <th>Column 2</th>         <th>Column 3</th>     </tr>    <tr>        <td>Text1</td>         <td>Text2</td>         <td>Text3</td>     </tr>    <tr>        <td>Text4</td>         <td>Text5</td>         <td>Text6</td>     </tr></table>

其中<th>表示标题、<td>表示内容。

对齐方法

可以设置align来自定义对齐：

<table border="1" width="600px" cellspacing="10">    <tr>        <th align="left">Column 1</th>         <th align="center">Column 2</th>         <th align="right">Column 3</th>     </tr>    <tr>  <td align="left">Text1</td>         <td align="center">Text2</td>         <td align="right">Text3</td>     </tr>    <tr>        <td align="left">Text4</td>         <td align="center">Text5</td>         <td align="right">Text6</td>     </tr></table>

复杂符号绘制

在html中，需要通过：

$具体Latex语句$

<table border="1" width="600px" cellspacing="10">    <tr>        <th align="center">$a_{j}$</th>         <th align="center">$x^{n}$</th>         <th align="center">$\sigma$</th>     </tr>    <tr>  <td align="center">Text1</td>         <td align="center">Text2</td>         <td align="center">Text3</td>     </tr>    <tr>        <td align="center">Text4</td>         <td align="center">Text5</td>         <td align="center">Text6</td>     </tr></table>

合并单元格

合并行

可以通过colspan实现行的合并。

<table border="1" width="600px" cellspacing="10">    <tr>        <th colspan="2" align="center">Column 1</th>         <th align="center">Column 2</th>     </tr>    <tr>  <td align="center">Text1</td>         <td align="center">Text2</td>         <td align="center">Text3</td>     </tr>    <tr>        <td align="center">Text4</td>         <td align="center">Text5</td>         <td align="center">Text6</td>     </tr></table>

这样一来，第一行前两列就成功合并了，以此类推如果想要合并前三列，把colspan="2"改成colspan="3"就可以实现。

合并列

可以通过rowspan实现行的合并。

<table border="1" width="600px" cellspacing="10">    <tr>        <th align="center">Column 1</th>         <th align="center">Column 2</th> <th align="center">Column 3</th>    </tr>    <tr>  <td align="center">Text1</td>         <td align="center">Text2</td>         <td rowspan="2" align="center">Text3</td>     </tr>    <tr>        <td align="center">Text4</td>         <td align="center">Text5</td>    </tr></table>

这样一来，第三列后两列就成功合并了，以此类推如果想要合并更多三列，把colspan="2"的2改成其他数字就可以实现。

不过要注意的是，合并列以后，上面的行会占用下面的行，也就是说下面的行要减少相应的列。比如上述例子中，第二行的第三列的rowspan设置为2（列数跨度为2），那么也就是说，这个格子会占用第三行的一列，所以第三行应该少设置一列。

同时合并行和列

同时使用colspan和rowspan可以实现同时合并行和列

<table border="1" width="600px" cellspacing="10">    <tr>        <th align="center">Column 1</th>         <th align="center">Column 2</th> <th align="center">Column 3</th>    </tr>    <tr>  <td align="center">Text1</td>         <td colspan="2" rowspan="2" align="center">Text2</td>     </tr>    <tr>        <td align="center">Text3</td>     </tr></table>

用处

单纯形法是一种线性规划迭代算法，能够在有限步内找到线性规划问题的最优解(如果解存在的话)。

算法步骤

以下述线性规划问题为例： $$\begin{aligned}\max z = 2x_{1} + 3x_{2} \\\text{s.t.} \quad \left\{\begin{aligned} x_{1} + 2x_{2} &\le 8 \\ 4x_{1} &\le 16 \\ 4x_{2} &\le 12 \\ x_{1}, x_{2} &\ge 0\end{aligned}\right.\end{aligned}$$其中，第一行是线性目标，大括号里面的内容是约束条件。

化为标准型

• 确定线性目标是求的max问题，如果是min问题，则将等号两边都乘以-1，从而转变为max问题。

• 确定最后一行的每一个x都大于等于0，如果有小于等于的x，则将那个x变成两个大于等于0的数的相减。​例如：如果$x_{1}\le0$，则$x_{1}$可以化成$x_{1}^{'}-x_{1}^{''}$。​转换以后将最后一行变成$x_{1}^{'}\ge 0, x_{1}^{''}\ge 0, x_{2}\ge 0$，将最后一行以外约束条件里面的$x_{1}$也变成$x_{1}^{'}-x_{1}^{''}$。

• 确定最后一行以外的约束条件都是$\le$，如果有$\ge$，则不等号两边乘以-1从而变号为$\le$。

• 单纯形法硬性要求后续约束条件化成的矩阵中存在单位矩阵，所以对于没有单位矩阵的情况，需要手动凑单位矩阵。除最后一行以外的约束条件有几行，就增加几个额外的大于等于0的变量用于凑单位矩阵。例如：上述线性规划问题凑完以后的结果为： $$\begin{aligned}\max z = 2x_{1} + 3x_{2} + 0x_{3} + 0x_{4} + 0x_{5} \\\text{s.t.} \quad\left\{\begin{array}{rcl} x_{1} + 2x_{2} + x_{3} & = & 8 \\ 4x_{1} + x_{4} & = & 16 \\ 4x_{2} + x_{5} & = & 12 \\ x_{1}, x_{2}, x_{3}, x_{4}, x_{5} & \ge & 0\end{array}\right.\end{aligned}$$增加了三个新的变量$x_{3}, x_{4}, x_{5}$,这样不仅凑出了单位矩阵(后续解释)，而且还去掉了不等号。

• 将其余每一行缺失的变量都用0补上，得到最终化为标准型的结果为：$$\begin{aligned}\max z = 2x_{1} + 3x_{2} + 0x_{3} + 0x_{4} + 0x_{5} \\\text{s.t.} \quad\left\{\begin{matrix} x_{1} + 2x_{2} + x_{3} & = & 8 \\ 4x_{1} + x_{4} & = & 16 \\ 4x_{2} + x_{5} & = & 12 \\ x_{1}, x_{2}, x_{3}, x_{4}, x_{5} & \ge & 0\end{matrix}\right.\end{aligned}$$

列出初始单纯形表

规则如下：

1. 列数等于变量的个数。
2. 行数等于大括号中多变量的式子的个数。
3. 对于$c_{j}$行的数字根据目标函数中各变量的系数找。
4. 每个变量所在列的数字根据大括号中多变量式子中该变量的系数找。
5. 找出变量下方已填写数字构成的矩阵中的单位矩阵，依次将单位矩阵对应的变量写在“基”那一列的下面。
6. 将5中找到的变量上方的数字依次写在$c_{j}$那一列的下面。
7. 将大括号中多变量式子右侧数字依次填到b那一列的下面。

找出可行解

令“基”所在列的变量与b所在列的数字对应相等，再令其他变量等于0。

即$X^{(0)}=(0,0,8,16,12)$。

求出检验数

检验数$\sigma_{j}$计算公式如下：

例如：$\sigma_{1}=c_{1}-(c_{B1}\cdot x_{11}+c_{B2}\cdot x_{12}+c_{B3}\cdot x_{13})=2-(0\cdot 1+0\cdot 4+0\cdot 0)=2$

判断最优解

观察一下$\sigma_{j}$这一行的数字看一下是否都$\le$0，

若这些数字都$\le$，则找到的可行解是最优解。

若这些数字有>0的，则该可行解不是最优解，需继续进行下一步。

获取入基变量

找到$\sigma_{j}$行最大的数字那一列对应的变量$x_{a}$作为入基变量。

在本例中，此时的最大$\sigma_{j}$为3，其对应的变量是$x_{2}$。

获取出基变量

求出$\theta_{i}=b_{i}\div x_{ai}$,其中$x_{ai}$是入基变量对应的那一列。

若$\theta\ge 0$，则把$\theta$的值填到表中；

若$\theta\le 0$，则不用把$\theta$的值填到表中；

若$\theta$无意义，则不用把$\theta$填到表中。

注意：若求出的$\theta$都$\le$0，则该线性规划问题的解为无解解。

在本例中： $$\begin{aligned}\theta_{1} &= \frac{b_{1}}{x_{21}} = \frac{8}{2} = 4 \\\theta_{2} &= \frac{b_{2}}{x_{22}} = \frac{16}{0} \quad \text{(无意义)} \\\theta_{3} &= \frac{b_{3}}{x_{23}} = \frac{12}{4} = 3\end{aligned}$$

找到表中$\theta_{i}$最小值对应“基”列的变量$x_{b}$作为出基变量。

在本例中，最小的$\theta_{i}$是$\theta_{3}$，故其对应的变量$x_{5}$作为出基变量。

绘制下一轮单纯形表

在原基础上对单纯形表进行扩展:

处理出入基变量

找到上一轮中入基变量对应列和出基变量对应行交叉的数字m并填入新一轮的表中。(本轮中的m是4)

在新表中用$x_{a}$(入基)上面的数字代替$x_{b}$(出基)前面的数字，用$x_{a}$代替$x_{b}$，其余变量不变。(本例中用$x_{2}$替换“基”中的$x_{5}$)