011 《Prompt Engineering for Programmers: A Practical Guide to AI-Assisted Development》

🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟

书籍大纲

▮▮▮▮ 1. chapter 1： 初探提示工程 (Introduction to Prompt Engineering)
▮▮▮▮▮▮▮ 1.1 人工智能辅助开发 (AI-Assisted Development) 的兴起
▮▮▮▮▮▮▮ 1.2 什么是提示工程 (What is Prompt Engineering)？
▮▮▮▮▮▮▮ 1.3 为什么程序员需要学习提示工程 (Why Prompt Engineering for Programmers)?
▮▮▮▮▮▮▮ 1.4 本书的目标、结构与面向读者 (Book Objectives, Structure, and Target Audience)
▮▮▮▮ 2. chapter 2： 提示工程的基础知识 (Fundamentals of Prompt Engineering)
▮▮▮▮▮▮▮ 2.1 大型语言模型 (Large Language Models, LLMs) 概览
▮▮▮▮▮▮▮▮▮▮▮ 2.1.1 Transformer 架构 (Transformer Architecture) 简介
▮▮▮▮▮▮▮▮▮▮▮ 2.1.2 预训练与微调 (Pre-training and Fine-tuning)
▮▮▮▮▮▮▮ 2.2 提示 (Prompt) 的基本构成要素 (Basic Components of a Prompt)
▮▮▮▮▮▮▮▮▮▮▮ 2.2.1 指令 (Instruction)
▮▮▮▮▮▮▮▮▮▮▮ 2.2.2 上下文 (Context)
▮▮▮▮▮▮▮▮▮▮▮ 2.2.3 输入数据 (Input Data)
▮▮▮▮▮▮▮▮▮▮▮ 2.2.4 输出指示 (Output Indicator)
▮▮▮▮▮▮▮ 2.3 提示的类型 (Types of Prompts)
▮▮▮▮▮▮▮▮▮▮▮ 2.3.1 零样本提示 (Zero-shot Prompting)
▮▮▮▮▮▮▮▮▮▮▮ 2.3.2 少样本提示 (Few-shot Prompting)
▮▮▮▮▮▮▮▮▮▮▮ 2.3.3 思维链提示 (Chain-of-Thought Prompting)
▮▮▮▮▮▮▮▮▮▮▮ 2.3.4 角色扮演提示 (Role-Playing Prompting)
▮▮▮▮▮▮▮ 2.4 影响提示效果的关键因素 (Key Factors Influencing Prompt Effectiveness)
▮▮▮▮▮▮▮▮▮▮▮ 2.4.1 清晰度与简洁性 (Clarity and Conciseness)
▮▮▮▮▮▮▮▮▮▮▮ 2.4.2 指令的明确性 (Specificity of Instructions)
▮▮▮▮▮▮▮▮▮▮▮ 2.4.3 上下文的相关性 (Relevance of Context)
▮▮▮▮ 3. chapter 3： 面向编程任务的提示工程技巧 (Prompt Engineering Techniques for Programming Tasks)
▮▮▮▮▮▮▮ 3.1 代码生成 (Code Generation)
▮▮▮▮▮▮▮▮▮▮▮ 3.1.1 基本代码生成提示 (Basic Code Generation Prompts)
▮▮▮▮▮▮▮▮▮▮▮ 3.1.2 指定编程语言和范式 (Specifying Programming Language and Paradigm)
▮▮▮▮▮▮▮▮▮▮▮ 3.1.3 利用注释生成代码 (Generating Code from Comments)
▮▮▮▮▮▮▮▮▮▮▮ 3.1.4 复杂代码逻辑的分解与提示 (Decomposition and Prompting for Complex Logic)
▮▮▮▮▮▮▮▮▮▮▮ 3.1.5 代码生成案例分析：Web 应用后端 API (Case Study: Web Application Backend API)
▮▮▮▮▮▮▮ 3.2 代码调试与错误修复 (Code Debugging and Error Fixing)
▮▮▮▮▮▮▮▮▮▮▮ 3.2.1 错误信息提示 (Prompting with Error Messages)
▮▮▮▮▮▮▮▮▮▮▮ 3.2.2 代码片段分析与错误定位 (Code Snippet Analysis and Error Localization)
▮▮▮▮▮▮▮▮▮▮▮ 3.2.3 利用提示生成修复代码建议 (Generating Code Fix Suggestions with Prompts)
▮▮▮▮▮▮▮▮▮▮▮ 3.2.4 调试案例分析：Python 脚本的 Bug 修复 (Case Study: Bug Fixing in a Python Script)
▮▮▮▮▮▮▮ 3.3 代码解释与文档生成 (Code Explanation and Documentation Generation)
▮▮▮▮▮▮▮▮▮▮▮ 3.3.1 代码解释提示 (Code Explanation Prompts)
▮▮▮▮▮▮▮▮▮▮▮ 3.3.2 自动生成代码注释 (Automatic Code Comment Generation)
▮▮▮▮▮▮▮▮▮▮▮ 3.3.3 生成 API 文档和用户手册 (Generating API Documentation and User Manuals)
▮▮▮▮▮▮▮▮▮▮▮ 3.3.4 文档生成案例分析：Java 类库的文档自动生成 (Case Study: Automatic Documentation Generation for a Java Library)
▮▮▮▮▮▮▮ 3.4 代码重构与优化 (Code Refactoring and Optimization)
▮▮▮▮▮▮▮▮▮▮▮ 3.4.1 代码风格改进提示 (Code Style Improvement Prompts)
▮▮▮▮▮▮▮▮▮▮▮ 3.4.2 性能优化建议提示 (Performance Optimization Suggestion Prompts)
▮▮▮▮▮▮▮▮▮▮▮ 3.4.3 代码重构案例分析：提升遗留系统的可维护性 (Case Study: Improving Maintainability of Legacy Systems)
▮▮▮▮▮▮▮ 3.5 测试用例生成 (Test Case Generation)
▮▮▮▮▮▮▮▮▮▮▮ 3.5.1 单元测试用例生成提示 (Unit Test Case Generation Prompts)
▮▮▮▮▮▮▮▮▮▮▮ 3.5.2 集成测试用例生成提示 (Integration Test Case Generation Prompts)
▮▮▮▮▮▮▮▮▮▮▮ 3.5.3 测试驱动开发 (Test-Driven Development, TDD) 中的提示应用
▮▮▮▮▮▮▮▮▮▮▮ 3.5.4 测试用例生成案例分析：针对算法函数的测试用例生成 (Case Study: Test Case Generation for Algorithm Functions)
▮▮▮▮ 4. chapter 4： 高级提示工程技巧 (Advanced Prompt Engineering Techniques)
▮▮▮▮▮▮▮ 4.1 思维链 (Chain-of-Thought, CoT) 的进阶应用
▮▮▮▮▮▮▮▮▮▮▮ 4.1.1 多步推理提示 (Multi-step Reasoning Prompts)
▮▮▮▮▮▮▮▮▮▮▮ 4.1.2 结合外部知识的提示 (Prompts Incorporating External Knowledge)
▮▮▮▮▮▮▮ 4.2 提示的迭代与优化 (Prompt Iteration and Optimization)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.1 A/B 测试与提示效果评估 (A/B Testing and Prompt Effectiveness Evaluation)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.2 基于反馈的提示改进 (Feedback-based Prompt Refinement)
▮▮▮▮▮▮▮ 4.3 处理复杂任务的提示策略 (Prompt Strategies for Complex Tasks)
▮▮▮▮▮▮▮▮▮▮▮ 4.3.1 任务分解 (Task Decomposition) 与子任务提示 (Sub-task Prompts)
▮▮▮▮▮▮▮▮▮▮▮ 4.3.2 提示链 (Prompt Chaining) 与工作流 (Workflow) 设计
▮▮▮▮▮▮▮ 4.4 提示工程中的伦理与安全考量 (Ethical and Safety Considerations in Prompt Engineering)
▮▮▮▮▮▮▮▮▮▮▮ 4.4.1 避免生成有害代码 (Avoiding Generation of Harmful Code)
▮▮▮▮▮▮▮▮▮▮▮ 4.4.2 数据隐私与安全 (Data Privacy and Security)
▮▮▮▮ 5. chapter 5： 实战案例分析 (Practical Case Studies)
▮▮▮▮▮▮▮ 5.1 案例一：使用 AI 辅助快速开发 RESTful API (Case Study 1: Rapid RESTful API Development with AI Assistance)
▮▮▮▮▮▮▮▮▮▮▮ 5.1.1 需求分析与提示设计 (Requirement Analysis and Prompt Design)
▮▮▮▮▮▮▮▮▮▮▮ 5.1.2 代码生成与调试过程 (Code Generation and Debugging Process)
▮▮▮▮▮▮▮▮▮▮▮ 5.1.3 性能测试与优化 (Performance Testing and Optimization)
▮▮▮▮▮▮▮ 5.2 案例二：利用 AI 自动化代码审查流程 (Case Study 2: Automating Code Review Process with AI)
▮▮▮▮▮▮▮▮▮▮▮ 5.2.1 代码审查规则的提示工程实现 (Prompt Engineering Implementation of Code Review Rules)
▮▮▮▮▮▮▮▮▮▮▮ 5.2.2 集成到 CI/CD 流程 (Integration into CI/CD Pipeline)
▮▮▮▮▮▮▮▮▮▮▮ 5.2.3 效果评估与持续改进 (Effectiveness Evaluation and Continuous Improvement)
▮▮▮▮▮▮▮ 5.3 案例三：构建智能代码助手 IDE 插件 (Case Study 3: Building an Intelligent Code Assistant IDE Plugin)
▮▮▮▮▮▮▮▮▮▮▮ 5.3.1 插件架构设计 (Plugin Architecture Design)
▮▮▮▮▮▮▮▮▮▮▮ 5.3.2 核心功能：代码补全、错误检测、文档查询 (Core Features: Code Completion, Error Detection, Documentation Query)
▮▮▮▮▮▮▮▮▮▮▮ 5.3.3 用户体验优化 (User Experience Optimization)
▮▮▮▮ 6. chapter 6： 提示工程的工具与生态 (Tools and Ecosystem for Prompt Engineering)
▮▮▮▮▮▮▮ 6.1 在线提示工程平台 (Online Prompt Engineering Platforms)
▮▮▮▮▮▮▮▮▮▮▮ 6.1.1 OpenAI Playground
▮▮▮▮▮▮▮▮▮▮▮ 6.1.2 其他常用平台介绍
▮▮▮▮▮▮▮ 6.2 代码编辑器与 IDE 插件 (Code Editors and IDE Plugins)
▮▮▮▮▮▮▮▮▮▮▮ 6.2.1 集成 AI 辅助功能的编辑器 (Editors with Integrated AI Assistance)
▮▮▮▮▮▮▮▮▮▮▮ 6.2.2 常用插件推荐与使用指南 (Recommended Plugins and Usage Guide)
▮▮▮▮▮▮▮ 6.3 提示工程的开源库与框架 (Open-source Libraries and Frameworks for Prompt Engineering)
▮▮▮▮▮▮▮▮▮▮▮ 6.3.1 LangChain 等工具介绍
▮▮▮▮▮▮▮▮▮▮▮ 6.3.2 自定义工具与库的开发 (Development of Custom Tools and Libraries)
▮▮▮▮ 7. chapter 7： 最佳实践与未来趋势 (Best Practices and Future Trends)
▮▮▮▮▮▮▮ 7.1 提示工程的最佳实践 (Best Practices for Prompt Engineering)
▮▮▮▮▮▮▮▮▮▮▮ 7.1.1 迭代优化提示 (Iteratively Optimizing Prompts)
▮▮▮▮▮▮▮▮▮▮▮ 7.1.2 维护提示库 (Maintaining a Prompt Library)
▮▮▮▮▮▮▮▮▮▮▮ 7.1.3 团队协作与提示共享 (Team Collaboration and Prompt Sharing)
▮▮▮▮▮▮▮ 7.2 提示工程的未来发展趋势 (Future Trends in Prompt Engineering)
▮▮▮▮▮▮▮▮▮▮▮ 7.2.1 更智能的 AI 模型 (More Intelligent AI Models)
▮▮▮▮▮▮▮▮▮▮▮ 7.2.2 自动化提示工程 (Automated Prompt Engineering)
▮▮▮▮▮▮▮▮▮▮▮ 7.2.3 提示工程在软件工程领域的更广泛应用 (Wider Applications in Software Engineering)
▮▮▮▮ 8. chapter 8： 参考文献 (References)
▮▮▮▮▮▮▮ 8.1 相关书籍与论文 (Related Books and Papers)
▮▮▮▮▮▮▮ 8.2 在线资源与社区 (Online Resources and Communities)

1. chapter 1： 初探提示工程 (Introduction to Prompt Engineering)

1.1 人工智能辅助开发 (AI-Assisted Development) 的兴起

近年来，人工智能（Artificial Intelligence, AI）技术取得了 революционный 般的进步，尤其是在自然语言处理（Natural Language Processing, NLP）领域。大型语言模型（Large Language Models, LLMs）例如 GPT-3、GPT-4 等的出现，标志着人工智能技术在理解和生成人类语言方面达到了前所未有的水平。这些模型不仅能够进行流畅的对话，还能执行更为复杂的任务，例如文本摘要、机器翻译、代码生成等。

随着人工智能技术的日益成熟和普及，软件开发领域也正在经历一场深刻的变革。人工智能辅助开发 (AI-Assisted Development) 的概念应运而生，并迅速成为行业内的热点话题。人工智能辅助开发指的是利用人工智能技术来辅助软件开发过程，旨在提高开发效率、降低开发成本、并提升软件质量。

人工智能在软件开发中的应用场景日益广泛，例如：

① 代码生成 (Code Generation)：AI 模型可以根据自然语言描述或简单的指令，自动生成代码片段甚至完整的程序。这极大地减轻了程序员编写重复性代码的工作负担，让他们能够更专注于解决更复杂的问题。例如，GitHub Copilot、Codeium 等工具已经广泛应用于代码生成，显著提升了开发效率。
② 代码调试与错误修复 (Code Debugging and Error Fixing)：AI 模型可以分析代码中的错误信息，帮助程序员快速定位并修复 Bug。一些先进的 AI 工具甚至能够自动生成修复代码的建议，加速调试过程。
③ 代码解释与文档生成 (Code Explanation and Documentation Generation)：理解和维护代码库是软件开发中的一项重要任务。AI 模型可以帮助程序员快速理解代码的功能和逻辑，并自动生成代码注释、API 文档和用户手册，降低维护成本。
④ 代码重构与优化 (Code Refactoring and Optimization)：AI 模型可以分析代码的结构和性能，提供代码重构和优化的建议，帮助程序员编写更清晰、更高效的代码。
⑤ 测试用例生成 (Test Case Generation)：编写全面的测试用例是保证软件质量的关键环节。AI 模型可以根据代码的功能和逻辑，自动生成各种类型的测试用例，提高测试覆盖率和效率。

人工智能辅助开发的兴起，预示着软件开发模式的转变。程序员的角色也在悄然发生变化，从传统的“代码编写者”逐渐转变为“提示工程师 (Prompt Engineer)”和“AI 协作伙伴 (AI Collaborator)”。掌握提示工程技能，将成为程序员在新时代的核心竞争力。

1.2 什么是提示工程 (What is Prompt Engineering)？

提示工程 (Prompt Engineering) 是一门新兴的学科，专注于研究如何设计和优化 提示 (Prompt)，从而更有效地与大型语言模型（LLMs）等人工智能系统进行交互，以获得期望的输出结果。简单来说，提示工程就是“教导 AI 如何更好地为你工作”的艺术和科学。

在人工智能辅助开发的背景下，提示工程尤为重要。程序员可以通过精心设计的提示，引导 AI 模型完成各种编程任务，例如代码生成、代码调试、文档编写等。一个好的提示能够充分发挥 AI 模型的潜力，而一个糟糕的提示则可能导致模型产生错误或无用的输出。

提示工程并非简单的“提问”，而是一项需要技巧和策略的工作。它涉及到对 LLM 工作原理的理解、对任务目标的明确定义、以及对提示语的巧妙构建。有效的提示通常包含以下关键要素：

① 清晰的指令 (Clear Instructions)：明确告诉 AI 模型你希望它做什么，例如“生成一个 Python 函数，用于计算斐波那契数列”。
② 相关的上下文 (Relevant Context)：提供必要的背景信息，帮助 AI 模型更好地理解任务，例如“假设我们正在开发一个 Web 应用的后端 API”。
③ 具体的输入数据 (Specific Input Data)：如果任务需要处理特定的数据，需要在提示中提供这些数据，例如“请根据以下 JSON 数据生成对应的 TypeScript 接口定义：{ "name": "John", "age": 30 }”。
④ 明确的输出指示 (Explicit Output Indicators)： 指示 AI 模型输出的格式和内容，例如“请以 Markdown 格式输出代码，并添加详细的注释”。

提示工程的核心目标是 优化提示 (Prompt Optimization)，即通过不断地尝试、调整和改进提示，找到能够产生最佳结果的提示策略。这通常需要程序员具备一定的实验精神和迭代思维，不断探索不同的提示方法，并根据模型的反馈进行优化。

总而言之，提示工程是连接人类智慧和人工智能的关键桥梁。掌握提示工程技能，程序员将能够更好地利用 AI 技术，提升开发效率和创造力，迎接人工智能驱动的软件开发新时代。

1.3 为什么程序员需要学习提示工程 (Why Prompt Engineering for Programmers)?

在人工智能技术日新月异的今天，提示工程 (Prompt Engineering) 对于程序员而言，不再是一项可有可无的附加技能，而是一项至关重要的核心竞争力。原因如下：

① 提升开发效率，解放生产力：
借助提示工程，程序员可以将重复性、低创造性的编程任务交给 AI 模型完成，例如生成样板代码、编写单元测试、生成文档等。这极大地节省了程序员的时间和精力，让他们能够专注于解决更具挑战性和创新性的问题，例如系统架构设计、复杂业务逻辑实现、性能优化等。

② 降低学习成本，加速技术掌握：
面对不断涌现的新技术、新框架和新语言，程序员需要不断学习和适应。提示工程可以帮助程序员快速上手新技术。例如，可以通过提示 AI 模型生成特定框架的代码示例、解释复杂的 API 文档、甚至提供学习路径建议，从而加速学习过程，降低学习门槛。

③ 拓展编程能力，突破技能瓶颈：
提示工程不仅可以提升现有编程技能的效率，还能拓展程序员的编程能力边界。例如，即使程序员不熟悉某种编程语言，也可以通过提示 AI 模型生成该语言的代码，从而实现跨语言编程。此外，AI 模型还可以提供代码优化的新思路、发现潜在的 Bug，帮助程序员突破技能瓶颈，提升代码质量。

④ 适应未来趋势，掌握核心竞争力：
人工智能辅助开发已成为软件开发的未来趋势。掌握提示工程技能，意味着程序员能够更好地适应这一趋势，并在这个新的开发模式中占据优势地位。未来，能够熟练运用提示工程的程序员，将比传统程序员更具竞争力，更受市场青睐。

⑤ 促进人机协作，激发创新潜力：
提示工程不仅仅是利用 AI 工具，更是一种人机协作的模式。程序员通过提示与 AI 模型进行对话和交流，共同解决问题，激发创新灵感。这种人机协作的模式，可以产生超越人类或 AI 单独工作所能达到的效果，推动软件技术的创新发展。

简而言之，学习提示工程对于程序员而言，是 顺应时代发展、提升个人价值、掌握未来竞争力的必然选择。它不仅能够帮助程序员更高效地完成工作，更能够拓展他们的技能边界，激发创新潜力，让他们在人工智能时代保持领先地位。

1.4 本书的目标、结构与面向读者 (Book Objectives, Structure, and Target Audience)

本书 《Prompt Engineering for Programmers: A Practical Guide to AI-Assisted Development》 旨在成为程序员学习和掌握提示工程技能的 系统性、结构化、权威性 指南。本书的目标是：

① 构建知识框架 (Knowledge Framework)：系统地介绍提示工程的基础知识、核心概念、关键技巧和高级应用，帮助读者建立完整的提示工程知识体系。
② 提供丰富的应用实例 (Rich Application Examples)：结合大量的编程实例，演示如何将提示工程应用于代码生成、代码调试、文档生成、代码重构、测试用例生成等各种编程任务中，让读者能够 知其然，更知其所以然。
③ 打造实战指南 (Practical Guide)：注重实践操作，提供大量的实战案例分析、技巧总结和最佳实践建议，帮助读者快速上手提示工程，并将其应用于实际的软件开发项目中。
④ 提供参考文献 (References)： 引用最新的研究成果、工具资源和社区资料，为读者提供深入学习和持续提升的资源指引。

本书的结构安排如下：

⚝ 第 1 章：初探提示工程 (Introduction to Prompt Engineering)： 概述人工智能辅助开发的兴起，介绍提示工程的概念、重要性以及本书的目标、结构和面向读者。
⚝ 第 2 章：提示工程的基础知识 (Fundamentals of Prompt Engineering)： 介绍大型语言模型的基本原理、提示的基本构成要素、提示的类型以及影响提示效果的关键因素，为后续章节的学习打下坚实的基础。
⚝ 第 3 章：面向编程任务的提示工程技巧 (Prompt Engineering Techniques for Programming Tasks)： 详细讲解如何运用提示工程技巧解决各种编程任务，包括代码生成、代码调试、代码解释与文档生成、代码重构与优化、测试用例生成等，并结合丰富的案例进行演示。
⚝ 第 4 章：高级提示工程技巧 (Advanced Prompt Engineering Techniques)： 深入探讨思维链 (Chain-of-Thought, CoT) 等高级提示技巧的应用，介绍提示的迭代与优化方法，以及处理复杂任务的提示策略，帮助读者提升提示工程的水平。
⚝ 第 5 章：实战案例分析 (Practical Case Studies)： 通过三个典型的实战案例，演示如何将提示工程应用于实际的软件开发项目中，包括快速开发 RESTful API、自动化代码审查流程、构建智能代码助手 IDE 插件等，帮助读者将理论知识应用于实践。
⚝ 第 6 章：提示工程的工具与生态 (Tools and Ecosystem for Prompt Engineering)： 介绍常用的在线提示工程平台、代码编辑器与 IDE 插件、开源库与框架等工具资源，帮助读者选择合适的工具，提升提示工程的效率。
⚝ 第 7 章：最佳实践与未来趋势 (Best Practices and Future Trends)： 总结提示工程的最佳实践经验，探讨提示工程的未来发展趋势，帮助读者更好地应用和发展提示工程技能。
⚝ 第 8 章：参考文献 (References)： 提供相关的书籍、论文、在线资源和社区链接，方便读者深入学习和交流。

本书的 面向读者 (Target Audience) 包括：

⚝ 编程初学者 (Beginners)： 即使是编程零基础的读者，也可以通过本书了解人工智能辅助开发的基本概念和提示工程的入门知识，为未来的编程学习打下基础。
⚝ 中级程序员 (Intermediate Programmers)： 本书可以帮助中级程序员系统地学习提示工程的技巧和方法，提升开发效率，拓展编程能力，并在工作中更好地应用 AI 技术。
⚝ 高级程序员与技术专家 (Experts)： 本书的高级章节和实战案例分析，可以为高级程序员和技术专家提供更深入的思考和实践指导，帮助他们掌握提示工程的前沿技术，并在团队和组织中推广和应用提示工程。

无论你是编程新手还是经验丰富的开发者，相信本书都能为你提供有价值的知识和技能，助你在人工智能时代更好地进行软件开发，提升个人和团队的竞争力。

END_OF_CHAPTER

2. chapter 2： 提示工程的基础知识 (Fundamentals of Prompt Engineering)

2.1 大型语言模型 (Large Language Models, LLMs) 概览

大型语言模型（Large Language Models, LLMs）是现代提示工程的核心。理解 LLMs 的基本概念和工作原理，对于有效地进行提示工程至关重要。本节将概述 LLMs 的关键特性，并深入探讨 Transformer 架构以及预训练与微调这两个核心概念。

2.1.1 Transformer 架构 (Transformer Architecture) 简介

Transformer 架构是驱动当前最先进 LLMs 的基石。它由 Google 在 2017 年的论文 "Attention is All You Need" 中提出，并彻底改变了自然语言处理（Natural Language Processing, NLP）领域。相较于之前的循环神经网络（Recurrent Neural Networks, RNNs）和长短期记忆网络（Long Short-Term Memory networks, LSTMs），Transformer 架构在处理长序列数据时展现出显著的优势，并且能够更好地并行化计算，从而大大加速了模型的训练过程。

Transformer 架构的核心创新在于 自注意力机制 (Self-Attention Mechanism)。自注意力机制允许模型在处理序列中的每个位置时，能够同时关注到序列中所有其他位置的信息，并根据相关性赋予不同的权重。这种机制使得模型能够捕捉到文本中长距离的依赖关系，例如，理解句子中代词的指代对象，或者把握段落的主题和逻辑结构。

Transformer 模型主要由 编码器 (Encoder) 和 解码器 (Decoder) 两部分组成，或者仅使用解码器部分（例如，GPT 系列模型）。

① 编码器 (Encoder)：编码器的主要任务是将输入序列（例如，文本）转换为一种中间表示形式，也称为上下文向量或嵌入（Embedding）。这个中间表示捕捉了输入序列的语义信息。编码器由多层相同的 编码器层 (Encoder Layer) 堆叠而成。每个编码器层包含两个主要的子层：

▮▮▮▮ⓐ 多头自注意力层 (Multi-Head Self-Attention Layer)：这是 Transformer 的核心组件。它计算输入序列中每个词语与其他所有词语之间的相关性，并据此更新每个词语的表示。 “多头” 指的是使用多个独立的自注意力机制并行计算，然后将结果拼接起来，从而让模型能够从不同的角度关注输入序列的信息。
▮▮▮▮ⓑ 前馈神经网络层 (Feed-Forward Network Layer)：这是一个简单的全连接神经网络，对每个位置的表示进行独立的非线性变换，增强模型的表达能力。

② 解码器 (Decoder)：解码器的任务是根据编码器产生的中间表示，生成目标序列（例如，翻译后的文本，生成的代码）。解码器也由多层相同的 解码器层 (Decoder Layer) 堆叠而成。每个解码器层包含三个主要的子层：

▮▮▮▮ⓐ 掩码多头自注意力层 (Masked Multi-Head Self-Attention Layer)：与编码器中的自注意力层类似，但增加了一个 “掩码” 机制。掩码确保在生成序列的某个位置时，模型只能关注到之前已生成的位置，而不能 “看到” 未来的信息。这对于自回归生成任务（例如，文本生成）至关重要。
▮▮▮▮ⓑ 编码器-解码器注意力层 (Encoder-Decoder Attention Layer)：这一层连接编码器和解码器。它允许解码器在生成每个位置的词语时，关注到编码器产生的输入序列的中间表示，从而将输入序列的信息融入到生成过程中。
▮▮▮▮ⓒ 前馈神经网络层 (Feed-Forward Network Layer)：与编码器中的前馈神经网络层相同，用于增强模型的表达能力。

Transformer 架构的优势总结如下：

① 并行计算：自注意力机制允许模型并行处理序列中的所有位置，显著提高了训练速度。
② 长距离依赖：自注意力机制能够有效地捕捉长距离的依赖关系，克服了 RNNs 在处理长序列时的梯度消失问题。
③ 强大的表达能力：多层堆叠的 Transformer 层和多头注意力机制赋予模型强大的表达能力，使其能够学习复杂的语言模式。

Transformer 架构的成功，为 LLMs 的发展奠定了坚实的基础。例如，GPT (Generative Pre-trained Transformer) 系列模型就是基于 Transformer 解码器架构构建的。理解 Transformer 架构的基本原理，有助于我们更好地理解 LLMs 的能力和局限性，从而更有效地进行提示工程。

2.1.2 预训练与微调 (Pre-training and Fine-tuning)

预训练（Pre-training）和微调（Fine-tuning）是训练现代 LLMs 的核心范式。这种两阶段的训练方法使得模型能够先从海量无标签数据中学习通用的语言表示，然后在特定任务的有标签数据上进行微调，从而在各种 NLP 任务上取得优异的性能。

① 预训练 (Pre-training)：预训练阶段的目标是让模型学习通用的语言知识和表示。这个阶段通常使用海量的无标签文本数据，例如，互联网上的网页文本、书籍、新闻文章等。预训练任务的设计至关重要，常见的预训练任务包括：

▮▮▮▮ⓐ 掩码语言模型 (Masked Language Modeling, MLM)：例如，BERT 模型使用的预训练任务。MLM 的目标是随机掩盖输入文本中的一些词语，然后让模型预测被掩盖的词语。这迫使模型理解上下文信息，学习词语之间的关系。
▮▮▮▮ⓑ 因果语言模型 (Causal Language Modeling, CLM)：例如，GPT 模型使用的预训练任务。CLM 的目标是根据之前的词语预测下一个词语。这使得模型能够学习生成连贯的文本。
▮▮▮▮ⓒ 对比学习 (Contrastive Learning)：通过构建正负样本对，让模型学习区分相似和不相似的文本表示。这有助于模型学习更鲁棒的语义表示。

预训练阶段的模型通常非常庞大，参数量可达数十亿甚至数千亿。预训练需要大量的计算资源和时间。预训练完成后，模型就获得了一个通用的语言模型，具备了理解和生成文本的基本能力。

② 微调 (Fine-tuning)：微调阶段是在预训练模型的基础上，针对特定任务进行进一步的训练。这个阶段使用有标签的数据集，例如，情感分类、文本摘要、机器翻译等任务的数据集。微调的目标是让预训练模型适应特定的任务，提高在特定任务上的性能。

微调通常采用监督学习的方式进行。例如，对于情感分类任务，可以使用标注了情感极性的文本数据来微调预训练模型，使其能够更准确地判断文本的情感。微调阶段通常只需要较小的学习率和较少的训练数据，因为预训练模型已经学习到了大量的通用语言知识。

预训练和微调的优势在于：

① 知识迁移 (Knowledge Transfer)：预训练阶段学习到的通用语言知识可以迁移到各种下游任务中，提高了模型在各种任务上的性能。
② 数据效率 (Data Efficiency)：由于预训练模型已经具备了较好的初始化参数，微调阶段只需要少量的有标签数据就能达到很好的效果，降低了对有标签数据的需求。
③ 强大的泛化能力 (Strong Generalization Ability)：预训练模型在海量数据上学习，具备了强大的泛化能力，能够处理各种各样的文本输入。

预训练和微调已经成为训练 LLMs 的标准流程。理解预训练和微调的概念，有助于我们更好地理解 LLMs 的训练过程和能力来源，从而更好地利用 LLMs 进行提示工程。例如，我们可以根据任务的特点选择合适的预训练模型，并设计合适的微调策略，以获得更好的提示效果。

2.2 提示 (Prompt) 的基本构成要素 (Basic Components of a Prompt)

一个有效的提示（Prompt）通常由几个基本要素构成。理解这些要素，并有效地组织它们，是构建高质量提示的关键。一个典型的提示可以包含以下几个核心组成部分：指令（Instruction）、上下文（Context）、输入数据（Input Data）和输出指示（Output Indicator）。

2.2.1 指令 (Instruction)

指令（Instruction）是提示中最核心的部分，它明确地告诉 LLM 你希望它做什么。指令应该清晰、简洁、明确，避免歧义。指令的质量直接决定了 LLM 的输出质量。

指令可以包括：

① 任务类型：例如，"翻译成英文"、"生成代码"、"总结文章"、"回答问题" 等。明确任务类型有助于 LLM 理解你的意图。
② 约束条件：例如，"使用 Python 语言"、"字数限制在 100 字以内"、"风格要正式" 等。约束条件可以引导 LLM 生成符合特定要求的输出。
③ 角色设定：例如，"假设你是一位资深的软件工程师"、"扮演一位历史学家" 等。角色设定可以影响 LLM 的输出风格和内容。

示例：

⚝ 指令：将以下中文句子翻译成英文。
⚝ 指令：请用 Python 编写一个函数，计算斐波那契数列的第 n 项。
⚝ 指令：总结这篇新闻报道的主要内容，字数限制在 200 字以内。
⚝ 指令：你是一位专业的代码审查员，请审查以下代码，并指出潜在的 bug 和改进建议。

在实际应用中，指令可以根据具体任务进行灵活设计。关键是要确保指令能够清晰地传达你的意图，引导 LLM 生成期望的输出。

2.2.2 上下文 (Context)

上下文（Context）是指为 LLM 提供背景信息，帮助它更好地理解指令和输入数据。上下文可以包括相关的背景知识、示例、或者对话历史等。合适的上下文能够显著提高提示的效果，尤其是在处理复杂任务或者需要特定领域知识的任务时。

上下文可以包括：

① 背景知识：例如，在进行代码生成任务时，可以提供相关的 API 文档、库的使用说明等作为背景知识。
② 示例：少样本提示（Few-shot Prompting）中，会提供一些输入输出示例作为上下文，引导 LLM 学习期望的输出模式。
③ 对话历史：在对话系统中，之前的对话轮次可以作为上下文，帮助 LLM 理解当前对话的语境。
④ 相关文档或数据：例如，在问答系统中，可以提供相关的文档作为上下文，让 LLM 从文档中寻找答案。

示例：

⚝ 任务：根据用户评论判断情感极性。
⚝ 上下文：用户评论：“这家餐厅的菜品很美味，服务也很周到，下次还会再来！”
⚝ 指令：判断用户评论的情感极性（正面/负面）。

在这个例子中，用户评论本身就是上下文，它提供了判断情感极性的依据。

⚝ 任务：生成一段关于人工智能发展历程的介绍。
⚝ 上下文：背景知识：人工智能起源于 20 世纪 50 年代，经历了多次发展浪潮和低谷，近年来随着深度学习技术的突破，再次迎来快速发展。
⚝ 指令：请根据以上背景知识，生成一段 200 字左右的人工智能发展历程介绍。

在这个例子中，背景知识作为上下文，帮助 LLM 生成更准确、更全面的介绍。

合理利用上下文，可以有效地提升提示的质量和效果。在设计提示时，要根据任务的特点，考虑是否需要提供额外的上下文信息，以及如何组织和呈现这些信息。

2.2.3 输入数据 (Input Data)

输入数据（Input Data）是提示中需要 LLM 处理的具体内容。根据任务的不同，输入数据可以是文本、代码、图像、音频等各种形式。输入数据的质量和形式也会影响 LLM 的输出结果。

输入数据可以是：

① 文本：例如，需要翻译的句子、需要总结的文章、需要分析的用户评论等。
② 代码：例如，需要调试的代码片段、需要解释的代码函数、需要重构的代码模块等。
③ 结构化数据：例如，JSON、CSV 等格式的数据，可以用于数据分析、数据生成等任务。
④ 多模态数据：例如，图像、音频、视频等，可以用于多模态任务，例如，图像描述生成、语音识别等。

示例：

⚝ 指令：翻译成英文。
⚝ 输入数据： “你好，世界！”

在这个例子中，“你好，世界！” 就是输入数据，LLM 需要将其翻译成英文。

⚝ 指令：请解释以下 Python 代码的功能。
⚝ 输入数据：

                                
                                    

                            
1
                            
def factorial(n):
                        

                            
2
                            
    if n == 0:
                        

                            
3
                            
        return 1
                        

                            
4
                            
    else:
                        

                            
5
                            
        return n * factorial(n-1)
                        
                                
                            

在这个例子中，Python 代码片段就是输入数据，LLM 需要解释这段代码的功能。

在提示工程中，要根据任务的类型和要求，准备合适的输入数据。对于复杂的任务，可能需要对输入数据进行预处理，例如，文本清洗、数据格式转换等，以提高提示的效果。

2.2.4 输出指示 (Output Indicator)

输出指示（Output Indicator）是提示中用来引导 LLM 生成特定格式或特定类型输出的指令。输出指示可以包括期望的输出格式、输出长度、输出风格等。通过明确输出指示，可以更好地控制 LLM 的输出结果，使其更符合我们的需求。

输出指示可以包括：

① 输出格式：例如，"以 JSON 格式输出"、"以 Markdown 格式输出"、"生成一个列表" 等。
② 输出长度：例如，"字数限制在 100 字以内"、"生成一段不超过 5 行的代码" 等。
③ 输出风格：例如，"风格要正式"、"风格要幽默"、"用简洁明了的语言" 等。
④ 输出类型：例如，"生成代码"、"生成摘要"、"生成翻译"、"生成答案" 等。

示例：

⚝ 指令：总结这篇文章的主要内容。
⚝ 输出指示：字数限制在 200 字以内。

在这个例子中，“字数限制在 200 字以内” 就是输出指示，它限制了 LLM 生成的摘要的长度。

⚝ 指令：请用 Python 编写一个函数，计算斐波那契数列的第 n 项。
⚝ 输出指示：请提供代码，并添加详细的注释。

在这个例子中，“请提供代码，并添加详细的注释” 就是输出指示，它要求 LLM 生成代码，并添加注释。

合理使用输出指示，可以有效地引导 LLM 生成符合期望的输出结果。在设计提示时，要根据任务的需求，明确输出指示，以便更好地控制 LLM 的行为。

2.3 提示的类型 (Types of Prompts)

根据提示中提供的示例数量和提示策略的不同，可以将提示分为不同的类型。常见的提示类型包括零样本提示（Zero-shot Prompting）、少样本提示（Few-shot Prompting）、思维链提示（Chain-of-Thought Prompting）和角色扮演提示（Role-Playing Prompting）等。

2.3.1 零样本提示 (Zero-shot Prompting)

零样本提示（Zero-shot Prompting）是最简单的提示方式。在零样本提示中，我们只提供指令，不提供任何示例。LLM 需要完全依靠其在预训练阶段学到的知识来完成任务。

零样本提示的优点是简单直接，不需要额外的示例数据。但其缺点是，对于复杂的任务或者需要特定输出格式的任务，零样本提示的效果可能不够理想。

示例：

⚝ 指令：将以下中文句子翻译成英文：“今天天气真好！”

在这个例子中，我们只提供了翻译指令和待翻译的句子，没有提供任何翻译示例。LLM 需要直接根据指令进行翻译。

零样本提示适用于一些比较简单、直接的任务，例如，简单的翻译、简单的问答、简单的文本分类等。对于更复杂的任务，可能需要使用更高级的提示技巧。

2.3.2 少样本提示 (Few-shot Prompting)

少样本提示（Few-shot Prompting）是在提示中提供少量的输入输出示例（通常是 1-5 个），以帮助 LLM 更好地理解任务，并学习期望的输出模式。少样本提示可以显著提高 LLM 在复杂任务上的性能，尤其是在零样本提示效果不佳的情况下。

少样本提示的优点是能够有效地引导 LLM 学习任务的特点和期望的输出格式，提高输出质量。缺点是需要准备少量的示例数据，并且示例的选择和组织也会影响提示的效果。

示例：

⚝ 指令：判断电影评论的情感极性（正面/负面）。
⚝ 示例：
▮▮▮▮⚝ 输入：“这部电影太棒了，剧情紧凑，演员演技精湛，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“剧情平淡，节奏拖沓，浪费时间。” -> 输出：负面
▮▮▮▮⚝ 输入：“特效很炫酷，但剧情空洞。” -> 输出：中性
▮▮▮▮⚝ 输入：“演员表现出色，但剧本有缺陷。” -> 输出：中性
▮▮▮▮⚝ 输入：“非常感人，看完热泪盈眶。” -> 输出：正面
▮▮▮▮⚝ 输入：“这部电影真是烂透了！” -> 输出：负面
▮▮▮▮⚝ 输入：“还行吧，中规中矩。” -> 输出：中性
▮▮▮▮⚝ 输入：“超出预期，惊喜连连！” -> 输出：正面
▮▮▮▮⚝ 输入：“令人失望，毫无亮点。” -> 输出：负面
▮▮▮▮⚝ 输入：“值得一看，推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“不推荐，浪费钱。” -> 输出：负面
▮▮▮▮⚝ 输入：“一般般，没啥感觉。” -> 输出：中性
▮▮▮▮⚝ 输入：“太精彩了，年度最佳！” -> 输出：正面
▮▮▮▮⚝ 输入：“简直是灾难片！” -> 输出：负面
▮▮▮▮⚝ 输入：“还不错，可以看看。” -> 输出：正面
▮▮▮▮⚝ 输入：“无聊至极，昏昏欲睡。” -> 输出：负面
▮▮▮▮⚝ 输入：“非常喜欢，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“太差劲了，不忍直视。” -> 输出：负面
▮▮▮▮⚝ 输入：“还可以，打发时间。” -> 输出：中性
▮▮▮▮⚝ 输入：“绝对经典，不容错过！” -> 输出：正面
▮▮▮▮⚝ 输入：“简直是侮辱观众智商！” -> 输出：负面
▮▮▮▮⚝ 输入：“马马虎虎，凑合着看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级好看，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“垃圾电影，浪费生命！” -> 输出：负面
▮▮▮▮⚝ 输入：“一般般，没啥亮点。” -> 输出：中性
▮▮▮▮⚝ 输入：“非常精彩，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片一部，不值得看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“太好看了，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂到家了，不看为妙。” -> 输出：负面
▮▮▮▮⚝ 输入：“一般，没啥意思。” -> 输出：中性
▮▮▮▮⚝ 输入：“非常棒，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别浪费时间。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂透了，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“一般，没啥感觉。” -> 输出：中性
▮▮▮▮⚝ 输入：“非常赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，不推荐。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级棒，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮⚝ 输入：“超级赞，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“烂片，别看。” -> 输出：负面
▮▮▮▮⚝ 输入：“还行，可以看看。” -> 输出：中性
▮▮▮▮▮▮▮▮⚝ 输入：“这部电影太棒了，剧情紧凑，演员演技精湛，强烈推荐！” -> 输出：正面
▮▮▮▮⚝ 输入：“剧情平淡，节奏拖沓，浪费时间。” -> 输出：负面
▮▮▮▮⚝ 输入：“特效很炫酷，但剧情空洞。” -> 输出：中性
▮▮▮▮⚝ ... (更多示例)
⚝ 指令：判断以下电影评论的情感极性（正面/负面/中性）： “这部电影的特效非常出色，但剧情略显薄弱。”

在这个例子中，我们提供了几个电影评论情感分类的示例，帮助 LLM 理解任务，并学习如何判断情感极性。然后，我们给出一个新的评论，让 LLM 进行分类。

少样本提示适用于需要模型学习特定模式或风格的任务，例如，风格迁移、复杂的关系抽取、多步推理等。通过提供示例，可以有效地引导 LLM 生成更符合期望的输出。

2.3.3 思维链提示 (Chain-of-Thought Prompting)

思维链提示（Chain-of-Thought Prompting, CoT）是一种更高级的提示技巧，旨在引导 LLM 模拟人类的思考过程，逐步推理，最终得出答案。CoT 提示的核心思想是在提示中显式地引导 LLM 展示其推理步骤，而不仅仅是直接给出最终答案。

CoT 提示通常通过在少样本示例中加入推理过程的描述来实现。例如，对于一个数学问题，可以引导 LLM 先分解问题，然后逐步计算，最后给出答案。

CoT 提示的优点是能够提高 LLM 在复杂推理任务上的性能，尤其是在需要多步推理或者需要利用外部知识的任务上。缺点是提示设计相对复杂，需要仔细设计推理步骤的引导。

示例：

⚝ 任务：计算 12 * 15 的结果。
⚝ 零样本提示：
▮▮▮▮⚝ 指令：计算 12 * 15 的结果。
▮▮▮▮⚝ 输出：180

⚝ 思维链提示 (Few-shot CoT)：
▮▮▮▮⚝ 示例：
▮▮▮▮▮▮▮▮⚝ 输入：计算 2 * 3 的结果。
▮▮▮▮▮▮▮▮⚝ 思维链：首先，2 乘以 3 等于 6。所以答案是 6。
▮▮▮▮▮▮▮▮⚝ 输出：6
▮▮▮▮▮▮▮▮⚝ 输入：计算 5 * 7 的结果。
▮▮▮▮▮▮▮▮⚝ 思维链：首先，5 乘以 7 等于 35。所以答案是 35。
▮▮▮▮▮▮▮▮⚝ 输出：35
▮▮▮▮⚝ 指令：计算 12 * 15 的结果。
▮▮▮▮⚝ 思维链：首先，12 乘以 10 等于 120，然后 12 乘以 5 等于 60，最后 120 加上 60 等于 180。所以答案是 180。
▮▮▮▮⚝ 输出：180

在这个例子中，思维链提示通过示例引导 LLM 展示了计算过程，使得 LLM 在处理更复杂的计算问题时，能够更可靠地得出正确答案。

思维链提示适用于需要复杂推理的任务，例如，数学问题、逻辑推理、常识推理等。通过引导 LLM 展示推理过程，可以提高模型的可解释性和可靠性。

2.3.4 角色扮演提示 (Role-Playing Prompting)

角色扮演提示（Role-Playing Prompting）是指在提示中设定 LLM 的角色，让 LLM 以特定的身份和视角来回答问题或完成任务。角色扮演提示可以有效地引导 LLM 生成更符合特定领域或特定风格的输出。

角色扮演提示的优点是能够利用 LLM 的知识和生成能力，模拟不同领域专家的思维方式和表达风格，从而获得更专业、更个性化的输出。缺点是角色设定需要与任务目标相匹配，不恰当的角色设定可能会适得其反。

示例：

⚝ 任务：解释什么是区块链技术。
⚝ 角色扮演提示：
▮▮▮▮⚝ 指令：假设你是一位资深的区块链技术专家，请用通俗易懂的语言解释什么是区块链技术，并举例说明其应用场景。

在这个例子中，通过设定 LLM 的角色为 “资深的区块链技术专家”，可以引导 LLM 从专业的角度，用更权威、更深入的语言来解释区块链技术。

⚝ 任务：为初学者介绍 Python 编程语言。
⚝ 角色扮演提示：
▮▮▮▮⚝ 指令：你是一位经验丰富的 Python 编程导师，请为编程初学者介绍 Python 编程语言的特点、应用领域以及学习路径。

在这个例子中，通过设定 LLM 的角色为 “经验丰富的 Python 编程导师”，可以引导 LLM 从教学的角度，用更友好、更易懂的语言来介绍 Python 编程语言，并提供学习建议。

角色扮演提示适用于需要特定领域知识或特定风格的任务，例如，技术咨询、创意写作、教育辅导等。通过合理设定角色，可以有效地提高提示的效果和输出质量。

2.4 影响提示效果的关键因素 (Key Factors Influencing Prompt Effectiveness)

提示工程的有效性受到多种因素的影响。理解这些关键因素，并在实践中加以注意和优化，是提高提示效果的关键。影响提示效果的主要因素包括：清晰度与简洁性、指令的明确性、上下文的相关性等。

2.4.1 清晰度与简洁性 (Clarity and Conciseness)

提示的清晰度（Clarity）和简洁性（Conciseness）是影响提示效果的首要因素。一个清晰简洁的提示能够更准确地传达意图，减少 LLM 的理解偏差，从而提高输出质量。

① 清晰度 (Clarity)：提示的语言应该清晰明确，避免使用模糊、歧义的词语和句子。要确保指令、上下文、输入数据和输出指示都能够被 LLM 准确理解。

② 简洁性 (Conciseness)：提示的语言应该简洁明了，避免冗余、复杂的句子结构。在保证信息完整的前提下，尽量使用简洁的语言表达，提高提示的效率。

优化建议：

① 使用明确的动词：例如，使用 “翻译”、“总结”、“生成”、“解释” 等明确的任务动词，避免使用 “可以”、“能否” 等模糊的表达。
② 避免使用双重否定：例如，将 “不要不这样做” 改为 “请这样做”。
③ 拆分复杂句子：将复杂的长句子拆分成多个简单句，提高可读性。
④ 去除冗余信息：检查提示中是否包含不必要的词语和句子，删除冗余信息，保持提示的简洁。

示例：

⚝ 不清晰的提示：你能不能大概把这篇文章的主要意思告诉我一下？
⚝ 清晰简洁的提示：请总结这篇文章的主要内容。

⚝ 不简洁的提示：请你使用 Python 编程语言，编写一段代码，这段代码的功能是计算从 1 加到 100 的和，并且请你把代码输出给我。
⚝ 简洁的提示：请用 Python 编写代码，计算 1 到 100 的和。

提高提示的清晰度和简洁性，可以有效地提高 LLM 的理解准确率和输出质量。在实际应用中，要不断优化提示的语言表达，使其更加清晰简洁。

2.4.2 指令的明确性 (Specificity of Instructions)

指令的明确性（Specificity of Instructions）是指指令需要足够具体、明确，能够指导 LLM 生成期望的输出。指令越明确，LLM 越容易理解任务目标，并生成符合要求的输出。

指令的明确性可以体现在以下几个方面：

① 任务目标的明确：明确告诉 LLM 你希望它完成什么任务，例如，是翻译、摘要、代码生成，还是问答等。
② 约束条件的明确：如果对输出有特定的约束条件，例如，语言、格式、长度、风格等，需要在指令中明确指出。
③ 输出要求的明确：明确告诉 LLM 你期望的输出类型和格式，例如，是文本、代码、JSON，还是列表等。

优化建议：

① 明确指定编程语言：在代码生成任务中，明确指定编程语言，例如，"使用 Python 编写..."、"用 Java 实现..."。
② 明确指定输出格式：如果需要 JSON 格式输出，明确指出 "以 JSON 格式输出"。
③ 明确指定长度限制：如果需要摘要字数限制，明确指出 "字数限制在 200 字以内"。
④ 明确指定风格要求：如果需要特定风格的文本，例如，"风格要正式"、"风格要幽默"，需要在指令中明确指出。

示例：

⚝ 不明确的指令：写一段代码。
⚝ 明确的指令：请用 Python 编写一个函数，计算斐波那契数列的第 n 项。

⚝ 不明确的指令：总结一下这篇文章。
⚝ 明确的指令：请总结这篇文章的主要内容，字数限制在 200 字以内。

提高指令的明确性，可以有效地引导 LLM 生成更符合期望的输出结果。在实际应用中，要根据任务的需求，尽可能地明确指令，减少 LLM 的理解偏差。

2.4.3 上下文的相关性 (Relevance of Context)

上下文的相关性（Relevance of Context）是指提供的上下文信息需要与任务目标和输入数据高度相关。相关的上下文能够为 LLM 提供有用的背景知识和语境信息，帮助它更好地理解任务，并生成更准确、更合理的输出。

不相关的上下文信息可能会干扰 LLM 的理解，降低提示的效果。因此，在提示工程中，要仔细选择和组织上下文信息，确保其与任务的高度相关性。

上下文的相关性可以体现在以下几个方面：

① 背景知识的相关性：提供的背景知识需要与任务主题密切相关，能够帮助 LLM 理解任务的领域知识。
② 示例的相关性：少样本提示中的示例需要与当前任务类型和输入数据相似，能够引导 LLM 学习正确的输出模式。
③ 对话历史的相关性：在对话系统中，对话历史需要与当前对话轮次相关，能够提供对话的语境信息。

优化建议：

① 筛选相关背景知识：在提供背景知识时，要筛选与任务主题最相关的知识，避免提供无关或冗余的信息。
② 选择相似的示例：在少样本提示中，选择与当前任务输入数据相似的示例，提高示例的引导效果。
③ 维护相关的对话历史：在对话系统中，维护相关的对话历史，过滤掉无关的对话轮次，提高对话的连贯性。

示例：

⚝ 任务：根据用户评论判断情感极性。
⚝ 相关上下文：用户评论：“这家餐厅的菜品很美味，服务也很周到，下次还会再来！”
⚝ 不相关上下文：天气预报：“今天晴转多云，气温 25-30 摄氏度。”

在这个例子中，用户评论是判断情感极性的相关上下文，而天气预报是无关上下文。使用相关上下文能够提高情感分类的准确性，而使用无关上下文则会干扰 LLM 的判断。

提高上下文的相关性，可以有效地提高 LLM 的理解能力和输出质量。在实际应用中，要仔细选择和组织上下文信息，确保其与任务的高度相关性，从而获得更好的提示效果。

END_OF_CHAPTER

3. chapter 3： 面向编程任务的提示工程技巧 (Prompt Engineering Techniques for Programming Tasks)

3.1 代码生成 (Code Generation)

3.1.1 基本代码生成提示 (Basic Code Generation Prompts)

代码生成是提示工程在编程领域中最直接和最常用的应用之一。通过简单的自然语言描述，我们可以指示大型语言模型 (Large Language Models, LLMs) 生成各种类型的代码。本节将介绍一些基本的代码生成提示技巧，帮助读者快速入门。

① 指令性提示 (Instructional Prompts)：
最基础的代码生成提示是直接给出明确的指令，告诉模型需要生成什么代码。例如：

                                
                                    

                            
1
                            
请用 Python 编写一个函数，计算两个数的和。
                        
                                
                            

模型可能会生成如下代码：

                                
                                    

                            
1
                            
def add_numbers(a, b):
                        

                            
2
                            
  """
                        

                            
3
                            
  该函数计算两个数的和。
                        

                            
4
                            
  """
                        

                            
5
                            
  return a + b
                        

                            
6
                            

                        

                            
7
                            
# 示例
                        

                            
8
                            
result = add_numbers(5, 3)
                        

                            
9
                            
print(result)  # 输出 8
                        
                                
                            

② 示例驱动提示 (Example-driven Prompts)：
提供输入输出示例可以更清晰地表达需求，尤其是在逻辑较为复杂时。例如：

                                
                                    

                            
1
                            
任务：编写一个函数，判断一个数是否为偶数。
                        

                            
2
                            

                        

                            
3
                            
示例：
                        

                            
4
                            
输入：4
                        

                            
5
                            
输出：True
                        

                            
6
                            

                        

                            
7
                            
输入：7
                        

                            
8
                            
输出：False
                        

                            
9
                            

                        

                            
10
                            
请用 Python 实现该函数。
                        
                                
                            

模型可能会生成：

                                
                                    

                            
1
                            
def is_even(number):
                        

                            
2
                            
  """
                        

                            
3
                            
  判断一个数是否为偶数。
                        

                            
4
                            
  """
                        

                            
5
                            
  return number % 2 == 0
                        

                            
6
                            

                        

                            
7
                            
# 示例
                        

                            
8
                            
print(is_even(4))  # 输出 True
                        

                            
9
                            
print(is_even(7))  # 输出 False
                        
                                
                            

③ 补全式提示 (Completion Prompts)：
对于简单的代码片段，可以使用补全式提示，让模型续写代码。例如，我们只想让模型完成函数体：

                                
                                    

                            
1
                            
def greet(name):
                        

                            
2
                            
  # 在下方续写函数体，实现打印问候语的功能
                        
                                
                            

模型可能会补全：

                                
                                    

                            
1
                            
def greet(name):
                        

                            
2
                            
  # 在下方续写函数体，实现打印问候语的功能
                        

                            
3
                            
  print(f"Hello, {name}!")
                        

                            
4
                            

                        

                            
5
                            
# 示例
                        

                            
6
                            
greet("Alice") # 输出 Hello, Alice!
                        
                                
                            

这些基本提示方法简单易用，适用于快速生成简单的代码片段。在实际应用中，可以根据具体需求灵活选择合适的提示方式。

3.1.2 指定编程语言和范式 (Specifying Programming Language and Paradigm)

在进行代码生成时，明确指定编程语言和编程范式至关重要。不同的编程语言和范式有其独特的语法、特性和适用场景。清晰地指定这些信息可以帮助模型更准确地理解需求，生成符合预期的代码。

① 指定编程语言 (Specifying Programming Language)：
在提示中直接指出所需的编程语言是最基本的操作。例如：

                                
                                    

                            
1
                            
请用 Java 编写一个类，实现栈 (Stack) 数据结构。
                        
                                
                            

模型会生成 Java 代码：

                                
                                    

                            
1
                            
public class Stack {
                        

                            
2
                            
    private int maxSize;
                        

                            
3
                            
    private int[] stackArray;
                        

                            
4
                            
    private int top;
                        

                            
5
                            

                        

                            
6
                            
    public Stack(int size) {
                        

                            
7
                            
        maxSize = size;
                        

                            
8
                            
        stackArray = new int[maxSize];
                        

                            
9
                            
        top = -1;
                        

                            
10
                            
    }
                        

                            
11
                            

                        

                            
12
                            
    public void push(int value) {
                        

                            
13
                            
        if (top < maxSize - 1) {
                        

                            
14
                            
            stackArray[++top] = value;
                        

                            
15
                            
        } else {
                        

                            
16
                            
            System.out.println("Stack Overflow");
                        

                            
17
                            
        }
                        

                            
18
                            
    }
                        

                            
19
                            

                        

                            
20
                            
    public int pop() {
                        

                            
21
                            
        if (top >= 0) {
                        

                            
22
                            
            return stackArray[top--];
                        

                            
23
                            
        } else {
                        

                            
24
                            
            System.out.println("Stack Underflow");
                        

                            
25
                            
            return -1; // 或者抛出异常
                        

                            
26
                            
        }
                        

                            
27
                            
    }
                        

                            
28
                            

                        

                            
29
                            
    public boolean isEmpty() {
                        

                            
30
                            
        return (top == -1);
                        

                            
31
                            
    }
                        

                            
32
                            

                        

                            
33
                            
    // ... 其他方法
                        

                            
34
                            
}
                        
                                
                            

如果需要生成其他语言的代码，只需更改提示中的语言名称即可。例如，将 "Java" 替换为 "Python"、"JavaScript" 或 "C++"。

② 指定编程范式 (Specifying Programming Paradigm)：
除了编程语言，编程范式也会影响代码的结构和风格。常见的编程范式包括：

⚝ 面向对象编程 (Object-Oriented Programming, OOP)：强调使用对象和类来组织代码。
⚝ 函数式编程 (Functional Programming, FP)：强调使用纯函数和不可变数据。
⚝ 命令式编程 (Imperative Programming)：强调通过改变程序状态来完成计算。
⚝ 声明式编程 (Declarative Programming)：强调描述期望的结果，而不是具体的步骤。

在提示中指定编程范式，可以引导模型生成特定风格的代码。例如，要求使用函数式编程风格实现某个功能：

                                
                                    

                            
1
                            
请用 JavaScript 函数式编程风格编写一个函数，计算列表中所有偶数的平方和。
                        
                                
                            

模型可能会生成如下代码：

                                
                                    

                            
1
                            
const sumOfSquaresOfEvens = (numbers) => {
                        

                            
2
                            
  return numbers
                        

                            
3
                            
    .filter(number => number % 2 === 0)
                        

                            
4
                            
    .map(number => number ** 2)
                        

                            
5
                            
    .reduce((sum, square) => sum + square, 0);
                        

                            
6
                            
};
                        

                            
7
                            

                        

                            
8
                            
// 示例
                        

                            
9
                            
const numbers = [1, 2, 3, 4, 5, 6];
                        

                            
10
                            
console.log(sumOfSquaresOfEvens(numbers)); // 输出 56 (4 + 16 + 36)
                        
                                
                            

通过指定编程语言和范式，可以更精确地控制代码生成的方向，提高生成代码的质量和适用性。在实际项目中，根据项目需求和团队技术栈选择合适的语言和范式，并在提示中明确指出，是提高开发效率的关键。

3.1.3 利用注释生成代码 (Generating Code from Comments)

利用注释生成代码是一种高效且直观的编程方式。程序员可以使用自然语言在注释中描述代码逻辑，然后通过提示工程技术将注释转换为实际的代码。这种方法特别适用于快速原型开发和生成代码框架。

① 单行注释生成 (Single-line Comment Generation)：
最简单的形式是从单行注释生成代码。例如，在 Python 中，我们可以写下注释：

                                
                                    

                            
1
                            
# 定义一个函数，接收一个字符串参数，并返回其反转后的字符串
                        
                                
                            

然后，我们可以提示模型根据这个注释生成代码。模型可能会生成：

                                
                                    

                            
1
                            
# 定义一个函数，接收一个字符串参数，并返回其反转后的字符串
                        

                            
2
                            
def reverse_string(s):
                        

                            
3
                            
  return s[::-1]
                        

                            
4
                            

                        

                            
5
                            
# 示例
                        

                            
6
                            
print(reverse_string("hello")) # 输出 olleh
                        
                                
                            

② 多行注释 (文档字符串) 生成 (Multi-line Comment (Docstring) Generation)：
对于函数、类或模块，通常使用多行注释（在 Python 中称为文档字符串 docstring）来描述其功能、参数和返回值。我们可以利用这些文档字符串作为提示，生成函数或类的骨架代码。例如，在 Java 中：

                                
                                    

                            
1
                            
/**
                        

                            
2
                            
 * 这是一个简单的计算器类，提供加法和减法功能。
                        

                            
3
                            
 * @author Lecturer
                        

                            
4
                            
 * @version 1.0
                        

                            
5
                            
 */
                        

                            
6
                            
public class Calculator {
                        

                            
7
                            

                        

                            
8
                            
    // 加法运算
                        

                            
9
                            
    // @param a 加数
                        

                            
10
                            
    // @param b 被加数
                        

                            
11
                            
    // @return 两数之和
                        

                            
12
                            
    public int add(int a, int b) {
                        

                            
13
                            
        // TODO: 实现加法逻辑
                        

                            
14
                            
    }
                        

                            
15
                            

                        

                            
16
                            
    // 减法运算
                        

                            
17
                            
    // @param a 被减数
                        

                            
18
                            
    // @param b 减数
                        

                            
19
                            
    // @return 两数之差
                        

                            
20
                            
    public int subtract(int a, int b) {
                        

                            
21
                            
        // TODO: 实现减法逻辑
                        

                            
22
                            
    }
                        

                            
23
                            
}
                        
                                
                            

我们可以提示模型根据类和方法的注释，填充 TODO 部分的代码。模型可能会生成：

                                
                                    

                            
1
                            
/**
                        

                            
2
                            
 * 这是一个简单的计算器类，提供加法和减法功能。
                        

                            
3
                            
 * @author Lecturer
                        

                            
4
                            
 * @version 1.0
                        

                            
5
                            
 */
                        

                            
6
                            
public class Calculator {
                        

                            
7
                            

                        

                            
8
                            
    // 加法运算
                        

                            
9
                            
    // @param a 加数
                        

                            
10
                            
    // @param b 被加数
                        

                            
11
                            
    // @return 两数之和
                        

                            
12
                            
    public int add(int a, int b) {
                        

                            
13
                            
        return a + b;
                        

                            
14
                            
    }
                        

                            
15
                            

                        

                            
16
                            
    // 减法运算
                        

                            
17
                            
    // @param a 被减数
                        

                            
18
                            
    // @param b 减数
                        

                            
19
                            
    // @return 两数之差
                        

                            
20
                            
    public int subtract(int a, int b) {
                        

                            
21
                            
        return a - b;
                        

                            
22
                            
    }
                        

                            
23
                            
}
                        
                                
                            

③ 混合使用注释和代码片段 (Mixed Use of Comments and Code Snippets)：
在实际开发中，我们还可以混合使用注释和已有的代码片段作为提示。例如，我们可能已经写好函数签名和部分逻辑，但希望模型根据注释完成剩余部分：

                                
                                    

                            
1
                            
def process_data(data):
                        

                            
2
                            
  """
                        

                            
3
                            
  处理输入数据，步骤如下：
                        

                            
4
                            
  1. 过滤掉空值
                        

                            
5
                            
  2. 将所有字符串转换为小写
                        

                            
6
                            
  3. 去除首尾空格
                        

                            
7
                            
  4. 返回处理后的数据列表
                        

                            
8
                            
  """
                        

                            
9
                            
  # TODO: 实现数据处理逻辑
                        

                            
10
                            
  return data # 占位符，需要替换为实际代码
                        
                                
                            

模型可以根据注释和已有的函数框架，生成完整的函数体：

                                
                                    

                            
1
                            
def process_data(data):
                        

                            
2
                            
  """
                        

                            
3
                            
  处理输入数据，步骤如下：
                        

                            
4
                            
  1. 过滤掉空值
                        

                            
5
                            
  2. 将所有字符串转换为小写
                        

                            
6
                            
  3. 去除首尾空格
                        

                            
7
                            
  4. 返回处理后的数据列表
                        

                            
8
                            
  """
                        

                            
9
                            
  processed_data = []
                        

                            
10
                            
  for item in data:
                        

                            
11
                            
    if item is not None: # 过滤空值
                        

                            
12
                            
      item = str(item).lower().strip() # 转换为字符串，小写，去除空格
                        

                            
13
                            
      processed_data.append(item)
                        

                            
14
                            
  return processed_data
                        

                            
15
                            

                        

                            
16
                            
# 示例
                        

                            
17
                            
data = ["  Hello ", None, "WORLD  ", "Python"]
                        

                            
18
                            
processed_data = process_data(data)
                        

                            
19
                            
print(processed_data) # 输出 ['hello', 'world', 'python']
                        
                                
                            

利用注释生成代码，可以将编程过程从传统的“先思考，后编码”模式，转变为“先注释，后生成，再完善”的模式。这种模式更符合人类的思维习惯，可以提高编程效率和代码可读性。

3.1.4 复杂代码逻辑的分解与提示 (Decomposition and Prompting for Complex Logic)

当面临复杂的编程任务时，直接使用一个笼统的提示往往难以得到满意的结果。大型语言模型虽然强大，但在处理复杂逻辑时也可能出现理解偏差或生成错误代码。为了解决这个问题，我们需要将复杂任务分解为更小的、更具体的子任务，并针对每个子任务设计相应的提示。这种“分而治之”的策略可以显著提高代码生成的质量和准确性。

① 任务分解 (Task Decomposition)：
将复杂任务分解为一系列更小的、可管理的子任务是关键的第一步。分解的方法可以根据任务的性质和逻辑流程来确定。常见的分解策略包括：

⚝ 按功能模块分解：将任务分解为不同的功能模块，例如用户认证模块、数据处理模块、UI 渲染模块等。
⚝ 按步骤分解：将任务分解为完成任务所需的步骤序列，例如数据读取、数据清洗、数据分析、结果展示等。
⚝ 按抽象层次分解：从高层次抽象描述开始，逐步细化到具体的实现细节。

例如，假设我们要开发一个电商网站的订单处理系统。我们可以将其分解为以下子任务：

1. 订单创建：用户提交订单，包括商品信息、用户信息、支付信息等。
2. 订单支付：处理用户支付，验证支付状态。
3. 库存管理：更新商品库存，防止超卖。
4. 物流配送：安排商品发货，跟踪物流信息。
5. 订单状态更新：更新订单状态，例如已支付、已发货、已完成等。

② 子任务提示 (Sub-task Prompts)：
针对每个子任务，设计具体的提示。提示应尽可能清晰、明确，并包含完成子任务所需的所有信息。例如，对于“订单创建”子任务，我们可以设计如下提示：

                                
                                    

                            
1
                            
请用 Java 编写一个 Order 类，包含以下字段：
                        

                            
2
                            
- orderId (订单ID，String 类型)
                        

                            
3
                            
- userId (用户ID，String 类型)
                        

                            
4
                            
- orderItems (订单商品列表，List 类型)
                        

                            
5
                            
- orderAmount (订单总金额，double 类型)
                        

                            
6
                            
- orderStatus (订单状态，枚举类型，包括 CREATED, PAID, SHIPPED, COMPLETED)
                        

                            
7
                            
- orderDate (下单日期，Date 类型)
                        

                            
8
                            

                        

                            
9
                            
同时，为 Order 类添加构造方法和 getter/setter 方法。
                        
                                
                            

对于 “OrderItem” 类，可以设计类似的提示：

                                
                                    

                            
1
                            
请用 Java 编写一个 OrderItem 类，包含以下字段：
                        

                            
2
                            
- productId (商品ID，String 类型)
                        

                            
3
                            
- productName (商品名称，String 类型)
                        

                            
4
                            
- quantity (商品数量，int 类型)
                        

                            
5
                            
- price (商品单价，double 类型)
                        

                            
6
                            

                        

                            
7
                            
同样，添加构造方法和 getter/setter 方法。
                        
                                
                            

③ 提示链 (Prompt Chaining)：
对于依赖于前一个子任务结果的子任务，可以使用提示链的方式。即，将前一个子任务的输出作为下一个子任务的输入，形成一个提示序列。例如，在订单处理系统中，订单创建子任务生成的 Order 类可以作为订单支付子任务的上下文信息。

④ 迭代优化 (Iterative Optimization)：
即使进行了任务分解和精细化提示，一次性生成的代码也可能不完全符合预期。这时，需要进行迭代优化。通过分析生成的代码，找出不足之处，并针对性地调整提示，再次生成代码。重复这个过程，直到得到满意的结果。

通过任务分解和精细化提示，我们可以有效地应对复杂编程任务，提高代码生成的质量和效率。这种方法也更符合软件开发的实际流程，即将复杂问题分解为小问题，逐步解决。

3.1.5 代码生成案例分析：Web 应用后端 API (Case Study: Web Application Backend API)

本节将通过一个案例分析，演示如何使用提示工程技术快速生成 Web 应用的后端 API 代码。我们将以一个简单的待办事项 (To-Do List) 应用为例，使用 Python 和 Flask 框架，生成处理待办事项增删改查 (CRUD) 操作的 API 接口。

需求描述：
构建一个 RESTful API，用于管理待办事项。API 应该支持以下操作：

⚝ 创建待办事项 (Create)：POST /todos，接收待办事项内容，创建新的待办事项。
⚝ 读取待办事项列表 (Read)：GET /todos，返回所有待办事项列表。
⚝ 读取单个待办事项 (Read)：GET /todos/{id}，根据 ID 返回指定待办事项。
⚝ 更新待办事项 (Update)：PUT /todos/{id}，根据 ID 更新指定待办事项的内容或状态。
⚝ 删除待办事项 (Delete)：DELETE /todos/{id}，根据 ID 删除指定待办事项。

提示设计与代码生成步骤：

① 创建 Flask 应用框架：
首先，我们需要创建一个基本的 Flask 应用框架。提示如下：

                                
                                    

                            
1
                            
请用 Python 和 Flask 框架，创建一个基本的 Web 应用框架，包含：
                        

                            
2
                            
- 导入 Flask 模块
                        

                            
3
                            
- 创建 Flask 应用实例
                        

                            
4
                            
- 定义一个根路由 '/'，返回 "Hello, Flask!"
                        

                            
5
                            
- 运行应用
                        
                                
                            

模型生成代码：

                                
                                    

                            
1
                            
from flask import Flask
                        

                            
2
                            

                        

                            
3
                            
app = Flask(__name__)
                        

                            
4
                            

                        

                            
5
                            
@app.route('/')
                        

                            
6
                            
def index():
                        

                            
7
                            
    return 'Hello, Flask!'
                        

                            
8
                            

                        

                            
9
                            
if __name__ == '__main__':
                        

                            
10
                            
    app.run(debug=True)
                        
                                
                            

② 定义待办事项数据模型 (Data Model)：
我们需要一个数据结构来存储待办事项。提示如下：

                                
                                    

                            
1
                            
请定义一个 Python 类 Todo，表示待办事项，包含以下属性：
                        

                            
2
                            
- id (int 类型，唯一标识符)
                        

                            
3
                            
- task (str 类型，待办事项内容)
                        

                            
4
                            
- completed (bool 类型，是否已完成，默认为 False)
                        

                            
5
                            

                        

                            
6
                            
添加构造方法和 __repr__ 方法。
                        
                                
                            

模型生成代码：

                                
                                    

                            
1
                            
class Todo:
                        

                            
2
                            
    def __init__(self, id, task, completed=False):
                        

                            
3
                            
        self.id = id
                        

                            
4
                            
        self.task = task
                        

                            
5
                            
        self.completed = completed
                        

                            
6
                            

                        

                            
7
                            
    def __repr__(self):
                        

                            
8
                            
        return f"<Todo {self.id}: {self.task}, Completed: {self.completed}>"
                        
                                
                            

③ 实现 API 接口：
接下来，我们为每个 API 接口设计提示。

⚝ 创建待办事项 (POST /todos)：

                                
                                    

                            
1
                            
请在 Flask 应用中，添加一个 POST /todos 路由，用于创建待办事项。
                        

                            
2
                            
- 接收 JSON 格式的请求数据，包含 "task" 字段
                        

                            
3
                            
- 创建新的 Todo 对象，ID 自增
                        

                            
4
                            
- 将 Todo 对象添加到内存列表 (todos) 中
                        

                            
5
                            
- 返回新创建的 Todo 对象，JSON 格式，状态码 201 (Created)
                        
                                
                            

模型生成代码 (部分，完整代码见后文)：

                                
                                    

                            
1
                            
from flask import request, jsonify
                        

                            
2
                            

                        

                            
3
                            
todos = [] # 内存列表存储待办事项
                        

                            
4
                            
next_todo_id = 1 # ID 自增
                        

                            
5
                            

                        

                            
6
                            
@app.route('/todos', methods=['POST'])
                        

                            
7
                            
def create_todo():
                        

                            
8
                            
    global next_todo_id
                        

                            
9
                            
    data = request.get_json()
                        

                            
10
                            
    task = data.get('task')
                        

                            
11
                            
    if not task:
                        

                            
12
                            
        return jsonify({"message": "Task is required"}), 400
                        

                            
13
                            
    todo = Todo(next_todo_id, task)
                        

                            
14
                            
    todos.append(todo)
                        

                            
15
                            
    next_todo_id += 1
                        

                            
16
                            
    return jsonify(todo.__dict__), 201
                        
                                
                            

⚝ 读取待办事项列表 (GET /todos)：

                                
                                    

                            
1
                            
请添加一个 GET /todos 路由，返回所有待办事项列表。
                        

                            
2
                            
- 从内存列表 (todos) 中获取所有 Todo 对象
                        

                            
3
                            
- 将 Todo 对象列表转换为 JSON 格式返回
                        
                                
                            

⚝ 读取单个待办事项 (GET /todos/{id})：

                                
                                    

                            
1
                            
请添加一个 GET /todos/ 路由，根据 ID 返回指定待办事项。
                        

                            
2
                            
- 从内存列表 (todos) 中查找指定 ID 的 Todo 对象
                        

                            
3
                            
- 如果找到，返回 Todo 对象，JSON 格式
                        

                            
4
                            
- 如果未找到，返回 404 状态码
                        
                                
                            

⚝ 更新待办事项 (PUT /todos/{id})：

                                
                                    

                            
1
                            
请添加一个 PUT /todos/ 路由，根据 ID 更新指定待办事项。
                        

                            
2
                            
- 接收 JSON 格式的请求数据，可以包含 "task" 和 "completed" 字段
                        

                            
3
                            
- 从内存列表 (todos) 中查找指定 ID 的 Todo 对象
                        

                            
4
                            
- 如果找到，更新 Todo 对象的属性
                        

                            
5
                            
- 返回更新后的 Todo 对象，JSON 格式
                        

                            
6
                            
- 如果未找到，返回 404 状态码
                        
                                
                            

⚝ 删除待办事项 (DELETE /todos/{id})：

                                
                                    

                            
1
                            
请添加一个 DELETE /todos/ 路由，根据 ID 删除指定待办事项。
                        

                            
2
                            
- 从内存列表 (todos) 中查找指定 ID 的 Todo 对象
                        

                            
3
                            
- 如果找到，从列表中删除
                        

                            
4
                            
- 返回 204 状态码 (No Content)
                        

                            
5
                            
- 如果未找到，返回 404 状态码
                        
                                
                            

④ 整合代码：
将模型生成的各个 API 接口代码片段整合到 Flask 应用框架中，并进行必要的调整和测试。

完整代码示例 (整合后的代码)：

                                
                                    

                            
1
                            
from flask import Flask, request, jsonify
                        

                            
2
                            

                        

                            
3
                            
app = Flask(__name__)
                        

                            
4
                            

                        

                            
5
                            
class Todo:
                        

                            
6
                            
    def __init__(self, id, task, completed=False):
                        

                            
7
                            
        self.id = id
                        

                            
8
                            
        self.task = task
                        

                            
9
                            
        self.completed = completed
                        

                            
10
                            

                        

                            
11
                            
    def __repr__(self):
                        

                            
12
                            
        return f"<Todo {self.id}: {self.task}, Completed: {self.completed}>"
                        

                            
13
                            

                        

                            
14
                            
todos = [] # 内存列表存储待办事项
                        

                            
15
                            
next_todo_id = 1 # ID 自增
                        

                            
16
                            

                        

                            
17
                            
@app.route('/')
                        

                            
18
                            
def index():
                        

                            
19
                            
    return 'Hello, Flask!'
                        

                            
20
                            

                        

                            
21
                            
@app.route('/todos', methods=['POST'])
                        

                            
22
                            
def create_todo():
                        

                            
23
                            
    global next_todo_id
                        

                            
24
                            
    data = request.get_json()
                        

                            
25
                            
    task = data.get('task')
                        

                            
26
                            
    if not task:
                        

                            
27
                            
        return jsonify({"message": "Task is required"}), 400
                        

                            
28
                            
    todo = Todo(next_todo_id, task)
                        

                            
29
                            
    todos.append(todo)
                        

                            
30
                            
    next_todo_id += 1
                        

                            
31
                            
    return jsonify(todo.__dict__), 201
                        

                            
32
                            

                        

                            
33
                            
@app.route('/todos', methods=['GET'])
                        

                            
34
                            
def get_todos():
                        

                            
35
                            
    todo_list = [todo.__dict__ for todo in todos]
                        

                            
36
                            
    return jsonify(todo_list)
                        

                            
37
                            

                        

                            
38
                            
@app.route('/todos/<int:id>', methods=['GET'])
                        

                            
39
                            
def get_todo(id):
                        

                            
40
                            
    todo = next((todo for todo in todos if todo.id == id), None)
                        

                            
41
                            
    if todo:
                        

                            
42
                            
        return jsonify(todo.__dict__)
                        

                            
43
                            
    return jsonify({"message": "Todo not found"}), 404
                        

                            
44
                            

                        

                            
45
                            
@app.route('/todos/<int:id>', methods=['PUT'])
                        

                            
46
                            
def update_todo(id):
                        

                            
47
                            
    todo = next((todo for todo in todos if todo.id == id), None)
                        

                            
48
                            
    if not todo:
                        

                            
49
                            
        return jsonify({"message": "Todo not found"}), 404
                        

                            
50
                            
    data = request.get_json()
                        

                            
51
                            
    if 'task' in data:
                        

                            
52
                            
        todo.task = data['task']
                        

                            
53
                            
    if 'completed' in data:
                        

                            
54
                            
        todo.completed = data['completed']
                        

                            
55
                            
    return jsonify(todo.__dict__)
                        

                            
56
                            

                        

                            
57
                            
@app.route('/todos/<int:id>', methods=['DELETE'])
                        

                            
58
                            
def delete_todo(id):
                        

                            
59
                            
    global todos
                        

                            
60
                            
    todos = [todo for todo in todos if todo.id != id]
                        

                            
61
                            
    return '', 204
                        

                            
62
                            

                        

                            
63
                            
if __name__ == '__main__':
                        

                            
64
                            
    app.run(debug=True)
                        
                                
                            

案例总结：
通过这个案例，我们展示了如何使用提示工程技术，将 Web 应用后端 API 的开发任务分解为多个子任务，并针对每个子任务设计清晰的提示。利用模型生成的代码片段，我们可以快速搭建起一个功能完善的 RESTful API。这种方法大大提高了开发效率，降低了开发门槛。在实际项目中，可以根据具体需求，进一步扩展和完善 API 功能。

END_OF_CHAPTER

4. chapter 4： 高级提示工程技巧 (Advanced Prompt Engineering Techniques)

4.1 思维链 (Chain-of-Thought, CoT) 的进阶应用

思维链 (Chain-of-Thought, CoT) 提示是一种强大的技术，它通过引导大型语言模型 (Large Language Models, LLMs) 逐步推理来解决复杂问题。在基础章节中，我们已经了解了 CoT 的基本概念和应用。本节将深入探讨 CoT 的进阶应用，包括如何构建更复杂的多步推理提示，以及如何将外部知识融入到 CoT 提示中，以提升模型在特定领域或任务上的性能。

4.1.1 多步推理提示 (Multi-step Reasoning Prompts)

多步推理提示旨在模拟人类解决复杂问题的思维过程，将一个复杂的问题分解为多个逻辑步骤，并引导模型逐步推导答案。这种方法尤其适用于需要逻辑推理、数学计算、规划或问题分解的任务。

① 设计多步推理提示的关键步骤：
▮▮▮▮ⓑ 问题分解：首先，将复杂问题分解为一系列更小的、可管理的子问题。每个子问题都应该是一个逻辑步骤，最终导向最终答案。
▮▮▮▮ⓒ 步骤指令设计：为每个子问题设计明确的指令，引导模型按照预期的逻辑路径进行推理。指令应该清晰、具体，并指示模型输出中间步骤的思考过程。
▮▮▮▮ⓓ 步骤连接：确保各个步骤之间逻辑连贯，前一步骤的输出可以作为后一步骤的输入。可以使用占位符或明确的指示词来连接步骤。
▮▮▮▮ⓔ 最终答案指示：在所有推理步骤完成后，明确指示模型输出最终答案。

② 多步推理提示的示例：

假设我们需要解决一个需要多步计算的数学问题：

问题： 一个农场有 15 只鸡和 7 头猪。鸡每天下 12 个蛋，猪每天吃 5 公斤饲料。如果每公斤饲料 2 元，那么农场主每天在鸡和猪身上花费多少钱？

多步推理提示：

                                
                                    

                            
1
                            
Let's think step by step.
                        

                            
2
                            
首先，计算猪每天吃的饲料量。
                        

                            
3
                            
然后，计算猪每天饲料花费。
                        

                            
4
                            
最后，将鸡和猪每天的花费相加，得到总花费。
                        

                            
5
                            

                        

                            
6
                            
猪每天吃 7 头 * 5 公斤/头 = ？公斤饲料。
                        

                            
7
                            
猪每天饲料花费是 ？公斤 * 2 元/公斤 = ？元。
                        

                            
8
                            
农场主每天在鸡和猪身上的总花费是 鸡的花费 + 猪的花费 = ？元。
                        

                            
9
                            

                        

                            
10
                            
请给出最终答案：
                        
                                
                            

预期模型输出 (示例)：

                                
                                    

                            
1
                            
Let's think step by step.
                        

                            
2
                            
首先，计算猪每天吃的饲料量。
                        

                            
3
                            
猪每天吃 7 头 * 5 公斤/头 = 35 公斤饲料。
                        

                            
4
                            
然后，计算猪每天饲料花费。
                        

                            
5
                            
猪每天饲料花费是 35 公斤 * 2 元/公斤 = 70 元。
                        

                            
6
                            
最后，将鸡和猪每天的花费相加，得到总花费。
                        

                            
7
                            
农场主每天在鸡和猪身上的总花费是 鸡的花费 + 猪的花费 = 70 元。（鸡的花费为 0，因为问题只问了在鸡和猪身上花费多少钱，而鸡是产蛋，不是花费）
                        

                            
8
                            

                        

                            
9
                            
最终答案：70 元
                        
                                
                            

③ 多步推理提示的应用场景：

⚝ 复杂计算问题：例如，物理、化学、工程学等领域的计算题。
⚝ 逻辑推理问题：例如，逻辑谜题、演绎推理、归纳推理等。
⚝ 规划和决策问题：例如，旅行路线规划、项目管理、资源分配等。
⚝ 代码生成中的复杂逻辑：将复杂的功能需求分解为多个子任务，逐步生成代码。

④ 多步推理提示的优势：

⚝ 提高复杂问题解决能力：通过分解问题，模型可以更好地理解和处理复杂任务。
⚝ 增强模型的可解释性：中间推理步骤的输出可以帮助我们理解模型的思考过程，并进行调试和改进。
⚝ 减少错误率：逐步推理可以减少在复杂问题中出现错误的可能性。

⑤ 实践建议：

⚝ 逐步增加推理步骤：从简单的两步推理开始，逐步增加步骤的复杂性。
⚝ 使用清晰的步骤指示词：例如，“首先”，“然后”，“接下来”，“最后” 等，引导模型按步骤推理。
⚝ 迭代优化提示：根据模型的输出结果，不断调整和优化推理步骤和指令。

4.1.2 结合外部知识的提示 (Prompts Incorporating External Knowledge)

大型语言模型虽然在预训练阶段学习了海量的知识，但其知识仍然是静态的，并且可能存在过时或不准确的情况。为了提高模型在特定领域或任务上的性能，我们可以将外部知识融入到提示中。这可以通过多种方式实现，例如提供背景知识、相关文档片段、知识库查询结果等。

① 结合外部知识的提示方法：

⚝ 上下文注入 (Context Injection)：将相关的外部知识直接添加到提示的上下文中。这可以是文本片段、表格数据、代码示例等。
⚝ 知识库检索 (Knowledge Retrieval)：在提示中指示模型查询外部知识库，并将检索到的知识用于生成答案。可以使用工具如搜索引擎、知识图谱、数据库等。
⚝ 混合方法 (Hybrid Approach)：结合上下文注入和知识库检索，根据任务需求选择合适的方法或组合。

② 上下文注入的示例：

假设我们需要模型回答关于特定技术栈的问题，例如 "Spring Boot 的核心特性是什么？"。我们可以先从外部知识源（如官方文档）中检索相关信息，然后将其注入到提示中。

外部知识 (来自 Spring Boot 官方文档)：

Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can "just run". We take an opinionated view of the Spring platform and libraries so you can get started with minimum fuss. Most Spring Boot applications need minimal Spring configuration.

结合外部知识的提示：

                                
                                    

                            
1
                            
请根据以下 Spring Boot 的官方描述，回答 "Spring Boot 的核心特性是什么？"
                        

                            
2
                            

                        

                            
3
                            
官方描述：
                        

                            
4
                            
> Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can "just run". We take an opinionated view of the Spring platform and libraries so you can get started with minimum fuss. Most Spring Boot applications need minimal Spring configuration.
                        

                            
5
                            

                        

                            
6
                            
答案：
                        
                                
                            

预期模型输出 (示例)：

                                
                                    

                            
1
                            
根据 Spring Boot 的官方描述，其核心特性是：
                        

                            
2
                            
- 简化 Spring 应用的创建，使其易于构建独立的、生产级别的 Spring 应用。
                        

                            
3
                            
- 采用固执己见的 Spring 平台和库视图，以便用户可以快速启动，减少配置的麻烦。
                        

                            
4
                            
- 大多数 Spring Boot 应用只需要最少的 Spring 配置。
                        
                                
                            

③ 知识库检索的示例：

假设我们需要模型回答 "最新的 Python 版本是什么？"。我们可以指示模型使用搜索引擎查询最新信息。

提示：

                                
                                    

                            
1
                            
请使用搜索引擎查询 "最新的 Python 版本"，并给出答案。
                        
                                
                            

预期模型输出 (示例)：

                                
                                    

                            
1
                            
（模型执行搜索引擎查询，例如 "最新的 Python 版本"）
                        

                            
2
                            

                        

                            
3
                            
根据最新的搜索结果，最新的 Python 版本是 Python 3.12.x (具体版本号可能会随时间更新)。
                        
                                
                            

④ 结合外部知识提示的应用场景：

⚝ 领域特定问题解答：例如，医学、法律、金融等专业领域的问题。
⚝ 需要最新信息的问题：例如，新闻事件、技术更新、实时数据查询等。
⚝ 需要特定知识背景的任务：例如，根据公司内部文档生成报告、根据产品手册回答用户问题等。

⑤ 结合外部知识提示的优势：

⚝ 提高答案的准确性和可靠性：外部知识可以补充模型自身的知识，减少幻觉和错误。
⚝ 扩展模型的知识范围：模型可以处理超出其预训练知识范围的问题。
⚝ 适应动态变化的信息：通过实时检索外部知识，模型可以获取最新的信息。

⑥ 实践建议：

⚝ 选择合适的知识源：根据任务需求选择权威、可靠的知识源。
⚝ 优化知识检索策略：提高知识检索的效率和准确性。
⚝ 平衡内部知识和外部知识：合理利用模型的预训练知识和外部知识，避免过度依赖外部知识导致模型泛化能力下降。

4.2 提示的迭代与优化 (Prompt Iteration and Optimization)

提示工程是一个迭代的过程。最初的提示可能无法产生理想的结果，我们需要不断地调整和优化提示，以提高模型的性能。本节将介绍提示迭代和优化的方法，包括 A/B 测试、效果评估以及基于反馈的改进策略。

4.2.1 A/B 测试与提示效果评估 (A/B Testing and Prompt Effectiveness Evaluation)

A/B 测试是一种常用的实验方法，用于比较不同提示的效果。通过 A/B 测试，我们可以量化不同提示策略的优劣，并选择最佳的提示方案。提示效果评估是 A/B 测试的关键环节，我们需要定义合适的评估指标，并设计有效的评估方法。

① A/B 测试的步骤：

① 确定目标：明确 A/B 测试的目标，例如提高代码生成的准确率、降低错误修复的时间等。
② 设计变体：创建至少两个提示变体 (A 和 B)，每个变体代表一种不同的提示策略。例如，变体 A 使用更简洁的指令，变体 B 使用更详细的指令。
③ 分配流量：将用户或任务随机分配到不同的提示变体组。确保每组用户或任务的特征分布相似，以保证测试的公平性。
④ 收集数据：收集模型在不同提示变体下的输出结果和相关指标数据。例如，代码生成任务的准确率、错误修复任务的成功率和时间等。
⑤ 分析结果：使用统计方法分析收集到的数据，比较不同提示变体之间的效果差异。判断哪个提示变体在目标指标上表现更优。
⑥ 迭代优化：根据 A/B 测试的结果，选择表现最佳的提示变体，并将其作为新的基准。然后，可以基于最佳变体进行进一步的迭代优化，开始新一轮的 A/B 测试。

② 提示效果评估指标：

⚝ 代码生成任务：
▮▮▮▮⚝ 语法正确率：生成代码的语法错误率。
▮▮▮▮⚝ 功能正确率：生成代码的功能是否符合需求。
▮▮▮▮⚝ 代码质量：代码的可读性、可维护性、性能等。
▮▮▮▮⚝ 生成速度：生成代码所需的时间。
⚝ 代码调试与错误修复任务：
▮▮▮▮⚝ 错误修复成功率：模型成功修复代码错误的比例。
▮▮▮▮⚝ 错误定位准确率：模型定位错误位置的准确率。
▮▮▮▮⚝ 修复时间：模型修复错误所需的时间。
⚝ 代码解释与文档生成任务：
▮▮▮▮⚝ 解释质量：代码解释的清晰度、准确性、完整性。
▮▮▮▮⚝ 文档质量：文档的完整性、可读性、实用性。
▮▮▮▮⚝ 用户满意度：用户对代码解释或文档的满意度评分。
⚝ 代码重构与优化任务：
▮▮▮▮⚝ 代码风格改进程度：代码风格改进的程度，例如代码规范的符合度。
▮▮▮▮⚝ 性能提升幅度：代码性能提升的幅度，例如运行速度的提升。
▮▮▮▮⚝ 可维护性提升：代码可维护性的提升，例如代码复杂度的降低。
⚝ 测试用例生成任务：
▮▮▮▮⚝ 测试覆盖率：生成的测试用例对代码的覆盖率。
▮▮▮▮⚝ 测试有效性：生成的测试用例是否能够有效检测代码中的错误。
▮▮▮▮⚝ 测试用例质量：测试用例的可读性、可维护性。

③ 评估方法：

⚝ 人工评估：由人工专家对模型的输出结果进行评估和打分。适用于评估质量要求较高、难以自动化评估的任务，例如代码质量、解释质量、文档质量等。
⚝ 自动化评估：使用自动化工具或脚本对模型的输出结果进行评估。适用于可以量化评估的任务，例如语法正确率、功能正确率、测试覆盖率等。
⚝ 用户反馈：收集用户对模型输出结果的反馈，例如用户满意度调查、用户行为数据分析等。适用于评估用户体验和实用性的任务。

④ A/B 测试的工具：

⚝ 在线提示工程平台：许多在线平台 (例如 OpenAI Playground) 提供了 A/B 测试功能，可以方便地进行提示变体的比较和评估。
⚝ 自定义评估脚本：可以编写自定义脚本来自动化 A/B 测试流程，包括流量分配、数据收集、结果分析等。
⚝ 实验管理平台：可以使用专门的实验管理平台 (例如 Optimizely, VWO) 来进行更复杂的 A/B 测试和多变量测试。

⑤ 实践建议：

⚝ 从小规模测试开始：先进行小规模的 A/B 测试，快速验证提示策略的可行性。
⚝ 控制变量：在 A/B 测试中，尽量只改变一个提示变量，以便准确评估该变量的影响。
⚝ 关注统计显著性：使用统计方法分析 A/B 测试结果，确保结果具有统计显著性，避免随机性干扰。
⚝ 持续迭代优化：A/B 测试是一个持续迭代的过程，不断进行测试和优化，逐步提升提示效果。

4.2.2 基于反馈的提示改进 (Feedback-based Prompt Refinement)

基于反馈的提示改进是一种利用模型输出结果的反馈信息来优化提示的方法。反馈可以是人工反馈，也可以是自动化评估的反馈。通过分析反馈信息，我们可以了解提示的不足之处，并进行针对性的改进。

① 反馈类型：

⚝ 显式反馈 (Explicit Feedback)：用户或评估者直接提供的反馈，例如对模型输出结果的评分、评论、修改建议等。
⚝ 隐式反馈 (Implicit Feedback)：通过用户行为间接反映的反馈，例如用户是否采纳了模型生成的代码、用户在代码文档上停留的时间等。
⚝ 自动化评估反馈 (Automated Evaluation Feedback)：自动化评估工具提供的反馈，例如代码语法错误报告、测试用例执行结果等。

② 基于反馈的提示改进策略：

⚝ 错误分析与纠正：分析模型输出结果中的错误类型和原因，针对性地修改提示，以避免类似错误再次发生。例如，如果模型生成的代码存在语法错误，可以检查提示中是否缺少必要的语法指示或上下文信息。
⚝ 效果提升与优化：分析模型输出结果的优点和不足，针对性地优化提示，以进一步提升模型的效果。例如，如果模型生成的代码功能基本正确，但代码质量不高，可以修改提示，加入代码风格、性能等方面的要求。
⚝ 用户意图理解：分析用户反馈，深入理解用户的真实意图和需求，根据用户意图调整提示，以更好地满足用户需求。例如，如果用户对模型生成的代码不满意，可以与用户沟通，了解用户的具体需求，并根据用户需求修改提示。

③ 反馈循环：

基于反馈的提示改进是一个循环迭代的过程，包括以下步骤：

① 设计提示：根据任务需求设计初始提示。
② 模型生成：使用提示让模型生成输出结果。
③ 收集反馈：收集用户反馈、自动化评估反馈或隐式反馈。
④ 分析反馈：分析反馈信息，识别提示的不足之处和改进方向。
⑤ 改进提示：根据反馈信息修改和优化提示。
⑥ 重复循环：重复步骤 ②-⑤，不断迭代优化提示。

④ 反馈工具与平台：

⚝ 用户反馈收集工具：可以使用问卷调查、用户评论系统、用户行为分析工具等收集用户反馈。
⚝ 自动化评估工具：可以使用代码静态分析工具、测试框架、代码质量评估工具等进行自动化评估。
⚝ 提示工程平台：一些提示工程平台提供了反馈收集和管理功能，可以方便地进行基于反馈的提示改进。

⑤ 实践建议：

⚝ 重视用户反馈：用户反馈是提示改进的重要来源，要认真对待用户反馈，并将其作为改进提示的重要依据。
⚝ 建立反馈循环机制：建立完善的反馈收集、分析和改进机制，确保提示能够持续迭代优化。
⚝ 结合多种反馈类型：综合利用显式反馈、隐式反馈和自动化评估反馈，全面了解提示的效果和不足。
⚝ 迭代速度与质量平衡：在追求快速迭代的同时，也要保证提示改进的质量，避免盲目修改导致提示效果下降。

4.3 处理复杂任务的提示策略 (Prompt Strategies for Complex Tasks)

在软件开发中，我们经常面临各种复杂的编程任务，例如构建大型系统、解决复杂的算法问题、进行多模块代码集成等。处理这些复杂任务需要更高级的提示策略，本节将介绍任务分解和提示链等策略，帮助程序员更好地利用提示工程解决复杂问题。

4.3.1 任务分解 (Task Decomposition) 与子任务提示 (Sub-task Prompts)

任务分解是将一个复杂的任务拆分成多个更小的、更易于管理的子任务的过程。对于每个子任务，我们可以设计专门的子任务提示，引导模型逐步完成复杂任务。任务分解可以降低复杂性，提高模型在复杂任务上的性能。

① 任务分解的步骤：

① 理解复杂任务：深入理解复杂任务的需求、目标和约束条件。
② 识别子任务：将复杂任务分解为一系列逻辑上相互关联的子任务。子任务应该尽可能独立、明确，并且易于描述和实现。
③ 确定子任务依赖关系：分析子任务之间的依赖关系，确定子任务的执行顺序。
④ 设计子任务提示：为每个子任务设计专门的提示，明确子任务的目标、输入、输出和约束条件。
⑤ 组合子任务结果：将各个子任务的输出结果组合起来，形成最终的解决方案。

② 任务分解的示例：

假设我们需要使用 AI 辅助开发一个简单的在线购物网站的后端 API。这是一个相对复杂的任务，可以分解为以下子任务：

⚝ 子任务 1：数据库设计：设计数据库表结构，包括商品表、用户表、订单表等。
⚝ 子任务 2：API 接口设计：设计 RESTful API 接口，包括商品列表接口、商品详情接口、订单创建接口等。
⚝ 子任务 3：代码生成：根据数据库设计和 API 接口设计，生成后端 API 的代码。
⚝ 子任务 4：单元测试：为生成的 API 代码编写单元测试用例。
⚝ 子任务 5：集成测试：进行 API 接口的集成测试。

对于每个子任务，我们可以设计相应的子任务提示。例如，对于子任务 1 (数据库设计)，可以设计如下提示：

子任务提示 (数据库设计)：

                                
                                    

                            
1
                            
请为在线购物网站设计数据库表结构，包括商品表、用户表、订单表。
                        

                            
2
                            
商品表应包含商品 ID、商品名称、商品描述、商品价格、库存等字段。
                        

                            
3
                            
用户表应包含用户 ID、用户名、密码、邮箱、地址等字段。
                        

                            
4
                            
订单表应包含订单 ID、用户 ID、商品 ID、订单数量、订单总价、订单状态等字段。
                        

                            
5
                            
请以 Markdown 格式输出数据库表结构，包括表名、字段名、字段类型、主键、外键等信息。
                        
                                
                            

③ 子任务提示的优势：

⚝ 降低复杂性：将复杂任务分解为多个简单的子任务，降低了每个子任务的难度。
⚝ 提高模型性能：针对每个子任务设计专门的提示，可以更好地引导模型完成任务，提高模型在复杂任务上的性能。
⚝ 增强可控性：通过控制子任务的分解粒度和执行顺序，可以更好地控制复杂任务的完成过程。
⚝ 便于模块化开发：子任务分解与模块化开发思想一致，便于将复杂系统分解为多个模块进行开发和维护。

④ 任务分解的应用场景：

⚝ 大型系统开发：例如，电商平台、社交网络、企业级应用等。
⚝ 复杂算法问题：例如，路径规划、资源调度、优化算法等。
⚝ 多模块代码集成：例如，微服务架构、分布式系统等。
⚝ 自动化工作流设计：例如，CI/CD 流程、数据处理流程、业务流程自动化等。

⑤ 实践建议：

⚝ 合理分解任务：根据任务的复杂程度和模型的能力，合理分解任务，避免过度分解或分解不足。
⚝ 明确子任务目标：确保每个子任务的目标明确、可衡量、可实现。
⚝ 设计清晰的子任务提示：为每个子任务设计清晰、具体的提示，明确子任务的输入、输出和约束条件。
⚝ 灵活组合子任务：根据任务需求，灵活组合子任务，形成不同的任务执行流程。

4.3.2 提示链 (Prompt Chaining) 与工作流 (Workflow) 设计

提示链 (Prompt Chaining) 是将多个提示串联起来，形成一个提示序列或工作流，以完成更复杂的任务。每个提示的输出作为下一个提示的输入，形成一个链式反应。提示链可以模拟复杂的工作流程，实现多步骤、多环节的任务处理。

① 提示链的构建方法：

① 定义任务流程：分析复杂任务的逻辑流程，确定需要执行的步骤和环节。
② 设计提示节点：为每个步骤或环节设计一个提示节点，明确该节点的目标、输入、输出和处理逻辑。
③ 连接提示节点：将各个提示节点按照任务流程连接起来，形成一个提示链。可以使用占位符、变量或中间结果存储机制来传递节点之间的信息。
④ 执行提示链：按照提示链的顺序依次执行各个提示节点，并将前一个节点的输出作为后一个节点的输入。
⑤ 监控与调整：监控提示链的执行过程，根据实际情况调整提示节点或流程，优化提示链的效果。

② 提示链的示例：

假设我们需要使用 AI 辅助完成一个代码审查工作流，包括代码风格检查、安全漏洞扫描和性能分析三个环节。我们可以构建一个提示链来完成这个工作流。

⚝ 提示链工作流：

                                
                                    

                            
1
                            
graph LR
                        

                            
2
                            
    A[开始] --> B{代码风格检查提示};
                        

                            
3
                            
    B --> C{代码风格检查结果};
                        

                            
4
                            
    C --> D{安全漏洞扫描提示};
                        

                            
5
                            
    D --> E{安全漏洞扫描结果};
                        

                            
6
                            
    E --> F{性能分析提示};
                        

                            
7
                            
    F --> G{性能分析结果};
                        

                            
8
                            
    G --> H[结束];
                        

                            
9
                            

                        

                            
10
                            
    style B fill:#f9f,stroke:#333,stroke-width:2px
                        

                            
11
                            
    style D fill:#f9f,stroke:#333,stroke-width:2px
                        

                            
12
                            
    style F fill:#f9f,stroke:#333,stroke-width:2px
                        
                                
                            

⚝ 提示节点示例：

⚝ 代码风格检查提示节点：

                                
                                    

                            
1
                            
请对以下代码进行代码风格检查，并给出代码风格改进建议。
                        

                            
2
                            
代码：
                        
                                
                            

                                
                                    

                            
1
                            
# 待检查的代码片段
                        

                            
2
                            
def my_function(input):
                        

                            
3
                            
  if(input> 10):
                        

                            
4
                            
    return "large"
                        

                            
5
                            
  else:
                        

                            
6
                            
    return "small"
                        
                                
                            

⚝ 安全漏洞扫描提示节点：

                                
                                    

                            
1
                            
请对以下代码进行安全漏洞扫描，并给出潜在的安全漏洞和修复建议。
                        

                            
2
                            
代码：
                        
                                
                            

                                
                                    

                            
1
                            
# 待检查的代码片段 (可能包含安全漏洞)
                        

                            
2
                            
def process_user_input(user_input):
                        

                            
3
                            
    eval(user_input) # 潜在的安全漏洞：eval 函数
                        
                                
                            

⚝ 性能分析提示节点：

                                
                                    

                            
1
                            
请对以下代码进行性能分析，并给出性能优化建议。
                        

                            
2
                            
代码：
                        
                                
                            

                                
                                    

                            
1
                            
# 待分析的代码片段 (可能存在性能瓶颈)
                        

                            
2
                            
def slow_function(n):
                        

                            
3
                            
    result = []
                        

                            
4
                            
    for i in range(n):
                        

                            
5
                            
        for j in range(n):
                        

                            
6
                            
            result.append(i * j)
                        

                            
7
                            
    return result
                        
                                
                            

③ 提示链的应用场景：

⚝ 自动化工作流：例如，代码审查工作流、文档生成工作流、数据处理工作流等。
⚝ 多步骤任务处理：例如，复杂问题解答、多轮对话、多阶段代码生成等。
⚝ 复杂系统构建：例如，构建智能助手、自动化测试系统、智能客服系统等。
⚝ 流程自动化：例如，业务流程自动化、审批流程自动化、任务分配自动化等。

④ 提示链的优势：

⚝ 处理复杂任务：提示链可以将复杂任务分解为多个简单的步骤，逐步完成复杂任务。
⚝ 提高效率：自动化执行提示链，可以提高任务处理效率，减少人工干预。
⚝ 增强灵活性：可以根据任务需求灵活设计和调整提示链的流程和节点。
⚝ 可扩展性：可以方便地扩展提示链的功能，添加新的提示节点，支持更复杂的任务。

⑤ 实践建议：

⚝ 可视化设计工具：可以使用可视化工具 (例如 Node-RED, LangChain 的可视化界面) 设计和管理提示链。
⚝ 模块化提示节点：将提示节点设计成模块化的组件，便于复用和组合。
⚝ 错误处理机制：在提示链中加入错误处理机制，处理节点执行失败的情况，保证提示链的稳定性。
⚝ 监控与日志：监控提示链的执行状态，记录日志信息，便于调试和优化。

4.4 提示工程中的伦理与安全考量 (Ethical and Safety Considerations in Prompt Engineering)

随着提示工程在软件开发领域的广泛应用，伦理和安全问题也日益凸显。我们需要关注如何避免生成有害代码、保护数据隐私与安全，确保提示工程的健康发展。本节将探讨提示工程中的伦理与安全考量。

4.4.1 避免生成有害代码 (Avoiding Generation of Harmful Code)

大型语言模型可能会生成包含漏洞、恶意代码或不安全的代码。作为程序员，我们需要采取措施，通过提示工程技术来降低生成有害代码的风险。

① 有害代码的类型：

⚝ 安全漏洞代码：例如，SQL 注入漏洞、跨站脚本攻击 (XSS) 漏洞、命令注入漏洞等。
⚝ 恶意代码：例如，病毒、木马、勒索软件等。
⚝ 不安全的代码：例如，资源泄漏、死锁、竞争条件等。
⚝ 偏见或歧视性代码：例如，基于种族、性别、宗教等歧视的代码。

② 避免生成有害代码的策略：

⚝ 安全提示设计：在提示中加入安全约束和指导，引导模型生成安全的代码。例如，明确指示模型避免使用不安全的函数或库，要求模型进行输入验证和安全处理。
⚝ 安全代码示例：在提示中提供安全的代码示例，作为模型学习的参考。
⚝ 安全审查机制：对模型生成的代码进行安全审查，包括人工审查和自动化安全扫描。
⚝ 安全工具集成：将安全扫描工具集成到提示工程工作流中，自动化检测和过滤有害代码。
⚝ 模型微调与安全对齐：使用安全数据集对模型进行微调，增强模型的安全意识和能力。进行安全对齐 (Safety Alignment)，使模型的目标与人类的安全价值观对齐。

③ 安全提示设计的示例：

不安全的提示 (可能导致 SQL 注入漏洞)：

                                
                                    

                            
1
                            
请生成 Python 代码，根据用户输入的用户名查询数据库用户信息。
                        

                            
2
                            
用户输入：' OR '1'='1
                        
                                
                            

安全的提示 (避免 SQL 注入漏洞)：

                                
                                    

                            
1
                            
请生成 Python 代码，使用参数化查询 (Parameterized Query) 或预编译语句 (Prepared Statement) 安全地根据用户输入的用户名查询数据库用户信息。
                        

                            
2
                            
用户输入：' OR '1'='1
                        
                                
                            

预期模型输出 (安全代码示例)：

                                
                                    

                            
1
                            
import sqlite3
                        

                            
2
                            

                        

                            
3
                            
def get_user_info(username):
                        

                            
4
                            
    conn = sqlite3.connect('users.db')
                        

                            
5
                            
    cursor = conn.cursor()
                        

                            
6
                            

                        

                            
7
                            
    # 使用参数化查询，避免 SQL 注入漏洞
                        

                            
8
                            
    cursor.execute("SELECT * FROM users WHERE username = ?", (username,))
                        

                            
9
                            
    user_info = cursor.fetchone()
                        

                            
10
                            

                        

                            
11
                            
    conn.close()
                        

                            
12
                            
    return user_info
                        

                            
13
                            

                        

                            
14
                            
username = input("请输入用户名：")
                        

                            
15
                            
user = get_user_info(username)
                        

                            
16
                            
if user:
                        

                            
17
                            
    print("用户信息:", user)
                        

                            
18
                            
else:
                        

                            
19
                            
    print("用户不存在")