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

贪心算法应用：社交网络影响力最大化问题详解

news 2025/9/18 7:31:44

Java中的贪心算法应用：社交网络影响力最大化问题详解

贪心算法是一种在每一步选择中都采取当前状态下最优的选择，从而希望导致结果是全局最优的算法策略。在社交网络影响力最大化问题中，贪心算法被广泛用于选择最具影响力的节点集合。下面我将从理论基础到具体实现，全面详细地讲解这一应用。

1. 问题定义与背景

1.1 社交网络影响力最大化问题

影响力最大化问题(Influence Maximization Problem)可以形式化定义为：给定一个社交网络图G=(V,E)，其中V代表用户(节点)，E代表用户之间的关系(边)，以及一个正整数k，目标是找到一个大小为k的节点集合S⊆V，使得在某种传播模型下，从S出发能够激活(影响)的预期节点数最大化。

1.2 传播模型

常用的传播模型有两种：

  1. 独立级联模型(Independent Cascade Model, IC)：

    • 每个活跃节点有单次机会以概率p激活其每个不活跃的邻居
    • 激活过程是独立的
    • 过程持续直到没有新的节点被激活

  2. 线性阈值模型(Linear Threshold Model, LT)：

    • 每个节点v有一个阈值θ_v，均匀分布在[0,1]中
    • 每个边(u,v)有一个权重b(u,v)，表示u对v的影响力
    • 当v的活跃邻居的总影响力超过θ_v时，v被激活

2. 贪心算法理论基础

2.1 贪心算法框架

对于影响力最大化问题，贪心算法的基本框架如下：

  1. 初始化选择的节点集合S为空集
  2. 对于i从1到k：
    a. 遍历所有不在S中的节点v，计算将v加入S后的边际影响力增益σ(S∪{v}) - σ(S)
    b. 选择具有最大边际增益的节点v加入S
  3. 返回集合S

2.2 子模性(Submodularity)与近似保证

影响力最大化函数σ(·)具有子模性(submodular)和单调性(monotone)：

  • 单调性：对于任意S⊆T⊆V，有σ(S) ≤ σ(T)
  • 子模性：对于任意S⊆T⊆V和任意v∈V\T，有σ(S∪{v}) - σ(S) ≥ σ(T∪{v}) - σ(T)

由于这些性质，贪心算法可以提供(1-1/e)≈63%的近似保证，这是理论上的最优近似比。

3. Java实现详解

下面我将分步骤展示如何在Java中实现贪心算法解决影响力最大化问题。

3.1 数据结构定义

首先定义社交网络的基本数据结构：

import java.util.*;// 定义节点类
class Node {int id;List<Edge> neighbors;public Node(int id) {this.id = id;this.neighbors = new ArrayList<>();}public void addNeighbor(Node neighbor, double probability) {neighbors.add(new Edge(this, neighbor, probability));}
}// 定义边类
class Edge {Node source;Node target;double probability; // 激活概率public Edge(Node source, Node target, double probability) {this.source = source;this.target = target;this.probability = probability;}
}// 定义社交网络图
class SocialNetwork {Map<Integer, Node> nodes;public SocialNetwork() {nodes = new HashMap<>();}public void addNode(int id) {nodes.put(id, new Node(id));}public void addEdge(int sourceId, int targetId, double probability) {Node source = nodes.get(sourceId);Node target = nodes.get(targetId);source.addNeighbor(target, probability);}public Node getNode(int id) {return nodes.get(id);}public Set<Node> getAllNodes() {return new HashSet<>(nodes.values());}
}

3.2 影响力传播模拟

实现独立级联模型的传播模拟：

class InfluenceSpread {// 模拟独立级联模型的影响传播public static double simulateIC(SocialNetwork network, Set<Node> seedSet, int simulations) {double totalSpread = 0;for (int i = 0; i < simulations; i++) {Set<Node> activated = new HashSet<>(seedSet);Queue<Node> queue = new LinkedList<>(seedSet);while (!queue.isEmpty()) {Node current = queue.poll();for (Edge edge : current.neighbors) {Node neighbor = edge.target;if (!activated.contains(neighbor) && Math.random() < edge.probability) {activated.add(neighbor);queue.add(neighbor);}}}totalSpread += activated.size();}return totalSpread / simulations;}
}

3.3 贪心算法实现

实现贪心算法选择最具影响力的k个节点：

class GreedyInfluenceMaximization {private SocialNetwork network;private int simulations;public GreedyInfluenceMaximization(SocialNetwork network, int simulations) {this.network = network;this.simulations = simulations;}public Set<Node> findMostInfluentialNodes(int k) {Set<Node> seedSet = new HashSet<>();Set<Node> remainingNodes = new HashSet<>(network.getAllNodes());for (int i = 0; i < k; i++) {System.out.println("Selecting seed " + (i+1) + " of " + k);Node bestNode = null;double bestSpread = -1;// 遍历所有剩余节点，寻找边际增益最大的节点for (Node node : remainingNodes) {Set<Node> tempSet = new HashSet<>(seedSet);tempSet.add(node);double spread = InfluenceSpread.simulateIC(network, tempSet, simulations);if (spread > bestSpread) {bestSpread = spread;bestNode = node;}}if (bestNode != null) {seedSet.add(bestNode);remainingNodes.remove(bestNode);System.out.println("Selected node " + bestNode.id + " with estimated spread: " + bestSpread);}}return seedSet;}
}

3.4 优化实现：CELF算法

上述基本贪心算法效率较低，我们可以实现更高效的CELF(成本效益懒惰前向)优化：

class CELFInfluenceMaximization {private SocialNetwork network;private int simulations;public CELFInfluenceMaximization(SocialNetwork network, int simulations) {this.network = network;this.simulations = simulations;}public Set<Node> findMostInfluentialNodes(int k) {Set<Node> seedSet = new HashSet<>();PriorityQueue<NodeSpread> maxHeap = new PriorityQueue<>((a, b) -> Double.compare(b.marginalGain, a.marginalGain));// 初始化：计算所有节点的初始边际增益System.out.println("Initializing marginal gains...");for (Node node : network.getAllNodes()) {Set<Node> tempSet = new HashSet<>();tempSet.add(node);double spread = InfluenceSpread.simulateIC(network, tempSet, simulations);maxHeap.add(new NodeSpread(node, spread, 0));}for (int i = 0; i < k; i++) {System.out.println("Selecting seed " + (i+1) + " of " + k);while (true) {NodeSpread current = maxHeap.poll();if (current.lastUpdated == i) {seedSet.add(current.node);System.out.println("Selected node " + current.node.id + " with marginal gain: " + current.marginalGain);break;} else {// 重新计算边际增益Set<Node> tempSet = new HashSet<>(seedSet);tempSet.add(current.node);double newSpread = InfluenceSpread.simulateIC(network, tempSet, simulations);double marginalGain = newSpread - InfluenceSpread.simulateIC(network, seedSet, simulations);maxHeap.add(new NodeSpread(current.node, marginalGain, i));}}}return seedSet;}private class NodeSpread {Node node;double marginalGain;int lastUpdated;public NodeSpread(Node node, double marginalGain, int lastUpdated) {this.node = node;this.marginalGain = marginalGain;this.lastUpdated = lastUpdated;}}
}

3.5 完整示例与测试

创建一个完整的示例来测试我们的实现：

public class InfluenceMaximizationExample {public static void main(String[] args) {// 创建社交网络SocialNetwork network = new SocialNetwork();// 添加节点for (int i = 1; i <= 10; i++) {network.addNode(i);}// 添加边和激活概率network.addEdge(1, 2, 0.5);network.addEdge(1, 3, 0.3);network.addEdge(2, 3, 0.4);network.addEdge(2, 4, 0.2);network.addEdge(3, 5, 0.6);network.addEdge(4, 5, 0.3);network.addEdge(4, 6, 0.4);network.addEdge(5, 7, 0.5);network.addEdge(6, 7, 0.3);network.addEdge(6, 8, 0.2);network.addEdge(7, 9, 0.4);network.addEdge(8, 9, 0.5);network.addEdge(9, 10, 0.6);// 使用贪心算法寻找最具影响力的3个节点int k = 3;int simulations = 1000; // 每次传播模拟的次数System.out.println("=== Basic Greedy Algorithm ===");GreedyInfluenceMaximization greedy = new GreedyInfluenceMaximization(network, simulations);Set<Node> seedSet = greedy.findMostInfluentialNodes(k);System.out.println("\nSelected seed nodes:");for (Node node : seedSet) {System.out.println("Node " + node.id);}// 计算最终影响范围double finalSpread = InfluenceSpread.simulateIC(network, seedSet, simulations * 10);System.out.println("\nEstimated final influence spread: " + finalSpread);System.out.println("\n=== CELF Optimized Algorithm ===");CELFInfluenceMaximization celf = new CELFInfluenceMaximization(network, simulations);Set<Node> celfSeedSet = celf.findMostInfluentialNodes(k);System.out.println("\nSelected seed nodes (CELF):");for (Node node : celfSeedSet) {System.out.println("Node " + node.id);}double celfFinalSpread = InfluenceSpread.simulateIC(network, celfSeedSet, simulations * 10);System.out.println("\nEstimated final influence spread (CELF): " + celfFinalSpread);}
}

4. 算法优化与改进

4.1 性能优化技术

  1. CELF优化：如前所示，利用子模性减少不必要的计算
  2. NewGreedy算法：在每次迭代中重用之前的模拟结果
  3. 社区检测：先检测网络中的社区结构，然后在社区内部应用贪心算法
  4. 启发式方法：使用度中心性、接近中心性等启发式方法预选候选节点

4.2 并行化实现

利用多线程加速传播模拟过程：

class ParallelInfluenceSpread {private static final int THREADS = Runtime.getRuntime().availableProcessors();public static double simulateIC(SocialNetwork network, Set<Node> seedSet, int simulations) {ExecutorService executor = Executors.newFixedThreadPool(THREADS);List<Future<Double>> futures = new ArrayList<>();int simulationsPerThread = simulations / THREADS;for (int i = 0; i < THREADS; i++) {futures.add(executor.submit(() -> {double localSpread = 0;for (int j = 0; j < simulationsPerThread; j++) {Set<Node> activated = new HashSet<>(seedSet);Queue<Node> queue = new LinkedList<>(seedSet);while (!queue.isEmpty()) {Node current = queue.poll();for (Edge edge : current.neighbors) {Node neighbor = edge.target;if (!activated.contains(neighbor) && Math.random() < edge.probability) {activated.add(neighbor);queue.add(neighbor);}}}localSpread += activated.size();}return localSpread;}));}executor.shutdown();double totalSpread = 0;for (Future<Double> future : futures) {try {totalSpread += future.get();} catch (Exception e) {e.printStackTrace();}}return totalSpread / (simulationsPerThread * THREADS);}
}

4.3 近似计算技术

  1. RIS (Reverse Influence Sampling)：

    • 从随机节点出发，反向模拟影响传播
    • 构建一组反向可达集(RR sets)
    • 通过覆盖这些RR sets来选择种子节点

  2. SKIM算法：

    • 结合RIS和子模性
    • 提供更高效的影响力估计

5. 实际应用中的考虑因素

5.1 动态网络处理

现实中的社交网络是动态变化的，需要考虑：

class DynamicSocialNetwork extends SocialNetwork {private Map<Integer, Long> lastUpdateTimes = new HashMap<>();public void updateNode(int id) {lastUpdateTimes.put(id, System.currentTimeMillis());}public void addEdgeWithTimestamp(int sourceId, int targetId, double probability) {super.addEdge(sourceId, targetId, probability);long now = System.currentTimeMillis();lastUpdateTimes.put(sourceId, now);lastUpdateTimes.put(targetId, now);}public double getNodeFreshness(int id) {Long lastUpdate = lastUpdateTimes.get(id);if (lastUpdate == null) return 0;long elapsed = System.currentTimeMillis() - lastUpdate;// 新鲜度衰减函数，例如指数衰减return Math.exp(-elapsed / (1000.0 * 60 * 60 * 24)); // 按天衰减}
}

5.2 多因素影响力模型

更复杂的影响力模型可以考虑：

  1. 节点属性(年龄、性别、兴趣等)
  2. 内容相关性
  3. 时间衰减因素
  4. 用户活跃度
class AdvancedInfluenceSpread {public static double simulateAdvancedIC(SocialNetwork network, Set<Node> seedSet, Map<Node, Double> userActivity, Map<Node, Map<String, Double>> userInterests,String contentTopic,int simulations) {double totalSpread = 0;for (int i = 0; i < simulations; i++) {Set<Node> activated = new HashSet<>(seedSet);Queue<Node> queue = new LinkedList<>(seedSet);while (!queue.isEmpty()) {Node current = queue.poll();double activityFactor = userActivity.getOrDefault(current, 0.5);for (Edge edge : current.neighbors) {Node neighbor = edge.target;if (!activated.contains(neighbor)) {// 计算内容相关性double contentRelevance = computeContentRelevance(userInterests.get(neighbor), contentTopic);// 综合激活概率double effectiveProb = edge.probability * activityFactor * contentRelevance;if (Math.random() < effectiveProb) {activated.add(neighbor);queue.add(neighbor);}}}}totalSpread += activated.size();}return totalSpread / simulations;}private static double computeContentRelevance(Map<String, Double> interests, String topic) {if (interests == null) return 0.5;return interests.getOrDefault(topic, 0.0);}
}

6. 评估与验证

6.1 评估指标

  1. 影响范围(Spread)：被激活的节点数量
  2. 运行时间：算法执行时间
  3. 内存使用：算法内存消耗
  4. 可扩展性：处理大规模网络的能力

6.2 基准测试

class Benchmark {public static void runBenchmark(SocialNetwork network, int k, int simulations) {System.out.println("=== Benchmarking Influence Maximization Algorithms ===");System.out.println("Network size: " + network.getAllNodes().size() + " nodes");System.out.println("Seed set size: " + k);System.out.println("Simulations per step: " + simulations);// 测试基本贪心算法long startTime = System.currentTimeMillis();GreedyInfluenceMaximization greedy = new GreedyInfluenceMaximization(network, simulations);Set<Node> greedySeeds = greedy.findMostInfluentialNodes(k);long greedyTime = System.currentTimeMillis() - startTime;double greedySpread = InfluenceSpread.simulateIC(network, greedySeeds, simulations * 10);// 测试CELF算法startTime = System.currentTimeMillis();CELFInfluenceMaximization celf = new CELFInfluenceMaximization(network, simulations);Set<Node> celfSeeds = celf.findMostInfluentialNodes(k);long celfTime = System.currentTimeMillis() - startTime;double celfSpread = InfluenceSpread.simulateIC(network, celfSeeds, simulations * 10);// 输出结果System.out.println("\n=== Results ===");System.out.printf("Greedy Algorithm: %.2f spread in %d ms\n", greedySpread, greedyTime);System.out.printf("CELF Algorithm: %.2f spread in %d ms\n", celfSpread, celfTime);System.out.printf("Speedup: %.2fx\n", (double)greedyTime/celfTime);System.out.printf("Spread ratio: %.2f%%\n", (celfSpread/greedySpread)*100);}
}

7. 实际应用案例

7.1 病毒式营销

class ViralMarketingCampaign {private SocialNetwork network;private int budget; // 可以转化为k值private Map<Integer, Double> customerValues; // 客户价值public ViralMarketingCampaign(SocialNetwork network, int budget, Map<Integer, Double> customerValues) {this.network = network;this.budget = budget;this.customerValues = customerValues;}public Set<Node> selectInfluencers() {// 考虑客户价值的改进贪心算法Set<Node> seedSet = new HashSet<>();Set<Node> remainingNodes = new HashSet<>(network.getAllNodes());for (int i = 0; i < budget; i++) {Node bestNode = null;double bestValue = -1;for (Node node : remainingNodes) {Set<Node> tempSet = new HashSet<>(seedSet);tempSet.add(node);double spread = InfluenceSpread.simulateIC(network, tempSet, 1000);double value = spread * customerValues.getOrDefault(node.id, 1.0);if (value > bestValue) {bestValue = value;bestNode = node;}}if (bestNode != null) {seedSet.add(bestNode);remainingNodes.remove(bestNode);}}return seedSet;}
}

7.2 信息传播控制

class InformationControl {private SocialNetwork network;private Set<Node> blockedNodes = new HashSet<>();public InformationControl(SocialNetwork network) {this.network = network;}// 使用贪心算法选择要封锁的节点以最小化谣言传播public void selectNodesToBlock(int k) {for (int i = 0; i < k; i++) {Node bestBlock = null;double maxReduction = 0;// 模拟不封锁任何节点时的传播double originalSpread = simulateRumorSpread(blockedNodes);for (Node candidate : network.getAllNodes()) {if (!blockedNodes.contains(candidate)) {Set<Node> tempBlocked = new HashSet<>(blockedNodes);tempBlocked.add(candidate);double newSpread = simulateRumorSpread(tempBlocked);double reduction = originalSpread - newSpread;if (reduction > maxReduction) {maxReduction = reduction;bestBlock = candidate;}}}if (bestBlock != null) {blockedNodes.add(bestBlock);System.out.println("Blocked node " + bestBlock.id + ", estimated reduction: " + maxReduction);}}}private double simulateRumorSpread(Set<Node> blocked) {// 模拟谣言传播，考虑封锁的节点Set<Node> activated = new HashSet<>();// 随机选择一个未被封锁的节点作为谣言源List<Node> possibleSeeds = new ArrayList<>();for (Node node : network.getAllNodes()) {if (!blocked.contains(node)) {possibleSeeds.add(node);}}if (!possibleSeeds.isEmpty()) {Node seed = possibleSeeds.get((int)(Math.random() * possibleSeeds.size()));activated.add(seed);Queue<Node> queue = new LinkedList<>();queue.add(seed);while (!queue.isEmpty()) {Node current = queue.poll();for (Edge edge : current.neighbors) {Node neighbor = edge.target;if (!activated.contains(neighbor) && !blocked.contains(neighbor) && Math.random() < edge.probability) {activated.add(neighbor);queue.add(neighbor);}}}}return activated.size();}
}

8. 扩展与未来方向

8.1 多目标优化

同时考虑多个目标，如：

  • 最大化影响力
  • 最小化成本
  • 平衡覆盖多样性
class MultiObjectiveInfluenceMaximization {private SocialNetwork network;private Map<Node, Double> nodeCosts;private double budget;public Set<Node> findParetoOptimalSeeds() {Set<Node> seedSet = new HashSet<>();Set<Node> remainingNodes = new HashSet<>(network.getAllNodes());double remainingBudget = budget;while (remainingBudget > 0 && !remainingNodes.isEmpty()) {Node bestNode = null;double bestRatio = -1;for (Node node : remainingNodes) {double cost = nodeCosts.getOrDefault(node, 1.0);if (cost > remainingBudget) continue;Set<Node> tempSet = new HashSet<>(seedSet);tempSet.add(node);double spread = InfluenceSpread.simulateIC(network, tempSet, 1000);double ratio = spread / cost;if (ratio > bestRatio) {bestRatio = ratio;bestNode = node;}}if (bestNode != null) {double cost = nodeCosts.getOrDefault(bestNode, 1.0);seedSet.add(bestNode);remainingNodes.remove(bestNode);remainingBudget -= cost;} else {break;}}return seedSet;}
}

8.2 在线学习与自适应

结合多臂老虎机(MAB)和在线学习技术：

class AdaptiveInfluenceMaximization {private SocialNetwork network;private Map<Node, Double> nodeQualityEstimates = new HashMap<>();private Map<Node, Integer> nodeSelectionCounts = new HashMap<>();public Set<Node> selectSeeds(int k, int rounds) {// 初始化for (Node node : network.getAllNodes()) {nodeQualityEstimates.put(node, 0.1); // 乐观初始化nodeSelectionCounts.put(node, 0);}Set<Node> seedSet = new HashSet<>();for (int round = 0; round < rounds; round++) {// UCB1算法选择节点Node selectedNode = selectNodeByUCB();// 模拟传播并观察结果Set<Node> tempSet = new HashSet<>(seedSet);tempSet.add(selectedNode);double spread = InfluenceSpread.simulateIC(network, tempSet, 100);// 更新估计updateNodeEstimate(selectedNode, spread);// 如果节点表现好，加入种子集if (spread > threshold) {seedSet.add(selectedNode);if (seedSet.size() >= k) break;}}return seedSet;}private Node selectNodeByUCB() {Node bestNode = null;double bestValue = -1;double totalSelections = nodeSelectionCounts.values().stream().mapToInt(i -> i).sum() + 1;for (Node node : network.getAllNodes()) {double estimate = nodeQualityEstimates.get(node);int count = nodeSelectionCounts.get(node);double ucbValue = estimate + Math.sqrt(2 * Math.log(totalSelections) / (count + 1));if (ucbValue > bestValue) {bestValue = ucbValue;bestNode = node;}}return bestNode;}private void updateNodeEstimate(Node node, double observedSpread) {int count = nodeSelectionCounts.get(node);double currentEstimate = nodeQualityEstimates.get(node);double newEstimate = (currentEstimate * count + observedSpread) / (count + 1);nodeQualityEstimates.put(node, newEstimate);nodeSelectionCounts.put(node, count + 1);}
}

9. 总结

贪心算法在社交网络影响力最大化问题中的应用是一个研究深入且实践广泛的领域。通过本文的详细讲解，我们可以看到：

  1. 贪心算法基于子模性提供了理论保证的近似解
  2. Java实现需要考虑数据结构设计、传播模拟和算法优化
  3. CELF等优化技术可以显著提高算法效率
  4. 实际应用中需要考虑网络动态性、多因素影响等复杂情况
  5. 该领域仍在不断发展，与机器学习、多目标优化等结合是未来方向

影响力最大化问题是一个典型的NP难问题，贪心算法提供了一种在合理时间内获得高质量解的途径，使其成为社交网络分析、病毒式营销、舆情控制等领域的核心算法之一。


文章转载自：

http://DCcs2eF2.jgcrr.cn
http://Xl4H4wzy.jgcrr.cn
http://65Jtfx2U.jgcrr.cn
http://eDjhVOqQ.jgcrr.cn
http://iqsUUqjj.jgcrr.cn
http://K23AKqvs.jgcrr.cn
http://gAd2kBMx.jgcrr.cn
http://YuLNyyf1.jgcrr.cn
http://UJBFVXOJ.jgcrr.cn
http://tHceUBTs.jgcrr.cn
http://olbwGDDB.jgcrr.cn
http://O9rDO02T.jgcrr.cn
http://bugPi99p.jgcrr.cn
http://mDV6Dkhx.jgcrr.cn
http://zmQhxtVP.jgcrr.cn
http://3ZGWSQ11.jgcrr.cn
http://0Ic0U2X3.jgcrr.cn
http://Sr4DNOhi.jgcrr.cn
http://zQ6sI84A.jgcrr.cn
http://vZHVSIfl.jgcrr.cn
http://4KLUxN8T.jgcrr.cn
http://IzTxx1er.jgcrr.cn
http://g2RJp6qi.jgcrr.cn
http://pLxt739D.jgcrr.cn
http://dQdqDFPL.jgcrr.cn
http://S3jrLrxm.jgcrr.cn
http://Ws40CVLj.jgcrr.cn
http://4TJMKtnw.jgcrr.cn
http://RrmlMtN6.jgcrr.cn
http://f5QEERfn.jgcrr.cn
http://www.dtcms.com/a/387849.html

相关文章：

  • 更改 Compose 应用程序以适应不同环境
  • 大模型——GPT-5-Codex 发布，可以7小时连续编程，但OpenAI 封杀了API
  • 【C语言】C 动态内存管理全解析：malloc/calloc/realloc 与柔性数组实战
  • Python测试框架：unittest、pytest对比
  • 仓颉编程语言青少年基础教程：class（类）（下）
  • 【LVS入门宝典】深入解析负载均衡：LVS的核心作用与实现原理
  • 7.4缓存
  • vscode单击暂时预览文件 双击持续打开文件
  • 机器视觉 真实项目案例征集
  • 一根网线搞定远程运维，GL-RM1PE 深度体验：远程运维、装机、开机一体化的 KVM over IP
  • Ubuntu20.04仿真 | 云台相机可直接使用文件
  • Docker学习记录——构建本地镜像，从Windows向Ubuntu推送
  • MyBatis分页：PageHelper
  • 基于python BERT的新闻文本分类与用户行为预测的分析与应用
  • MFC实战：OBJ模型加载与3D渲染指南
  • FAQ：珠海网络推广哪家好？GEO优化能带来哪些优势？
  • （论文速读）CLR-GAN: 通过一致的潜在表征和重建提高gan的稳定性和质量
  • MFC_Static
  • TDengine IDMP 基本功能——数据可视化（3. 饼图）
  • Spring基础创建
  • 智能的非数学本质
  • CNB迁移和UI定制
  • 基于OpenTelemetry与Jaeger的分布式追踪原理深度解析与实践指南
  • EasyDSS视频直播RTMP推流技术如何实现多机型的无人机视频统一直播
  • 智能扫地机器人方案开发,基于32位MCU
  • 【STM32 CubeMX + Keil】DAC 输出0~3.3V间任意电压
  • git submodule命令详解
  • HTTP/2.0是什么？
  • 深度学习基础：从线性回归到 Softmax 回归的完整梳理
  • 深度学习之线性回归与 Softmax 回归