目录
介绍
CodeProject.AI Server提供了粘合剂、基础架构和前端，可以将您希望公开给应用程序的任何AI项目捆绑在一起。通过为您的AI项目的代码创建一个简单的包装器，您可以获得一个具有完整生命周期管理、部署、更新和接触任何应用程序、任何语言的模块。您有趣的控制台项目现在随处可用。
我们的示例CodeProject.AI服务器模块
在我们的示例中，我们将使用一个简单的Python程序，该程序使用PyTorch和YOLOv8模型来执行对象检测。我们将使用的这个程序是一个在控制台上运行的python文件，使用
python3 detect.py --input test.jpg --assets assets --model yolov8m --threshold 0.6它将产生类似于
Label confidence bounding box
====================================================
chair 91% (102, 272) - (242, 421)
potted plant 88% (9, 226) - (71, 337)
chair 72% (235, 203) - (336, 358)
laptop 69% (231, 221) - (300, 259)
chair 66% (0, 361) - (91, 439)
我们将把它变成一个通过API调用调用的CodeProject.AI模块
http://localhost:32168/v1/vision/detect并且其会返回
{
"success":true,
"message":"Found chair, potted plant, chair...",
"count":5,
"predictions":[
{
"confidence":0.9158754944801331,
"label":"chair",
"x_min":102,
"y_min":272,
"x_max":242,
"y_max":421
},
...
{
"confidence":0.665546715259552,
"label":"chair",
"x_min":0,
"y_min":361,
"x_max":91,
"y_max":439
}
],
"processMs":398,
"inferenceMs":386
}要处理的图像通过简单的HTTP POST调用传递到此API。这意味着任何能够进行HTTP调用的应用程序现在都可以使用您的python代码。
不再需要担心设置Python和虚拟环境，也不必再担心如何在.NET应用中使用Python代码。CodeProject.AI Server向所有人公开您的Python页面。
构建模块的步骤
- 定义模块的设置。这允许CodeProject.AI安装程序为我们设置环境，并向服务器提供有关如何启动模块以及模块将服务的API路由的信息。
- 创建安装脚本。允许我们下载资产或安装所需的任何支持库
- 编写一个适配器来包装我们现有的代码。它提供了我们的代码和CodeProject.AI服务器之间的通信。
- 编写测试页面。这使我们能够轻松测试模块
- 编写打包程序脚本。不是必需的，但它允许您以zip形式重新分发模块注册表的模块
让我们开始吧：modulesettings.json文件
modulesettings.json文件是这一切的真正主力。
模块设置存储在modulesettings.json文件中。如果对不同平台（例如运行时的不同版本）具有不同的设置，则可以使用modulesettings.<target>.json文件。有关文件名定位选项的说明，请参阅文档。
在本练习中，我们将在Windows中运行Python 3.9，在Linux中运行Python 3.8。旧版本，是的，但由于它们使用的包的要求，AI项目通常使用旧版本的Python。随意使用您的代码使用的任何版本。
该modulesettings.json文件的基本格式为
{
"Modules": {
"DemoModulePython": {
"Name": "My module name",
"Version": "2.0.0",
"PublishingInfo" : {
...
},
"LaunchSettings": {
...
},
"EnvironmentVariables": {
...
},
"GpuOptions" : {
...
},
"InstallOptions" : {
...
},
"UIElements" : {
...
},
"RouteMaps": [
{
...
}]
}
}
}让我们来看看这个并填写值
名称和版本应不言自明，模块ID是希望提供且不与其他模块冲突的任何ID。我们将模块标记为DemoModulePython。
我们的PublishingInfo部分将包含：
"PublishingInfo" : {
"Description" : "Provides Object Detection YOLOv8",
"Category" : "Computer Vision",
"Stack" : "Python, PyTorch, YOLO",
"License" : "AGPL-3.0",
"LicenseUrl" : "https://www.gnu.org/licenses/agpl-3.0.en.html",
"Author" : "Chris Maunder",
"Homepage" : "https://codeproject.com/ai",
"BasedOn" : "ultralytics", // What project is this based on?
"BasedOnUrl" : "https://github.com/ultralytics/ultralytics" // The URL for that project
}LaunchSettings将包含
"LaunchSettings": {
"AutoStart" : true, // Start this when the server starts
"FilePath" : "detect_adapter.py", // Name of file that gets launched
"Runtime" : "python3.8", // file is launched by Python
"RuntimeLocation" : "Local", // We want our own virt. env., not a shared one
"PostStartPauseSecs" : 1, // Generally 1 if using GPU, 0 for CPU
"Queue" : "objdetect_queue", // Can be left as null if you wish
"Parallelism" : 0 // 0 = Default (number of CPUs - 1)
}- FilePath和Runtime 是这里最重要的字段。如果您愿意，可以省略其他所有内容。
- 队列指定服务器将放置来自客户端的请求的位置，以及模块将在其中查找要处理的请求的队列的名称。您可以将其留空，也可以提供一个名称，以防您希望多个模块为同一队列提供服务。
- 并行性表示将运行以处理此队列的并行任务数。
- RuntimeLocation目前仅用于Python，可以“共享”，这意味着该模块将使用共享虚拟环境来节省空间，或者“本地”表示venv将是该模块的本地（以避免包冲突）
EnvironmentVariables部分包含我们希望在启动前设置的任何环境变量
"EnvironmentVariables": {
"CPAI_MODEL_YOLODEMO_MODEL_SIZE" : "Medium", // tiny, small, medium, large
"CPAI_MODEL_YOLODEMO_MODELS_DIR" : "%CURRENT_MODULE_PATH%/assets"
}请注意CURRENT_MODULE_PATH宏的用法。有关此内容的详细信息，请参阅宏。
GpuOptions 仅用于GPU设置
"GpuOptions": {
"InstallGPU" : true, // Should we install GPU enabled code?
"EnableGPU" : true, // Should we enable GPU support (if installed)
"AcceleratorDeviceName" : null, // eg "cuda:0" or just leave blank for default
"HalfPrecision" : "enable" // For code that supports half-precision. Use 'Force', 'Enable', 'Disable'
}- HalfPrecision 允许您在不支持它的旧CUDA卡上禁用半精度操作。省略这一点通常是安全的CodeProject.AI因为服务器可以代表您进行一些有根据的猜测
InstallOptions 描述模块应该或是否可以安装的方式、位置和位置
"InstallOptions": {
"Platforms": [ "windows", "linux" ],
"ModuleReleases": [
{ "ModuleVersion": "1.0.0", "ServerVersionRange": [ "1.0.0", "2.4.9" ],
"ReleaseDate": "2023-01-01", "ReleaseNotes": "Initial Release",
"Importance": "Major" },
{ "ModuleVersion": "2.0.0", "ServerVersionRange": [ "2.5.0", "" ],
"ReleaseDate": "2023-02-14", "ReleaseNotes": "Updated for Server 2.5.0",
"Importance": "Major" }
]
}- 平台是平台列表。支持的选项包括：windows、macos、linux、raspberrypi、orangepi、jetson，以及arm64变体：windows-arm64、macos-arm64、linux-arm64。或者，使用“all”表示它可以在任何地方运行。
- ModuleReleases是版本和与之兼容的服务器版本的数组。在这种情况下，版本1与CodeProject.AI Server版本1到2.4.9兼容，模块版本2与CodeProject.AI版本2.5及更高版本兼容
UIElements 为服务器提供有关UI选项的信息。我们将只讨论显示在仪表板中模块行上的上下文菜单。我们将提供一个提供模型大小的菜单。添加第二个菜单选项就像添加另一个菜单对象（{ "Label": .... "Options": ...})一样简单
"UIElements" : {
"Menus": [{
"Label": "Half Precision",
"Options": [
{ "Label": "Force on", "Setting": "CPAI_HALF_PRECISION", "Value": "force" },
{ "Label": "Use Default", "Setting": "CPAI_HALF_PRECISION", "Value": "enable" },
{ "Label": "Disable", "Setting": "CPAI_HALF_PRECISION", "Value": "disable" }
]
}]
},路由映射用于定义模块的API路由。
"RouteMaps": [{
"Name": "Python YOLOv8 Object Detector",
"Route": "vision/detection",
"Method": "POST",
"Command": "detect",
"Description": "Detects objects",
"Inputs": [
{
"Name": "image",
"Type": "File",
"Description": "The HTTP file object (image) to be analyzed."
},
{
"Name": "min_confidence",
"Type": "Float",
"Description": "The minimum confidence level (0.0 - 1.0) for an object will be detected.",
"DefaultValue": 0.4,
"MinValue": 0.0,
"MaxValue": 1.0
}],
"Outputs": [{
"Name": "success",
"Type": "Boolean",
"Description": "True if successful."
},
...
]
}
]- 路由是调用方将用于调用此模块的路由。路由视觉/检测将对应API调用http://localhost:32168/v1/vision/detection
- 命令是将发送到此路由的命令。您可以设置路径相同但发送不同命令的路由。由您的模块来适当地处理该命令
- 输入和输出定义输入参数和输出结果，用于自动记录模块
添加适用于Windows的变体模块设置文件
为了这个演示，我们将添加一个专门用于Windows的modulesettings文件，并将Python版本从3.8更改为Windows的3.9。我们将命名该modulesettings.windows.json文件，它将仅包含覆盖的值：
{
"Modules": {
"DemoModulePython": {
"LaunchSettings": {
"Runtime": "python3.9"
}
}
}
}设置系统
我们模块的大部分设置将根据模块设置文件的内容自动处理，因此在某些情况下，您的设置脚本将是空的。在我们的例子中，我们将下载YOLOv8模型，所以我们的设置脚本非常基本
VBScript
@if "%1" NEQ "install" (
echo This script is only called from ..\..\setup.bat
@pause
@goto:eof
)
REM Download the YOLO models from the CodeProject models/ folder and store in /assets
call "%sdkScriptsDirPath%\utils.bat" GetFromServer "models/" "models-yolo8-pt.zip" "assets" "Downloading Standard YOLO models..."if [ "$1" != "install" ]; then
read -t 3 -p "This script is only called from: bash ../../setup.sh"
echo
exit 1
fi
# Download the YOLO models from the CodeProject models/ folder and store in /assets
getFromServer "models/" "models-yolo8-pt.zip" "assets" "Downloading Standard YOLO models..."在这里，我们使用CodeProject.AI SDK中的getFromServer方法。有关这些内容的更多信息，请参阅安装脚本文档。请注意，除非您的资产托管在CodeProject服务器上，否则您需要从存储资产的任何位置手动下载资产。
安装的核心由CodeProject.AI服务器安装脚本处理。他们将嗅探出运行时（Python），并确保安装了我们选择的版本，设置了虚拟环境，并安装了所需的python包（如相应的requirements.txt文件中指定的那样）。
Post安装
在某些情况下，您可能需要为修补库等方案执行一些安装后命令。这是通过包含安装程序将执行的post-install.bat / post-install.sh文件（如果存在）来完成的。在我们的演示中，我们包含了修补ultralytics库的安装后脚本。
Requirements.txt
如果您有针对不同平台的不同requirements.txt文件，请查看requirements.txt文档。
.NET
对于.NET模块，.NET已作为服务器安装程序的一部分进行安装。
编写模块本身：适配器
我们将要包装的代码位于与本文关联的zip下载中。在detect.py文件中，您将找到我们想要在do_detection方法中提供的代码的实质：
def do_detection(img: any, threshold: float = 0.4, models_dir: str = "assets",
model_name: str = "yolov8m", resolution: int = 640,
use_Cuda: bool = False, accel_device_name: int = 0,
use_MPS: bool = False, use_DirectML: bool = False,
half_precision: str = "enable"):此方法将输出一个对象，其形式为
{
"message" : "Detected car, bike and person",
"count" : 3,
"predictions" : [ ... ],
"success" : True,
"processMs" : 50,
"inferenceMs" : 20
}其中predictions是对象数组，其形式为
{
"confidence": 0.87,
"label": "car",
"x_min": 20,
"y_min": 10,
"x_max": 100,
"y_max": 50,
}传递给do_detection方法的参数在这里并不那么重要。只要你了解你的代码需要什么，你就可以跟上。
为了包装此方法，我们创建一个适配器，该适配器派生自CodeProject.AI Server SDK中的ModuleRunner类
适配器的基本骨架是
# Import or general libraries
import os
import sys
# Import the CodeProject.AI SDK. This will add to the PATH var for future imports
sys.path.append("../../SDK/Python")
from common import JSON
from request_data import RequestData # RequestData is passed to 'process'
from module_options import ModuleOptions # Handle options passed to the module
from module_runner import ModuleRunner # The ModuleRumne core
from module_logging import LogMethod # For logging
# Import the method of the module we're wrapping
from detect import do_detection
# Our adapter
class YOLOv8_adapter(ModuleRunner):
def initialize(self):
# (optional) initialise the module.
def process(self, data: RequestData) -> JSON:
# process the request and return the results as JSON
def status(self) -> JSON:
# (optional) return the module status as JSON
def update_statistics(self, response):
# (optional) Update statistics if required
def selftest(self) -> JSON:
# (optional but encouraged) Perform a self-test
def cleanup(self) -> None:
# (optional) Perform any cleanup required
if __name__ == "__main__":
YOLOv8_adapter().start_loop()这些方法中的每一个都重写父类ModuleRunner中的相应方法。您只需要覆盖process，但对于我们的示例，我们将展示一个典型的initialize和selftest，并展示status和update_statistics是如何工作的。
初始化
您可以选择其中之一。这种方法为我们设置了一切。在这里，我们将嗅探是否启用了GPU代码、设置一些值并初始化一些统计信息。
def initialise(self):
# Can we use the GPU (via PyTorch / CUDA)?
if self.system_info.hasTorchCuda:
self.can_use_GPU = True
self.inference_device = "GPU"
self.inference_library = "CUDA"
self.models_dir = ModuleOptions.getEnvVariable("CPAI_MODULE_YOLODEMO_MODEL_DIR", "assets")
self.std_model_name = ModuleOptions.getEnvVariable("CPAI_MODULE_YOLODEMO_MODEL_NAME", "yolov8m")
self.resolution_pixels = ModuleOptions.getEnvVariable("CPAI_MODULE_YOLODEMO_RESOLUTION", 640)
self.accel_device_name = "cuda" if self.can_use_GPU else "cpu"
# Let's store some stats
self._num_items_found = 0
self._histogram = {}ModuleRunner具有一个system_info属性，该属性提供有关当前环境的大量信息，并对常见库（如PyTorch）执行一些基本功能检查。在这里，我们检查是否启用了CUDA。如果是这样，我们设置can_use_GPU = True来表示我们的模块可以使用GPU，并设置推理设备和库，以便可以在仪表板中报告。
我们使用该ModuleOptions类来帮助嗅探环境变量中设置的值，同时还提供默认值。
_num_items_found和_histogram属性将存储有关我们发现的内容的信息。这些将补充ModuleRunner类中默认收集的统计数据。
过程
在此演示中，我们的过程方法将以两种不同的方式（默认模型和自定义模型）执行一件事（检测对象），以演示路由和命令。我们有两条路由：/v1/vision/detect和/v1/vision/custom/<model>，其中<model>是用于对象检测的自定义模型的名称。
我们使用data（RequestData）object来获取传递给该方法的参数和文件。在下面的自检和资源管理器讨论中，你将了解如何将参数和文件传递到服务器API。
该data.command属性将命令传递给路由，并且data.segments包含路由本身之后的路由段。例如，路由/v1/vision/custom使用“/v1/vision/custom/model-name”调用，因此segments将包含单个条目“model-name”
我们还使用该ModuleRunner.log方法将日志条目发送回服务器。
该process方法非常简单：它收集参数并将它们发送到我们的do_detection方法，然后返回结果。这是一个JSON响应，所以我们不需要做任何后期处理。
def process(self, data: RequestData) -> JSON:
response = None
if data.command == "detect": # Detection using standard models (API: /v1/vision/detection)
threshold: float = float(data.get_value("min_confidence", "0.4"))
img: Image = data.get_image(0)
model_name: str = "yolov8m"
response = do_detection(img, threshold, self.models_dir, model_name,
self.resolution_pixels, self.can_use_GPU, self.accel_device_name,
False, False, self.half_precision)
elif data.command == "custom": # Detection using custom model (API: /v1/vision/custom/<model>)
threshold: float = float(data.get_value("min_confidence", "0.4"))
img: Image = data.get_image(0)
model_name: str = None
if data.segments and data.segments[0]:
model_name = data.segments[0]
if not model_name:
return { "success": False, "error": "No custom model specified" }
if not os.path.exists(os.path.join(self.models_dir, model_name + ".pt")):
return { "success": False, "error": f"Could not find custom model {model_name}" }
self.log(LogMethod.Info | LogMethod.Server,
{
"filename": __file__,
"loglevel": "information",
"method": sys._getframe().f_code.co_name,
"message": f"Detecting using {model_name}"
})
response = do_detection(img, threshold, self.models_dir, model_name,
self.resolution_pixels, self.can_use_GPU, self.accel_device_name,
False, False, self.half_precision)
else:
response = { "success" : False }
self.report_error(None, __file__, f"Unknown command {data.command}")
return responseupdate_statistics
每次调用process后都会调用此方法。我们将覆盖此方法，以便我们可以嗅出检测到的内容并生成一些统计信息
def update_statistics(self, response):
super().update_statistics(response)
if "success" in response and response["success"] and "predictions" in response:
predictions = response["predictions"]
self._num_items_found += len(predictions)
for prediction in predictions:
label = prediction["label"]
if label not in self._histogram:
self._histogram[label] = 1
else:
self._histogram[label] += 1状态
此方法返回模块的状态。默认实现返回统计信息，例如调用次数和平均推理时间，因此我们将添加一些统计信息。
def status(self) -> JSON:
statusData = super().status()
statusData["numItemsFound"] = self._num_items_found
statusData["histogram"] = self._histogram
return statusData自检
我们将讨论的最后一种selftest方法。该方法在安装过程结束时调用，以让用户知道模块是否安装成功。
该process方法需要一个RequestData对象，因此我们将创建一个新RequestData对象，设置命令，添加属性/值对，然后添加文件。然后，我们将调用我们的process方法并返回结果。
在此示例中，我们将在项目中的test文件夹下包含一个home-office.jpg图像。
def selftest(self) -> JSON:
file_name = os.path.join("test", "home-office.jpg")
request_data = RequestData()
request_data.command = "detect"
request_data.add_file(file_name)
request_data.add_value("min_confidence", 0.4)
result = self.process(request_data)
print(f"Info: Self-test for {self.module_id}. Success: {result['success']}")
return { "success": result['success'], "message": "Object detection test successful"}模块的测试页和资源管理器UI
CodeProject.AI Server提供了一个HTTP API，因此最简单的测试方法是通过Postman、Swagger或您自己编写的简单HTML页面等工具。我们会做后者。
我们将编写一个简单的网页，该网页将通过其API调用该模块并显示结果。我们使用一个特殊的文件“explore.html”来执行此操作，该文件的编写方式将允许CodeProject.AI服务器的资源管理器从此explore.html文件中提取UI并将其合并到服务器的主explorer.html文件中
整个HTML文件如下所示。请注意标有
- 开始/结束资源管理器样式
- 开始/结束资源管理器标记
- 启动/结束资源管理器脚本
这三个部分将从此文件中提取并插入到主服务器的explorer.html文件中。为了使其无缝工作，最好使用与主服务器的资源管理器文件相同的脚本并遵循相同的命名约定explorer.html explore.html
具体说来
- 我们包含explorer.js类，以便访问用于调用服务器API的方法。
- 我们包含用于显示图像结果的imgPreview和imgMask元素
- 我们包括一个用于显示文本结果的results元素。
- 我们将任何可能与_MID_宏发生命名冲突的ID作为前缀。此标记将替换为主 explorer.html 文件中模块的ID，以避免名称冲突。
我们的页面是：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>Object Detection (YOLOv8) Module Test</title>
<!-- CSS and script helpers from the server -->
<link id="bootstrapCss" rel="stylesheet" type="text/css" href="http://localhost:32168/assets/bootstrap-dark.min.css">
<link rel="stylesheet" type="text/css" href="http://localhost:32168/assets/server.css?v=2.5.0.0">
<script type="text/javascript" src="http://localhost:32168/assets/server.js"></script>
<script type="text/javascript" src="http://localhost:32168/assets/explorer.js"></script>
<style>
/* START EXPLORER STYLE */
/* styles for this module if needed */
/* END EXPLORER STYLE */
</style>
</head>
<body class="dark-mode">
<!-- START EXPLORER MARKUP -->
<div class="form-group row">
<label class="col-form-label col-2">Image</label>
<input id="_MID_image" class="col form-control btn-light" type="file" style="width:17rem"
onchange="return previewImage(this)" />
<input id="_MID_things" class="form-control btn-success" type="button" value="Detect Objects"
style="width:11rem" onclick="_MID_onDetectThings(_MID_image)"/>
</div>
<!-- END EXPLORER MARKUP -->
<div class="w-100 position-relative form-control my-4 p-0">
<div id="imgMask" class="position-absolute"
style="left:0;top:0;pointer-events:none;z-index:10"></div>
<img src="" id="imgPreview" class="w-100" style="height:250px;visibility:hidden">
</div>
<div>
<h2>Results</h2>
<div id="results" name="results" class="bg-light p-3" style="min-height: 100px;"></div>
</div>
<script type="text/javascript">
// START EXPLORER SCRIPT
async function _MID_onDetectThings(fileChooser) {
clearImagePreview();
if (fileChooser.files.length == 0) {
alert("No file was selected for vision detection");
return;
}
showPreviewImage(fileChooser.files[0]);
let images = [fileChooser.files[0]];
setResultsHtml("Detecting objects...");
let data = await submitRequest('vision', 'detection', images, null);
if (data) {
showResultsBoundingBoxes(data.predictions);
showPredictionSummary(data)
};
}
// END EXPLORER SCRIPT
</script>
</body>
</html>创建打包程序
最后一步（可选）是创建打包程序。CodeProject.AI Server代码包含一个脚本create_packages.bat（适用于Windows）和 create_packages.sh（适用于macOS/Linux），这些脚本将遍历模块并使用您创建的package.bat/package.sh脚本创建包。此包是一个简单的zip文件，安装程序可以使用您在上面创建的install.bat/install.sh文件进行安装。
@Echo off
REM Module Packaging script. To be called from create_packages.bat
set moduleId=%~1
set version=%~2
tar -caf %moduleId%-%version%.zip --exclude=__pycache__ --exclude=*.development.* --exclude=*.log ^
rembg\* *.py modulesettings.* requirements.* install.sh install.bat explore.html test\*#!/bin/bash
# Module Packaging script. To be called from create_packages.sh
moduleId=$1
version=$2
tar -caf ${moduleId}-${version}.zip --exclude=__pycache__ --exclude=*.development.* --exclude=*.log \
rembg/* *.py modulesettings.* requirements.* install.sh install.bat explore.html test/*整合一切：安装和测试
此时，我们有一个模块、一个安装脚本和一个测试客户端。让我们试一试
1、确保已下载最新的 CodeProject.AI存储库。这已经包含了我们讨论过的所有代码
2、将模块文件夹复制到src/modules文件夹下的CodeProject.AI Server代码中。打开终端并转到该文件夹，然后运行主CodeProject.AI Server安装脚本
..\..\setup.batbash ../../setup.sh这将看到类似于
Installing CodeProject.AI Analysis Module
======================================================================
CodeProject.AI Installer
======================================================================
47.6Gb of 380Gb available on BOOTCAMP
General CodeProject.AI setup
Creating Directories...Done
GPU support
CUDA Present...No
ROCm Present...No
Reading DemoModulePython settings.......Done
Installing module Python Object Detector (YOLOv8) 1.0.0
Installing Python 3.9
Python 3.9 is already installed
Creating Virtual Environment (Shared)...Virtual Environment already present
Confirming we have Python 3.9 in our virtual environment...present
Downloading Standard YOLO models...already exists...Expanding...Done.
Copying contents of models-yolo8-pt.zip to assets...done
Downloading Custom YOLO models...already exists...Expanding...Done.
Copying contents of custom-models-yolo8-pt.zip to custom-models...done
Installing Python packages for Python Object Detector (YOLOv8)
Installing GPU-enabled libraries: If available
Ensuring Python package manager (pip) is installed...Done
Ensuring Python package manager (pip) is up to date...Done
Python packages specified by requirements.txt
- Installing PyTorch, for Tensor computation and Deep neural networks...checked...done
- Installing TorchVision, for Computer Vision based AI...checked...done
- Installing Ultralytics package for object detection in images...checked...done
Installing Python packages for the CodeProject.AI Server SDK
Ensuring Python package manager (pip) is installed...Done
Ensuring Python package manager (pip) is up to date...Done
Python packages specified by requirements.txt
- Installing Pillow, a Python Image Library...checked...done
- Installing Charset normalizer...checked...done
- Installing aiohttp, the Async IO HTTP library...checked...done
- Installing aiofiles, the Async IO Files library...checked...done
- Installing py-cpuinfo to allow us to query CPU info...checked...done
- Installing Requests, the HTTP library...checked...done
Executing post-install script for Python Object Detector (YOLOv8)
Applying Ultralytics patch
1 file(s) copied.
Self test: Self-test passed
Module setup time 00:00:28.37
Setup complete
Total setup time 00:00:29.28 安装Python，设置虚拟环境，用于安装python包的requirement.txt文件，下载模型并运行安装后脚本。您的模块也经过测试，现在可以启动了。
请注意，如果在Linux或macOS上运行此设置，则将使用Python 3.8。在Windows上，由于我们的modulesettings.windows.json文件，我们将安装Python 3.9。
3、通过在Visual Studio或VS Code中启动新的调试会话来启动服务器。
4、在Debug中，运行时会自动启动CodeProject.AI Dashboard。服务器启动后，将启动所有后端模块（包括新模块），仪表板将显示类似于
5、在浏览器中启动explore.html文件，选择一个文件，然后单击“提交”按钮。应显示结果。还要在服务器的explorer.html中进行测试。
结论
为CodeProject.AI编写模块并不困难，但您需要牢记许多事项。modulesettings.json文件定义设置和启动参数，并且能够使用不同的变体覆盖模块设置文件，从而对环境进行非常精细的缩放控制。Python需求文件的类似系统为将Python应用程序安装在各种硬件和软件组合上通常涉及的巨大复杂性提供支持。
选择要包装并向世界公开的代码确实需要考虑将该代码安装在远程用户的计算机上的实用性，但是安装和安装后脚本在解决可能弹出的细微差别（或直接障碍）方面提供了很大的灵活性。
对于典型的开发人员来说，唯一剩下的就是托管下载并将您的模块发送给我们。我们总是很乐意将模块包含在主CodeProject.AI模块注册表中。
向我们展示您的创造力，让我们努力将所有这些令人敬畏的AI项目从您的桌面和Jupyter notebook中解脱出来，并放入数十万CodeProject.AI服务器用户可以享受的模块中。
https://www.codeproject.com/Articles/5377531/CodeProject-AI-Module-creation-A-full-walkthrough
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
