去年底跟一个制造业的架构师聊天，他提到一个数字让我印象很深。他们公司的采购管理系统上线三年，代码量翻了两倍多。我问是业务规模扩大了吗，他说不是，供应商数量基本没变，采购频次也差不多。问题是业务规则一直在变——供应商评估维度从5个变成8个又变成12个，审批流程从两级变成三级又变成带条件分支，合规要求从国内标准扩展到出口管制。每次变更都要改代码、测回归、排期上线，一个看似简单的规则调整，实际走完流程要一到两周。他说了句话让我琢磨了很久："我们不是在开发系统，我们是在追赶业务。"这个现象在采购供应链领域相当普遍。制造企业的采购周期从季度压缩到月度，零售商的供应商准入标准随市场波动调整，跨境贸易的合规要求每年都有新变化。一套采购管理系统上线几年后，代码库中大部分逻辑是在初始版本之后新增的——这反映的是业务对系统持续演进的真实需求，也暴露了传统开发模式在应对这种演进时的吃力。这不是某个团队能力的问题，而是采购供应链系统本身的复杂度决定的。要理解这个复杂度，得从三个层面来看。数据层的复杂度，核心在于实体间的高密度关联。 采购供应链涉及的核心实体包括供应商、物料、采购订单、入库单、质检报告、发票、付款计划。这些实体之间不是简单的一对多关系，而是多对多的网状关联。具体来说：一个供应商供应多种物料，一种物料从多个供应商采购——这是供应商和物料之间的多对多关系，需要一个供应商物料关联表来维护。一个采购订单分多次入库，一次入库对应多张发票——这是订单、入库、发票三者之间的复杂关联。一张发票可能涵盖多个采购订单的部分金额，而付款计划又跟发票的状态挂钩。在**数据库**层面，这种关系模型需要设计中间表、外键约束、级联更新策略，还得处理事务一致性和并发控制。假如采购订单删除时，关联的入库单和发票该怎么处理——是级联删除、置空还是阻止删除？这取决于业务规则，但业务规则本身是可能变化的。还有一个容易被忽视的问题：字段的校验规则和业务约束。"采购金额不能超过预算"这个约束，在数据库层面需要触发器和约束来实现，但"超过预算后走特殊审批流程"这个逻辑，数据层管不了，得交给流程层。数据模型设计和业务逻辑设计是交织在一起的，分开设计就容易出问题。传统开发模式下，仅数据建模阶段通常需要3到5个工作日。这还是在需求明确的前提下。如果需求本身在迭代——比如供应商评估维度从5个扩展到12个——数据模型的修改会波及整个应用栈：页面显示、表单校验、报表查询、集成映射，每一层都得跟着改。流程层的复杂度，来自业务分支的多样性和动态性。采购流程从来不是一条直线。正常采购走标准审批——申请人提交，部门主管审核，采购经理复核，财务确认预算，总经理审批。紧急采购走简化审批——跳过一些节点，但需要有紧急采购的申请理由和备案。退货采购触发的是另一套流程：质检确认，仓储接收，采购发起退货申请，供应商确认，财务处理退款。供应商索赔又不一样——涉及质检、法务、财务多部门协同，还有外部法律文书的流转。这些分支逻辑如果用BPMN2.0标准来建模，一个中等规模制造企业的采购流程图大约包含60到80个节点。每个节点需要配置：参与角色、操作界面、数据读写权限、超时处理策略、异常分支路径。编码实现的工作量在2000到3000行代码，这还不包括前端页面和测试用例。更麻烦的是，这些分支逻辑不是一成不变的。今天走标准审批的采购类型，下季度可能因为金额阈值调整而走另一条路径。紧急采购的定义——什么是"紧急"——可能随业务策略变化。而且这些变化往往是多个规则同时调整，牵一发而动全身。审批流还有一个天然的需求：可追溯。每一次审批动作、每一个节点的处理时间、每一次驳回的原因，都需要记录在案。这些审计日志不仅是合规要求，也是后续流程优化的数据基础。传统开发中，审计日志的实现方式五花八门——有的用数据库触发器，有的在代码里埋点，有的用AOP切面——但不管哪种方式，都需要额外的工作量和维护成本。**集成层**的复杂度，主要在于异构系统的协议差异和数据格式冲突。采购系统从来不是孤立运行的。它需要与多个外部系统交互：ERP同步物料主数据和供应商主数据，WMS对接入库预期和库存更新，财务系统交互应付账款和发票校验，供应商门户下发订单、确认交期，物流系统跟踪在途货物状态。这些系统的接口协议各不相同——SOAP、REST、JDBC、文件交换。数据格式也五花八门——XML、JSON、CSV、EDI。认证方式各有一套——BasicAuth、OAuth2、API Key、数字证书。每新增一个集成点，平均需要手写2000行左右的适配代码，涉及连接管理、协议转换、数据映射、错误处理、重试机制和日志记录。集成还有一个被低估的难点：数据一致性和事务边界。采购订单创建后，需要同步给ERP和WMS。如果ERP同步成功但WMS同步失败，订单状态应该怎么处理？是全部回滚还是部分成功？这涉及分布式事务和补偿机制的设计。传统开发中，这类问题通常靠消息队列和最终一致性方案来解决，但实现起来相当复杂，而且测试起来更复杂。这三层叠加在一起，一个中等规模的采购管理系统从需求到上线，周期通常在6到12周，后续维护成本是开发成本的1.5到2倍。每次业务变更，开发团队需要定位修改点、评估影响范围、回归测试，周期至少一周。这不是某一个环节的效率问题，而是整个开发范式的效率天花板。米缀AI低代码开发平台的做法，是把上述过程中的大部分工作交由AI自动处理。技术路径是：用户用自然语言描述业务需求，平台自动完成数据建模、界面生成、逻辑编排和测试运行。整个流程中，用户不需要编写代码，也不需要拖拽配置——这是零代码在AI时代的一种具体实现，平台的架构分为五层。交互层负责接收自然语言指令并将其转化为结构化意图数据。这一层处理的不只是简单的关键词匹配，而是语义解析和实体识别。当用户输入"创建一个采购订单管理模块，包含订单创建、提交审批、审批通过后自动生成采购单并同步给仓库"时，AI需要识别出：这是一个包含CRUD操作和审批流的模块，"采购订单"是核心实体，"审批"是业务流程的关键节点，"自动生成"和"同步"是触发动作。交互层还支持从文档中提取需求。用户可以直接上传现有的采购流程文档——可能是Word格式的流程图说明，也可能是Excel格式的字段清单——AI会自动解析其中的结构并转化为平台可处理的格式。这对于已有线下流程规范的企业来说，降低了迁移门槛。意图理解层对结构化需求进行深入解析，自动拆解出需要构建的功能模块及其依赖关系。以采购系统为例，AI识别出的模块包括供应商档案管理、资质审核流程、评分卡数据模型、采购申请审批流、订单生成逻辑、库存同步接口。这些模块之间存在依赖关系：订单生成依赖供应商和物料数据，库存同步依赖订单和入库数据。意图理解层会建立一张依赖关系图，确保生成顺序和测试覆盖都能遵循正确的依赖顺序。 这一层还涉及对隐含需求的理解。当用户提到"采购申请"时，隐含的需求可能包括：申请人信息自动填充、部门预算校验、审批人根据金额阈值自动路由。平台会基于开发知识库中的行业最佳实践，将这些隐含需求显式化，并生成确认项让用户核对。这样做的目的是减少需求理解阶段的歧义——这是传统项目中导致返工的主要原因之一。多智能体协作层是平台的关键机制。平台内置了五个专业AI Agent：需求分析Agent、功能设计Agent、前台构建Agent、后台构建Agent、测试Agent。需求分析Agent接收意图理解层的输出，进一步细化需求规格，生成功能需求文档和数据需求文档。它还会识别需求中的模糊点，生成问题清单反馈给用户确认。功能设计Agent基于确认后的需求规格，规划应用的功能模块划分、页面流转逻辑、权限体系设计。它输出的是一份应用设计方案，包含了模块结构图和页面路由设计。前台构建Agent和后台构建Agent并行工作。前台Agent生成响应式UI组件，后台Agent生成业务逻辑API。两个Agent通过共享的数据模型定义保持一致性，确保前后端接口的字段名、数据类型、校验规则完全匹配。测试Agent在前后端构建完成后自动介入，生成覆盖主要业务流程的测试用例——包括正常路径和异常路径。测试用例会模拟不同角色的操作——采购员提交申请、主管审批、财务复核——验证每个节点的权限控制和数据流转是否正确。这五个Agent不是各自为战的独立模块。它们基于统一的知识库和任务目标协同工作，每个Agent的输出作为下一个Agent的输入，形成了一条自动化的开发流水线。需求分析Agent的输出要符合功能设计Agent的输入规范，功能设计Agent的输出要能被前后台构建Agent理解，测试Agent的用例要覆盖所有Agent产出的功能点。这种协作机制通过Agent之间的接口契约和状态同步来保证。代码生成层将各Agent的输出转化为可执行代码。这里采用了大模型和小模型协同的架构。大模型负责复杂的推理和功能设计任务——比如理解用户的业务描述、生成数据模型和流程设计。小模型专注于代码生成和性能优化——比如将设计转化为具体的RESTful API实现、优化数据库查询语句。大模型消耗的Token成本较高，不适合高频调用。平台的设计是让大模型处理那些需要深层理解的决策性任务，一旦决策完成，后续具体的代码实现交给小模型来完成。这种"大模型定策略、小模型抓执行"的分工方式，在保证输出质量的同时也控制了运行成本。开发知识库在这层起到的作用是质量约束。知识库基于企业级项目经验构建，包含了数据模型设计规范、API设计规范、字段命名规范、索引策略、事务边界划分、日志规范等内容。生成代码时会参考这些规范，确保代码风格一致、结构清晰、易于后续维护。具体到采购系统的例子，当生成供应商评估功能时，知识库会提供标准供应商评估模型作为参考——包含基本信息、资质信息、财务信息、合作历史等模块，以及默认的评估维度打分机制。用户可以根据实际需求调整，但不需要从零开始设计数据结构。测试运行层在代码生成后自动执行测试。测试Agent生成用例后，在隔离环境中运行应用，模拟用户操作和数据流转，验证功能是否符合预期。测试结果会生成报告，标注通过和未通过的用例。对于未通过的用例，平台会尝试自动修复——分析错误日志，定位问题代码，重新生成并再次测试。如果自动修复失败，才会将问题标记为需要人工介入。 在传统开发模式中，测试是一个独立阶段，通常在开发完成后才开始，发现问题后再回到开发阶段修复，形成反复迭代。平台的做法是将测试前置并自动化——应用生成的同时测试就在运行，生成完成时测试结果已经出来。这种测试左移的做法减少了"开发等测试、测试等修复"的等待时间。测试运行层还有一个功能：性能基准测试。对于采购系统这种涉及数据查询和审批流转的应用，响应时间是关键指标。平台会自动执行并发查询测试，记录平均响应时间和吞吐量，如果发现性能瓶颈，会给出优化建议。采购系统的生成过程从需求输入到可运行版本，可以在30分钟内完成。我让平台跑了一遍上述的采购订单管理生成，实际记录的时间是28分钟，包含了从需求输入到应用可访问的全部流程。这个数字当然不包含需求确认和业务逻辑讨论的时间——那是人的工作——但代码生成的部分确实不需要额外等待。这个变化对项目协作的影响，值得展开说一说。项目协作的核心任务之一是任务拆解和分配。传统模式下，项目经理拿到需求后要拆解成具体开发任务：数据建模、前端页面、后端接口、集成对接、测试用例——然后分配给不同人员。一个中等规模的采购系统，任务拆解清单通常在50到80项，排期依赖关系复杂，项目经理的大部分精力花在了排期协调和进度追踪上。当平台自动完成应用生成后，任务拆解的对象从"代码开发"变成了"业务功能确认"。项目经理的职责从协调排期转向了确认业务逻辑——供应商评分卡的维度对不对，审批流程的分支条件准不准，集成映射的字段匹配是否完整。这更接近产品经理的工作性质，而不是项目调度员。具体来说，任务看板的构成会发生变化。传统项目看板上的任务项大多是技术性质的——"设计采购订单数据表"、"开发审批流接口"、"编写供应商同步脚本"。在平台上，这些技术任务被平台承担了，看板上呈现的任务变成了业务验证性质的——"确认采购订单字段清单"、"验证审批流程分支正确性"、"测试供应商数据同步结果"。任务数量从50到80项减少到10到15项，每项任务的完成时间从数天缩短到数小时。任务进度的更新方式也变了。传统模式下，开发人员每天花15到20分钟更新任务状态、填写工时、备注进度。在平台上，任务状态与应用的测试结果自动关联——测试通过的任务自动标记为完成，测试未通过的任务自动标记为阻塞并关联错误日志。进度更新从人工填报变成了系统自动同步。 还有一个容易被忽略的协作环节是代码审查。传统开发模式中，代码审查是保障质量的重要手段，但也是协作成本的来源之一——审查者需要理解代码的业务背景、检查代码规范、验证测试覆盖。当代码由AI生成后，代码审查的内容从"检查代码写得对不对"变成了"检查AI生成的逻辑是否符合业务预期"。审查者不再需要逐行检查语法和风格，只需要验证关键业务逻辑的正确性。对于采购系统来说，审查的重点会落在审批节点的路由条件、金额计算逻辑、集成数据的字段映射这些业务敏感点上。再来看跨组织协作这个具体场景。采购供应链系统天然涉及多个组织——企业内部有采购部、仓储部、财务部、质检部，外部有供应商、物流商、审计机构。传统模式下，外部角色的系统接入是个不小的工程——开通VPN、分配账号、培训使用、数据权限控制——每一步都有安全考量和沟通成本。平台内置了200多个预置连接器，覆盖了SAP、用友、Salesforce等主流企业软件，也支持MySQL、达梦等数据库的直连。供应商可以通过平台开放的API接口提交发货单、更新库存状态，不需要额外部署客户端。数据权限控制可以精确到字段级别——供应商能看到自己的订单和发货状态，但看不到其他供应商的信息和其他品类的采购价格。这个集成能力的配置方式同样不需要写代码。用户用自然语言描述"需要与现有ERP系统同步物料主数据，每天凌晨两点全量同步，平时增量同步"，平台会自动匹配对应的连接器，生成数据映射配置和同步调度策略。同步过程中如果出现字段格式不匹配或数据校验失败，平台会记录异常日志并触发告警通知。在采购系统这个场景里，跨组织协作还有另外一个维度——供应商的自主填报能力。传统的供应商管理方式中，供应商信息的更新依赖采购员手动录入，数据滞后且容易出错。平台生成的供应商门户界面允许供应商自主维护企业信息、上传资质文件、更新产品目录。这些数据变更会触发内部审核流程，审核通过后自动同步到ERP和WMS。这套机制从采购员的被动维护变成了供应商的主动参与，数据更新的时效性和准确性都有改善。实时协同是另一个对项目协作有实际影响的特性。基于OT（Operational Transformation）算法，平台支持多人同时编辑同一表单，操作实时同步，冲突自动解决。在采购系统的项目协作中，这个能力具体体现在几个方面。采购流程的定义本身就需要多人参与——采购经理定义业务规则，IT人员确认技术约束，合规部门审核流程合法性。传统模式下，流程定义是串行的，每个角色依次处理。在平台上，相关人员可以同时在线编辑同一份流程定义，各自的修改实时可见，冲突时平台自动合并或提示确认。流程定义的时间从串行的几天缩短到并行的几小时。供应商评估也是一个多人协作场景。不同部门对供应商有不同的评估维度——采购部关注价格和交期，质检部关注合格率和退货率，财务部关注账期和付款条件。传统模式下，这些评估数据分散在各系统里，汇总需要人工整理。平台上的供应商评估界面允许各部门同时录入数据，系统自动汇总并计算综合评分，项目经理可以实时查看评估进展和结果分布。数据填报中的协同编辑还有一个技术细节值得提一下：离线支持。当网络不稳定时，编辑操作会在本地保存操作日志，网络恢复后自动与云端同步合并。这在跨地域协作场景中比较实用——供应商在工厂车间填报发货数据时，可能网络条件不太好，离线支持能保证填报过程不被中断。再回到采购系统本身的运维阶段。系统上线后，业务规则仍然在持续变化。采购审批的金额阈值调整了，供应商评估的维度增加了，出口管制要求变了——这些变化在传统模式下都需要开发排期。平台上，运维人员可以直接用自然语言描述变更需求。比如："采购审批的金额阈值从10万调整为20万，20万以下走部门审批，20万以上走总经理审批。紧急采购的审批流程保持不变。"平台需要解析这个描述，识别出变更点：一个条件判断的值从10改为20，分支逻辑相应调整。然后自动修改审批流的条件节点配置，生成变更影响分析报告——列出受影响的页面、接口和数据表——在确认后自动部署变更。变更的追溯也变得更清晰。平台记录每一次变更的自然语言描述和对应的系统修改，形成完整的变更日志。当需要回溯某个业务规则的变更原因时，可以直接查看当时的描述记录，不需要翻代码提交记录去猜测当时改了什么、为什么改。采购系统的代码量可能还会继续增长——业务不会停止变化——但增长的逻辑变了。以前是开发人员在追赶业务，现在平台在辅助开发人员追赶业务。传统开发模式下，业务规则的变化触发的是完整的软件工程流程——需求分析、设计评审、编码实现、测试验证、上线部署。这个流程的时间消耗远大于实际的编码工作量。平台把编码和测试部分自动化之后，流程简化为"描述变更-自动生成-业务确认"三个步骤，时间消耗主要在于业务确认环节——而这恰恰是人的判断发挥作用的地方。米缀AI低代码开发平台的价值不在于"代码生成速度快"，而在于它把开发人员的精力从编写基础设施代码解放出来，转向了更有价值的业务逻辑设计和验证。代码生成是手段，让开发人员更好地理解业务才是目的。采购供应链这个场景比较有代表性——数据模型复杂、流程分支多、集成要求高、业务规则频繁变化。如果AI能在这个场景里证明自己有用，那么在复杂度相当甚至更低的场景里应该同样适用。 说到底，软件开发的本质不是写代码，而是把业务需求转化为可执行的逻辑。代码只是这个转化过程的中间产物。如果这个转化过程可以更直接——从自然语言到可运行逻辑，跳过中间的编码环节——那开发效率的提升就是结构性的，而不是线性的。零代码这个概念的真正含义，就是让这个转化过程对开发者尽可能透明。当然，平台目前还有边界。高度定制化的非标准功能、涉及复杂算法实现的模块、需要深度性能调优的场景，仍然需要专业开发人员介入。但采购供应链管理系统这类以数据流转和流程审批为核心的企业应用，恰好落在平台的能力范围内。这大概就是米缀AI低代码开发平台在项目协作场景中最实际的定位：把业务规则变化带来的重复性开发工作自动化，让开发人员和项目经理把时间花在理解业务和验证逻辑上，而不是追赶代码变更。

过去十年，国内制造业在信息化建设上的投入不可谓不大。MES、ERP、SCADA、QMS、PLM陆续上线，两化融合贯标从试点向全行业推进，智能制造能力成熟度评估也成了多数规上企业的标配。从资产角度看，制造企业已积累了相当规模的软件资产；但从运维角度看，这些资产大多以"黑盒"形式存在——交付即固化，每一次业务变化都意味着一次外部开发流程的重新启动。以生产质量控制为例。制造业的生产过程涉及大量的质量检验节点、工艺参数控制和追溯要求。当客户投诉某批次产品存在质量问题时，质量部门需要快速追溯该批次对应的原料批次、生产设备、操作人员、工艺参数记录等全链路信息。然而现实是，这些数据分散在MES、ERP、SCADA等多个系统中，追溯一次往往需要质量工程师花数天时间从不同系统导出数据、手工匹配、逐一排查。更棘手的是，当企业引入新设备或调整工艺路线时，现有的质量追溯链路往往需要同步调整——增加新的数据采集点、修改检验标准、更新追溯规则。信息部门在拿到需求后，不得不依赖原厂商的排期。厂商的开发队列里排着全国数十家企业的类似需求，一个看似简单的追溯字段调整，往往要等上数周甚至数月。期间，质量部门只能用手工方式处理追溯请求，差错率和人力成本同步上升。这不是个别厂商的服务问题，而是传统软件交付模式与制造业业务动态性之间的结构性矛盾。传统开发将"需求"与"代码"绑定得太紧，一旦需求变化，必须回到编码环节，而编码资源又不在企业内部。IT部门作为企业最懂业务的数字化力量，恰恰在系统演进上缺少灵活的自主手段。一个值得注意的现象是，国内多家制造企业IT部门的年度需求统计中，约六到七成属于中等及以下复杂度的流程调整、报表修改、权限变更和界面优化。这些需求在技术上并不复杂——生产监控看板上增加一个设备状态指标，质量追溯报表中增加一个字段，工艺参数的预警阈值调整一下——如果具备源码和开发环境，一个中级工程师半天到一天即可完成。但正是这些"小改动"，消耗了IT部门和厂商之间大量的沟通成本、排队时间和测试等待，最终使得平均响应周期被拉长至以"周"甚至"月"为单位。更深层的问题在于，这种"需求—排期—交付"模式不仅影响效率，还在潜移默化中改变了企业内部对数字化的态度。生产部门提需求的积极性在下降——因为知道提了也要等很久，不如先让班组长用Excel手工记录。IT部门的价值感在下降——因为大量时间花在了"催"和"等"上，而不是真正的系统规划和数据治理。企业管理层对数字化投入的回报预期在降低——花了钱上了系统，但业务一变化系统就跟不上，投入产出比难以衡量。要打破这个困局，必须缩短从需求表达到功能落地的路径，让业务语言能够直接驱动系统行为，而非经过多道翻译。这正是AI低代码开发平台进入制造业场景的根本逻辑。  从需求到应用：一个生产质量控制在AI应用构建中的完整路径理解AI低代码平台如何工作，最好的方式不是看架构图，而是跟踪一个具体的生产业务需求从提出到交付的全过程。假设生产质量部门提出需求："建立一个生产质量追溯系统。每个生产批次完工后，系统自动汇总该批次对应的原料批次、设备参数、操作人员、检验记录，生成一份完整的质量追溯报告。当客户投诉时，质量工程师输入产品批次号，即可一键查询该批次的全链路质量数据。"在传统开发模式下，这个需求需要经历以下环节：产品经理梳理需求、撰写需求文档；架构师设计数据模型和接口规范（涉及MES中的工单数据、SCADA中的设备参数、QMS中的检验记录）；后台开发工程师编写数据表和API（需要跨系统数据关联和聚合）；前台开发工程师设计查询页面和报告模板；测试工程师编写用例、执行测试；运维工程师配置环境、完成上线。六个角色、四到六周时间，这还是假设一切顺利、没有需求变更的情况。在传统低代码平台中，这类需求同样面临挑战。用户需要手动从组件库中拖拽表单组件、配置多个数据源连接、用可视化方式编写跨表关联查询逻辑、设计报告模板的布局和导出格式。学习曲线虽然比纯代码开发平缓，但仍然需要相当程度的平台熟悉度和技术理解。一旦涉及多系统数据聚合和复杂计算逻辑，拖拽配置的工作量和出错概率都会显著上升。而在一款以AI为核心的平台上，质量工程师只需要在AI应用构建界面中用口语化中文输入上述描述，后续过程完全由系统自动接管。该平台的处理链路分为五个层次：意图理解层随后将解析后的需求拆解为可执行的技术子任务：数据实体识别（批次主表、原料批次关联表、设备参数记录表、检验结果表、操作人员表）、页面结构规划（查询入口页面、追溯报告展示页、异常标记与处理页）、数据聚合逻辑定义（批次→原料批次→设备参数→检验结果的关联路径、时间范围的筛选逻辑、异常数据的标注规则）、集成点识别（从MES获取工单和批次信息、从SCADA获取设备运行参数、从QMS获取检验记录）。交互层首先接收用户的自然语言输入，进行语义解析和意图识别。这一步的关键在于理解用户的真实需求——不仅仅是字面意思，还包括隐含的业务规则和行业惯例。例如，"生产批次"隐含了需要引用工单系统和批次管理规则，"全链路质量数据"隐含了需要跨MES、SCADA、QMS等多个系统的数据聚合，"一键查询"隐含了需要高性能的查询接口和合理的缓存策略。代码生成层根据各Agent的输出，同步生成完整的后台界面代码、RESTfulAPI接口、数据库DDL脚本、权限配置文件和应用运行描述文件。所有代码均基于平台内置的开发知识库——该知识库沉淀了二十年以上的企业级开发经验和制造行业最佳实践——确保输出的代码在可维护性、安全性和性能方面符合企业级标准。多智能体协作层随即并行启动四个专业Agent：需求分析Agent生成结构化的任务清单和验收标准，确保需求理解没有遗漏；功能设计Agent规划模块边界、数据流和权限矩阵，输出应用的整体架构方案；后台构建Agent生成符合工业场景操作习惯的响应式页面和业务逻辑API，包括多条件组合查询、跨系统数据聚合、报告自动生成、异常数据标注；测试Agent则自动生成覆盖主路径和异常分支的测试用例——输入存在的批次号应返回完整报告，输入不存在的批次号应给出明确提示，跨系统数据源不可用时应有降级处理——并执行自动化回归验证。测试运行层完成自动化联调验证，包括接口连通性测试、跨系统数据一致性校验、权限隔离验证和性能基准测试（批量批次查询的响应时间应满足SLA要求）。验证通过后，应用即可发布为正式运行版本。整个流程从需求输入到可操作版本上线，耗时在四十分钟以内。全程不需要编写一行代码，也不需要任何拖拽组件的操作。这便是零代码在该场景下的真实含义——开发行为本身归零，AI承担从需求解析到代码生成的全部技术工作。更关键的是后续演进能力。当质量部门在实际使用中发现，部分客户要求追溯报告中增加"该批次生产当日的环境温湿度记录"，只需在原需求描述后补充一句："追溯报告中增加生产当日车间温湿度数据，从环境监测系统获取。"AI即时解析变更，自动识别需要新增的数据源——环境监测系统——以及对应的关联键（生产日期和车间编号），并同步更新数据模型、查询逻辑和报告模板。原数据表结构通过扩展字段而非重构的方式保留，历史追溯报告不受影响。这种持续演进的灵活性，是传统开发和普通代码生成工具难以实现的。从技术实现的角度看，这种能力依赖于平台"大模型+小模型"的协同架构。大模型（LLM）负责复杂的推理和功能设计——理解用户的自然语言需求、拆解为技术任务、规划系统架构——这部分需要大模型的跨域知识和推理能力。小模型（SLM）则专注于高精度的代码生成和性能调优——生成符合规范的数据库DDL、编写高效的跨系统数据聚合API、优化大数据量查询的响应性能——这部分需要的是专业领域的精准执行，而非广泛的通用知识。两者分工协作，兼顾了理解的深度和执行的精度。  从"等厂商排期"到"自主构建"：IT部门职能的结构性迁移在已引入AI低代码开发平台的制造企业中，IT部门的运作方式正在发生三个方向的变化。这些变化并非理论推演，而是实际运行数月后可观察到的趋势。变化1：人力从被动维护转向主动规划。日常的增删改查类需求被AI接管后，工程师们开始有精力投入之前想做但排不上日程的工作：梳理企业数据资产目录、优化核心系统的数据质量、参与生产工艺优化模型的设计、探索基于实时数据的运营监控看板。有制造企业IT负责人做了一个粗略的统计：平台使用半年后，团队投入到"主动规划类工作"的时间占比从不足15%提升到了接近50%。这意味着在不增加编制的前提下，IT部门实现了内部资源的重新配置。一个更值得关注的细节是，IT工程师的工作满意度也在提升——没有人愿意长期做重复性的"改报表、调字段"工作，当工程师们能够参与更有创造性的系统规划和数据治理时，团队的稳定性和积极性都会改善。变化2：需求响应从批处理变为即时处理。传统模式下，IT部门通常累积一批需求后统一提交厂商，单个需求的等待时间被人为拉长——不是因为IT部门不想快，而是因为每一次提交都需要整理文档、沟通确认、跟踪进度，批次处理是唯一可行的方式。而在AI应用构建模式下，IT工程师面对新需求时只需要判断两点：是否涉及核心系统底层数据结构的变更——如果是，仍需要遵循数据治理的规范流程，因为核心数据模型的变更会影响多个系统；如果不涉及底层变更，则直接在平台上通过自然语言生成或调整应用，与业务部门现场确认逻辑后即可发布。需求响应周期从以"周"计缩短为以"小时"计，这个变化带来的不仅是效率数字的改善，更是IT部门与业务部门之间关系的重构。当生产部门发现"今天提的需求明天就能用上"，他们对数字化的信任度会明显提升。信任度提升后，业务部门会更主动地梳理自己的管理流程、提出更有价值的数字化改进方案，形成正向循环。有企业IT部门反馈，平台上线后，业务部门主动提出的数据治理类需求——而非简单的流程调整类需求——占比从不足10%上升到了30%以上，这意味着业务部门开始把IT部门当作"数据合作伙伴"而非"系统修理工"。变化3：业务部门从需求提出者变为共建者。在平台"导师模式"下，AI以引导式、低Token消耗的方式辅助用户快速构建应用，操作门槛极低。质量部、生产调度中心、设备管理科等具备一定信息素养的部门，在经过IT部门授权后可以直接使用AI应用构建功能，自行生成符合本部门管理需求的轻量级工具。IT部门的角色则从"开发者"转变为"平台管理员"——负责制定应用规范、审核数据权限、监控运行质量、处理跨部门的数据共享需求，而不再需要为每一个业务部门的个性化需求投入开发资源。这种转变符合一个行业共识：企业数字化的未来，不是IT部门包办一切，而是IT部门赋能全企业，让每个业务单元都具备一定的数字化能力。当然，这种转变也带来新的管理课题：如何确保业务部门自建应用的数据安全？如何避免应用质量参差不齐？如何防止数据孤岛在新的层面上重新形成？这些问题的答案在于平台本身的治理能力——统一的权限体系、统一的数据字典、统一的审计日志、统一的应用发布流程——使得IT部门能够在"放权"的同时保持"可控"。  存量系统互联：AI应用构建中的数据集成能力对于系统庞杂的制造企业，任何新平台如果不能与现有MES、ERP、SCADA、QMS等核心系统打通，都只是新增一个孤岛。这是IT负责人在面对新平台时最关心的技术问题，也是最容易被忽视的隐性门槛。米缀AI低代码开发平台的集成引擎内置200余个预置连接器，覆盖主流数据库（Oracle、SQLServer、MySQL及达梦、人大金仓等国产数据库）、工业系统接口（支持与MES、ERP、PLC等系统集成）和标准REST/SOAP协议。AI在生成应用时，会自动分析需求中的数据来源意图，推荐最优集成路径，并生成字段映射和同步策略。以前述质量追溯系统为例，AI在解析"自动汇总该批次对应的原料批次、设备参数、操作人员、检验记录"时，会检索已配置的数据源，判断批次主数据位于MES系统、设备参数位于SCADA系统、检验记录位于QMS系统，随后生成对应的只读查询接口，并在后台完成跨系统的数据关联和聚合逻辑。IT工程师只需确认数据源和映射关系是否正确，无需编写任何数据库连接字符串或SQL代码。对于更复杂的跨系统数据融合——如将MES的工单和批次信息、SCADA的设备运行参数、QMS的检验记录、ERP的物料信息整合为一份完整的产品质量档案——平台的数据流引擎支持可视化ETL/ELT编排，自动调度多源数据的抽取、清洗、转换和加载。数据流引擎的核心能力包括：实时与批量双模式运行，满足不同场景的数据时效性要求；可视化拖拽式编排，降低数据管道构建的技术门槛；内置50余种数据处理器（过滤、聚合、连接、计算等），覆盖常见的数据加工需求；支持Python、JavaScript等脚本语言嵌入，满足复杂转换逻辑的定制需求。所有数据流转过程自动生成血缘图谱，每一笔数据的来源、变换路径和消费方清晰可查，满足质量追溯合规审计要求。在集成架构层面，平台采用"连接器+数据采集+开放API"三模并行的设计。连接器模式提供开箱即用的系统对接能力；数据采集模式支持双向实时同步和智能清洗，打通数据孤岛；开放API模式则将平台内的应用、数据、流程标准化为RESTfulAPI，支持灵活的生态集成。这种三层架构确保了平台既能"接入"现有系统，也能"暴露"自身能力，实现双向的互联互通。  安全与合规：ID化脱敏解决大模型数据外泄顾虑工业数据安全是制造企业采用任何AI类平台的首要前提，也是讨论最多、顾虑最集中的环节。IT负责人最常问的一个问题是：大模型需要数据才能工作，但生产数据、工艺参数、客户信息不能出企业，这怎么解决？该平台采用了一套ID化脱敏传输机制。在与大模型交互时，所有涉及产品名称、客户信息、供应商信息、具体工艺参数等敏感字段在离开企业内网之前，自动替换为内部唯一标识ID。大模型在整个推理和代码生成过程中只接触到脱敏后的ID数据——它知道"产品ID_P001需要关联工艺参数ID_Param003"，但不知道P001对应的具体产品名称和客户信息。真实信息始终停留的企业可控环境内。大模型返回结果后，平台再将ID还原为原始数据呈现给终端用户。这套机制的核心价值在于：企业可以利用大模型的推理能力完成复杂的应用设计和代码生成，但不需要将任何真实的生产数据或客户信息暴露给外部模型服务。对于对数据主权有严格要求的制造企业而言，这是能否使用AI类平台的前提条件。在更细粒度的数据安全层面，平台提供菜单级、数据行级、字段级和操作按钮级的四级权限体系。以生产质量控制场景为例：一线操作工只能查看和录入自己负责工序的检验数据；班组长可以编辑本班组的质量记录；质量部经理拥有全厂质量统计权限；而外部审核人员只能查看脱敏后的汇总报表，不能查看具体产品信息和客户信息。所有操作行为均记录在审计日志中，支持按时间、用户、操作类型、影响数据范围等多维度追溯。数据传输全程采用TLS1.3加密，存储采用AES—256加密算法，密钥独立管理。平台在安全合规方面已通过等保2.0三级认证，符合数据安全法、个人信息保护法以及GDPR合规要求。在信创适配方面，平台已完成与鲲鹏、海光、飞腾等国产CPU架构、麒麟和统信UOS等国产操作系统、达梦和人大金仓及高斯等国产数据库、东方通和金蝶天燕等国产中间件的全面兼容测试。平台生成的应用默认运行于全信创技术栈，无需二次适配。对于正在推进信创替代的制造企业而言，这意味着在获得AI开发能力的同时，不需要额外承担技术栈异构带来的适配成本和风险。成本视角：从项目制到平台制的财务重构从企业管理者角度看，该平台的价值不仅体现在效率提升，更体现在成本结构的根本性改变。传统模式下，企业数字化建设遵循"项目制"逻辑：每个管理系统——无论是质量追溯、设备管理、还是生产监控——都需要独立立项、招标、开发、测试、验收、维保。一个中等复杂度的生产质量管理系统，定制开发费用通常在数十万到上百万元之间，后续每年维保费用为合同额的10%到15%。当工艺或质量标准变化要求系统修改时，厂商通常将非合同约定的修改视为新需求，额外计费。累计三到五年，一个系统的总拥有成本（TCO）往往是初始采购价的2到3倍。更重要的是，项目制模式下，企业购买了一次性的"软件成品"，而非持续的"软件能力"。成品交付后即进入固化状态，下一次需求变化时又开始新一轮的立项、招标、开发循环。这种模式的本质问题在于：企业正在为"变化"反复付费，而不是在为"能力"一次性投资。平台制模式则完全不同。企业获得的是平台本身的使用授权，而非单个应用的建设合同。在授权周期内，企业可以在平台上无限量构建和运行应用，每一次需求变更和功能迭代都不产生额外的开发费用。从财务角度看，这不是"买一个系统"，而是"建一条生产线"——有了生产线之后，生产多少个产品、修改多少次设计，边际成本趋近于零。平台支持生产计划管理、工单管理、物料管理、设备管理、质量管理等关键业务场景的应用搭建，可实现生产流程的全流程数字化管控。企业可根据自身业务重点，优先部署最迫切的模块，后续根据管理需求逐步叠加设备联网、质量追溯等增值功能，避免传统开发中常见的过度建设问题。粗略估算，一家中型制造企业每年在内部管理类系统的外包开发和维保上的支出通常在百万元级别，其中约六成属于中等及以下复杂度的流程和报表类需求，理论上可由平台承载。直接财务节省之外，隐性收益更值得关注：当IT部门从被动维护中释放，企业内数据分析类项目的立项数量显著增加——有企业IT负责人反馈，平台上线后，内部新立项的数据分析类项目数量比前一年翻了一番。这并非因为预算增加了，而是因为人力从日常维护中被释放出来，有了思考和规划的空间。  结语：让懂业务的人定义技术制造业数字化转型走到今天，硬件和基础系统已不再是短板，真正的瓶颈在于系统对业务变化的响应速度。米缀AI低代码开发平台所提供的，不是一套更快的开发工具，而是一种新的技术生产关系——让最了解生产业务的质量部门、设备管理部门和生产调度中心，能够直接用自然语言驱动系统演进，不再被厂商排期和代码壁垒所钳制。这种转变的技术本质，是将"需求→设计→编码→测试→上线"这条传统长链路，压缩为"需求描述→AI全自动生成→人工确认"的短链路。压缩的关键在于AI承担了中间所有技术翻译和执行工作，而业务人员只需要做自己最擅长的事——描述业务。当一名IT工程师可以把精力从"改一个查询条件"转向"梳理企业数据资产目录"，当一名质量工程师可以在半小时内把头脑中的追溯逻辑变成可用的工具，数字化才真正从"支撑业务"走向"驱动业务"。这不仅是效率的提升，更是企业数字化能力的范式转移：从"购买成品软件"到"自主定义系统"，从"被动等待厂商"到"即时响应变化"。当然，任何技术平台都有其适用边界。对于涉及核心生产工艺控制、需要国家级认证的工控类系统，仍然需要严格的工程规范和认证流程。但对于制造企业日常管理中大量存在的流程类、报表类、协作类应用需求——生产监控看板、质量追溯报表、设备巡检记录、工艺参数优化分析——AI低代码开发提供了一条前所未有的高效路径。这条路径是否适合每一家企业，取决于企业自身的数字化战略和团队能力。但有一点是确定的：当业务变化的速度越来越快，而传统开发模式的响应速度越来越跟不上时，探索新的技术范式就不再是一个选择题，而是一个必答题。

前段时间在一个AI工具合集站（dy.877ai.cn）上翻Claude 4.6的开发者反馈，发现一个让我有点共鸣的评价：“用了Claude 4.6之后，GPT-4o的打开频率断崖式下降，现在一周打开不了一次。”下面跟了一串“+1”的回复。作为一个ChatGPT Plus连续付费两年多的老用户，我对GPT-4o一直有感情。它陪我写了无数代码，帮我解决了数不清的技术问题。但过去一周我发现自己也在经历同样的变化——GPT-4o的对话框安安静静地躺在那里，而Claude 4.6的使用频率一天比一天高。这个转变是怎么发生的？我复盘了一下。一周前的AI使用格局先交代一下我之前的使用习惯，方便你判断这个变化的参考价值。我的日常工作以Go后端开发为主，偶尔写Python脚本和React前端。AI使用场景按频率排：代码生成与调试最多，其次是技术文档阅读和分析，然后是技术方案设计和评审，最后是代码审查。一周前我的AI工具分工是这样的：Gemini 3.5 Flash负责日常快速代码生成和文档翻译，它的速度让我愿意随时提问。GPT-4o负责需要深度推理的任务——架构设计评审、多模态图像分析、复杂的跨文件代码生成。偶用Claude 3.5 Sonnet做代码审查。GPT-4o在我工具链里的位置是“复杂任务处理器”。日常琐事找Gemini，遇到真正需要思考的问题才开GPT-4o。什么变了：三个关键任务上的差距变化不是突然发生的，而是在几个具体任务的体验对比中慢慢积累的。第一件事是审查一段Go并发代码。这段代码实现了一个Worker Pool，大约200行，我知道里面埋着三个并发安全问题。我先扔给了GPT-4o。它找到了其中两个，漏了一个——一个map在goroutine间共享时没有加锁，它标注了“可能存在并发风险”，但没有给出具体会触发什么问题的分析。我需要自己推断严重程度，再决定要不要改。同样的代码给Claude 4.6。它找到了全部三个问题。对于GPT-4o漏掉的那个，它不只是标注“这里有风险”，而是追踪了这个map被哪些goroutine访问、在什么时序下会触发数据竞争、以及可能导致的后果。更让我意外的是它在审查过程中的行为——它一开始标注了一个sync.Mutex保护的map可能存在并发读，但继续往下审时发现这个读操作在锁的保护范围内，于是在报告末尾主动更正了之前的标注，说明“此前的并发风险标注不成立，予以撤回”。这个“自修正”行为直接改变了我对AI审查意见的处理方式。GPT-4o的审查报告，我需要逐条验证——它有时候会误报，有时候会把一个问题的严重程度夸大或缩小。验证的过程几乎和人工审查一样耗时。Claude 4.6的报告，我开始逐渐减少验证频率，因为它在审查过程中已经自己过滤了一遍。第二件事是分析一个分布式系统的Raft脑裂问题。这个问题有三个层面的信息需要关联：网络分区的时序、Leader选举的超时配置、日志复制的状态。GPT-4o给出的分析覆盖了网络分区和选举超时，但在日志复制的状态推断上有一个逻辑跳跃——它从一个日志条目的存在推断出另一个节点的状态，但这个推断成立的前提条件没有被检查。Claude 4.6的分析路径是：先做排除，把不可能的方向过滤掉。然后把可能方向拆成几个子方向，逐一推演。每个推演步骤都写了依据——不是“可能是这样”，而是“根据题面中‘Follower未触发选举’这个约束，可以排除通信中断的可能性”。整个推理链路有四个层次，每一层都建立在前一层的基础上。倒不是说Claude 4.6的最终结论比GPT-4o更正确——两者都得出了正确的根因判断。但推理过程的透明度有差距。GPT-4o跳过了一个前提条件的检查，这个跳步不影响最终结论，但让我对它的推理过程产生了一丝不确定。Claude 4.6的完整链路让我敢直接采信它的结论。信任是一次次的“它说得对”积累起来的，也是一次次的“它这里跳了”消耗掉的。第三件事是写一份技术方案文档。我给它一段需求描述和几个约束条件，让它出初稿。这份文档需要包含需求分析、方案对比、详细设计和风险评估四个部分。GPT-4o的初稿在我规定的框架内填得很好，每个部分都覆盖了。但Claude 4.6多做了一件事：它在风险评估部分主动标注了一个我没想到的风险点——某个第三方服务的调用频率限制可能会在活动高峰期触发，需要在方案中增加降级策略。这个风险点不在我给的任何材料里，是它基于“这个方案依赖了外部服务”这个事实自己推断出来的。GPT-4o也能给出有价值的风险评估，但它通常需要我在Prompt里明确要求“请分析外部依赖的风险”。Claude 4.6则更倾向于自己判断这个方案里有哪些值得提醒的隐藏风险。这三个任务的共同指向是：Claude 4.6在我日常工作中最需要“思考”而非“执行”的环节上，表现更接近一个可以信赖的协作者。GPT-4o的优势在于响应速度和多模态，但在需要深度推理和严谨审查的场景下，两者之间出现了可感知的差距。不是GPT-4o变差了，是使用场景重新分配了GPT-4o没有被闲置。多模态任务——架构图转代码、UI截图生成页面、ER图转DDL——我仍然在用GPT-4o，它在这方面的精度仍然领先。快速代码片段生成我仍然用Gemini 3.5 Flash，它的速度无可替代。GPT-4o减少的，是那些“需要认真思考”的场景。以前遇到复杂Bug排查、代码审查、架构评审、技术方案评估，第一反应是“开GPT-4o”。现在变成了“开Claude 4.6”。这个切换不是因为GPT-4o在这些场景下变差了，而是因为Claude 4.6的表现更让人放心——它的推理链路更完整，审查意见更少需要二次验证，方案输出更严谨。角色从“唯一的主力AI”变成了“多模态专用AI”。不是在降级，而是在重新分工。一周后的新格局一周下来，我的AI工具分工变成了这样：Claude 4.6负责所有需要深度推理的任务——代码审查、复杂Bug排查、技术方案设计、架构评审、技术学习。这是我日常工作中最需要“思考”的环节，也是它价值最明显的场景。GPT-4o退居多模态专用——图像识别、UI截图转代码、ER图分析。这些任务它仍然是最强的，而且和Claude 4.6形成了互补：一个深度思考，一个广度覆盖。Gemini 3.5 Flash保持快速响应——日常代码片段、文档翻译、简单问答。它在这个位置上无人能替，因为速度优势太明显。三个模型各司其职，Claude 4.6的加入填补了“严谨推理”这个生态位。这个位子之前是GPT-4o在兼任，但它不是一个专门的推理模型，在推理深度和透明度上和Claude 4.6有天然差距。Claude 4.6出现后，这个位子终于有了专职选手。这也带来一些思考Claude 4.6的风格不是所有场景下都是优点。它的“严谨”有时候会表现为“过于谨慎”——在一些不需要过度推理的简单任务上，它会给出比GPT-4o更长的推理过程，生成速度也会慢一些。如果你只是要一个快速答案，这个风格反而显得啰嗦。还有一点，Claude 4.6对复杂推理任务的处理速度略慢于GPT-4o。不是明显的慢，但在连续等待时会有所感知。这个差距对于需要高强度连续交互的场景会有影响。另外，Claude 4.6的多模态能力虽然相比前代有提升，但在精度和响应速度上和GPT-4o仍有差距。上传架构图进行分析时，GPT-4o的识别准确率和速度都更强。这些都不是致命问题，但决定了Claude 4.6和GPT-4o之间不是简单的替代关系。更准确的说法是：两者重新分工，各做各最擅长的事。一周下来，我对这次AI工具格局变化的感受是：GPT-4o没有被淘汰，但它不再是我打开AI时的默认选项。日常默认变成了Claude 4.6，GPT-4o和Gemini在特定场景下被调用。这个变化来得比预期快，但仔细想想，它不是一次突变，而是一周里一次又一次“这个任务用Claude更好”的选择积累起来的结果。你的AI使用格局最近有变化吗？有没有哪个模型从主力变成了备胎？评论区聊聊。

怎么上传图片呢，根据ui图片生成怎么上传图片呢，根据ui图片生成怎么上传图片呢，根据ui图片生成

随着人工智能技术的飞速发展，生成式AI（Generative AI）已经从一个科幻概念变成了现实。其强大的创造力和多样化的应用场景，正在重新定义各行各业的工作方式和创新模式。今天，我们来聊一聊生成式AI如何推动各个领域的变革，带来令人惊叹的变化。欢迎大家在评论区留言讨论哦~

AI写作已经不再是科幻电影里的概念，它正逐渐渗透到我们的日常工作中。作为一种工具，它既能提升效率，也带来了一些争议。AI写作并非要取代人类，而是辅助我们更好地完成内容创作。你在使用AI写作时，遇到的最大挑战是什么？欢迎在评论区分享你的经验。

一、华为云产品与DeepSeek技术融合价值华为开发者空间为开发者提供了一站式云原生开发环境，整合了昇腾AI算力、鲲鹏处理器等根技术资源。结合华为云MaaS（大模型即服务），开发者可快速调用DeepSeek-R1/V3等开源大模型，实现从代码生成到部署的全流程优化。DeepSeek的RLHF（基于人类反馈的强化学习）技术显著提升了代码生成的逻辑性和实用性，尤其在金融领域，其处理复杂业务逻辑和数据处理需求时表现突出。二、开发环境搭建与DeepSeek部署1. 开发环境准备华为云账号：完成实名认证后云主机部署：在开发者空间创建云主机（注意不要选择ARM型主机，内存4G以上），安装Ubuntu 22.04系统。DeepSeek部署：通过ollama工具部署DeepSeek-R1:1.5B模型，命令：bashcurl -fssl https://ollama.com/install.sh | shollama run deepseek-r1:1.5b验证模型：输入你好，<think>触发交互式问答。2. DeepSeek Token获取登录华为云MaaS控制台，进入“模型推理-旧版服务”，选择DeepSeek版本并领取200万免费Token，用于后续API调用。三、智能代码生成助手开发实践1. 功能设计场景：金融领域自动化代码生成。技术架构：前端：HarmonyOS NEXT应用（DevEco Studio 5.0.9）集成CodeGPT插件，调用DeepSeek API。后端：云主机部署DeepSeek模型，通过RESTful API与前端交互。知识库：基于RAG技术构建金融领域代码片段库，提升生成准确性。2. 关键代码实现python代码生成服务接口from flask import Flask, request import openai app = Flask(__name__) openai.api_key = "DeepSeek-API-Key" 从华为云MaaS获取 @app.route('/generate_code', methods='POST') def generate_code(): prompt = request.json'prompt' 调用DeepSeek生成代码 response = openai.Completion.create( engine="deepseek-r1", prompt=prompt, max_tokens=1000 ) return {'code': response.choices0.text.strip()} if __name__ == '__main__': app.run(host='0.0.0.0', port=5000) 代码说明：通过Flask搭建API服务，集成DeepSeek的代码生成能力，支持自然语言指令转代码。3. RAG知识库构建数据集准备：收集金融领域GitHub开源项目代码（如量化交易策略、财务报表分析脚本）。向量索引生成：from langchain.vectorstores import Chromafrom langchain.embeddings import OpenAIEmbeddingsembeddings = OpenAIEmbeddings(api_key=“DeepSeek-API-Key”)database = Chroma.from_documents(code_dataset, embeddings)检索优化：通过昇腾云的稀疏路由算法提升检索效率，响应时间降低30%。四、应用效果与优化1. 实操展示输入指令：“生成基于Python的移动平均线策略代码，支持TA-Lib库调用。”输出示例：import talibimport pandas as pddef moving_average_strategy(data, short_window=5, long_window=20): signals = pd.DataFrame(index=data.index) signals'signal' = 0.0 signals'short_mavg' = talib.SMA(data'close', short_window) signals'long_mavg' = talib.SMA(data'close', long_window) signals'signal'short_window: = np.where(signals'short_mavg'short_window: > signals'long_mavg'short_window:, 1.0, 0.0) return signals 2.后续优化低代码扩展：通过Dify框架构建可视化界面，支持非技术人员配置生成规则。本次实践验证了华为开发者空间与DeepSeek在金融领域的协同价值，未来 结合华为云ModelArts Studio实现自动化部署，探索多模态代码生成（如结合金融数据图表生成分析脚本）。我正在参加【案例共创】第3期：基于华为开发者空间+DeepSeek实现智能代码生成助手 --金融领域代码自动化实践

一、技术融合价值与背景华为云与DeepSeek的合作为智能体开发提供了“大脑+手脚”的黄金组合：DeepSeek：作为语言基座，擅长需求理解与框架生成（中文问答准确率64.1%），可快速输出代码框架Manus：作为执行引擎，支持快速任务拆解，能自动调用浏览器、Excel等工具完成复杂流程华为云生态：通过ModelArts Studio提供昇腾算力支持，推理速度较GPU提升30%二、开发环境搭建1. 资源准备华为云账号：完成实名认证后，免费领取DeepSeek相关免费Token- 模型部署：在ModelArts Studio领取DeepSeek-R1-671B-4K模型（200万免费Token）通过ollama工具部署模型，命令：bashcurl -fssl https://ollama.com/install.sh | shollama run deepseek-r1:1.5b2. 工具链配置Dify编排平台：配置OpenAI-API兼容供应商，填入华为云模型API地址（需去掉/v1/chat/completions）Manus Studio：安装插件支持华为云API调用，设置执行超时阈值（建议300秒）三、智能体开发实践1. 功能设计场景：企业级软件开发自动化（如API接口开发、测试用例生成）技术架构：A用户需求 --> B(DeepSeek需求解析) B --> C{Manus任务拆解} C --> D代码生成 C --> E测试用例生成 D --> F代码部署 E --> F F --> G结果反馈 2. 关键代码实现python需求解析接口from flask import Flask, request import openai app = Flask(__name__) openai.api_key = "DeepSeek-API-Key" @app.route('/parse_demand', methods='POST') def parse_demand(): prompt = request.json'prompt' response = openai.Completion.create( engine="deepseek-r1", prompt=prompt, max_tokens=1000 ) return {'tasks': response.choices0.text.strip().split('\n')} 任务执行引擎 import subprocess def execute_task(task): if task'type' == 'code': subprocess.run('python', 'code_generator.py', task'params') elif task'type' == 'test': subprocess.run('pytest', task'params') 多智能体协作yaml协作配置文件smart_agents: - name: code_generator type: deepseek api_key: "your_deeepseek_token" - name: test_executor type: manus tools: - pytest - Selenium --- 四、应用效果与优化1. 实操案例输入指令：“开发用户登录API，支持OAuth2.0认证”输出流程：DeepSeek生成代码框架（耗时5秒）Manus自动创建Git分支并提交代码（耗时12秒）调用Postman生成测试用例（耗时8秒）部署至华为云函数计算（耗时30秒）性能优化昇腾加速：将模型推理部署至昇腾超节点，提升响应速度成本控制：通过华为云弹性伸缩策略，闲时自动释放GPU资源安全加固：启用华为云密钥管理服务（KMS）加密API密钥五、总结与展望本次实践验证了华为云+DeepSeek+Manus的技术组合优势：不但提升代码开发效率，而且华为云MaaS与ModelArts Studio提供稳定运行环境，支持企业级应用落地，未来会继续探索与华为云IoT、GaussDB的深度集成，构建端到端智能体。我正在参加【案例共创】第3期：基于华为云+DeepSeek打造企业级智能体开发实践 ——从需求拆解到自动化执行的技术链路

Manus 比起传统的AI Agent厉害在哪里？为什么能继deepseek之后引起这么大轰动？

   当华为云正式推出Deepseek智能体开发平台时，我意识到这可能是改变AI应用开发范式的重要转折点。作为长期关注AI大模型的开发者，我立即申请了体验资格，希望通过实战验证：这个宣称能'降低AI开发门槛'的平台，是否真能帮助开发者快速构建企业级智能体？下面我就带大家一起体验一下。一、准备工作1. 注册并登录华为云账号：前往华为云官网（华为云官网），注册并登录您的账号。2. 申请免费Deepseek的Token额度：在华为云服务列表中，找到并开通Model Arts Studio服务。在模型广场中找到DeepSeek R1并在操作中选择领取。3. 华为云Deepseek体验如果想直接使用这个部署在华为云上的Deepseek，直接点击体验即可。200万的免费TOKEN足够用一段时间了。在目前Deepseek官网全面爆满的情况下，在华为的昇腾平台上体验Deepseek效果也还不错。但是由于这个模型并不是全尺寸的，因此整体还不能和满血版的Deepseek R1相提并论。四、使用DIFY编排工具构建基于Deepseek的AI智能体首先说明一下这个基于Deepseek的智能体和基于其它大模型的智能体没有任何区别，全面的步骤指引大家也可参考我之前的文章，下面我仅简要对相关步骤进行梳理。《【案例共创】基于华为云Model Arts Studio及DIFY编排工具，创建AI智能体的攻略_社区活动_华为云论坛》1. 获取模型API KEY：在操作中选择"调用“并把弹窗中的API KEY复制下来1. 配置模型供应商：点击右上角“设置”，进入模型供应商页签。选择“OpenAI-API-compatible”供应商，并填入Model Arts Studio中获取的模型名称、API Key和API地址（注意删除最后面的“chat/completions”部分）。2.创建并编排AI智能体：在DIFY中，点击“工作室”，选择“从空白创建”。选择应用类型，如“聊天助手”，并给应用起一个名字、选择合适的图标和描述。创建完毕后，进入编排界面。填写提示词，用于约束AI给出专业的回复。可以使用内置的提示生成器，并插入自定义变量。添加开场白和上下文，以提升用户体验和对话的精准度。如果需要，可以在“上下文”内引用知识库，以限制AI对话的范围。3. 测试并发布AI智能体：在编排完成后，通过右侧的对话框进行测试，确保效果符合预期。如果效果可行，选择“发布”保存所有编排。发布后，可以在DIFY平台中看到一个完整的AI智能体应用。 三、总结通过本文的介绍，相信对于如何运用基于华为云的Deepseek模型大家已经有了初步的了解，通过本次实践，我认为Deepseek正在推动两个重要转变：一是将大模型能力真正转化为可落地的生产工具，二是重构传统AI开发流程。建议开发者重点关注其与华为云IoT、GaussDB等服务的联动可能性，这可能是构建企业级AI中台的关键路径。我正在参加【案例共创】第1期 书写云产品应用构建开发最佳实践/评测，共创官方文档cid:link_1

如何用AI能识别评论是否有恶意？有好的解决办法吗   谢谢谢谢

一、前言在人工智能技术日新月异的今天，构建和运行一个AI智能体已经成为许多开发者和企业的需求。本文将详细介绍如何利用华为云Model Arts Studio及DIFY编排工具，快速构建并运行一个AI智能体。注：目前在华为云的官网上有很多大模型可以免费体验。二、准备工作1. 注册并登录华为云账号：前往华为云官网（https://www.huaweicloud.com/），注册并登录您的账号。2. 开通Model Arts Studio服务：在华为云服务列表中，找到并开通Model Arts Studio服务。目前有很多大模型可以申请到免费使用的TOKENS。3. 部署DIFY平台：这里推荐用华为云Flexus X实例，一键部署DIFY平台，注意计算规格不要低于C7.xlarge.2。三、使用Model Arts Studio部署大语言模型使用1. 选择并定制大语言模型：登录Model Arts Studio平台（目前仅华东二区域支持）。在模型广场选择您想要使用的大语言模型，如“qwen2-72b”，并点击“微调”，在正式创建前对于该模型进行微调。2. 创建并配置模型：点击左上角“创建模型”，在弹出窗口中自定义模型名称，并选择使用推荐权重文件。配置好后点击“创建”。3. 部署模型：点击右上角的“部署”按钮。在部署页面中配置服务名称、资源规格和QPS，配置好后点击“提交”，启动模型部署。当服务状态变为“运行中”时，表示模型已部署完成。4. 获取API信息：点击“更多”->“调用”，在弹窗中查看到该服务的API地址及模型名称。进入“鉴权管理”，创建API Key并保存密钥。也可以通过“调用”功能，跳转到API Key管理页面四、使用DIFY编排工具构建AI智能体1. 配置模型供应商：点击右上角“设置”，进入模型供应商页签。选择“OpenAI-API-compatible”供应商，并填入Model Arts Studio中获取的模型名称、API Key和API地址（注意删除最后面的“chat/completions”部分）。2.创建并编排AI智能体：在DIFY中，点击“工作室”，选择“从空白创建”。选择应用类型，如“聊天助手”，并给应用起一个名字、选择合适的图标和描述。创建完毕后，进入编排界面。填写提示词，用于约束AI给出专业的回复。可以使用内置的提示生成器，并插入自定义变量。添加开场白和上下文，以提升用户体验和对话的精准度。如果需要，可以在“上下文”内引用知识库，以限制AI对话的范围。3. 测试并发布AI智能体：在编排完成后，通过右侧的对话框进行测试，确保效果符合预期。如果效果可行，选择“发布”保存所有编排。发布后，可以在DIFY平台中看到一个完整的AI智能体应用。五、后续优化操作嵌入业务网站：可以将AI智能体嵌入到业务网站中，制作具有业务数据的官网AI客服、业务知识问答等应用。API开发：基于API进行开发，扩展AI智能体的功能和应用场景。监控与优化：在华为Model Arts平台的概览内监控、跟踪应用程序在生产环境中的性能。分析生产环境中应用的使用成本、延迟、用户反馈、性能等指标，并通过持续调试、迭代不断改进应用程序。六、总结通过本文的介绍，您已经了解了如何基于华为云Model Arts Studio及DIFY编排工具，快速构建并运行一个AI智能体。希望这篇攻略能为您的AI应用开发之路提供帮助。祝您在AI技术的探索和应用中取得更多成就！我正在参加【案例共创】第1期 书写云产品应用构建开发最佳实践/评测，共创官方文档https://bbs.huaweicloud.com/forum/thread-0217170307934787108-1-1.html

方案介绍随着AI的迅速发展，自从 OpenAI 发布 Sora 文本生成视频模型后，文本生成视频的 AI 技术引起了无数圈内圈外人士的关注和实验。该解决方案基于MoneyPrinter，为你提供一个文本生成短视频的WebUI应用。只需输入视频主题或关键词，就可以全自动生成视频文案、视频素材、视频字幕、视频背景音乐，最后合成一个高清的短视频。开始使用步骤 1 访问该促销活动购买页面，按照如下配置完成AI生成短视频服务器的部署。步骤 2 登录弹性云服务器控制台。使用Linux连接工具登录服务器，或者在控制台单击“远程登录”（建议使用远程连接工具，后续使用过程中需要下载短视频文件）。步骤 3 等待15分钟左右，进入服务器后，查看环境部署日志。输入命令：tail -f /tmp/install-MoneyPrinter-baseENV.log，如下图所示则表示基础环境部署成功（使用Ctrl+C按键即可退出查看日志界面）。步骤 4 修改配置文件，路径为“/home/project/MoneyPrinterTurbo/config.toml”。按照 config.toml 文件中的说明，配置好 pexels_api_keys 和 llm_provider（默认moonshot）相关的 API Key。获取方式请参考https://www.pexels.com/api/（pexels_api_key）和https://platform.moonshot.cn/console/api-keys（moonshot_api_key）。​步骤 5 输入命令：vim /home/project/MoneyPrinterTurbo/config.toml，按下键盘i键，修改pexels_api_keys和moonshot_api_key的值，在键盘按下Esc，输入“：wq”保存。步骤 6 预启动服务。输入如下命令：conda activate MoneyPrinterTurbocd /home/project/MoneyPrinterTurbo/bash webui.sh执行后，输入邮箱地址，即可启动服务。步骤 7 使用Ctrl + C停止服务，使用后台方式启动服务。输入以下命令：conda activate MoneyPrinterTurbocd /home/project/MoneyPrinterTurbo/bash webui.sh > /home/project/MoneyPrinterTurbo/webui.log 2>&1 &步骤 8 登录弹性云服务器控制台。选择购买的服务器，单击服务器名称进入详细页面，在新页面单击“安全组”。步骤 9 单击“配置规则”，选择“入方向规则”。步骤 10 单击“复制”，修改放通8501端口。步骤 11 打开浏览器，输入http://EIP:8501，即可访问WebUI界面。步骤 12 给定一个关键词，使用AI自动生成视频文案。步骤 13 根据页面提示及自身需要，选改参数设置，单击“生成视频”，等待视频自动生成。步骤 14 下拉页面，可以查看当前任务生成的日志。待出现“视频生成完成”，可直接下拉页面，查看或下载生成的视频。常见问题问题一：Read time out. 因为网络波动影响，可能会有视频素材下载失败，报错如下：解决办法：终止此次任务，单击前端页面“stop”停止此次任务。刷新页面，重新发起任务。

1.Scikit-learn包含内容 Classification分类Regression回归Clustering聚类Dimensionality reduction降维Model selection模型选择Preprocessing特征工程 2.scikit-learn数据集API介绍 sklearn.datasets.load_*()：获取小规模数据集，数据包含在datasets里例：sklearn.datasets.load_iris():加载并返回鸢尾花数据集sklearn.datasets.fetch_*(data_home=None)：获取大规模数据集，需要从网络上下载，函数的第一个参数是data_home，表示数据集下载的目录，默认是**~/scikit_learn_data/** 3.sklearn数据集的使用 load和fetch返回的数据类型datasets.base.Bunch(字典格式)data：特征数据数组，是[n_samples * n_features]的二维numpy.ndarry数组target：标签数组，是n_samples的一维numpy.ndarry数组DESCR：数据描述feature_names：特征名，新闻数据，手写数字、回归数据集没有target_names：标签名例：from sklearn.datasets import load_irisdef datasets_demo():    """    sklearn数据集使用    :return:    """    # 获取数据集    iris = load_iris()    print("鸢尾花数据集：\n", iris)    print("查看数据集描述：\n", iris["DESCR"])           # 数据集的描述信息    print("查看特征值的名字：\n", iris.feature_names)    print("查看特征值：\n", iris.data, iris.data.shape)  # shape:(150,4)    return Noneif __name__ == "__main__":    datasets_demo() 查看特征值的名字： ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'] 4.数据集划分 sklearn.model_selection.train_test_split(arrays,*options) x 数据集的特征值y 数据集的标签值test_size测试集的大小，一般为floatrandom_state随机数种子，不同的种子会造成不同的随机采样结果。相同的种子采样结果相同return训练集特征值，测试集特征值，训练集目标值，测试集目标值 5.特征提取（将任意数据（如文本或图像）转化为可用于机器学习的数字特征） 字典特征提取文本特征提取图像特征提取  （1）字典特征提取作用：对字典数据进行特征值化sklearn.feature_extraction.DictVectorizer(sparse=True, …)DictVectorizer.fit_transform(X)， X：字典或者包含字典的迭代器返回值，返回sparse矩阵DictVectorizer.inverse_transform(X)， X：array数组或者sparse矩阵 返回值：转换之前数据格式DictVectorizer.get_feature_names()：返回类别名称例：from sklearn.feature_extraction import DictVectorizerdef dict_demo():    """    字典特征抽取    :return:    """    data = [{'city':'北京', 'temperature':100},            {'city':'上海', 'temperature':60},            {'city':'深圳', 'temperature':30}]    # 1、实例化一个转换器类    #transfer = DictVectorizer() # 返回sparse矩阵    transfer = DictVectorizer(sparse=False)    # 2、调用fit_transform()    data_new = transfer.fit_transform(data)    print("data_new：\n", data_new)   # 转化后的    print("特征名字：\n", transfer.get_feature_names())    return Noneif __name__ == "__main__":    dict_demo()输出：data_new： [[  0.   1.   0. 100.] [  1.   0.   0.  60.] [  0.   0.   1.  30.]] 特征名字： ['city=上海', 'city=北京', 'city=深圳', 'temperature'] （2）文本特征提取      单词作为特征      作用：对文本数据进行特征值化sklearn.feature_extraction.text.CountVectorizer(stop_words=[])：返回词频矩阵CountVectorizer.fit_transform(X)，X：文本或者包含文本字符串的可迭代对象，返回值：返回sparse矩阵CountVectorizer.inverse_transform(X)，X：array数组或者sparse矩阵，返回值：转换之前数据格CountVectorizer.get_feature_names()：返回值：单词列表①英文文本分词from sklearn.feature_extraction.text import CountVectorizerdef count_demo():    """    文本特征抽取：CountVectorizer    :return:    """    data = ['life is short,i like like python',            'life is too long,i dislike python']    # 1、实例化一个转换器类    transfer = CountVectorizer()    # 2、调用fit_transform    data_new = transfer.fit_transform(data)    print("data_new：\n", data_new.toarray())  # toarray转换为二维数组    print("特征名字：\n", transfer.get_feature_names())    return Noneif __name__ == "__main__":    count_demo()输出:data_new： [[0 1 1 2 0 1 1 0] [1 1 1 0 1 1 0 1]]特征名字： ['dislike', 'is', 'life', 'like', 'long', 'python', 'short', 'too']②停用词：stop_words=[]from sklearn.feature_extraction.text import CountVectorizerdef count_demo():    """    文本特征抽取：CountVectorizer    :return:    """    data = ['life is short,i like like python',            'life is too long,i dislike python']    # 1、实例化一个转换器类    transfer = CountVectorizer(stop_words=['is', 'too'])    # 2、调用fit_transform    data_new = transfer.fit_transform(data)    print("data_new：\n", data_new.toarray())  # toarray转换为二维数组    print("特征名字：\n", transfer.get_feature_names())    return Noneif __name__ == "__main__":    count_demo()输出：data_new： [[0 1 2 0 1 1] [1 1 0 1 1 0]]特征名字： ['dislike', 'life', 'like', 'long', 'python', 'short']③中文分本分词例1:from sklearn.feature_extraction.text import CountVectorizerdef count_demo():    """    文本特征抽取：CountVectorizer    :return:    """    data = ['我 爱 北京 天安门',            '天安门 上 太阳 升']    # 1、实例化一个转换器类    transfer = CountVectorizer()    # 2、调用fit_transform    data_new = transfer.fit_transform(data)    print("data_new：\n", data_new.toarray())  # toarray转换为二维数组    print("特征名字：\n", transfer.get_feature_names())    return Noneif __name__ == "__main__":    count_demo()输出：data_new： [[1 1 0] [0 1 1]]特征名字： ['北京', '天安门', '太阳']例2：from sklearn.feature_extraction.text import CountVectorizerimport jiebadef count_chinese_demo2():    """    中文文本特征抽取，自动分词    :return:    """    data = ['一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。',            '我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。',            '如果只用一种方式了解某件事物，他就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。']    data_new = []    for sent in data:        data_new.append(cut_word(sent))    print(data_new)     # 1、实例化一个转换器类    transfer = CountVectorizer()    # 2、调用fit_transform    data_final = transfer.fit_transform(data_new)    print("data_final:\n", data_final.toarray())    print("特征名字：\n", transfer.get_feature_names())    return Nonedef cut_word(text):    """    进行中文分词：“我爱北京天安门” -> "我 爱  北京 天安门"    :param text:    :return:    """    return ' '.join(jieba.cut(text)) if __name__ == "__main__":    count_chinese_demo2()    #print(cut_word('我爱北京天安门'))输出：['一种 还是 一种 今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。', '我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。', '如果 只用 一种 方式 了解 某件事 物 ， 他 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。']data_final: [[2 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 1  0] [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 0  1] [1 1 0 0 4 2 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0  0]]特征名字： ['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某件事', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '还是', '这样']注：关键词：在某一个类别的文章中，出现的次数很多，但是在其他类别的文章中出现很少④Tf-idf文本特征提取（这种方法是计算特征词的重要程度的）Tf-idf的主要思想是：如果某个词或短语在一篇文章中出现的概率高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来区分Tf-idf作用：用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度TF-IDF:衡量重要程度TF：词频IDF：逆向文档频率，可以由总文件数目 / 包含该词语之文件的数目，再将得到的商取以10为底的对数得到例：from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizerimport jiebadef cut_word(text):    """    进行中文分词：“我爱北京天安门” -> "我 爱  北京 天安门"    :param text:    :return:    """    return ' '.join(jieba.cut(text))def tfidf_demo():    """    用TF-IDF的方法进行文本特征抽取    :return:    """    data = ['一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。',            '我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。',            '如果只用一种方式了解某件事物，他就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。']    data_new = []    for sent in data:        data_new.append(cut_word(sent))    print(data_new)     # 1、实例化一个转换器类    transfer = TfidfVectorizer()    # 2、调用fit_transform    data_final = transfer.fit_transform(data_new)    print("data_final:\n", data_final.toarray())    print("特征名字：\n", transfer.get_feature_names())    return Noneif __name__ == "__main__":    tfidf_demo()    #print(cut_word('我爱北京天安门')输出：['一种 还是 一种 今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。', '我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。', '如果 只用 一种 方式 了解 某件事 物 ， 他 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。']data_final: [[0.30847454 0.         0.20280347 0.         0.         0.  0.40560694 0.         0.         0.         0.         0.  0.20280347 0.         0.20280347 0.         0.         0.  0.         0.20280347 0.20280347 0.         0.40560694 0.  0.20280347 0.         0.40560694 0.20280347 0.         0.  0.         0.20280347 0.20280347 0.         0.         0.20280347  0.        ] [0.         0.         0.         0.2410822  0.         0.  0.         0.2410822  0.2410822  0.2410822  0.         0.  0.         0.         0.         0.         0.         0.2410822  0.55004769 0.         0.         0.         0.         0.2410822  0.         0.         0.         0.         0.48216441 0.  0.         0.         0.         0.         0.2410822  0.  0.2410822 ] [0.12826533 0.16865349 0.         0.         0.67461397 0.33730698  0.         0.         0.         0.         0.16865349 0.16865349  0.         0.16865349 0.         0.16865349 0.16865349 0.  0.12826533 0.         0.         0.16865349 0.         0.  0.         0.16865349 0.         0.         0.         0.33730698  0.16865349 0.         0.         0.16865349 0.         0.  0.        ]]特征名字： ['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某件事', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '还是', '这样'] 特征预处理 （1）归一化：Sklearn.preprocessing.MinMaxScaler(feature_range(0,1)…)MinMaxScaler.fit_transform(X)，X：numpy array格式的数据[n_samples,n_features]，返回值：转换后的形式相同的array例：import pandas as pdfrom sklearn.preprocessing import MinMaxScalerdef minmax_demo():    """    归一化    :return:    """    # 1、获取数据    data = pd.read_csv("datingTestSet2.txt", sep='\t')    data = data.iloc[:, :3]    print("data:\n", data)    # 2、实例化一个转换器类    transform = MinMaxScaler()    #transform = MinMaxScaler(feature_range=[2,3])    # 3、调用fit_transform    data_new = transform.fit_transform(data)    print("data_new:\n", data_new)    return Noneif __name__ == "__main__":    minmax_demo()注：最大值与最小值非常容易受到异常值影响，所以这种方法鲁棒性较差，只适合传统精确小数据场景 （2）标准化：（通过对原始数据进行变换把数据变换到均值为0，标准差为1的范围内）（受异常值影响较小，在已有样本足够多的情况下比较稳定，适合现代嘈杂大数据场景）sklearn.perprocessing.StandradScaler()处理之后，对每列来说，所有数据都聚集在均值为0附近，标准差为1StandardScaler.fit_transform(X)，X;numpy array格式的数据[n_samples,n_features]，返回值：转化后的形状相同的array例子：from sklearn.preprocessing import MinMaxScaler, StandardScalerdef stand_demo():    """    标准化    :return:    """    # 1、获取数据    data = pd.read_csv("datingTestSet2.txt", sep='\t')    data = data.iloc[:, :3]    print("data:\n", data)    # 2、实例化一个转换器类    transform = StandardScaler()    #transform = StandardScaler(feature_range=[2,3])    # 3、调用fit_transform    data_new = transform.fit_transform(data)    print("data_new:\n", data_new)    return Noneif __name__ == "__main__":    stand_demo() 7.特征降维（1）降维是指在某些限定条件下，降低随机变量（特征）个数，得到一组“不相关”主变量的过程（2）方式：特征选择①Filter过滤式：主要探究特征本身特点、特征与特征和目标值之间关联a.方差选择法：低方差特征过滤（低方差代表那一列数据差别不大，所以不是主要特征）b. 相关系数：特征与特征之间的相关程度②Embedded嵌入式：算法自动选择特征（特征与目标值之间的关联）A.决策树：信息熵、信息增益B.正则化：L1、L2C.深度学习：卷积等 过滤式例：sklearn.feature_selection.VArianceThreshold(threshold=0.0)删除所有低方差特征Variance.fit_transform(X)，X：numpy array格式的数据[m_sample,n_features]，返回值：训练集差异低于threadshold的特征将被删除。默认值是保留非零方差特征，即删除所有样本中具有相同值的特征from sklearn.feature_selection import VarianceThresholddef variance_demo():    """    低方差特征过滤    :return:    """    # 1、获取数据    data = pd.read_csv('factor_returns.csv')    print('data:\n', data)    data = data.iloc[:,1:-2]    print('data:\n', data)    # 2、实例化一个转换器类    #transform = VarianceThreshold()    transform = VarianceThreshold(threshold=10)    # 3、调用fit_transform    data_new = transform.fit_transform(data)    print("data_new\n", data_new, data_new.shape)    return Noneif __name__ == "__main__":    variance_demo() 相关系数：（输出的结果相关系数看前面那个）from sklearn.feature_selection import VarianceThresholdfrom scipy.stats import pearsonrdef variance_demo():    """    低方差特征过滤    :return:    """    # 1、获取数据    data = pd.read_csv('factor_returns.csv')    print('data:\n', data)    data = data.iloc[:,1:-2]    print('data:\n', data)    # 2、实例化一个转换器类    #transform = VarianceThreshold()    transform = VarianceThreshold(threshold=10)    # 3、调用fit_transform    data_new = transform.fit_transform(data)    print("data_new\n", data_new, data_new.shape)    # 计算两个变量之间的相关系数    r = pearsonr(data["pe_ratio"],data["pb_ratio"])    print("相关系数：\n", r)    return Noneif __name__ == "__main__":    variance_demo() 注：如果特征与特征相关性很高：选取其中一个加权求和主成分分析 主成分分析（高维数据转换为低维数据的过程，在此过程中可能会舍弃原有数据、创造新的变量）sklearn.decomposition.PCA(n_components=None)将数据分解为较低维度空间n_components:小数：表示保留百分之多少的信息整数：减少到多少特征PCA.fit_transform(X)，X：numpy array格式的数据[N_samples, n_features]，返回值：转换后指定维度的array例：from sklearn.decomposition import PCAdef pca_demo():    """    PCA降维    :return:    """    data = [[2,8,4,5], [6,3,0,8], [5,4,9,1]]    # 1、实例化一个转换器类    transform = PCA(n_components=2)  # 4个特征降到2个特征    # 2、调用fit_transform    data_new = transform.fit_transform(data)    print("data_new\n", data_new)    transform2 = PCA(n_components=0.95)  # 保留95%的信息    data_new2 = transform2.fit_transform(data)    print("data_new2\n", data_new2)    return Noneif __name__ == "__main__":    pca_demo()  案例：探究用户对物品类别的喜好细分降维1.获取数据（pd.read_csv()）2.合并表（pd.merge(表1，表2，on=['要连接的列','要连接的列'])）3.找表之间的关系（交叉表）（pd.crosstab（表['列'1]，表['列2']））4.PCA降维（引入，实例化，调用fit_transform） 8.sklearn转换器和估计器     8.1.1 转换器      （1）实例化一个转换器类      （2）调用fit_transform（）注：fit_transfrom为fit和transfrom的合成方法Fit  计算 即计算每一列的均值和标准差Transform  转换   8.1.2 估计器（estimator）（1）用于分类的估计器：      sklearn.neighbors    K近邻算法       sklearn.native_bayes    贝叶斯       sklearn.linear_model.LogisticRegression  逻辑回归       sklearn.tree  决策树与随机森林（2） 用于回归的估计器      sklearn.linear_model.LinearRegression 线性回归      sklearn.linear_model.Ridge  岭回归（3） 用于无监督学习的估计器      sklearn.cluster.Kmeans 聚类步骤：1.实例化一个estimator           2.estimator.fit(x_train,y_train)计算---------调用完毕，模型生成           3.模型评估          1) 直接比对真实值和预测值：y_predict =estimator.predict(x_test)           2) 计算准确率： accuracy = estimator.score(x_test,y_test) 8.2.1 KNN算法APIsklearn.neighbor.KNeighborsClassifier(n_neighbors=5, algorithm='auto')n_neighbors：int型，k_neighbors查询默认使用的邻居数algorithm：{‘auto’，‘ball_tree’，‘kd_tree’}之一 案例：鸢尾花种类预测步骤：1.获取数据           2.数据集划分           3.特征工程：标准化           4.KNN预估器流程           5.模型评估from sklearn.datasets import load_iris                  # 获取数据集from sklearn.model_selection import train_test_split    # 划分数据集from sklearn.preprocessing import StandardScaler        # 标准化from sklearn.neighbors import KNeighborsClassifier      # KNN算法分类 def knn_iris():    """    用KNN算法对鸢尾花进行分类    :return:    """    # 1、获取数据    iris = load_iris()     # 2、划分数据集    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)     # 3、特征工程：标准化    transfer = StandardScaler()    x_train = transfer.fit_transform(x_train)  # 训练集标准化    x_test = transfer.transform(x_test)        # 测试集标准化 注: x_test直接用transform，因为要对训练集和测试集做相同的处理，此处不需再计算，而直接使用训练集的测试结果     # 4、KNN算法预估器    estimator = KNeighborsClassifier(n_neighbors=3)    estimator.fit(x_train, y_train)     # 5、模型评估    # 方法1：直接比对真实值和预测值    y_predict = estimator.predict(x_test)    print("y_predict:\n", y_predict)    print("直接比对真实值和预测值：\n", y_test == y_predict)  # 直接比对     # 方法2：计算准确率    score = estimator.score(x_test, y_test)  # 测试集的特征值，测试集的目标值    print("准确率：\n", score)    return Noneif __name__ == "__main__":    knn_iris()  9.模型选择与调优   （1）交叉验证(cross validation)  （2）超参数搜索-----网格搜索（GridSearch）  9.1.1  模型选择与调优APIsklearn.model_selection.GridSearchCV(estimator, param_grid=None, cv=None)对估计器的指定参数进行详尽搜索estimator：估计器对象param_grid：估计器参数（dict）{“n_neighbors”:[1,3,5]}    注意是字典格式cv：指定几折交叉验证fit()：输入训练数据score()：准确率结果分析：最佳参数：best_params_最佳结果：best_score_最佳估计器：best_estimator_交叉验证结果：cv_results_ 鸢尾花案例增加K值调优（要在评估器后面加入调优）from sklearn.datasets import load_iris                  # 获取数据集from sklearn.model_selection import train_test_split    # 划分数据集from sklearn.preprocessing import StandardScaler        # 标准化from sklearn.neighbors import KNeighborsClassifier      # KNN算法分类from sklearn.model_selection import GridSearchCVdef knn_iris_gscv():    """    用KNN算法对鸢尾花进行分类    添加网格搜索和交叉验证    :return:    """    # 1、获取数据    iris = load_iris()     # 2、划分数据集    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)     # 3、特征工程：标准化    transfer = StandardScaler()    x_train = transfer.fit_transform(x_train)  # 训练集标准化    x_test = transfer.transform(x_test)        # 测试集标准化     # 4、KNN算法预估器    estimator = KNeighborsClassifier()    # 加入网格搜索与交叉验证    # 参数准备    param_dict = {"n_neighbors": [1,3,5,7,9,11]}    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10)  # 10折，数据量不大，可以多折     estimator.fit(x_train, y_train)     # 5、模型评估    # 方法1：直接比对真实值和预测值    y_predict = estimator.predict(x_test)    print("y_predict:\n", y_predict)    print("直接必读真实值和预测值：\n", y_test == y_predict)  # 直接比对     # 方法2：计算准确率    score = estimator.score(x_test, y_test)  # 测试集的特征值，测试集的目标值    print("准确率：", score)     # 查看最佳参数：best_params_    print("最佳参数：", estimator.best_params_)    # 最佳结果：best_score_    print("最佳结果：", estimator.best_score_)    # 最佳估计器：best_estimator_    print("最佳估计器：", estimator.best_estimator_)    # 交叉验证结果：cv_results_    print("交叉验证结果:", estimator.cv_results_)    return Noneif __name__ == "__main__":    knn_iris_gscv() 10.集成学习方法之随机森林  集成学习方法通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型，各种独立地学习和做出预测。这些预测最后结合成组合预测，因此优于任何一个单分类做出的预测 10.1.1  什么是随机森林   在机器学习中，随机森林是一个包含多个决策树的分类器，并且其输出的类别是由个别数输出的类别的众数而定例：如果训练了5棵树，5棵树的结果是True，1棵树的结果是False，那么最终结果就是True 10.1.2  随机森林原理过程  两个随机：        训练集随机: BoostStrap,N个样本中随机有放回抽样         特征值随机：从M个特征中随机抽取m个特征，M>>m  问题：为什么要采用BootStrap抽样 1. 为什么要随机抽样训练集？   如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的为什么要有放回地抽样?   如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每颗树都是“有偏的”，都是绝对“片面的”，也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树的投票表决 10.1.3 随机森林分类器APIsklearn.ensemble.RandomForestClassifier(n_estimators=10, criterion='gini', max_depth=None, /bootstrap=True, random_state=None, min_samples_split=2)n_estimators：integer，optional(default=10)森林里的树木数量，可以用网格搜索criteria：string，可选（default=‘gini’），分割特征的测量方法max_depth：integer或None，可选（默认无），树的最大深度5，8，15，25，30 可以用网格搜索max_teatures=‘auto’，每个决策树的最大特征数量if ‘auto’ ，then max_features = sqrt(n_features)if ‘sqrt’ ，then max_features = sqrt(n_features)if ‘log2’ ，then max_features = log2(n_features)if None，then max_features = n_featuresbooststrap：boolean，optional（default=True）是否在构建树时使用放回抽样min_samples_split：节点划分最少样本数min_samples_leaf：叶子节点的最小样本数超参数：n_estimator，max_depth，min_samples_split，min_samples_leaf10.1.4 随机森林案例预测：from sklearn.ensemble import RandomForestClassifierfrom sklearn.model_selection import GridSearchCVestimator = RandomForestClassifier()# 加入网格搜索与交叉验证# 参数准备param_dict = {"n_estimators":[120,200,300,500,800,1200], "max_depth":[5,8,15,25,30]}estimator = GridSearchCV(estimator, param_grid=param_dict, cv=3)  # 10折，数据量不大，可以多折estimator.fit(x_train, y_train) # 5、模型评估# 方法1：直接比对真实值和预测值y_predict = estimator.predict(x_test)print("y_predict:\n", y_predict)print("直接必读真实值和预测值：\n", y_test == y_predict)  # 直接比对 # 方法2：计算准确率score = estimator.score(x_test, y_test)  # 测试集的特征值，测试集的目标值print("准确率：", score)# 查看最佳参数：best_params_print("最佳参数：", estimator.best_params_)# 最佳结果：best_score_print("最佳结果：", estimator.best_score_)# 最佳估计器：best_estimator_print("最佳估计器：", estimator.best_estimator_)# 交叉验证结果：cv_results_print("交叉验证结果:", estimator.cv_results_) 10.1.5 随机森林算法总结  （1）在当前所有算法中，具有极好的准确率  （2）能够有效地运行在大数据集上，处理具有高维特征的输入样本，而且不需要降维  （3）能够评估各个特征在分类问题上的重要性 线性回归:1）线性回归是利用回归方程（函数）对一个或多个自变量（特征值）和因变量（目标值）之间关系进行建模的一种分析方式特点: 只有一个自变量的情况称为单变量回归，多于一个自变量情况的叫做多元回归 2）损失函数：最小二乘法 （均方误差）3）优化算法：① 正规方程：直接求解W                       ② 梯度下降：试错，改进4）线性回归API：sklearn.linear_model.LinearRegression(fit_intercept=True)fit_intercept：是否计算偏置LinearRegression.coef_：回归系数LinearRegression.intercept_：偏置5）梯度下降API：sklearn.linear_model.SGDRegressor(loss="squared_loss", fit_intercept=True, learning_rate='invscaling', eta0=0.01)SGDRegressor类实现了随机梯度下降学习，它支持不同的loss函数和正则化惩罚项来拟合线性回归模型loss：损失类型loss=“squared_loss”：普通最小二乘法fit_intercept：是否计算偏置learning_rate：string，optional学习率填充‘constant’：eta=eta0‘optimal’：eta=1.0 / (alpha*(t+t0)) [default]‘invscaling’：eta=eta0 / pow(t, power_t)SGDRegression.coef_：回归系数SGDRegression.intercept_：偏置 波士顿房价预测例：1）流程：获取数据集划分数据集特征工程：无量纲化-标准化预估器流程：fit() -> 模型，coef_  intercept_模型评估2）回归性能评估 ----均方误差（MSE）sklearn.metrics.mean_squared_error(y_ture, y_pred)均方误差回归损失y_true：真实值y_pred：预测值return：浮点数结果3）代码from sklearn.datasets import load_bostonfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import StandardScalerfrom sklearn.linear_model import LinearRegression, SGDRegressorfrom sklearn.metrics import mean_squared_errordef linner1():    """    正规方程的优化方法    :return:    """    # 1）获取数据    boston = load_boston()     # 2）划分数据集    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)     # 3）标准化    transfer = StandardScaler()    x_train = transfer.fit_transform(x_train)    x_test = transfer.transform(x_test)     # 4）预估器    estimator = LinearRegression()    estimator.fit(x_train, y_train)     # 5）得出模型    print("正规方程权重系数为：\n", estimator.coef_)    print("正规方程偏置为：\n", estimator.intercept_)     # 6）模型评估    y_predict = estimator.predict(x_test)    print("预测房价：\n", y_predict)    error = mean_squared_error(y_test, y_predict)    print("正规方程-均分误差为：\n", error)     return None def linner2():    """    梯度下降的优化方法    :return:    """    # 1）获取数据    boston = load_boston()    print("特征数量：\n", boston.data.shape)  # 几个特征对应几个权重系数     # 2）划分数据集    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)     # 3）标准化    transfer = StandardScaler()    x_train = transfer.fit_transform(x_train)    x_test = transfer.transform(x_test)     # 4）预估器    estimator = SGDRegressor(learning_rate="constant", eta0=0.001, max_iter=10000)    estimator.fit(x_train, y_train)     # 5）得出模型    print("梯度下降权重系数为：\n", estimator.coef_)    print("梯度下降偏置为：\n", estimator.intercept_)     # 6）模型评估    y_predict = estimator.predict(x_test)    print("预测房价：\n", y_predict)    error = mean_squared_error(y_test, y_predict)    print("梯度下降-均分误差为：\n", error)    return Noneif __name__ == '__main__':    linner1()    linner2() 4）对比:梯度下降正规方程需要选择学习率不需要需要迭代求解一次运算得出特征数量较大可以使用需要计算方程，时间复杂度O（n3） 5)梯度下降的扩展：GD、SGD、SAG   ① GD：  梯度下降，原始的梯度下降法需要计算所有样本的值才能够得出梯度，计算量大，所以后面才会有一系列改进   ② SGD：  随机梯度下降是一个优化方法。它在一次迭代时只考虑一个训练样本  优点: 高效、容易实现  缺点：需要许多超参数：比如正则项参数、迭代数            对于特征标准化是敏感的 ③ SAG  随机平均梯度法，由于收敛的速度太慢，有人提出SAG等基于梯度下降的算法 Scikit-learn:岭回归、逻辑回归等当中都会有SAG优化 欠拟合过拟合1）欠拟合：在训练集和测试集表现都不好原因：学习到数据的特征过少解决办法：增加数据的特征数量2）过拟合：在训练集表现好，但在测试集表现不好原因：学习到的特征过多，存在一些嘈杂特征，模型过于复杂解决办法：正则化 正则化：1）L1正则化：使其中一些W（权重）的值直接为0，删除这个特征的影响采用L1正则化的线性回归模型是LASSO回归2）L2正则化：使其中一些W（权重）的值都很小，都接近于0，削弱某个特征的影响采用L2正则化的线性回归模型是Ridge回归加入L2正则化后的损失函数：损失函数+惩罚项优点:越小的参数说明模型越简单，越简单的模型也不容易产生过拟合现象 线性回归的改进---岭回归1）.带有L2正则化的线性回归----岭回归2）.APIsklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True, solver='auto', normalize=False)alpha：正则化力度，取值范围：0-1,1-10solver：会根据数据自动选择优化方法sag：如果数据集、特征都较大，选择该随机梯度下降优化normalize：数据是否进行标准化normalize=False：可以在fit之前调用preprocessing.StandardScaler标准化数据Ridge.coef_：回归权重Ridge.intercept_：回归偏置3）例：from sklearn.datasets import load_bostonfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import StandardScalerfrom sklearn.linear_model import LinearRegression, SGDRegressor, Ridgefrom sklearn.metrics import mean_squared_errordef linner1():    """    正规方程的优化方法    :return:    """    # 1）获取数据    boston = load_boston()    # 2）划分数据集    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)    # 3）标准化    transfer = StandardScaler()    x_train = transfer.fit_transform(x_train)    x_test = transfer.transform(x_test)    # 4）预估器    estimator = LinearRegression()    estimator.fit(x_train, y_train)    # 5）得出模型    print("正规方程权重系数为：\n", estimator.coef_)    print("正规方程偏置为：\n", estimator.intercept_)    # 6）模型评估    y_predict = estimator.predict(x_test)    print("预测房价：\n", y_predict)    error = mean_squared_error(y_test, y_predict)    print("正规方程-均分误差为：\n", error)    return None def linner2():    """    梯度下降的优化方法    :return:    """    # 1）获取数据    boston = load_boston()    print("特征数量：\n", boston.data.shape)  # 几个特征对应几个权重系数    # 2）划分数据集    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)    # 3）标准化    transfer = StandardScaler()    x_train = transfer.fit_transform(x_train)    x_test = transfer.transform(x_test)    # 4）预估器    estimator = SGDRegressor(learning_rate="constant", eta0=0.001, max_iter=10000)    estimator.fit(x_train, y_train)    # 5）得出模型    print("梯度下降权重系数为：\n", estimator.coef_)    print("梯度下降偏置为：\n", estimator.intercept_)    # 6）模型评估    y_predict = estimator.predict(x_test)    print("预测房价：\n", y_predict)    error = mean_squared_error(y_test, y_predict)    print("梯度下降-均分误差为：\n", error)    return None def linner3():    """    岭回归    :return:    """    # 1）获取数据    boston = load_boston()    print("特征数量：\n", boston.data.shape)  # 几个特征对应几个权重系数    # 2）划分数据集    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)    # 3）标准化    transfer = StandardScaler()    x_train = transfer.fit_transform(x_train)    x_test = transfer.transform(x_test)    # 4）预估器    estimator = Ridge(alpha=0.5, max_iter=10000)  # 可默认参数    estimator.fit(x_train, y_train)    # 5）得出模型    print("岭回归-权重系数为：\n", estimator.coef_)    print("岭回归-下降偏置为：\n", estimator.intercept_)    # 6）模型评估    y_predict = estimator.predict(x_test)    print("预测房价：\n", y_predict)    error = mean_squared_error(y_test, y_predict)    print("岭回归-均分误差为：\n", error)    return Noneif __name__ == '__main__':    linner1()    linner2()    linner3() 逻辑回归:(解决二分类)1）.线性回归的输出就是逻辑回归的输入，将输出输入到sigmoid函数中，就将输出结果映射到[0,1]中，设置阈值，就能解决二分类问题2）.APIsklearn.linear_model.LogisticRefression(solver='liblinear', penalty='l2, C=1.0)penalty：正则化种类C：正则化力度solver：优化求解方式（默认开源的liblinear库实现）3）.例：癌症分类预测-良/恶性乳腺癌肿瘤预测流程分析获取数据数据处理：处理缺失值数据集划分特征工程：无量纲化处理——标准化逻辑回归预估器模型评估import pandas as pdimport numpy as np# 1、读取数据path = "cid:link_0"column_name = ['Sample code number', 'Clump Thickness', 'Uniformity of Cell Size', 'Uniformity of Cell Shape',                   'Marginal Adhesion', 'Single Epithelial Cell Size', 'Bare Nuclei', 'Bland Chromatin',                   'Normal Nucleoli', 'Mitoses', 'Class']data = pd.read_csv(path, names=column_name)  #699 rows × 11 columns# 2、缺失值处理# 1）替换-》np.nandata = data.replace(to_replace="?", value=np.nan)# 2）删除缺失样本data.dropna(inplace=True)  #683 rows × 11 columns# 3、划分数据集from sklearn.model_selection import train_test_split# 筛选特征值和目标值x = data.iloc[:, 1:-1]y = data["Class"]x_train, x_test, y_train, y_test = train_test_split(x, y)# 4、标准化from sklearn.preprocessing import StandardScalertransfer = StandardScaler()x_train = transfer.fit_transform(x_train)x_test = transfer.transform(x_test)from sklearn.linear_model import LogisticRegression# 5、预估器流程estimator = LogisticRegression()estimator.fit(x_train, y_train)# 逻辑回归的模型参数：回归系数和偏置estimator.coef_   # 权重estimator.intercept_  # 偏置# 6、模型评估# 方法1：直接比对真实值和预测值y_predict = estimator.predict(x_test)print("y_predict:\n", y_predict)print("直接比对真实值和预测值:\n", y_test == y_predict) # 方法2：计算准确率score = estimator.score(x_test, y_test)print("准确率为：\n", score) 分类评估方法:1）精确率与召回率精确率：预测结果为正例样本中真实为正例的比例召回率：真实为正例的样本中预测结果为正例的比例F1-score:反映了模型的稳健性2）API：sklearn.metrics.classification_report(y_true, y_pred, labels=[], target_names=None)y_true：真实目标值y_pred：估计器预测目标值labels：指定类别对应的数字target_names：目标类别名称return：每个类别精确率与召回率# 查看精确率、召回率、F1-scorefrom sklearn.metrics import classification_reportreport = classification_report(y_test, y_predict, labels=[2, 4], target_names=["良性", "恶性"]) 3）衡量样本不均衡下的评估ROC曲线与AUC指标TPR就是召回率  4）AUC计算APIfrom sklearn.metrics import roc_auc_scoreroc_auc_score(y_true, y_score)y_true：每个样本的真实类别，必须为0（反例）和1（正例）y_score：预测得分，可以是正类的估计概率、置信值或者分类器方法的返回值# y_true：每个样本的真实类别，必须为0(反例),1(正例)标记# 将y_test 转换成 0 1y_true = np.where(y_test > 3, 1, 0) from sklearn.metrics import roc_auc_scoreroc_auc_score(y_true, y_predict) 5）总结：AUC只能用来评价二分类AUC非常适合评价样本在不平衡中的分类器性能 6）模型保存和加载APIimport joblib保存：joblib.dump(rf, ‘test.pkl’)加载：estimator = joblib.load(‘test.pkl’)  无监督学习：聚类：K-means降维：PCA 1）K-means APIsklearn.cluster.KMeans(n_cluster=8, init='k-means++')n_clusters：开始聚类中心数量init：初始化方法，默认为‘k-means++’labels_：默认标记的类型，可以和真实值比较（不是值比较）from sklearn.cluster import KMeansestimator = KMeans(n_clusters=3)estimator.fit(data_new)y_predict = estimator.predict(data_new)2）K-means性能评估指标①轮廓系数②轮廓系数值分析③结论如果bi>>ai：趋近于1效果越好，bi<<ai:趋近于-1，效果不好。轮廓系数的值是介于[-1,1]，越趋近于1代表内聚度和分离度都相对较优 ④轮廓系数APIsklearn.metrics.silhouette_score(X, labels)计算所有样本的平均轮廓系数X：特征值labels：被聚类标记的目标值from  sklearn.metrics import silhouette_scoresilhouette_score(data_new, y_predict) ⑤K-means总结：特点分析：采用迭代式算法，直观易懂并且非常实用缺点：容易收敛到局部最优解（多次聚类）注：聚类一般在分类之前

Dataframe 属性dataframe函数import numpy as npimport pandas as pd # python list创建series# countries = ['USA','uk','china','france']# my_data = [100,200,300,400]# data = pd.Series(countries,my_data)# print(data) # numpy ndarray创建Series# array = np.array(my_data)# data1 = pd.Series(array)# print(data1) # python dict创建series# my_dict = {'usa':100,'china':200,'uk':300,'france':400}# data2 = pd.Series(my_dict)# print(data2) # 标量创建series# data3 = pd.Series(5,index = [1,2,3,4])# print(data3) # 从series获取数据# data4 = pd.Series([1,2,3,4],['usa','china','uk','france'])# print(data4['usa']) # series算数运算操作# series1 = pd.Series([1,2,3,4],['usa','china','uk','france'])# series2 = pd.Series([1,2,4,3],['usa','china','uk','canada'])# print(series1 - series2)# print(series1 * series2) # series创建dataframe# df = {'name': pd.Series([1,2,3,4],index = ['usa','china','uk','france']),#       'age': pd.Series([20,30,40,50],['usa','china','uk','france']),#       'data': pd.Series([4,3,2],['usa','china','uk'])}# df1 = pd.DataFrame(df)# print(df1) # 字典创建dataframe# data = {'name': ['zhangsan','lisi','wangwu'],#         'age': [10,20,30],#         'grade' : [1,2,3]}# print(data)# df2 = pd.DataFrame(data)# print(df2) # 获取、设置和删除列# print(type(df2['name']))# print(type(df2[['name','age']]))# df1['grade'] = pd.Series([6,7,8,9],['usa','china','uk','france'])# print(df1)# 删除 drop，axis=0对应行row，axis=1对应列column# df1.drop(['grade'],axis=1,inplace=True)# df1.drop(['usa'],axis=0,inplace=True)# print(df1)# loc按索引引用，iloc按这行在表中的位置引用# print(df1.loc['uk'])# print(df1.iloc[[0,1]])# print(df1.loc['uk','name'])# print(df1.loc[['uk','china'],['name','age']]) # 条件筛选# df = pd.DataFrame(np.random.rand(5,4),['a','b','c','d','e'],['h','i','j','k'])# print(df['h']>0.5)# print(df[df['h']>0.5][['i','h']])# print(df[(df['h']>0.5) | (df['i']<0.8)])# df1 = df.reset_index()# print(df1)# df['ID'] = [1,2,3,4,5]# df2 = df.set_index('ID')# print(df2) # 缺失值处理# 删除# dt = {'A':[1,np.nan,3],'B':[2,np.nan,np.nan],'C':[4,5,6]}# dt = pd.DataFrame(dt)# print(dt)# dt1 = dt.dropna(axis=1)# print(dt1)# dt.dropna(axis=0,inplace=True)# print(dt)# 填充# dt.fillna('10',inplace=True)# print(dt) # 分组统计# data = {'name': ['zhangsan','lisi','wangwu','liliu'],#         'age': [10,20,30,20],#          'grade' : [1,2,3,4]}# data = pd.DataFrame(data)# data1 = data.groupby('age').describe().transpose()# print(data1) # 堆叠 （concat）# df1 = pd.DataFrame(np.random.rand(3,2),['a','b','c'])# df2 = pd.DataFrame(np.random.rand(3,2),['d','e','f'])# df3 = pd.DataFrame(np.random.rand(3,2),['o','p','q'])# df = pd.concat([df1,df2,df3],axis=1)# print(df) # 归并 （merge）# left = pd.DataFrame({'key':['k0','k1','k2','k3']#                      ,'A':[1,2,3,4]#                      ,'B':[1,2,3,4]})# right = pd.DataFrame({'key':['k0','k1','k2','k3']#                      ,'c':[1,2,3,4]#                      ,'d':[1,2,3,4]})# dt1 = pd.merge(left,right,on='key')# print(dt1)# left1 = pd.DataFrame({'key1':['k0','k0','k1','k2']#                      ,'key2':['k0','k1','k0','k1']#                      ,'A':[1,2,3,4]#                      ,'B':[1,2,3,4]})# right2 = pd.DataFrame({'key1':['k0','k1','k1','k2'],#                       'key2':['k0','k0','k0','k0']#                      ,'c':[1,2,3,4]#                      ,'d':[1,2,3,4]})# dt2 = pd.merge(left1,right2,on=['key1','key2'])# print(dt2) # 连接 针对两个表之间没有太多共同的列 选择.join方法，连接采用索引作为公共的键，而不是某一列# left = pd.DataFrame({'A':[1,2,3],#                     'B':[3,4,5]},index=['k0','k1','k2'])# right = pd.DataFrame({'C':[1,2,3,4]#                     ,'D':[3,4,5,6]},index=['k0','k1','k2','k3'])# print(left.join(right,how='outer')) # 查找不重复的值df = pd.DataFrame({'col1':[1,2,3,4],'col2':[444,555,666,444],'col3':['abc','def','hig','xyz']})# print(df.info())# print(df.head()) # unique() 查找列中所有不重复的值# print(df['col2'].unique())# nunique() 查找所有不重复值的个数# print(df['col2'].nunique())# value.counts() 查找所有值和对应值的计数# print(df['col2'].value_counts()) # apply()自定义函数# print(df['col2'].apply(float)) # 获取dataframe的属性 包括列和索引的名字等等print(df.columns)print(df.index)print(df.dtypes) # 排序 sort()  sort_values()将整个表按某一列的值进行排序# print(df.sort_values()) # 查找空值 isnull()# print(df.isnull()) # 读取文件  支持csv、excel、html等# df = pd.read_csv('C://Users//Lenovo//Desktop//test.csv')# print(df)# # 写入csv文件   index = false代表不希望把索引列也存入文件中# df.to_csv('new1',index=False) # 时间序列 pandas.date_range(start=None, end=None, periods=None, freq=‘D’, tz=None, normalize=False, name=None,closed=None, **kwargs)# 返回固定频率DatetimeIndex，以日作为默认频率# 使用默认的每日频率指定开始和结束# test1 = pd.date_range(start='1/1/2024',end='1/4/2024')# print(test1)# 指定开始和期间，期间数（天）# test2 = pd.date_range(start='1/1/2024',periods=3)# print(test2)# 指定开始，结束和期间；频率自动生成（线性间隔）# test3 = pd.date_range(start='1/1/2024',end = '1/6/2024',periods=3)# print(test3)# 将频率改为'M'（月末频率）# test4 = pd.date_range(start='1/1/2024',periods=3,freq='M')# print(test4) # 通过时间序列绘图# ts=pd.Series(np.random.randn(1000),index=pd.date_range("20170301",periods=1000))# print(ts)# ts=ts.cumsum()     #cumsum 返回DataFrame或Series轴上的累积和。# print(ts)# from pylab import *    #需要导入绘图模块# ts.plot()      #绘图# show()      #展示