当前位置： 首页 > news >正文

贪心算法在网络入侵检测（NID）中的应用

news 2025/9/17 9:30:15

在这里插入图片描述

Java中贪心算法在网络入侵检测（NID）中的应用

贪心算法以其“每一步选择当前最优解”的特性，在处理NID中的某些特定、资源受限的子问题时非常有效。需要注意的是，贪心算法本身通常不直接用于最终的入侵判定（这通常是复杂模型的任务），而是作为预处理、特征选择、规则优化或决策路径构建的核心策略，以提高整个检测系统的效率和可管理性。

核心概念回顾

  1. 贪心算法：

    • 核心思想： 在解决问题的每一步，都做出在当前状态下看起来最好的选择（即局部最优解），并期望通过这一系列的局部最优选择最终导致全局最优解。
    • 特点： 简单、高效、易于实现。通常时间复杂度较低。
    • 关键点： 贪心算法的有效性高度依赖问题是否具有贪心选择性质（Greedy Choice Property）和最优子结构（Optimal Substructure）。证明这两个性质是确保贪心算法能获得全局最优解的关键。但在很多NID应用中，我们可能并不追求绝对最优，而是追求在有限资源（时间、计算能力、内存）下的高效且足够好的解决方案。
    • 经典应用场景： 活动选择问题、霍夫曼编码、最小生成树（Prim, Kruskal）、单源最短路径（Dijkstra）、背包问题（分数背包）等。

  2. 网络入侵检测（NID）：

    • 目标： 监控网络流量或系统活动，识别恶意行为或违反安全策略的活动。
    • 挑战：
      • 海量数据： 高速网络产生巨量数据包/事件。
      • 实时性要求： 许多攻击需要快速响应。
      • 资源限制： CPU、内存、带宽有限。
      • 特征维度高： 描述一个网络连接或事件的特征可能非常多（几十到上百个）。
      • 攻击多样性： 攻击手法层出不穷且不断演化。
      • 噪音与误报： 区分正常流量和恶意流量存在困难。
    • 主要技术：
      • 误用检测 (Misuse Detection): 基于已知攻击特征（签名、规则）进行匹配。例如Snort, Suricata的核心。
      • 异常检测 (Anomaly Detection): 建立正常行为模型，偏离该模型的活动视为异常（可能为攻击）。例如基于统计、机器学习（ML）的模型。

贪心算法在NID中的具体应用场景与Java实现

贪心算法在NID中主要应用于以下几个关键环节：

应用场景1：特征选择 (Feature Selection)

  • 问题： 原始网络数据（如NetFlow记录、数据包头信息、连接统计信息）包含大量特征（源IP、源端口、目的IP、目的端口、协议、包大小、包间隔、TCP标志位组合、连接持续时间、发送/接收字节数、错误包数量等）。很多特征可能冗余、无关、甚至噪声。高维特征会导致：
    • 模型训练和检测速度变慢（维度灾难）。
    • 模型复杂度增加，可能过拟合。
    • 存储和处理开销增大。
  • 贪心策略：
    • 核心思想： 逐步选择最能区分正常流量和攻击流量的特征子集。
    • 常用贪心标准：
      • 信息增益 (Information Gain - IG)： 衡量加入一个特征后，对类别标签（正常/攻击）不确定性减少的程度。选择IG最大的特征。
      • 信息增益比 (Gain Ratio)： 改进IG，克服其对取值较多特征的偏好。
      • 卡方检验 (Chi-Squared Test)： 衡量特征和类别标签之间的统计相关性。选择卡方值最大的特征。
      • 互信息 (Mutual Information)： 衡量特征和类别标签共享的信息量。
      • 基于模型的特征重要性： 训练一个简单模型（如决策树），根据特征在模型中的重要性（如减少的不纯度）排序，选择重要性最高的前k个特征（这本身也是一种贪心）。
  • 贪心算法类型：
    • 前向搜索 (Forward Selection)： 从一个空特征集开始，每次添加在当前子集下带来最大提升（根据上述标准）的特征。直到达到预定特征数k或添加新特征不再显著提升效果。
    • 后向消除 (Backward Elimination)： 从完整特征集开始，每次移除在当前子集下带来最小损失（或重要性最低）的特征。直到达到预定特征数k或移除特征会显著降低效果。
  • Java实现示例（前向搜索 - 基于信息增益）：
import java.util.*;public class GreedyFeatureSelector {// 假设数据格式：List<Map<String, Object>> dataPoints, 每个Map代表一个数据点，包含特征名->值，以及一个"label"键表示类别（正常/攻击）// 特征列表：List<String> allFeaturespublic static List<String> forwardSelection(List<Map<String, Object>> dataPoints, List<String> allFeatures, int k) {List<String> selectedFeatures = new ArrayList<>();Set<String> remainingFeatures = new HashSet<>(allFeatures);// 计算整个数据集的初始熵double initialEntropy = calculateEntropy(dataPoints);while (selectedFeatures.size() < k && !remainingFeatures.isEmpty()) {String bestFeature = null;double maxGain = Double.NEGATIVE_INFINITY;// 遍历所有剩余特征，计算添加该特征后的信息增益for (String feature : remainingFeatures) {// 计算添加feature后的条件熵double conditionalEntropy = calculateConditionalEntropy(dataPoints, selectedFeatures, feature);double gain = initialEntropy - conditionalEntropy; // IG = H(Y) - H(Y|X)if (gain > maxGain) {maxGain = gain;bestFeature = feature;}}// 添加带来最大信息增益的特征if (bestFeature != null) {selectedFeatures.add(bestFeature);remainingFeatures.remove(bestFeature);System.out.println("Added feature: " + bestFeature + ", Gain: " + maxGain);}}return selectedFeatures;}// 计算数据集dataPoints的熵 H(Y)private static double calculateEntropy(List<Map<String, Object>> dataPoints) {Map<Object, Integer> labelCounts = new HashMap<>();for (Map<String, Object> point : dataPoints) {Object label = point.get("label");labelCounts.put(label, labelCounts.getOrDefault(label, 0) + 1);}double entropy = 0.0;int totalPoints = dataPoints.size();for (int count : labelCounts.values()) {double p = (double) count / totalPoints;entropy -= p * Math.log(p) / Math.log(2); // log base 2}return entropy;}// 计算在已知selectedFeatures和当前候选特征currentFeature的条件下，类别标签的条件熵 H(Y | selectedFeatures, currentFeature)// 这是一个简化版本，假设特征都是离散的。实际中需要处理连续特征（分桶）和更高效的实现。private static double calculateConditionalEntropy(List<Map<String, Object>> dataPoints,List<String> selectedFeatures, String currentFeature) {// 1. 根据selectedFeatures + currentFeature的所有可能组合值对数据点分组Map<String, List<Map<String, Object>>> groups = new HashMap<>();for (Map<String, Object> point : dataPoints) {StringBuilder keyBuilder = new StringBuilder();for (String feat : selectedFeatures) {keyBuilder.append(point.get(feat).toString()).append("_");}keyBuilder.append(point.get(currentFeature).toString());String groupKey = keyBuilder.toString();groups.computeIfAbsent(groupKey, k -> new ArrayList<>()).add(point);}// 2. 计算每个组内的熵，然后加权平均double conditionalEntropy = 0.0;int totalPoints = dataPoints.size();for (List<Map<String, Object>> group : groups.values()) {double groupEntropy = calculateEntropy(group); // 计算该子组的熵double groupProb = (double) group.size() / totalPoints; // 该子组的概率conditionalEntropy += groupProb * groupEntropy;}return conditionalEntropy;}// 主函数示例用法public static void main(String[] args) {// 1. 加载数据 (这里省略具体数据加载代码，假设dataPoints和allFeatures已准备好)// List<Map<String, Object>> dataPoints = loadData("kddcup.data");// List<String> allFeatures = Arrays.asList("duration", "protocol_type", "service", ... , "dst_host_srv_rerror_rate");// 2. 选择前10个最重要的特征List<String> selected = forwardSelection(dataPoints, allFeatures, 10);System.out.println("Selected Features: " + selected);}
}

应用场景2：规则集精简与优化 (Rule Set Pruning/Optimization)

  • 问题： 基于签名的NIDS（如Snort）拥有成千上万条规则。每条规则都包含匹配条件（如特定协议、端口、载荷内容）和动作（告警、阻断）。庞大的规则集导致：
    • 匹配速度慢： 每个数据包需要与大量规则比较。
    • 内存占用高： 规则需要加载到内存中。
    • 维护困难： 更新和优化规则集变得复杂。
  • 贪心策略：
    • 核心思想： 在保持检测能力（覆盖尽可能多的已知攻击）的前提下，最小化规则集的大小。
    • 常用贪心标准：
      • 规则覆盖的攻击数量/重要性： 选择一条规则，能覆盖最多（或最重要）的、当前未被其他已选规则覆盖的攻击样本。
      • 规则执行代价： 考虑规则匹配所需的时间或资源（例如，检查载荷内容的规则比检查IP头的规则代价高）。优先选择高覆盖度/低代价比的规则。
      • 规则泛化能力： 选择能覆盖一类攻击而不仅是单个签名的规则（如果规则设计允许）。
  • 贪心算法类型：
    • 最大覆盖 (Maximum Coverage)： 贪心算法的经典应用。
      • 输入： 规则集合 R，攻击样本集合 A。每个规则 r 能覆盖一个子集 A_r ⊆ A。
      • 目标： 选择至多 k 条规则，使得覆盖的攻击样本数 | ∪_{r in S} A_r | 最大化。
      • 贪心步骤：
        1. 初始化已选规则集 S = ∅。
        2. 当 |S| < k 且还有未覆盖的攻击样本时：
          1. 选择一条规则 r，使得 A_r 与当前未被覆盖的攻击样本集合的交集 U 的大小 |U| 最大（即 r 能覆盖最多新攻击）。
          2. 将 r 加入 S。
          3. 将 U 中的攻击样本标记为已被覆盖。
        3. 返回 S。
  • Java实现示例（最大覆盖规则精简）：
import java.util.*;public class RuleSetOptimizer {// 表示一条规则static class Rule {String id;Set<String> coveredAttacks; // 该规则能覆盖的攻击ID集合// 其他属性：代价、优先级等public Rule(String id, Set<String> coveredAttacks) {this.id = id;this.coveredAttacks = coveredAttacks;}}// 贪心最大覆盖算法选择规则public static List<Rule> selectRulesWithMaxCoverage(List<Rule> allRules, int k) {List<Rule> selectedRules = new ArrayList<>();Set<String> uncoveredAttacks = new HashSet<>();// 初始化：收集所有规则覆盖的所有攻击（去重）for (Rule rule : allRules) {uncoveredAttacks.addAll(rule.coveredAttacks);}while (selectedRules.size() < k && !uncoveredAttacks.isEmpty()) {Rule bestRule = null;int maxNewCoverage = -1;// 遍历所有规则，找到覆盖最多新攻击的规则for (Rule rule : allRules) {if (selectedRules.contains(rule)) continue; // 已选规则跳过// 计算当前规则能覆盖的、尚未被覆盖的攻击数量int newCoverage = 0;for (String attack : rule.coveredAttacks) {if (uncoveredAttacks.contains(attack)) {newCoverage++;}}if (newCoverage > maxNewCoverage) {maxNewCoverage = newCoverage;bestRule = rule;}}// 如果找到符合条件的规则if (bestRule != null && maxNewCoverage > 0) {selectedRules.add(bestRule);// 从uncoveredAttacks中移除bestRule覆盖的攻击uncoveredAttacks.removeAll(bestRule.coveredAttacks);System.out.println("Selected rule: " + bestRule.id + ", New Attacks Covered: " + maxNewCoverage);} else {break; // 没有规则能覆盖新攻击或达到k条}}return selectedRules;}// 主函数示例用法public static void main(String[] args) {// 模拟数据List<Rule> rules = new ArrayList<>();rules.add(new Rule("R1", new HashSet<>(Arrays.asList("A1", "A2", "A3"))));rules.add(new Rule("R2", new HashSet<>(Arrays.asList("A3", "A4", "A5"))));rules.add(new Rule("R3", new HashSet<>(Arrays.asList("A5", "A6"))));rules.add(new Rule("R4", new HashSet<>(Arrays.asList("A7"))));// 选择最多2条规则List<Rule> optimizedRules = selectRulesWithMaxCoverage(rules, 2);System.out.println("Optimized Rules:");for (Rule r : optimizedRules) {System.out.println(" - " + r.id);}}
}

应用场景3：实时检测路径决策 (Decision Path for Real-time Detection)

  • 问题： 在实时NIDS中，对每个网络连接或数据包进行全量特征计算或匹配所有规则是非常低效的。需要一种机制快速判断一个连接是“明显正常”、“明显可疑”还是需要进一步深度检查。
  • 贪心策略：
    • 核心思想： 构建一个决策树 (Decision Tree) 或级联分类器 (Cascade Classifier)。决策树的构建过程（如ID3, C4.5, CART）本质上就是基于贪心算法（信息增益/基尼系数）选择分裂特征。级联分类器则是由一系列越来越复杂的分类器组成，前面的分类器快速过滤掉大部分明显正常的样本，只有可疑样本才进入后面的复杂分类器进行精细判断。
    • 贪心在决策树构建中的应用：
      1. 选择根节点： 计算所有特征的信息增益（或基尼不纯度减少量）。选择信息增益最大的特征作为当前节点的分裂特征。（贪心选择：当前最优特征）
      2. 递归分裂： 对分裂产生的每个子节点（对应特征的不同取值），递归地重复步骤1，直到满足停止条件（如节点样本纯度为0、达到最大深度、样本数小于阈值）。
      3. 剪枝 (Pruning)： （可选但重要）为避免过拟合，后续通常需要进行剪枝。剪枝本身也可能使用基于代价复杂度的贪心策略。
    • 效果：
      • 决策树本身就是一个分类模型，可用于最终判定。
      • 更重要的是，决策路径清晰。判断一个新样本时，只需要从根节点开始，根据其特征值沿着特定分支向下走，最终到达叶节点得到分类结果。这个过程非常高效，通常只需要检查少数几个关键特征。
  • Java实现（简化决策树构建 - 基于信息增益）：
import java.util.*;public class DecisionTreeIDS {static class TreeNode {String splitFeature; // 分裂特征名 (null表示叶节点)Object splitValue;   // 分裂点值 (离散值或连续值阈值)Map<Object, TreeNode> children; // 子节点映射 (特征值 -> 子节点)String classLabel;   // 叶节点的类别标签 (正常/攻击)public TreeNode(String label) { // 叶节点构造this.splitFeature = null;this.classLabel = label;}public TreeNode(String feature, Object value) { // 内部节点构造this.splitFeature = feature;this.splitValue = value;this.children = new HashMap<>();}}// 递归构建决策树 (简化版，仅处理离散特征)public static TreeNode buildTree(List<Map<String, Object>> data, List<String> features) {// 终止条件1: 所有数据点属于同一类别String majorityLabel = getMajorityLabel(data);if (majorityLabel != null) {return new TreeNode(majorityLabel);}// 终止条件2: 没有特征可用if (features.isEmpty()) {return new TreeNode(getMajorityLabel(data));}// 选择最佳分裂特征 (贪心：信息增益最大)String bestFeature = null;double maxGain = Double.NEGATIVE_INFINITY;Object bestSplitPoint = null; // 对于离散特征，splitPoint就是值本身for (String feature : features) {// 计算按feature分裂的信息增益 (简化：假设离散特征，每个值作为一个分支)double gain = calculateInformationGain(data, feature);if (gain > maxGain) {maxGain = gain;bestFeature = feature;// 对于离散特征，分裂点就是特征值本身，在构建子节点时使用}}// 创建内部节点TreeNode node = new TreeNode(bestFeature, null);// 复制特征列表，移除已选特征 (避免后续递归使用)List<String> remainingFeatures = new ArrayList<>(features);remainingFeatures.remove(bestFeature);// 根据bestFeature的取值将数据分组Map<Object, List<Map<String, Object>>> groups = new HashMap<>();for (Map<String, Object> point : data) {Object value = point.get(bestFeature);groups.computeIfAbsent(value, k -> new ArrayList<>()).add(point);}// 递归构建子树for (Map.Entry<Object, List<Map<String, Object>>> entry : groups.entrySet()) {Object featureValue = entry.getKey();List<Map<String, Object>> subset = entry.getValue();TreeNode child = buildTree(subset, remainingFeatures);node.children.put(featureValue, child);}return node;}// 计算按feature分裂的信息增益 (简化离散特征)private static double calculateInformationGain(List<Map<String, Object>> data, String feature) {double parentEntropy = calculateEntropy(data);Map<Object, List<Map<String, Object>>> groups = new HashMap<>();for (Map<String, Object> point : data) {Object value = point.get(feature);groups.computeIfAbsent(value, k -> new ArrayList<>()).add(point);}double childrenEntropy = 0.0;int totalSize = data.size();for (List<Map<String, Object>> group : groups.values()) {double p = (double) group.size() / totalSize;childrenEntropy += p * calculateEntropy(group);}return parentEntropy - childrenEntropy;}// 计算熵 (同FeatureSelector中的方法)private static double calculateEntropy(List<Map<String, Object>> data) { ... }// 获取数据集中占多数的类别标签 (如果全部一样则返回该标签，否则返回null)private static String getMajorityLabel(List<Map<String, Object>> data) {Map<String, Integer> counts = new HashMap<>();for (Map<String, Object> point : data) {String label = (String) point.get("label");counts.put(label, counts.getOrDefault(label, 0) + 1);}int max = 0;String majority = null;for (Map.Entry<String, Integer> entry : counts.entrySet()) {if (entry.getValue() > max) {max = entry.getValue();majority = entry.getKey();}}// 如果所有样本都是同一类别，或者虽然有两个以上类别但有一个明显占多数（这里简化，直接返回多数类）return majority;}// 使用决策树进行预测public static String predict(TreeNode root, Map<String, Object> dataPoint) {if (root.splitFeature == null) { // 到达叶节点return root.classLabel;}Object featureValue = dataPoint.get(root.splitFeature);TreeNode child = root.children.get(featureValue);if (child == null) {// 处理未见过的特征值：返回多数类或根据兄弟节点推测 (这里简化，返回null或默认类)return "normal"; // 假设默认是正常}return predict(child, dataPoint);}// 主函数示例用法public static void main(String[] args) {// 1. 加载训练数据// List<Map<String, Object>> trainingData = ...;// 2. 构建决策树List<String> features = new ArrayList<>(trainingData.get(0).keySet());features.remove("label"); // 移除标签列TreeNode root = buildTree(trainingData, features);// 3. 预测新样本Map<String, Object> newConnection = new HashMap<>();newConnection.put("duration", 0);newConnection.put("protocol_type", "tcp");newConnection.put("service", "http");// ... 设置其他特征值String prediction = predict(root, newConnection);System.out.println("Predicted Label: " + prediction);}
}

应用场景4：资源调度与优先级分配 (Resource Scheduling & Prioritization)

  • 问题： NIDS在高负载时（如遭受DDoS攻击），检测引擎可能无法处理所有传入的数据包/事件。需要决定哪些流量优先分析。
  • 贪心策略：
    • 核心思想： 根据流量的可疑程度或潜在危害分配优先级和处理资源。
    • 常用贪心标准：
      • 基于规则的初步评分： 快速应用一组轻量级规则或启发式方法，为每个数据包/连接分配一个初始风险分数（Suspicion Score）。例如：匹配了任何一条高危规则得高分；来自黑名单IP得高分；目标端口是敏感端口得中等分等。
      • 基于流/会话的聚合分数： 对属于同一会话的多个数据包进行分数累计或取最大值。
    • 贪心算法类型：
      • 优先级队列 (Priority Queue)： 使用贪心策略（总是处理队列中当前风险分数最高的项目）来调度待检测的数据包/事件。Java提供了高效的 PriorityQueue 实现。
  • Java实现（优先级队列调度）：
import java.util.*;public class SuspicionBasedScheduler {// 表示一个待检测的网络事件 (连接、数据包)static class NetworkEvent implements Comparable<NetworkEvent> {// ... 事件数据 (源IP, 目的IP, 端口, 协议, 载荷片段等)double suspicionScore; // 计算出的初始可疑分数public NetworkEvent(/* ... */, double score) {// ... 初始化数据this.suspicionScore = score;}@Overridepublic int compareTo(NetworkEvent other) {// 降序排列：分数越高，优先级越高 (在队列头部)return Double.compare(other.suspicionScore, this.suspicionScore);}}public static void main(String[] args) throws InterruptedException {// 创建一个基于suspicionScore降序的优先级队列 (最大堆)PriorityQueue<NetworkEvent> eventQueue = new PriorityQueue<>();// 模拟事件生产者 (例如，网络抓包线程)new Thread(() -> {Random rand = new Random();while (true) {// 模拟捕获一个新事件，并计算其初始可疑分数 (这里随机模拟)double score = rand.nextDouble() * 100; // 0-100分NetworkEvent event = new NetworkEvent(/* ... */, score);synchronized (eventQueue) {eventQueue.add(event); // 线程安全地添加eventQueue.notify();   // 通知消费者}try {Thread.sleep(rand.nextInt(50)); // 模拟事件到达间隔} catch (InterruptedException e) {}}}).start();// 检测引擎 (消费者)while (true) {NetworkEvent nextEvent = null;synchronized (eventQueue) {while (eventQueue.isEmpty()) {eventQueue.wait(); // 等待新事件}nextEvent = eventQueue.poll(); // 取出当前队列中分数最高的事件}// 深度检测这个高可疑度事件performDeepInspection(nextEvent);System.out.println("Processed event with score: " + nextEvent.suspicionScore);}}private static void performDeepInspection(NetworkEvent event) {// 使用更复杂的规则/模型进行详细检查// ...}
}

贪心算法在NID应用中的优势与局限性

  • 优势：

    • 高效率： 时间复杂度通常较低（O(n log n), O(n) 或 O(n^2) 在可控范围内），适用于NID对实时性的要求。
    • 简单直观： 算法逻辑清晰，易于理解、实现和调试。
    • 资源友好： 在特征选择、规则精简等场景下，能显著减少后续复杂模型的计算开销和内存占用。
    • 可解释性： 决策树、规则覆盖等应用的结果具有较好的可解释性，方便安全分析师理解系统行为。

  • 局限性与注意事项：

    • 局部最优陷阱： 贪心算法保证的是局部最优，不一定能获得全局最优解。例如在特征选择中，前向搜索选出的前k个特征组合，可能不如某个未被选中的特征与其他特征的组合好。
    • 依赖贪心选择标准： 算法的效果高度依赖于所选的贪心标准（如信息增益、覆盖率）。不同的标准可能导致不同的结果。
    • 忽略特征/规则间交互： 贪心策略通常是逐项添加或移除，可能忽略特征之间或规则之间的协同或抑制关系。
    • 对问题性质要求高： 只有满足贪心选择性质和最优子结构的问题，贪心算法才能保证全局最优。NID中的许多子问题（如特征选择）通常不严格满足，但贪心解在实践中往往足够好。
    • 不直接解决核心检测问题： 如前所述，贪心算法主要用于预处理和优化，最终的入侵判定通常需要更复杂的模型（如SVM、随机森林、深度学习、基于规则的复杂引擎）。

总结

贪心算法是Java实现网络入侵检测系统中不可或缺的优化工具。它通过高效地解决特征选择（降低维度）、规则集精简（加速匹配）、构建快速决策路径（实时过滤）、以及调度高可疑事件（优化资源）等关键子问题，显著提升了整个NIDS的性能和可扩展性。尽管存在局部最优等局限性，但在资源受限和实时性要求高的网络环境中，贪心策略提供的“足够好且高效”的解决方案具有极高的实用价值。理解其应用场景、选择合适的贪心标准、并认识到其局限性，对于设计和实现健壮的Java NIDS至关重要。实际系统通常会结合多种算法和技术（贪心作为关键组件之一）来达到最佳的检测效果和效率。


文章转载自：

http://BFPukoDD.xjqrn.cn
http://qqEpbe9C.xjqrn.cn
http://1jMIeuWE.xjqrn.cn
http://stqDqMXM.xjqrn.cn
http://Qo6meaHR.xjqrn.cn
http://wVlWLvSG.xjqrn.cn
http://dKZBplLS.xjqrn.cn
http://JvzXVznf.xjqrn.cn
http://MiXxjqOK.xjqrn.cn
http://Wrp0bUYn.xjqrn.cn
http://rijWIbod.xjqrn.cn
http://oQhxm0J1.xjqrn.cn
http://fZFC5zv4.xjqrn.cn
http://AyKJt9r1.xjqrn.cn
http://5Thpu14z.xjqrn.cn
http://LioLOjJg.xjqrn.cn
http://uM0yy27I.xjqrn.cn
http://7YNmVQ2W.xjqrn.cn
http://3sqUg59S.xjqrn.cn
http://2lQOJGrd.xjqrn.cn
http://JhNgkAfC.xjqrn.cn
http://tfona78x.xjqrn.cn
http://mEtWyu11.xjqrn.cn
http://ChDZxQwL.xjqrn.cn
http://h2N4QET8.xjqrn.cn
http://rq9tJ7WW.xjqrn.cn
http://cnpMolE8.xjqrn.cn
http://qWpUeBDk.xjqrn.cn
http://54teFgeG.xjqrn.cn
http://eAr2ygIa.xjqrn.cn
http://www.dtcms.com/a/386664.html

相关文章：

  • 数据搬家后如何处理旧 iPhone
  • [react native招聘]
  • IDE工具RAD Studio 13 Florence重磅发布：64 位 IDE + AI 组件全面升级！
  • session存储
  • Another Redis Desktop Manager 的 SCAN 使用问题与风险分析
  • MATLAB绘制一个新颖的混沌图像(新四翼混沌系统)
  • AI起名工具
  • typeScript 装饰器
  • 【算法磨剑：用 C++ 思考的艺术・单源最短路进阶】Bellman-Ford 与 SPFA 算法模板精讲，突破负权边场景
  • 单元测试：驱动模块与桩模块在自顶向下和自底向上的策略中的作用
  • SpringBoot MVC 快速入门
  • Nature Communications 北京大学联合德国马普所在触觉传感器方面取得进展，实现机器人指尖超分辨率力感知
  • 解决一次 “Failed to load model because protobuf parsing failed”：从现象到根因与修复
  • 从ppm到ppb：全面解读浓度单位转换的诀窍
  • 贪心算法应用：霍夫曼编码详解
  • NLP Subword 之 BBPE(Byte-level BPE) 算法原理
  • 【nodejs】Windows7系统下如何安装nodejs16以上版本
  • Part05 数学
  • 每天五分钟深度学习：深层神经网络的优势
  • PCGrad解决多任务冲突
  • 第十一章：游戏玩法和屏幕特效-Gameplay and ScreenEffects《Unity Shaders and Effets Cookbook》
  • Choerodon UI V1.6.7发布！为 H-ZERO 开发注入新动能
  • 科教共融，具创未来！节卡助力第十届浦东新区机器人创新应用及技能竞赛圆满举行
  • 食品包装 AI 视觉检测技术：原理、优势与数据应用解析
  • 【深度学习计算机视觉】05：多尺度目标检测之FPN架构详解与PyTorch实战
  • 从工业革命到人工智能：深度学习的演进与核心概念解析
  • [Emacs list使用及配置]
  • DQN在稀疏奖励中的局限性
  • 为何需要RAII——从“手动挡”到“自动挡”的进化
  • 第五课、Cocos Creator 中使用 TypeScript 基础介绍