DAMOYOLO-S代码实例：Python调用其Web API实现自动化目标检测流水线

优质文章学习记录

— 17 min read

DAMOYOLO-S代码实例：Python调用其Web API实现自动化目标检测流水线

你是不是也遇到过这样的场景？每天有成百上千张图片需要分析，手动上传、等待、下载结果，不仅效率低下，还容易出错。作为一名开发者，我经常需要处理大量的图像数据，寻找其中的特定目标——可能是监控视频中的异常行为，也可能是电商图片中的商品识别。

传统的目标检测方案要么需要复杂的本地部署，要么就是手动操作效率太低。直到我发现了DAMOYOLO-S这个高性能通用检测模型，特别是它提供的Web API服务，让我眼前一亮。今天，我就来分享如何用Python代码调用这个API，打造一个全自动的目标检测流水线。

1. DAMOYOLO-S：开箱即用的目标检测利器

1.1 什么是DAMOYOLO-S？

DAMOYOLO-S是一个基于TinyNAS架构的高性能通用目标检测模型。简单来说，它就像一个“火眼金睛”，能够在一张图片中快速准确地找出各种物体，并告诉你它们是什么、在哪里。

这个模型有几个让我特别喜欢的特点：

  • 开箱即用：不需要自己训练模型，内置了COCO数据集的80个常见类别识别能力
  • 部署简单：基于Gradio提供了Web界面，启动就能用
  • 性能优秀：在保持高精度的同时，推理速度也很快

1.2 为什么选择Web API方式？

你可能要问：既然有Web界面，为什么还要用代码调用呢？这里有几个实际的原因：

效率问题：想象一下，如果你有1000张图片需要处理，手动操作需要多久？每张图片上传、等待、下载结果，至少1分钟，1000张就是16个小时！而用代码自动化，可能只需要几十分钟。

集成需求：很多业务场景需要把目标检测功能集成到自己的系统中。比如电商平台需要自动识别商品，安防系统需要实时分析监控画面。

批量处理：代码可以轻松实现批量处理、错误重试、结果整理等功能，这些都是手动操作难以实现的。

2. 环境准备与API接口分析

2.1 理解DAMOYOLO的Web服务

在开始写代码之前，我们先要搞清楚DAMOYOLO的Web服务是怎么工作的。根据提供的使用手册，这个服务有几个关键信息：

  • 访问地址：https://gpu-vlvyxchvc7-7860.web.gpu.ZEEKLOG.net/
  • 输入：单张图片（支持PNG、JPG、JPEG格式）
  • 输出：带检测框的结果图片 + JSON格式的检测明细
  • 参数：可以调整置信度阈值（Score Threshold）

2.2 分析API调用方式

虽然手册没有直接提供API文档，但通过分析Web界面，我们可以推断出API的调用方式。Gradio框架通常提供两种调用方式：

  1. 通过Web界面交互：手动上传图片，点击按钮
  2. 通过HTTP API调用：直接向服务端发送请求

我们要用的是第二种方式。通过查看网络请求，我发现这个服务实际上接收一个POST请求，包含图片文件和阈值参数，然后返回处理结果。

3. Python调用API的基础实现

3.1 最简单的单张图片检测

让我们从一个最简单的例子开始。假设你有一张图片test.jpg，想要检测里面的物体：

import requests import json from PIL import Image import io def detect_single_image(image_path, threshold=0.3): """ 单张图片目标检测 参数: image_path: 图片文件路径 threshold: 置信度阈值，默认0.3 返回: dict: 包含检测结果的字典 """ # DAMOYOLO Web服务的API地址 api_url = "https://gpu-vlvyxchvc7-7860.web.gpu.ZEEKLOG.net/api/predict" # 准备请求数据 with open(image_path, 'rb') as f: files = {'image': f} data = {'threshold': str(threshold)} # 发送POST请求 response = requests.post(api_url, files=files, data=data) if response.status_code == 200: result = response.json() return result else: print(f"请求失败，状态码: {response.status_code}") return None # 使用示例 if __name__ == "__main__": # 检测单张图片 result = detect_single_image("test.jpg", threshold=0.25) if result: print(f"检测到 {result['count']} 个目标") for i, detection in enumerate(result['detections']): print(f"目标{i+1}: {detection['label']}, 置信度: {detection['score']:.3f}")

这个基础版本虽然简单，但已经能完成核心功能。不过在实际使用中，我们还需要考虑更多细节。

3.2 增强版的检测函数

实际应用中，我们可能需要处理各种情况：网络超时、图片格式转换、错误重试等。下面是一个更健壮的版本：

import requests import json import time from pathlib import Path from PIL import Image import io class DAMOYOLOClient: """DAMOYOLO Web API客户端""" def __init__(self, base_url="https://gpu-vlvyxchvc7-7860.web.gpu.ZEEKLOG.net", timeout=30, max_retries=3): """ 初始化客户端 参数: base_url: 服务基础URL timeout: 请求超时时间（秒） max_retries: 最大重试次数 """ self.base_url = base_url.rstrip('/') self.api_url = f"{self.base_url}/api/predict" self.timeout = timeout self.max_retries = max_retries def detect_image(self, image_input, threshold=0.3, save_result=False, output_dir="results"): """ 检测图片中的目标 参数: image_input: 可以是文件路径、PIL Image对象或字节数据 threshold: 置信度阈值 save_result: 是否保存结果图片 output_dir: 结果保存目录 返回: dict: 检测结果 """ # 准备图片数据 if isinstance(image_input, str) or isinstance(image_input, Path): # 文件路径 with open(image_input, 'rb') as f: image_bytes = f.read() image_name = Path(image_input).name elif isinstance(image_input, Image.Image): # PIL Image对象 img_byte_arr = io.BytesIO() image_input.save(img_byte_arr, format='JPEG') image_bytes = img_byte_arr.getvalue() image_name = f"image_{int(time.time())}.jpg" else: # 假设是字节数据 image_bytes = image_input image_name = f"image_{int(time.time())}.jpg" # 准备请求 files = {'image': (image_name, image_bytes, 'image/jpeg')} data = {'threshold': str(threshold)} # 带重试的请求 for attempt in range(self.max_retries): try: response = requests.post( self.api_url, files=files, data=data, timeout=self.timeout ) if response.status_code == 200: result = response.json() # 如果需要保存结果 if save_result and 'result_image' in result: self._save_result(image_name, result, output_dir) return result else: print(f"请求失败，状态码: {response.status_code}") except requests.exceptions.Timeout: print(f"请求超时，第{attempt+1}次重试...") if attempt < self.max_retries - 1: time.sleep(2 ** attempt) # 指数退避 else: raise except Exception as e: print(f"请求异常: {e}") if attempt < self.max_retries - 1: time.sleep(1) else: raise return None def _save_result(self, image_name, result, output_dir): """保存检测结果""" # 创建输出目录 output_path = Path(output_dir) output_path.mkdir(exist_ok=True) # 保存JSON结果 json_path = output_path / f"{Path(image_name).stem}_result.json" with open(json_path, 'w', encoding='utf-8') as f: json.dump(result, f, ensure_ascii=False, indent=2) print(f"结果已保存到: {json_path}") # 如果有结果图片，也保存 if 'result_image' in result and result['result_image']: # 这里需要根据实际API返回的图片数据格式处理 # 可能是base64编码，也可能是URL pass # 使用示例 if __name__ == "__main__": # 创建客户端 client = DAMOYOLOClient() # 检测单张图片 result = client.detect_image( "test.jpg", threshold=0.25, save_result=True ) if result: print(f"共检测到 {result['count']} 个目标") print(f"使用的阈值: {result['threshold']}") # 按置信度排序显示 detections = sorted(result['detections'], key=lambda x: x['score'], reverse=True) for i, det in enumerate(detections[:5]): # 显示前5个 print(f"{i+1}. {det['label']}: {det['score']:.3f} " f"(位置: {det['box']})")

这个增强版客户端考虑了实际使用中的各种情况，更加健壮和实用。

4. 构建自动化检测流水线

4.1 批量图片处理

在实际项目中，我们经常需要处理整个文件夹的图片。下面是一个批量处理的实现：

import concurrent.futures from pathlib import Path import pandas as pd class BatchProcessor: """批量图片处理器""" def __init__(self, client=None): self.client = client or DAMOYOLOClient() self.results = [] def process_folder(self, folder_path, threshold=0.3, max_workers=4, extensions=None): """ 处理文件夹中的所有图片 参数: folder_path: 图片文件夹路径 threshold: 置信度阈值 max_workers: 最大并发数 extensions: 支持的图片扩展名 返回: list: 所有图片的检测结果 """ if extensions is None: extensions = ['.jpg', '.jpeg', '.png', '.bmp'] folder = Path(folder_path) image_files = [] # 收集所有图片文件 for ext in extensions: image_files.extend(folder.glob(f'*{ext}')) image_files.extend(folder.glob(f'*{ext.upper()}')) print(f"找到 {len(image_files)} 张图片") # 使用线程池并发处理 with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor: # 提交所有任务 future_to_file = { executor.submit(self._process_single, img, threshold): img for img in image_files } # 收集结果 for future in concurrent.futures.as_completed(future_to_file): img_file = future_to_file[future] try: result = future.result() if result: result['filename'] = img_file.name self.results.append(result) print(f"✓ 处理完成: {img_file.name}") else: print(f"✗ 处理失败: {img_file.name}") except Exception as e: print(f"✗ 处理异常 {img_file.name}: {e}") return self.results def _process_single(self, image_path, threshold): """处理单张图片（供线程池调用）""" return self.client.detect_image(image_path, threshold) def save_to_csv(self, output_file="detection_results.csv"): """将结果保存为CSV文件""" if not self.results: print("没有结果可保存") return # 整理数据 data = [] for result in self.results: filename = result.get('filename', 'unknown') count = result.get('count', 0) threshold = result.get('threshold', 0) # 每个检测目标作为一行 for det in result.get('detections', []): data.append({ 'filename': filename, 'label': det.get('label', ''), 'score': det.get('score', 0), 'x1': det.get('box', {}).get('x1', 0), 'y1': det.get('box', {}).get('y1', 0), 'x2': det.get('box', {}).get('x2', 0), 'y2': det.get('box', {}).get('y2', 0), 'threshold': threshold, 'total_count': count }) # 创建DataFrame并保存 df = pd.DataFrame(data) df.to_csv(output_file, index=False, encoding='utf-8-sig') print(f"结果已保存到: {output_file}") return df def generate_summary(self): """生成统计摘要""" if not self.results: return None summary = { 'total_images': len(self.results), 'total_detections': sum(r.get('count', 0) for r in self.results), 'avg_detections_per_image': sum(r.get('count', 0) for r in self.results) / len(self.results), } # 统计各类别出现次数 category_counts = {} for result in self.results: for det in result.get('detections', []): label = det.get('label', 'unknown') category_counts[label] = category_counts.get(label, 0) + 1 summary['category_distribution'] = category_counts return summary # 使用示例 if __name__ == "__main__": # 创建处理器 processor = BatchProcessor() # 处理整个文件夹 print("开始批量处理图片...") results = processor.process_folder( "images_folder", threshold=0.25, max_workers=4 ) print(f"处理完成，共处理 {len(results)} 张图片") # 保存结果 df = processor.save_to_csv("detection_results.csv") # 生成统计摘要 summary = processor.generate_summary() if summary: print("\n=== 检测统计摘要 ===") print(f"总图片数: {summary['total_images']}") print(f"总检测目标数: {summary['total_detections']}") print(f"平均每张图片检测数: {summary['avg_detections_per_image']:.2f}") print("\n=== 类别分布（前10）===") sorted_categories = sorted( summary['category_distribution'].items(), key=lambda x: x[1], reverse=True )[:10] for label, count in sorted_categories: print(f"{label}: {count}次")

4.2 实时视频流处理

除了静态图片，我们还可以处理视频流。下面是一个简单的视频处理示例：

import cv2 import numpy as np from datetime import datetime class VideoProcessor: """视频流处理器""" def __init__(self, client=None, frame_interval=10): """ 初始化视频处理器 参数: client: DAMOYOLO客户端 frame_interval: 检测间隔帧数（每隔多少帧检测一次） """ self.client = client or DAMOYOLOClient() self.frame_interval = frame_interval self.frame_count = 0 def process_video(self, video_source, output_file=None, threshold=0.3, show_preview=True): """ 处理视频流 参数: video_source: 视频文件路径或摄像头ID output_file: 输出视频文件路径 threshold: 置信度阈值 show_preview: 是否显示实时预览 返回: list: 所有帧的检测结果 """ # 打开视频源 cap = cv2.VideoCapture(video_source) if not cap.isOpened(): print(f"无法打开视频源: {video_source}") return [] # 获取视频信息 fps = int(cap.get(cv2.CAP_PROP_FPS)) width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) print(f"视频信息: {width}x{height}, {fps}FPS") # 准备视频写入器 writer = None if output_file: fourcc = cv2.VideoWriter_fourcc(*'mp4v') writer = cv2.VideoWriter(output_file, fourcc, fps, (width, height)) all_results = [] print("开始处理视频...") start_time = datetime.now() while True: ret, frame = cap.read() if not ret: break self.frame_count += 1 # 每隔frame_interval帧检测一次 if self.frame_count % self.frame_interval == 0: # 转换格式并检测 frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) pil_image = Image.fromarray(frame_rgb) try: result = self.client.detect_image(pil_image, threshold) if result: all_results.append({ 'frame': self.frame_count, 'timestamp': self.frame_count / fps, 'detections': result.get('detections', []) }) # 在帧上绘制检测结果 frame = self._draw_detections(frame, result) except Exception as e: print(f"第{self.frame_count}帧检测失败: {e}") # 写入输出视频 if writer: writer.write(frame) # 显示预览 if show_preview: cv2.imshow('DAMOYOLO Detection', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break # 清理资源 cap.release() if writer: writer.release() if show_preview: cv2.destroyAllWindows() # 计算处理时间 end_time = datetime.now() duration = (end_time - start_time).total_seconds() print(f"视频处理完成，共处理 {self.frame_count} 帧") print(f"总耗时: {duration:.2f}秒，平均每帧: {duration/self.frame_count*1000:.1f}毫秒") return all_results def _draw_detections(self, frame, result): """在帧上绘制检测框和标签""" for det in result.get('detections', []): box = det.get('box', {}) label = det.get('label', '') score = det.get('score', 0) # 获取坐标 x1 = int(box.get('x1', 0)) y1 = int(box.get('y1', 0)) x2 = int(box.get('x2', 0)) y2 = int(box.get('y2', 0)) # 绘制矩形框 cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2) # 绘制标签和置信度 label_text = f"{label}: {score:.2f}" cv2.putText(frame, label_text, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) return frame # 使用示例 if __name__ == "__main__": # 处理视频文件 processor = VideoProcessor(frame_interval=5) results = processor.process_video( "test_video.mp4", output_file="output_video.mp4", threshold=0.25, show_preview=True ) # 分析视频检测结果 if results: total_detections = sum(len(r['detections']) for r in results) print(f"视频中检测到 {total_detections} 个目标") # 统计出现最多的目标 from collections import Counter all_labels = [] for r in results: for det in r['detections']: all_labels.append(det['label']) label_counts = Counter(all_labels) print("\n目标出现频率:") for label, count in label_counts.most_common(5): print(f" {label}: {count}次")

5. 实际应用场景与优化建议

5.1 常见应用场景

基于DAMOYOLO-S的自动化检测流水线，可以在很多实际场景中发挥作用：

电商场景：

  • 自动识别商品图片中的主体商品
  • 检测图片中是否有违禁品
  • 统计商品展示的完整性
# 电商图片批量检测示例 def analyze_product_images(image_folder): """分析电商产品图片""" processor = BatchProcessor() results = processor.process_folder(image_folder, threshold=0.2) product_stats = {} for result in results: filename = result['filename'] detections = result['detections'] # 找出置信度最高的检测结果（假设是主要商品） if detections: main_product = max(detections, key=lambda x: x['score']) label = main_product['label'] # 统计各类商品数量 product_stats[label] = product_stats.get(label, 0) + 1 # 检查图片质量（是否有完整商品展示） box = main_product['box'] box_area = (box['x2'] - box['x1']) * (box['y2'] - box['y1']) # 假设图片尺寸为800x600 image_area = 800 * 600 coverage = box_area / image_area if coverage < 0.3: print(f"警告: {filename} 中商品占比过小 ({coverage:.1%})") return product_stats

安防监控：

  • 实时检测监控画面中的人员、车辆
  • 统计特定区域的人流量
  • 检测异常行为或物品

内容审核：

  • 自动检测图片中的敏感内容
  • 识别违规物品
  • 批量审核用户上传的图片

5.2 性能优化建议

在实际使用中，你可能会遇到性能问题。这里有几个优化建议：

1. 调整检测频率： 对于视频处理，不需要每一帧都检测。根据场景需求调整检测间隔：

# 根据运动程度动态调整检测频率 class AdaptiveVideoProcessor(VideoProcessor): def __init__(self, client=None, base_interval=10, motion_threshold=0.1): super().__init__(client, base_interval) self.motion_threshold = motion_threshold self.prev_frame = None def process_frame(self, frame): # 计算帧间差异 if self.prev_frame is not None: motion = self.calculate_motion(self.prev_frame, frame) # 运动剧烈时增加检测频率 if motion > self.motion_threshold: self.frame_interval = max(1, self.base_interval // 2) else: self.frame_interval = self.base_interval self.prev_frame = frame.copy() return super().process_frame(frame)

2. 批量请求优化： 虽然DAMOYOLO的API目前只支持单张图片，但我们可以通过异步请求提高效率：

import asyncio import aiohttp class AsyncDAMOYOLOClient: """异步DAMOYOLO客户端""" async def detect_images_async(self, image_paths, threshold=0.3): """异步批量检测图片""" async with aiohttp.ClientSession() as session: tasks = [] for img_path in image_paths: task = self._detect_single_async(session, img_path, threshold) tasks.append(task) results = await asyncio.gather(*tasks, return_exceptions=True) return results async def _detect_single_async(self, session, image_path, threshold): """异步检测单张图片""" with open(image_path, 'rb') as f: files = {'image': f} data = {'threshold': str(threshold)} async with session.post(self.api_url, data=data, files=files) as response: if response.status == 200: return await response.json() else: return None

3. 结果缓存： 对于重复出现的场景，可以使用缓存减少重复检测：

from functools import lru_cache import hashlib class CachedDAMOYOLOClient(DAMOYOLOClient): """带缓存的DAMOYOLO客户端""" @lru_cache(maxsize=100) def detect_image_cached(self, image_bytes_hash, threshold): """带缓存的图片检测""" # 这里需要根据哈希值获取原始图片数据 # 实际实现需要存储图片数据到哈希的映射 pass def get_image_hash(self, image_bytes): """计算图片哈希值""" return hashlib.md5(image_bytes).hexdigest()

5.3 错误处理与监控

在生产环境中，良好的错误处理和监控是必不可少的：

import logging from datetime import datetime class ProductionDAMOYOLOClient(DAMOYOLOClient): """生产环境使用的DAMOYOLO客户端""" def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.setup_logging() self.metrics = { 'total_requests': 0, 'successful_requests': 0, 'failed_requests': 0, 'total_latency': 0 } def setup_logging(self): """设置日志""" logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler('damoyolo_client.log'), logging.StreamHandler() ] ) self.logger = logging.getLogger(__name__) def detect_image(self, image_input, threshold=0.3, **kwargs): """重写检测方法，添加监控""" start_time = datetime.now() self.metrics['total_requests'] += 1 try: result = super().detect_image(image_input, threshold, **kwargs) if result: self.metrics['successful_requests'] += 1 self.logger.info(f"检测成功: {len(result.get('detections', []))}个目标") else: self.metrics['failed_requests'] += 1 self.logger.warning("检测失败: 返回结果为空") return result except Exception as e: self.metrics['failed_requests'] += 1 self.logger.error(f"检测异常: {e}", exc_info=True) raise finally: # 记录延迟 latency = (datetime.now() - start_time).total_seconds() self.metrics['total_latency'] += latency def get_metrics(self): """获取性能指标""" metrics = self.metrics.copy() if metrics['total_requests'] > 0: metrics['success_rate'] = metrics['successful_requests'] / metrics['total_requests'] metrics['avg_latency'] = metrics['total_latency'] / metrics['total_requests'] return metrics

6. 总结与最佳实践

通过上面的代码示例，你应该已经掌握了如何使用Python调用DAMOYOLO-S的Web API来构建自动化目标检测流水线。让我总结一下关键要点：

6.1 核心收获

  1. 简单易用：DAMOYOLO-S提供了开箱即用的Web服务，通过简单的HTTP请求就能获得强大的目标检测能力
  2. 灵活扩展：基于Python的客户端可以轻松集成到各种应用中，无论是批量处理还是实时流处理
  3. 高效自动：相比手动操作，自动化流水线可以提升几十倍甚至上百倍的效率

6.2 最佳实践建议

根据我的实际使用经验，这里有几个建议：

阈值选择：

  • 默认0.3的阈值比较保守，可能会漏检一些目标
  • 对于需要高召回率的场景（如安防），建议使用0.15-0.25
  • 对于需要高精度的场景（如内容审核），可以保持0.3或更高

错误处理：

  • 一定要添加重试机制，网络请求可能会失败
  • 记录详细的日志，便于排查问题
  • 监控API的响应时间和成功率

性能优化：

  • 对于视频处理，合理设置检测间隔
  • 使用并发处理批量图片
  • 考虑使用缓存减少重复检测

结果处理：

  • 将检测结果结构化存储（如CSV、数据库）
  • 添加后处理逻辑，如非极大值抑制（NMS）
  • 根据业务需求过滤和分类检测结果

6.3 下一步探索方向

如果你对这个方案感兴趣，还可以进一步探索：

  1. 多模型集成：结合其他AI模型，如OCR、图像分类等
  2. 分布式处理：将任务分发到多个worker节点
  3. 实时报警：检测到特定目标时发送通知
  4. 模型微调：针对特定场景微调DAMOYOLO模型

目标检测只是AI应用的一个起点。通过自动化流水线，你可以将这项技术应用到更多实际场景中，真正发挥AI的价值。希望这篇文章能帮助你快速上手，如果有任何问题，欢迎在实践中继续探索。

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 ZEEKLOG星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。

Read more

【终极指南】基于ESP32的无人机开发：从零构建智能飞行平台

【终极指南】基于ESP32的无人机开发：从零构建智能飞行平台 【免费下载链接】esp-droneMini Drone/Quadcopter Firmware for ESP32 and ESP32-S Series SoCs. 项目地址: https://gitcode.com/GitHub_Trending/es/esp-drone 你是否想过亲手打造一台智能无人机？ESP32无人机开源飞行平台为你提供了一个完整的DIY无人机开发解决方案。这个项目不仅展示了如何利用ESP32芯片的强大能力，还为你揭示了从硬件组装到飞行控制的全过程，让每个人都能参与到智能飞行技术的探索中来。 🎯 为什么选择ESP32无人机？ 在众多无人机方案中，ESP32开源飞行平台凭借其独特优势脱颖而出： * 双核处理能力：ESP32芯片的双核架构确保飞行控制与数据处理并行不悖 * 内置无线通信：WiFi和蓝牙模块让你无需额外配件即可实现远程控制 * 丰富的传感器接口：轻松扩展陀螺仪、加速度计、磁力计等关键组件 * 成熟的软件生态：基于FreeRTOS实时操作系统，保证飞行稳定性 🚀 5
【论文阅读103】pinn-review-科学机器学习中的物理信息神经网络：现状与展望

【论文阅读103】pinn-review-科学机器学习中的物理信息神经网络：现状与展望

科学机器学习中的物理信息神经网络：现状与展望 作者：Salvatore Cuomo¹ · Vincenzo Schiano Di Cola² · Fabio Giampaolo¹ · Gianluigi Rozza³ · Maziar Raissi⁴ · Francesco Piccialli¹ 在线发表：2022年7月26日 摘要 物理信息神经网络（Physics-Informed Neural Networks，PINNs）是一类将模型方程（如偏微分方程，PDE）直接嵌入神经网络结构中的神经网络（NN）。目前，PINNs 已被广泛用于求解偏微分方程、分数阶方程、积分-微分方程以及随机偏微分方程。这一新兴方法作为一种多任务学习框架出现，在该框架中，神经网络不仅需要拟合观测数据，还需最小化 PDE 残差。 本文对物理信息神经网络相关文献进行了全面综述：研究的主要目标是阐明这类网络的特征、优势与局限性。同时，本文还涵盖了更广义的基于配点法（collocation-based）的物理约束神经网络研究，包括从最初的基础 PINN（
《星辰 RPA 全自动：做一个小红书自动发文机器人》

《星辰 RPA 全自动：做一个小红书自动发文机器人》

前引：在企业数智化转型的浪潮中，如何突破 “有 AI 无落地、有流程无智能” 的困局？星辰 Agent 与星辰 RPA 的出现，正是为了解决这一痛点。作为科大讯飞旗下的双核心产品，星辰 Agent 以企业级 Agentic Workflow 开发平台为底座，提供 AI 工作流编排、模型管理与跨系统连接能力；而星辰 RPA 则以超过 300 个自动化原子能力，让业务流程真正 “动” 起来！ 目录 一、企业机器人自动化平台：RPA （1）RPA介绍 （2）服务端安装 （1）clone项目 （2）配置为本地访问 （3）检查镜像源 （4）配置default.conf
MK米客方德SD NAND:无人机存储的高效解决方案

MK米客方德SD NAND:无人机存储的高效解决方案

在无人机技术迅猛发展的当下，飞控系统的数据记录对于飞行性能剖析、故障排查以及飞行安全保障极为关键。以往，SD 卡是飞控 LOG 记录常见的存储介质，但随着技术的革新，新的存储方案不断涌现。本文聚焦于以 ESP32 芯片为主控制器的无人机，创新性采用 SD NAND 芯片 MKDV32GCL-STPA 芯片进行 SD NAND 存储，测试其在飞控 LOG 记录功能中的表现。 米客方德 SD NAND 芯片特性 免驱动优势：与普通存储设备不同，在该应用场景下，SD NAND 无需编写复杂的驱动程序。这极大地简化了开发流程，缩短了开发周期，减少了潜在的驱动兼容性问题，让开发者能够更专注于实现核心功能。 自带坏块管理功能：存储设备出现坏块难以避免，而 MKDV32GCL - STPA 芯片自带的坏块管理机制可自动检测并处理坏块。这确保了数据存储的可靠性，避免因坏块导致的数据丢失或错误写入，提升了整个存储系统的稳定性。 尺寸小巧与强兼容性：