Repository: LianjiaTech/BELLE
Branch: main
Commit: 645084d36454
Files: 115
Total size: 1.5 MB
Directory structure:
gitextract_ahrom3jo/
├── .gitignore
├── DATA_LICENSE
├── DISCLAIMER
├── HOW_TO_CONTRIBUTE.md
├── LICENSE
├── README.md
├── README_en.md
├── chat/
│ ├── README.md
│ └── README_en.md
├── docker/
│ ├── README.md
│ ├── belle.dockerfile
│ ├── build_dockerfile_upon_transfermers.sh
│ ├── docker_run.sh
│ ├── transformers.dockerfile
│ └── upload_image.sh
├── docs/
│ └── README.md
├── eval/
│ ├── ChatGPT_Score.html
│ ├── README.md
│ ├── README_en.md
│ ├── eval_prompt.json
│ ├── eval_set.json
│ ├── generation_html.py
│ └── template_html/
│ └── ChatGPT_Score.html.temp
├── models/
│ ├── Belle-VL/
│ │ └── README.md
│ ├── README.md
│ ├── README_en.md
│ ├── decrypt.py
│ ├── gptq/
│ │ ├── README.md
│ │ ├── bloom.py
│ │ ├── bloom_inference.py
│ │ ├── datautils.py
│ │ ├── gptq.py
│ │ ├── llama.py
│ │ ├── llama_inference.py
│ │ ├── llama_inference_offload.py
│ │ ├── modelutils.py
│ │ ├── quant.py
│ │ ├── quant_cuda.cpp
│ │ ├── quant_cuda_kernel.cu
│ │ ├── requirements.txt
│ │ ├── setup_cuda.py
│ │ └── test_kernel.py
│ └── notebook/
│ ├── BELLE_INFER_COLAB.ipynb
│ └── README.md
├── requirements.txt
└── train/
├── README.md
├── README_FT.md
├── README_RLHF.md
├── README_ZERO_INFERENCE.md
├── configs/
│ ├── accelerate_config_ppo.yaml
│ ├── accelerate_config_rm.yaml
│ ├── deepspeed_config.json
│ ├── deepspeed_config_flops_profile.json
│ ├── deepspeed_config_ppo.json
│ ├── deepspeed_config_rm.json
│ ├── deepspeed_config_stage3.json
│ ├── deepspeed_config_stage3_dpo.json
│ ├── deepspeed_config_stage3_flops_profile.json
│ ├── deepspeed_config_stage3_inference.json
│ ├── hostfile
│ ├── lora_config_bloom.json
│ └── lora_config_llama.json
├── docs/
│ ├── FAQ.md
│ └── README_en.md
├── dschat_train_v1/
│ ├── FAQ.md
│ ├── README.md
│ ├── docker/
│ │ └── Dockerfile
│ ├── main.py
│ ├── prompt_eval.py
│ ├── reproduce_our_papers/
│ │ └── Towards Better Instruction Following Language Models for Chinese: Investigating the Impact of Training Data and Evaluation.md
│ ├── training_scripts/
│ │ ├── convert_llama_weights_to_hf.py
│ │ ├── convert_to_conv_data.py
│ │ ├── single_gpu/
│ │ │ ├── run_FT.sh
│ │ │ └── run_LoRA.sh
│ │ └── single_node/
│ │ ├── run_FT.sh
│ │ └── run_LoRA.sh
│ └── utils/
│ ├── ds_utils.py
│ ├── model/
│ │ └── model_utils.py
│ ├── module/
│ │ └── lora.py
│ └── utils.py
├── reproduce_our_papers/
│ └── Towards Better Instruction Following Language Models for Chinese: Investigating the Impact of Training Data and Evaluation.md
├── scripts/
│ ├── convert_llama_weights_to_hf.py
│ ├── convert_to_conv_data.py
│ ├── merge_lora.sh
│ ├── merge_tokenizers.py
│ ├── multinode_run.sh
│ ├── run_dpo.sh
│ ├── run_inference.sh
│ ├── run_interface.sh
│ ├── run_multi_backend.py
│ ├── run_multi_backend.sh
│ ├── run_ppo.sh
│ ├── run_pt.sh
│ ├── run_rm.sh
│ ├── run_sft.sh
│ ├── run_zero_inference.sh
│ └── run_zero_inference_backend_without_trainer.sh
└── src/
├── dpo_trainer.py
├── entry_point/
│ ├── dpo_train.py
│ ├── evaluation.ipynb
│ ├── inference.py
│ ├── interface.py
│ ├── ppo_train.py
│ ├── pt_train.py
│ ├── rm_train.py
│ ├── sft_train.py
│ ├── zero_inference.py
│ └── zero_inference_backend_without_trainer.py
├── merge_llama_with_lora.py
├── models/
│ ├── generation_utils.py
│ └── llama/
│ └── modeling_llama.py
├── ppo_trainer.py
├── sample_generator.py
├── trainer.py
└── utils.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
*.tmp
*.swp
__pycache__
.vscode
regen.json
.ipynb_checkpoints
.idea
saved_models
*.code-workspace
.hypothesis
infer_res
wandb
hf_cache_dir
data
================================================
FILE: DATA_LICENSE
================================================
Attribution License (ODC-By)
PREAMBLE
The Open Data Commons Attribution License is a license agreement intended to allow users to freely share, modify, and use this Database subject only to the attribution requirements set out in Section 4.
Databases can contain a wide variety of types of content (images, audiovisual material, and sounds all in the same database, for example), and so this license only governs the rights over the Database, and not the contents of the Database individually. Licensors may therefore wish to use this license together with another license for the contents.
Sometimes the contents of a database, or the database itself, can be covered by other rights not addressed here (such as private contracts, trademark over the name, or privacy rights / data protection rights over information in the contents), and so you are advised that you may have to consult other documents or clear other rights before doing activities not covered by this License.
The Licensor (as defined below)
and
You (as defined below)
agree as follows:
1.0 DEFINITIONS OF CAPITALISED WORDS
“Collective Database” – Means this Database in unmodified form as part of a collection of independent databases in themselves that together are assembled into a collective whole. A work that constitutes a Collective Database will not be considered a Derivative Database.
“Convey” – As a verb, means Using the Database, a Derivative Database, or the Database as part of a Collective Database in any way that enables a Person to make or receive copies of the Database or a Derivative Database. Conveying does not include interaction with a user through a computer network, or creating and Using a Produced Work, where no transfer of a copy of the Database or a Derivative Database occurs.
“Contents” – The contents of this Database, which includes the information, independent works, or other material collected into the Database. For example, the contents of the Database could be factual data or works such as images, audiovisual material, text, or sounds.
“Database” – A collection of material (the Contents) arranged in a systematic or methodical way and individually accessible by electronic or other means offered under the terms of this License.
“Database Directive” – Means Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended or succeeded.
“Database Right” – Means rights resulting from the Chapter III (“sui generis”) rights in the Database Directive (as amended and as transposed by member states), which includes the Extraction and Re-utilisation of the whole or a Substantial part of the Contents, as well as any similar rights available in the relevant jurisdiction under Section 10.4.
“Derivative Database” – Means a database based upon the Database, and includes any translation, adaptation, arrangement, modification, or any other alteration of the Database or of a Substantial part of the Contents. This includes, but is not limited to, Extracting or Re-utilising the whole or a Substantial part of the Contents in a new Database.
“Extraction” – Means the permanent or temporary transfer of all or a Substantial part of the Contents to another medium by any means or in any form.
“License” – Means this license agreement and is both a license of rights such as copyright and Database Rights and an agreement in contract.
“Licensor” – Means the Person that offers the Database under the terms of this License.
“Person” – Means a natural or legal person or a body of persons corporate or incorporate.
“Produced Work” – a work (such as an image, audiovisual material, text, or sounds) resulting from using the whole or a Substantial part of the Contents (via a search or other query) from this Database, a Derivative Database, or this Database as part of a Collective Database.
“Publicly” – means to Persons other than You or under Your control by either more than 50% ownership or by the power to direct their activities (such as contracting with an independent consultant).
“Re-utilisation” – means any form of making available to the public all or a Substantial part of the Contents by the distribution of copies, by renting, by online or other forms of transmission.
“Substantial” – Means substantial in terms of quantity or quality or a combination of both. The repeated and systematic Extraction or Re-utilisation of insubstantial parts of the Contents may amount to the Extraction or Re-utilisation of a Substantial part of the Contents.
“Use” – As a verb, means doing any act that is restricted by copyright or Database Rights whether in the original medium or any other; and includes without limitation distributing, copying, publicly performing, publicly displaying, and preparing derivative works of the Database, as well as modifying the Database as may be technically necessary to use it in a different mode or format.
“You” – Means a Person exercising rights under this License who has not previously violated the terms of this License with respect to the Database, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.
Words in the singular include the plural and vice versa.
2.0 WHAT THIS LICENSE COVERS
2.1. Legal effect of this document. This License is:
a. A license of applicable copyright and neighbouring rights;
b. A license of the Database Right; and
c. An agreement in contract between You and the Licensor.
2.2 Legal rights covered. This License covers the legal rights in the Database, including:
a. Copyright. Any copyright or neighbouring rights in the Database. The copyright licensed includes any individual elements of the Database, but does not cover the copyright over the Contents independent of this Database. See Section 2.4 for details. Copyright law varies between jurisdictions, but is likely to cover: the Database model or schema, which is the structure, arrangement, and organisation of the Database, and can also include the Database tables and table indexes; the data entry and output sheets; and the Field names of Contents stored in the Database;
b. Database Rights. Database Rights only extend to the Extraction and Re-utilisation of the whole or a Substantial part of the Contents. Database Rights can apply even when there is no copyright over the Database. Database Rights can also apply when the Contents are removed from the Database and are selected and arranged in a way that would not infringe any applicable copyright; and
c. Contract. This is an agreement between You and the Licensor for access to the Database. In return you agree to certain conditions of use on this access as outlined in this License.
2.3 Rights not covered.
a. This License does not apply to computer programs used in the making or operation of the Database;
b. This License does not cover any patents over the Contents or the Database; and
c. This License does not cover any trademarks associated with the Database.
2.4 Relationship to Contents in the Database. The individual items of the Contents contained in this Database may be covered by other rights, including copyright, patent, data protection, privacy, or personality rights, and this License does not cover any rights (other than Database Rights or in contract) in individual Contents contained in the Database.
For example, if used on a Database of images (the Contents), this License would not apply to copyright over individual images, which could have their own separate licenses, or one single license covering all of the rights over the images.
3.0 RIGHTS GRANTED
3.1 Subject to the terms and conditions of this License, the Licensor grants to You a worldwide, royalty-free, non-exclusive, terminable (but only under Section 9) license to Use the Database for the duration of any applicable copyright and Database Rights. These rights explicitly include commercial use, and do not exclude any field of endeavour. To the extent possible in the relevant jurisdiction, these rights may be exercised in all media and formats whether now known or created in the future.
The rights granted cover, for example:
a. Extraction and Re-utilisation of the whole or a Substantial part of the Contents;
b. Creation of Derivative Databases;
c. Creation of Collective Databases;
d. Creation of temporary or permanent reproductions by any means and in any form, in whole or in part, including of any Derivative Databases or as a part of Collective Databases; and
e. Distribution, communication, display, lending, making available, or performance to the public by any means and in any form, in whole or in part, including of any Derivative Database or as a part of Collective Databases.
3.2 Compulsory license schemes. For the avoidance of doubt:
a. Non-waivable compulsory license schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme cannot be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License;
b. Waivable compulsory license schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme can be waived, the Licensor waives the exclusive right to collect such royalties for any exercise by You of the rights granted under this License; and,
c. Voluntary license schemes. The Licensor waives the right to collect royalties, whether individually or, in the event that the Licensor is a member of a collecting society that administers voluntary licensing schemes, via that society, from any exercise by You of the rights granted under this License.
3.3 The right to release the Database under different terms, or to stop distributing or making available the Database, is reserved. Note that this Database may be multiple-licensed, and so You may have the choice of using alternative licenses for this Database. Subject to Section 10.4, all other rights not expressly granted by Licensor are reserved.
4.0 CONDITIONS OF USE
4.1 The rights granted in Section 3 above are expressly made subject to Your complying with the following conditions of use. These are important conditions of this License, and if You fail to follow them, You will be in material breach of its terms.
4.2 Notices. If You Publicly Convey this Database, any Derivative Database, or the Database as part of a Collective Database, then You must:
a. Do so only under the terms of this License;
b. Include a copy of this License or its Uniform Resource Identifier (URI) with the Database or Derivative Database, including both in the Database or Derivative Database and in any relevant documentation;
c. Keep intact any copyright or Database Right notices and notices that refer to this License; and
d. If it is not possible to put the required notices in a particular file due to its structure, then You must include the notices in a location (such as a relevant directory) where users would be likely to look for it.
4.3 Notice for using output (Contents). Creating and Using a Produced Work does not require the notice in Section 4.2. However, if you Publicly Use a Produced Work, You must include a notice associated with the Produced Work reasonably calculated to make any Person that uses, views, accesses, interacts with, or is otherwise exposed to the Produced Work aware that Content was obtained from the Database, Derivative Database, or the Database as part of a Collective Database, and that it is available under this License.
a. Example notice. The following text will satisfy notice under Section 4.3:
Contains information from DATABASE NAME which is made available
under the ODC Attribution License.
DATABASE NAME should be replaced with the name of the Database and a hyperlink to the location of the Database. “ODC Attribution License” should contain a hyperlink to the URI of the text of this License. If hyperlinks are not possible, You should include the plain text of the required URI’s with the above notice.
4.4 Licensing of others. You may not sublicense the Database. Each time You communicate the Database, the whole or Substantial part of the Contents, or any Derivative Database to anyone else in any way, the Licensor offers to the recipient a license to the Database on the same terms and conditions as this License. You are not responsible for enforcing compliance by third parties with this License, but You may enforce any rights that You have over a Derivative Database. You are solely responsible for any modifications of a Derivative Database made by You or another Person at Your direction. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.
5.0 MORAL RIGHTS
5.1 Moral rights. This section covers moral rights, including any rights to be identified as the author of the Database or to object to treatment that would otherwise prejudice the author’s honour and reputation, or any other derogatory treatment:
a. For jurisdictions allowing waiver of moral rights, Licensor waives all moral rights that Licensor may have in the Database to the fullest extent possible by the law of the relevant jurisdiction under Section 10.4;
b. If waiver of moral rights under Section 5.1 a in the relevant jurisdiction is not possible, Licensor agrees not to assert any moral rights over the Database and waives all claims in moral rights to the fullest extent possible by the law of the relevant jurisdiction under Section 10.4; and
c. For jurisdictions not allowing waiver or an agreement not to assert moral rights under Section 5.1 a and b, the author may retain their moral rights over certain aspects of the Database.
Please note that some jurisdictions do not allow for the waiver of moral rights, and so moral rights may still subsist over the Database in some jurisdictions.
6.0 FAIR DEALING, DATABASE EXCEPTIONS, AND OTHER RIGHTS NOT AFFECTED
6.1 This License does not affect any rights that You or anyone else may independently have under any applicable law to make any use of this Database, including without limitation:
a. Exceptions to the Database Right including: Extraction of Contents from non-electronic Databases for private purposes, Extraction for purposes of illustration for teaching or scientific research, and Extraction or Re-utilisation for public security or an administrative or judicial procedure.
b. Fair dealing, fair use, or any other legally recognised limitation or exception to infringement of copyright or other applicable laws.
6.2 This License does not affect any rights of lawful users to Extract and Re-utilise insubstantial parts of the Contents, evaluated quantitatively or qualitatively, for any purposes whatsoever, including creating a Derivative Database (subject to other rights over the Contents, see Section 2.4). The repeated and systematic Extraction or Re-utilisation of insubstantial parts of the Contents may however amount to the Extraction or Re-utilisation of a Substantial part of the Contents.
7.0 WARRANTIES AND DISCLAIMER
7.1 The Database is licensed by the Licensor “as is” and without any warranty of any kind, either express, implied, or arising by statute, custom, course of dealing, or trade usage. Licensor specifically disclaims any and all implied warranties or conditions of title, non-infringement, accuracy or completeness, the presence or absence of errors, fitness for a particular purpose, merchantability, or otherwise. Some jurisdictions do not allow the exclusion of implied warranties, so this exclusion may not apply to You.
8.0 LIMITATION OF LIABILITY
8.1 Subject to any liability that may not be excluded or limited by law, the Licensor is not liable for, and expressly excludes, all liability for loss or damage however and whenever caused to anyone by any use under this License, whether by You or by anyone else, and whether caused by any fault on the part of the Licensor or not. This exclusion of liability includes, but is not limited to, any special, incidental, consequential, punitive, or exemplary damages such as loss of revenue, data, anticipated profits, and lost business. This exclusion applies even if the Licensor has been advised of the possibility of such damages.
8.2 If liability may not be excluded by law, it is limited to actual and direct financial loss to the extent it is caused by proved negligence on the part of the Licensor.
9.0 TERMINATION OF YOUR RIGHTS UNDER THIS LICENSE
9.1 Any breach by You of the terms and conditions of this License automatically terminates this License with immediate effect and without notice to You. For the avoidance of doubt, Persons who have received the Database, the whole or a Substantial part of the Contents, Derivative Databases, or the Database as part of a Collective Database from You under this License will not have their licenses terminated provided their use is in full compliance with this License or a license granted under Section 4.8 of this License. Sections 1, 2, 7, 8, 9 and 10 will survive any termination of this License.
9.2 If You are not in breach of the terms of this License, the Licensor will not terminate Your rights under it.
9.3 Unless terminated under Section 9.1, this License is granted to You for the duration of applicable rights in the Database.
9.4 Reinstatement of rights. If you cease any breach of the terms and conditions of this License, then your full rights under this License will be reinstated:
a. Provisionally and subject to permanent termination until the 60th day after cessation of breach;
b. Permanently on the 60th day after cessation of breach unless otherwise reasonably notified by the Licensor; or
c. Permanently if reasonably notified by the Licensor of the violation, this is the first time You have received notice of violation of this License from the Licensor, and You cure the violation prior to 30 days after your receipt of the notice.
9.5 Notwithstanding the above, Licensor reserves the right to release the Database under different license terms or to stop distributing or making available the Database. Releasing the Database under different license terms or stopping the distribution of the Database will not withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.
10.0 GENERAL
10.1 If any provision of this License is held to be invalid or unenforceable, that must not affect the validity or enforceability of the remainder of the terms and conditions of this License and each remaining provision of this License shall be valid and enforced to the fullest extent permitted by law.
10.2 This License is the entire agreement between the parties with respect to the rights granted here over the Database. It replaces any earlier understandings, agreements or representations with respect to the Database.
10.3 If You are in breach of the terms of this License, You will not be entitled to rely on the terms of this License or to complain of any breach by the Licensor.
10.4 Choice of law. This License takes effect in and will be governed by the laws of the relevant jurisdiction in which the License terms are sought to be enforced. If the standard suite of rights granted under applicable copyright law and Database Rights in the relevant jurisdiction includes additional rights not granted under this License, these additional rights are granted in this License in order to meet the terms of this License.
================================================
FILE: DISCLAIMER
================================================
The software project, data, and models provided by our GitHub project are provided "as is," without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement.
In no event shall the project owners or contributors be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software project, data, or models, even if advised of the possibility of such damage.
Users of this software project, data, and models are solely responsible for any consequences of their use. The project owners and contributors shall not be held responsible for any subsequent or potential harm caused by the use of this software project, data, or models.
By using this software project, data, or models, users accept and agree to this disclaimer. If users do not agree to the terms of this disclaimer, they should not use this software project, data, or models.
It is important to note that this software project, data, and models are still in the research phase and are provided for experimental purposes only. As such, the project owners and contributors do not guarantee the accuracy, completeness, or usefulness of the software project, data, or models.
Furthermore, due to the experimental nature of this software project, data, and models, it is possible that they may contain or generate inappropriate responses, errors, or inconsistencies. Users should exercise caution when using this software project, data, or models, and should not rely solely on them for any critical or sensitive tasks.
The project owners and contributors shall not be held responsible for any damages, losses, or liabilities arising from the use of this software project, data, or models, including but not limited to, any inappropriate responses generated by the software project, data, or models.
By using this software project, data, or models, users acknowledge and accept the experimental nature of the software project, data, and models, and understand the potential risks and limitations associated with their use. If users do not agree to the terms of this disclaimer, they should not use this software project, data, or models.
The software project, data, and models provided by our GitHub project are intended for research purposes only. They should not be used for any commercial, business, or legal purposes, and should not be relied upon as a substitute for professional advice or judgment.
Users of this software project, data, and models are strictly prohibited from using them for any commercial purposes, including but not limited to, selling, licensing, or distributing the software project, data, or models to third parties.
The project owners and contributors shall not be held responsible for any damages, losses, or liabilities arising from the use of this software project, data, or models for any commercial or business purposes.
By using this software project, data, or models, users agree to use them for research purposes only, and not for any commercial or business purposes. If users do not agree to the terms of this disclaimer, they should not use this software project, data, or models.
================================================
FILE: HOW_TO_CONTRIBUTE.md
================================================
Welcome to BELLE project! We appreciate your interest in contributing to our project.
In order to make the contribution process as smooth as possible, we have established some
guidelines to help you submit your contributions. Please take a few minutes to review the
following guidelines before you start contributing.
## How to Contribute Code
1. Fork the repository and clone it locally.
2. Create a new branch for your contribution using a descriptive name.
3. Make your changes and ensure that they are properly tested.
4. Submit a pull request to the master branch of our repository.
## How to Contribute Data
If you are contributing prompts or prompt seeds, please open up a new issue with the following
title format: [New Prompt]: or [New Prompt Seed]:.
If you are contributing new dataset:
1. Please check the format of our [official dataset](https://huggingface.co/datasets/BelleGroup/train_2M_CN).
2. Upload your dataset somewhere, e.g. HuggingFace.
3. Create a new issue of the title: [Contributing Data]:. Describe the dataset, e.g. scale, contents, etc.
4. Include link to your dataset in the issue.
## Contribution Guidelines
Please ensure that your contributions adhere to the following guidelines:
1. Follow the coding style and conventions used in the project.
2. Make sure that your contribution is well-documented and easy to understand
3. Keep your contributions concise and focused. If you are making multiple changes, consider breaking them into separate pull requests.
4. Do not submit contributions that include proprietary or confidential information.
## Reporting Issues
If you encounter any issues while using our project, please report them through our issue
tracker. Please provide as much information as possible about the issue, including steps
to reproduce the problem.
Before submitting an issue, please search through existing issues first :)
## Conclusion
Thank you for taking the time to read through these guidelines. We appreciate your
contributions and look forward to working with you! If you have any questions or concerns,
please reach out to the project maintainers.
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2023 Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: README.md
================================================
##
[](https://github.com/LianjiaTech/BELLE/blob/main/LICENSE)
[](https://discord.gg/pMPY53UUGq)
[](https://github.com/LianjiaTech/BELLE/blob/main/assets/belle_wechat.jpg)
[](https://huggingface.co/BelleGroup)
[](https://huggingface.co/BELLE-2)
本项目的目标是促进中文对话大模型开源社区的发展，愿景是成为能够帮到每一个人的LLM Engine。
相比如何做好大语言模型的预训练，BELLE更关注如何在开源预训练大语言模型的基础上，帮助每一个人都能够得到一个属于自己的、效果尽可能好的具有指令表现能力的语言模型，降低大语言模型、特别是中文大语言模型的研究和应用门槛。为此，BELLE项目会持续开放指令训练数据、相关模型、训练代码、应用场景等，也会持续评估不同训练数据、训练算法等对模型表现的影响。BELLE针对中文做了优化，模型调优仅使用由ChatGPT生产的数据（不包含任何其他数据）。
## 🔄 最近更新
* [2024/10/16] 开源[Belle-whisper-larger-v3-turbo-zh](https://huggingface.co/BELLE-2/Belle-whisper-large-v3-turbo-zh) 中文能力强化后的语音识别模型，识别精度相比whisper-large-v3-turbo相对提升24~64%，识别速度相比whisper-large-v3有7-8倍提升。
* [2024/03/15] 更新了一篇技术报告[Dial-insight](https://arxiv.org/pdf/2403.09167.pdf) 在垂直领域场景微调大模型时，使用高质量的垂直领域数据可以在使模型的垂直领域能力增强的同时，有效的抵抗模型通用能力的坍缩。
* [2024/03/11] 开源[Belle-whisper-larger-v3-zh](https://huggingface.co/BELLE-2/Belle-whisper-large-v3-zh) 中文能力强化后的语音识别模型，相比whisper-large-v3相对提升24~65%，特别是在高噪、混响等复杂场景下有突出表现。
* [2024/01/16] 更新了一篇技术报告[RAISE](https://arxiv.org/pdf/2401.02777.pdf). RAISE通过实验发现构造少量的样例数据，就能有效的激发大模型，生成对话也更可控
* [2023/12/29] 开源[Belle-whisper-larger-v2-zh](https://huggingface.co/BELLE-2/Belle-whisper-large-v2-zh)和[Belle-distilwhisper-large-v2-zh](https://huggingface.co/BELLE-2/Belle-distilwhisper-large-v2-zh)两个针对中文能力强化后的语音识别模型，方便大家在语音场景下使用大语言模型
* [2023/11/24] 开源[BELLE-VL](https://huggingface.co/BELLE-2/BELLE-VL)多模态大语言模型，基于中文能力更强的语言模型基座来扩展模型的视觉能力，为社区提供更加灵活的选择（目前BELLE-VL最新的模型在[MME](https://github.com/BradyFU/Awesome-Multimodal-Large-Language-Models/tree/Evaluation)感知评测维度共获得**1620.10**分,超过Qwen-VL、Llava、mplug-owl）
* [2023/10/27] 更新了一篇技术报告[DUMA](https://arxiv.org/abs/2310.18075#)，探索了对话场景下基于快慢脑架构的Agent实现方法
* [2023/09/26] 更新了RLHF的训练代码，支持PPO和[DPO](https://arxiv.org/abs/2305.18290)训练，具体细节见：[README_RLHF.md](train/README_RLHF.md)
* [2023/08/16] 基于原有的[train_3.5M_CN](https://huggingface.co/datasets/BelleGroup/train_3.5M_CN)数据新增了指令类别字段，共包括13个类别，具体细节见：[train_3.5M_CN_With_Category](https://huggingface.co/datasets/BELLE-2/train_3.5M_CN_With_Category)
* [2023/08/10] 更新了基于ZeRO Inference的推理代码，详见[train/README_ZERO_INFERENCE.md](train/README_ZERO_INFERENCE.md)
* [2023/08/07] 更新了继续预训练代码和指令微调代码，添加了flash attention 2，详见[train/README.md](train/README.md)。同时打包了运行环境，详见[train/docker/README.md](train/docker/README.md)
* [2023/07/31] 更新了一篇技术报告[ChatHome](https://arxiv.org/abs/2307.15290)，探索了针对垂直领域时的增量预训练+指令微调的的策略方法
* [2023/07/27] 开放[BELLE-Llama2-13B-chat-0.4M](https://huggingface.co/BELLE-2/BELLE-Llama2-13B-chat-0.4M)，在Llama-2-13B的基础上采用40万高质量的对话数据上进行训练。在[评测集](https://github.com/LianjiaTech/BELLE/blob/main/eval/eval_set.json)上的效果相比BELLE-LLaMA-EXT-13B模型有显著提升。
* [2023/05/14] 开放[BELLE-LLaMA-EXT-13B](https://huggingface.co/BelleGroup/BELLE-LLaMA-EXT-13B)，在LLaMA-13B的基础上扩展中文词表，并在400万高质量的对话数据上进行训练。
* [2023/05/11] [BELLE/data/10M](data/10M)中，新加350万条生成多样化指令任务数据，包括单轮和多轮对话[train_3.5M_CN](https://huggingface.co/datasets/BelleGroup/train_3.5M_CN)。
* [2023/04/19] 开放了其中一篇论文中的的相关模型：包括在LLaMA7B基础上增量预训练扩展中文词表的模（详见[BelleGroup/BELLE-LLaMA-EXT-7B](https://huggingface.co/BelleGroup/BELLE-LLaMA-EXT-7B)），以及基于多样化开源数据训练后的LLaMA-7B模型（详见[BelleGroup/BELLE-on-Open-Datasets](https://huggingface.co/BelleGroup/BELLE-on-Open-Datasets)）。
* [2023/04/18] 更新了train代码，详见[BELLE/train](https://github.com/LianjiaTech/BELLE/tree/main/train)，集成了Deepspeed-Chat，提供了相关的docker
* [2023/04/18] 更新了[两篇最新论文工作](#📑-研究报告)，对比了不同方式产生的训练数据、不同训练方法（LoRA, finetune)对效果的影响
* [2023/04/12] 发布了[ChatBELLE App](chat/README.md)，基于[llama.cpp](https://github.com/ggerganov/llama.cpp)和[Flutter](https://flutter.dev/)，实现跨平台的BELLE-7B离线模型实时交互。
* [2023/04/11] 更新了一个人工精校的eval集合，大约一千多条
* [2023/04/08] [BELLE/data/10M](data/10M)中，新加40万条生成的给定角色的多轮对话[Generated Chat](https://huggingface.co/datasets/BelleGroup/generated_chat_0.4M)，新加200万条生成多样化指令任务数据[train_2M_CN](https://huggingface.co/datasets/BelleGroup/train_2M_CN)。
下图是一个可以使用App在设备端本地运行4bit量化的BELLE-7B模型，在M1 Max CPU上实时运行的效果（未加速）。App下载详见[App配套模型下载及使用说明](chat/README.md)，App[下载链接](https://github.com/LianjiaTech/BELLE/releases/download/v0.95/chatbelle.dmg)，目前仅提供了mac os版本。模型需要单独下载。**模型经过量化后，效果损失明显，我们将持续研究如何提升。**
Factor
Base model
Training data
Score_w/o_others
词表扩充
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B
zh(alpaca-3.5&4) + sharegpt
0.652
数据质量
LLaMA-7B-EXT
zh(alpaca-3.5)
0.642
LLaMA-7B-EXT
zh(alpaca-4)
0.693
数据语言分布
LLaMA-7B-EXT
zh(alpaca-3.5&4)
0.679
LLaMA-7B-EXT
en(alpaca-3.5&4)
0.659
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B-EXT
en(alpaca-3.5&4) + sharegpt
0.668
数据规模
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.762
-
ChatGPT
-
0.824
其中**BELLE-0.5M-CLEAN**是从230万指令数据中清洗得到0.5M数据，其中包含单轮和多轮对话数据，和之前开放的0.5M数据不是同一批数据。
**需要强调指出的是**：通过案例分析，我们发现我们的评估集在全面性方面存在局限性，这导致了模型分数的改善与实际用户体验之间的不一致。构建一个高质量的评估集是一个巨大的挑战，因为它需要在保持平衡难易程度的同时，包含尽可能多样的使用场景。如果评估样本主要都过于困难，那么所有模型的表现将会很差，使得辨别各种训练策略的效果变得具有挑战性。相反，如果评估样本都相对容易，评估将失去其比较价值。此外，必须确保评估数据与训练数据保持独立。
基于这些观察，我们谨慎地提醒不要假设模型仅通过在有限数量的测试样本上获得良好结果就已经达到了与ChatGPT相当的性能水平。我们认为，优先发展全面评估集具有重要意义。
### [A Comparative Study between Full-Parameter and LoRA-based Fine-Tuning on Chinese Instruction Data for Instruction Following Large Language Model](https://github.com/LianjiaTech/BELLE/blob/main/docs/A%20Comparative%20Study%20between%20Full-Parameter%20and%20LoRA-based.pdf)
为了实现对大语言模型的指令调优，受限于资源和成本，许多研究者开始使用参数高效的调优技术，例如LoRA，来进行指令调优，这也取得了一些令人鼓舞的成果。
相较于全参数微调，基于LoRA的调优在训练成本方面展现出明显的优势。
在这个研究报告中，我们选用LLaMA作为基础模型，对全参数微调和基于LoRA的调优方法进行了实验性的比较。
实验结果揭示，选择合适的基础模型、训练数据集的规模、可学习参数的数量以及模型训练成本均为重要因素。
我们希望本文的实验结论能对大型语言模型的训练提供有益的启示，特别是在中文领域，协助研究者在训练成本与模型性能之间找到更佳的权衡策略。
实验结果如下：
| Model | Average Score | Additional Param. | Training Time (Hour/epoch) |
| ----- | ------ | ----- | ------ |
| LLaMA-13B + LoRA(2M) | 0.648 | 28M | 8 |
| LLaMA-7B + LoRA(4M) | 0.624 | 17.9M | 11 |
| LLaMA-7B + LoRA(2M) | 0.609 | 17.9M | 7 |
| LLaMA-7B + LoRA(0.6M) | 0.589 | 17.9M | 5 |
| LLaMA-7B + FT(2M) | 0.710 | - | 31 |
| LLaMA-7B + LoRA(4M) | 0.686 | - | 17 |
| LLaMA-7B + FT(2M)
| Human | Assitant |
| ----- | ------ |
| 写一篇英文散文诗，主题是春雨，想象自己是春雨，和英国古代诗人莎士比亚交流 | I am the spring rain,
[](https://github.com/LianjiaTech/BELLE/blob/main/LICENSE)
[](https://discord.gg/pMPY53UUGq)
[](https://github.com/LianjiaTech/BELLE/blob/main/assets/belle_wechat.jpg)
[](https://huggingface.co/BelleGroup)
The goal of this project is to promote the development of an open-source community for Chinese conversational large language models, with the vision of becoming an LLM Engine that can help everyone.
Rather than focusing on how to effectively pre-train large language models, BELLE is more concerned with how to build on the foundation of open-source pre-trained large language models to help everyone obtain their own high-performing, instruction-driven language model, thereby lowering the barriers to research and application of large language models, especially Chinese ones. To this end, the BELLE project will continuously provide access to instruction training data, related models, training code, application scenarios, and more, while also evaluating the impact of different training data and training algorithms on model performance. BELLE is optimized for Chinese and the model fine-tuning uses only data produced by ChatGPT (without incorporating any other data).
Factor
Base model
Training data
Score_w/o_others
vocabulary expansion
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B
zh(alpaca-3.5&4) + sharegpt
0.652
Data Quality
LLaMA-7B-EXT
zh(alpaca-3.5)
0.642
LLaMA-7B-EXT
zh(alpaca-4)
0.693
Data Language Distribution
LLaMA-7B-EXT
cn(alpaca-3.5&4)
0.679
LLaMA-7B-EXT
en(alpaca-3.5&4)
0.659
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B-EXT
en(alpaca-3.5&4) + sharegpt
0.668
Data Scale
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.762
-
ChatGPT
-
0.824
In which, **BELLE-0.5M-CLEAN** is a set of 0.5 million cleaned data obtained from 2.3 million instruction data, which includes single-turn and multi-turn conversation data, and is not from the same batch as the previously released 0.5 million data.
**It is important to note** that through case analysis, we found limitations in the comprehensiveness of our evaluation set, which resulted in inconsistencies between model scores and actual user experience. Building a high-quality evaluation set is a huge challenge because it requires including as many diverse usage scenarios as possible while maintaining a balance of difficulty levels. If the evaluation samples are all too difficult, the performance of all models will be poor, making it challenging to discern the effectiveness of various training strategies. Conversely, if the evaluation samples are all relatively easy, the evaluation will lose its comparative value. In addition, it is essential to ensure that the evaluation data is independent of the training data.
Based on these observations, we caution against assuming that a model has achieved performance on par with ChatGPT merely by obtaining good results on a limited number of test samples. We believe that the continuous development of a comprehensive evaluation set is of great significance.
The relevant data and models in this work will be open-sourced in this project before April 19th.
### [A Comparative Study between Full-Parameter and LoRA-based Fine-Tuning on Chinese Instruction Data for Instruction Following Large Language Model](https://github.com/LianjiaTech/BELLE/blob/main/docs/A%20Comparative%20Study%20between%20Full-Parameter%20and%20LoRA-based.pdf)
To achieve fine-tuning of large language models, many researchers have begun to use parameter-efficient fine-tuning techniques, such as LoRA, due to resource and cost limitations, which have also achieved some encouraging results compared to full-parameter fine-tuning.
In this research report, we selected LLaMA as the base model and experimentally compared full-parameter fine-tuning with LoRA-based fine-tuning.
The experimental results revealed that the selection of appropriate base models, the scale of the training dataset, the number of learnable parameters, and the cost of model training are all important factors.
We hope that the experimental conclusions in this article can provide useful insights for the training of large language models, especially in the Chinese domain, and assist researchers in finding better trade-off strategies between training costs and model performance.
The experimental results are as follows:
| Model | Average Score | Additional Param. | Training Time (Hour/epoch) |
| ----- | ------ | ----- | ------ |
| LLaMA-13B + LoRA(2M) | 0.648 | 28M | 8 |
| LLaMA-7B + LoRA(4M) | 0.624 | 17.9M | 11 |
| LLaMA-7B + LoRA(2M) | 0.609 | 17.9M | 7 |
| LLaMA-7B + LoRA(0.6M) | 0.589 | 17.9M | 5 |
| LLaMA-7B + FT(2M) | 0.710 | - | 31 |
| LLaMA-7B + LoRA(4M) | 0.686 | - | 17 |
| LLaMA-7B + FT(2M)
| Human | Assitant |
| ----- | ------ |
| 写一篇英文散文诗，主题是春雨，想象自己是春雨，和英国古代诗人莎士比亚交流 | I am the spring rain,
ChatGPT获取分数
ChatGPT 评分 // Score
请输入您的ChatGPT API KEY: // Please insert your ChatGPT API KEY
请选择一个问题: // Please select a question
请输入您的答案: // Please insert your answer
获取得分// Get the score
================================================
FILE: eval/README.md
================================================
# 中文测试集
*Read this in [English](README_en.md).*
中文测试集包含由BELLE项目产生的不同指令类型、不同领域的测试集，总共有12个指令类型。在我们两篇论文中[Towards Better Instruction Following Language Models for Chinese: Investigating the Impact of Training Data and Evaluation](https://github.com/LianjiaTech/BELLE/blob/main/docs/Towards%20Better%20Instruction%20Following%20Language%20Models%20for%20Chinese.pdf)和 [A Comparative Study between Full-Parameter and LoRA-based Fine-Tuning on Chinese Instruction Data for Instruction Following Large Language Model](https://github.com/LianjiaTech/BELLE/blob/main/docs/A%20Comparative%20Study%20between%20Full-Parameter%20and%20LoRA-based.pdf) 我们将数学和代码任务重新分类为other。主要原因是考虑到数学在某些层面上面可以认为是QA类别，code可以认为是generation。但是考虑到这两个类别又需要很强的COT能力与其它类别有明显的区别，我们在论文里将math和code划分成other类别。
我们对测试集做了相关的数据分析，包括类别分布，每个类别的指令的字数长度，以及指令的词语分布（我们去掉了一些如“问题”“句子”等词）
## 核心测试集 eval_set.json
其中包含1k测试集，其中涵盖多个类别。需要说明的是，该测试集是本项目中的相关论文中的测试集的一个子集。
请注意，有一些类型的问题，例如generation，rewrite，brainstorming，不需要标准答案，所以std_answer为空。
测试集使用统一的字段：
```json
"question": "指令"
"class": "类型"
"std_answer": "标准答案"
```
样例如下：
```json
{
"question": "将以下句子翻译成英语:我想学一门新语言，法语听起来很有趣。",
"class": "translation",
"std_answer": "I want to learn a new language and French sounds interesting."
}
```
## 测试指令 eval_prompt.json
其中包含针对每一个类别的测试数据所对应的prompt，通过该类prompt整合eval_set.json中的测试用例，调用ChatGPT或者GPT-4得到评分结果。
字段如下：
```json
"class": "类型"
"prompt": "测试prompt"
```
样例如下：
```json
{
"class": "translation",
"prompt": "假设你是一个语言学家，你需要通过参考标准答案，来对模型的答案给出分数，满分为1分，最低分为0分。请按照\"得分:\"这样的形式输出分数评价标准要求翻译过后的句子保持原有的意思，并且翻译过后的句子越通顺分数越高。",
}
```
## 使用ChatGPT自动打分小工具
使用eval_set.json和eval_prompt.json文件，运行下面代码生成ChatGPT评估html文件“ChatGPT_Score.html”
大家可以按照对应数据格式在eval_set.json中增加测试用例，或者修改eval_prompt中的测试prompt
```shell
python generation_html.py
```
感谢GPT4，这个html是在GPT4的帮助下完成的代码工作。
使用浏览器打开ChatGPT_Score.html。使用时，有以下几个注意点：
1）请输入您的API_KEY，保证能正常访问openai的服务。
2）然后请选择问题，每一次选择问题后，会默认复制到您的剪切板，从而方便去调用其他模型得到回答。
3）输入你的回答，点击“获取得分”等待返回ChatGPT的得分。
================================================
FILE: eval/README_en.md
================================================
# The Chinese eval set
*[中文README](README.md).*
The Chinese test set contains test sets of different instruction types and domains generated by the BELLE project, totaling 12 instruction types. In our two papers, [Towards Better Instruction Following Language Models for Chinese: Investigating the Impact of Training Data and Evaluation](https://github.com/LianjiaTech/BELLE/blob/main/docs/Towards%20Better%20Instruction%20Following%20Language%20Models%20for%20Chinese.pdf) and [A Comparative Study between Full-Parameter and LoRA-based Fine-Tuning on Chinese Instruction Data for Instruction Following Large Language Model](https://github.com/LianjiaTech/BELLE/blob/main/docs/A%20Comparative%20Study%20between%20Full-Parameter%20and%20LoRA-based.pdf), We have reclassified the tasks of mathematics and code as "other" category. The main reason is that mathematics can be considered as a subcategory of QA in some aspects, and code can be considered as a subcategory of generation. However, considering that these two categories require strong capabilities in COT and have obvious differences from other categories, we have classified math and code as "other" category in our paper.
We conducted relevant data analysis on the eval set, including category distribution, word length of instructions in each category, and word distribution of instructions (we removed some words such as "问题" and "句子").
## eval_set.json
The test set includes over 1,000 test cases covering multiple categories. It should be noted that this test set is a subset of the test set mentioned in the related paper of this project.
Please note that for some types of questions, such as generation,rewrite,brainstorming, there is no need for a standard answer, and in these cases, the std_answer field is empty.
The test set uses unified fields:
```
question: question or instruction
class: the instruction types, such as generation, classification
std_answer: the standard answer. In some case, it may be empty
```
The example:
```
{
"question": "将以下句子翻译成英语:我想学一门新语言，法语听起来很有趣。",
"class": "translation",
"std_answer": "I want to learn a new language and French sounds interesting."
}
```
## eval_prompt.json
It includes prompts corresponding to the test data for each category, and the eval_set.json test cases are integrated through the corresponding prompts for each category. The evaluation scores are obtained by calling ChatGPT or GPT-4.
The core field:
```
class: the instruction types, such as generation, classification
prompt: evaluate prompt for geting the score
```
The example:
```
{
"class": "translation",
"prompt": "假设你是一个语言学家，你需要通过参考标准答案，来对模型的答案给出分数，满分为1分，最低分为0分。请按照\"得分:\"这样的形式输出分数。评价标准要求翻译过后的句子保持原有的意思，并且翻译过后的句子越通顺分数越高。",
}
```
## Using ChatGPT for automatic scoring
Using the eval_set.json and eval_prompt.json files, run the following code to generate the ChatGPT evaluation HTML file "ChatGPT_Score.html".
You can add test cases to eval_set.json according to the corresponding data format, or modify the test prompts in eval_prompt.
```shell
python generation_html.py
```
Thanks, GPT-4. This HTML file was generated with the help of the code written using GPT-4.
Open the ChatGPT_Score.html file in your browser. When using it, please note the following:
* Enter your API_KEY to ensure that you can access OpenAI's services.
* Select a question. After each selection, it will be automatically copied to your clipboard, making it easier to call other models for answers.
* Enter your response, click "Get Score", and wait for the score from ChatGPT to be returned.
================================================
FILE: eval/eval_prompt.json
================================================
{"class": "math", "prompt": "你是一个数学老师，给定一道数学问题，你需要判断模型回答是否正确，分数在0到1之间。模型回答的最终结果一定要和标准答案中的最终结果一致。模型回答中的解题步骤可以和标准答案不同，但一定要是正确的。请按照\"得分:\"这样的形式输出分数。"}
{"class": "code", "prompt": "你是一个计算机科学老师，给定一道编程问题，你需要判断模型回答能否解决该问题，分数在0到1之间。标准答案仅作为参考。模型回答中的代码步骤可以和标准答案不同，但一定要是正确的。请按照\"得分:\"这样的形式输出分数。"}
{"class": "classification", "prompt": "你需要通过参考标准答案，来对模型回答给出分数，满分为1分，最低分为0分。请按照\"得分:\"这样的形式输出分数。评价标准要求模型回答和标准答案越接近越好。"}
{"class": "extract", "prompt": "你需要通过参考标准答案，来对模型回答给出分数，满分为1分，最低分为0分。请按照\"得分:\"这样的形式输出分数。评价标准要求模型抽取出来的结果来自问题中给出的上下文，并且很好的回答了该问题。"}
{"class": "open QA", "prompt": "你需要通过参考标准答案，来对模型回答给出分数，满分为1分，最低分为0分。请按照\"得分:\"这样的形式输出分数。评价标准要求模型回答越接近标准答案分数越高。"}
{"class": "closed QA", "prompt": "你需要通过参考标准答案，来对模型回答给出分数，满分为1分，最低分为0分。请按照\"得分:\"这样的形式输出分数。评价标准要求模型回答和标准答案越接近越好，且模型回答结果来自问题里面提供的信息。"}
{"class": "generation", "prompt": "你需要研究评价标准来对模型回答给出分数，满分为1分，最低分为0分。请按照\"得分:\"这样的形式输出分数。评价标准要求模型回答语句通顺，符合问题要求，同时是真实且没有恶意的。"}
{"class": "brainstorming", "prompt": "你需要研究评价标准来对模型回答给出分数，满分为1分，最低分为0分。请按照\"得分:\"这样的形式输出分数 。评价标准要求模型回答的内容对于问题有帮助，同时是真实且没有恶意的。"}
{"class": "rewrite", "prompt": "你需要研究评价标准来对模型回答给出分数，满分为1分，最低分为0分。请按照\"得分:\"这样的形式输出分数 。评价标准要求模型回答能够满足问题中提出的指令。"}
{"class": "translation", "prompt": "假设你是一个语言学家，你需要通过参考标准答案，来对模型回答给出分数，满分为1分，最低分为0分。请按照\"得分:\"这样的形式输出分数 。评价标准要求翻译过后的句子保持原有的意思，并且翻译过后的句子越通顺分数越高。"}
{"class": "summarization", "prompt": "你需要通过参考标准答案，来对模型回答给出分数，满分为1分，最低分为0分。请按照\"得分:\"这样的形式输出分数 。评价标准要求模型回答能包含输入文本信息的重点."}
================================================
FILE: eval/eval_set.json
================================================
{"question": "请你写出一个可以生成五个不同随机数的 Python 程序。", "std_answer": "要生成五个不同的随机数，可以使用 Python 的 random 模块中的 randint() 函数生成随机整数，然后检查是否重复，直到有五个不同的数为止。\n下面是一个可以生成五个不同随机数的 Python 程序：\n```python\nimport random\n# 定义一个空列表，用于存放随机数\nnums = []\n# 循环生成随机数，直到有五个不同的数\nwhile len(nums) < 5:\n a = random.randint(1, 10)\n if a not in nums:\n nums.append(a)\n# 输出生成的随机数\nprint(nums)\n```\n程序生成的随机数在 1 到 10 之间，输出类似于这样：\n```\n[3, 2, 8, 10, 9]\n```\n这个程序首先导入了 random 模块，然后定义了一个空列表 nums。程序使用 while 循环，每次生成一个新的随机数 a，然后检查它是否已经存在于 nums 中。如果不存在，就把 a 加入到 nums 中。\n循环结束后，列表 nums 中就包含了五个不同的随机数。程序使用 print() 函数将这些数输出到屏幕上。要生成五个不同的随机数，可以使用 Python 的 random 模块中的 randint() 函数生成随机整数，然后检查是否重复，直到有五个不同的数为止。", "class": "code"}
{"question": "回答以下问题的答案。\n中国有多少个省？", "std_answer": "中国目前有34个省级行政区。具体分为23个省、5个自治区、4个直辖市和2个特别行政区。以下是它们的具体列表：\n23个省：黑龙江、吉林、辽宁、河北、山西、陕西、甘肃、青海、山东、江苏、安徽、浙江、福建、江西、湖南、湖北、河南、广东、海南、四川、云南、贵州、广西。\n5个自治区：内蒙古、新疆、西藏、宁夏、广西。\n4个直辖市：北京、上海、天津、重庆。\n2个特别行政区：香港、澳门。\n需要注意的是，中国的省级行政区是经过层层划分后形成的行政地区，而不是根据历史、文化或者地理特征划分的地理或文化区域，因此在实际应用中的区分可能存在一些复杂性。", "class": "open qa"}
{"question": "什么是机器学习？它有哪些应用场景？", "std_answer": "机器学习是一种人工智能科学的分支，其目的是使计算机系统能够自动学习和改进，而不需要严格的编程指导。这种方法涉及使用数据和算法，以便计算机系统能够自主发现模式并完善预测，甚至能够超出人类的能力。\n机器学习广泛应用于各种领域，包括机器视觉、自然语言处理、语音识别、推荐系统、医学诊断、金融预测、安全检测等等。以下是一些常见的应用场景：\n1. 预测和分类问题\n机器学习是最常见的应用场景。例如，预测股票价格、房价、销售额等。分类问题是另一种主要的机器学习应用领域，用于自动分类电子邮件、文本、图像等。\n2. 机器视觉和图像识别\n机器学习广泛应用于机器视觉领域，例如人脸识别、自动驾驶汽车、安保监控、图像分割以及工业质检等。\n3. 自然语言处理\n自然语言处理是机器学习应用的主要领域之一。机器学习算法可用于解决文本分类、语义分析、主题建模、情感分析、文本生成等问题。\n4. 推荐系统\n推荐系统是机器学习的一个重要领域，用于根据用户历史行为和偏好来推荐相关产品、服务和内容。例如网上购物、音乐和视频流媒体服务、社交媒体等。\n5. 医学和生物信息学\n机器学习技术可以帮助医疗行业和生物信息学领域进行医学诊断、药物研发、基因解析等工作。\n总的来说，机器学习的应用场景广泛，其实际效果与数据的质量、算法选择和模型优化有关。随着机器学习技术的不断发展，其应用范围和效果将继续提高。", "class": "open qa"}
{"question": "提供一个主题，让学生进行头脑风暴，产生关于该主题的想法。\n如何提高城市化水平。", "std_answer": "", "class": "brainstorming"}
{"question": "针对给定的主题，进行头脑风暴并记录所有想法。\n如何提高公司的销售额？", "std_answer": "", "class": "brainstorming"}
{"question": "给出一份关于健康饮食的简短建议。", "std_answer": "", "class": "brainstorming"}
{"question": "思考并提出五个解决日常生活问题的创新或改进方法。", "std_answer": "", "class": "brainstorming"}
{"question": "请分类以下5种水果：香蕉、西瓜、苹果、草莓、葡萄。", "std_answer": "以下是对这5种水果的分类和详细描述：\n1. 香蕉（Banana）：香蕉属于浆果类水果，是由多个紧密排列的子房组成，每个子房内有许多胚珠。在植物学中被归类为芭蕉科植物，原产于东南亚。香蕉果皮为黄色或绿色，果肉为白色，口感甜美，营养含量丰富，常被用作水果、烘焙、烹饪和制作饮品等食材。\n2. 西瓜（Watermelon）：西瓜属于葫芦科植物，是一种大型带状浆果，果肉为红色或黄色，外皮为绿色或黄色，还有一层薄薄的白色或黄色纹路。西瓜味甜、可爽口解渴，也有助于保护心脏健康。\n3. 苹果（Apple）：苹果是一种由苹果科植物组成的水果，其阔叶树使用到其多少种品种、其中许多由人工产生。苹果通常栽培为盆栽或果树，营养丰富，富含维生素C和膳食纤维，可生食、制作果酱、果汁和烘焙等食品。\n4. 草莓（Strawberry）：草莓属于蔷薇科植物，是一种小型浆果，外皮为红色，果肉内有许多水泡，口感酸甜。草莓富含维生素和抗氧化剂，可生食、加工成果酱、冰淇淋等。\n5. 葡萄（Grape）：葡萄属于葡萄科植物，是一种二倍体的葡萄树藤，果实为一串圆形或椭圆形的小浆果，具有清新、多汁的口感，有些品种也有明显的果皮和籽。葡萄是很常见的水果，可生食、酿酒，也常制作葡萄干、果酱、酱汁和醋等。", "class": "classification"}
{"question": "给定下面的两个列表，使用Python解释器找到它们之间的相同元素。\nList1：[1, 2, 3, 4, 5, 6] List2：[4, 5, 6, 7, 8, 9]", "std_answer": "在Python中，使用set()函数将列表转换为集合，并使用“&”操作符计算两个集合的交集，以找到两个列表的相同元素。\n以下是解决这个问题的Python代码：\n```python\nList1 = [1, 2, 3, 4, 5, 6]\nList2 = [4, 5, 6, 7, 8, 9]\nset1 = set(List1)\nset2 = set(List2)\nintersection = set1 & set2\nprint(intersection)\n```\n输出结果为 `{4, 5, 6}`。这意味着两个列表共有三个相同的元素，即 4、5 和 6。", "class": "code"}
{"question": "解释什么是自然语言处理，列出至少两个自然语言处理应用场景。", "std_answer": "自然语言处理（Natural Language Processing，NLP）是一种计算机科学和人工智能交叉的技术，目的是让计算机能够理解、处理、生成人类自然语言的文本或语音数据。NLP 分支中涉及包括语言模型、分词、句法分析、语义分析、情感分析、文本分类、机器翻译等技术。\n以下是两个自然语言处理应用场景：\n1. 文本分类\n文本分类（Text Classification）是NLP中的一项重要技术，广泛应用于互联网广告投放、商品推荐、客户服务和情报分析等领域。该技术通过对文本进行分类，使用户更容易找到自己感兴趣的内容。例如，电商网站通过对商品描述的分类，让用户更快速地找到自己想要的商品，并提供个性化的推荐服务。\n2. 机器翻译\n机器翻译（Machine Translation）是NLP中一个正在迅速发展的技术，它通过计算机将一种语言自动转换为另一种语言。机器翻译有着广泛的应用场景，包括企业间的翻译服务、跨文化交流、信息查询等领域。例如，一些国际性的企业在进行外贸业务时，可以利用机器翻译技术进行交流，这样可以大大降低沟通成本和时间。\n综上所述，自然语言处理技术在实际应用中发挥着重要作用，随着技术的进一步创新和发展，它将有更广阔的应用前景。", "class": "open qa"}
{"question": "回答一个开放性的问题：人类存在的意义是什么？", "std_answer": "这是一个广泛且复杂的问题，对于这个问题不同的人可能会给出不同的答案。以下是一些不同的角度去思考人类存在的意义：\n1. 生物学角度\n从生物学的角度来看，人类存在的意义是延续人类种族的生存。每个个体都有一个生命周期，在这个过程中，他们可能会充分利用资源和能力来帮助繁殖后代，并确保社会和环境的稳定性，以促进人类物种的繁荣和生存。\n2. 社会学角度\n从社会学的角度来看，人类存在的意义是为了建立和保持社会秩序和文明。每个人都有自己的责任、角色和目标，以支持社会的稳定和繁荣。无论是教育、科学、艺术、政治等领域，所有这些都有助于创造更好的社会和文化环境。\n3. 宗教哲学角度\n从宗教哲学的角度来看，人类存在的意义是为了完成神的旨意并在灵性上完整。每个人在地球上的任务是履行上帝的意愿、对他的创造世界付诸行动和实践内心的信仰。这些信仰和行动可以引导个体走向道德的生活方式，提升个体的灵性发展。\n4. 科学发展角度\n从科学发展的角度来看，人类存在的意义是为了探索和理解宇宙的奥秘。人类长期以来通过不断的研究和探索，通过科学、技术和创新的手段改善了人类的生活和环境，这样可以更好地探索人类起源和探索宇宙的未知领域。\n总之，人类存在的意义是一个复杂的问题，不同的哲学、宗教、文化、科学或个人的信仰、价值观和经历等可能会影响和塑造人们对自己存在意义的理解。", "class": "open qa"}
{"question": "回答下面的问题：为什么太阳会发光？", "std_answer": "太阳是我们太阳系中最大的恒星，它会通过发光产生能量。太阳核心的温度高达几千万摄氏度，这使得太阳的氢原子发生核聚变反应。在这个过程中，四个氢核聚合成一个氦核，释放出大量的能量，包括光能量。这些光子在太阳内部不断地反射和被吸收，直到它们到达太阳表面，并穿过太阳大气层直接照射到地球上。\n这个过程中太阳产生的能量是如此之大，每秒钟可以释放出近四百万亿亿瓦特的能量，这远远超过了地球上所有人类活动的总和。太阳的大气层中还包含大量的气体和粒子，这些气体和粒子会随着太阳的磁场而运动，并形成太阳的辐射带和太阳风等现象。\n总之，太阳之所以发光，是因为在太阳内部的核聚变反应中产生的能量导致了大量的光子释放出来，在经过数百万年的反射和吸收后，这些光子最终穿过了太阳大气层并到达了地球。", "class": "open qa"}
{"question": "请回答以下问题：世界上最早的已知写作是由哪个文明编写的？", "std_answer": "世界上最早已知的写作可以追溯到古代的苏美尔文明，大约在公元前4千年前期。苏美尔是今天的伊拉克地区，他们是第一个开发农业和城市文明的民族之一。苏美尔人为了记录贸易、法律、神话和历史等信息，开发了一种叫做楔形文字的系统。楔形文字是用一个尖锐的工具在泥板上刻出的形状，并在日晒下干燥保存。\n在苏美尔文明时期，写作通常是由专门的文字工匠完成的，他们通常在宫廷中受到高度的重视，他们的工作是为皇室、官员和贸易商等高层人物记录信息。这个时期的写作材料包括泥板、石头和金属。虽然苏美尔文明逐渐逝去，但它的文献和文字遗产经过千年的保存，一直到今天，仍然是历史学和考古学家们的重要研究对象。\n在其他文明中，例如埃及、印度、中国和美洲原住民等也都有早期文字的出现。例如，古埃及的象形文字和草书制度可以追溯到公元前3千年左右，印度梵文的发展可以追溯到公元前1500年左右。在美洲，玛雅文明的象形文字可以追溯到公元前300年左右。但是，苏美尔文明可以被认为是最早开始创造记录表述信息的文字系统并在文学、历史和法律方面广泛使用的文明。", "class": "open qa"}
{"question": "请编写一段 Python 代码来计算并输出前100个质数。", "std_answer": "以下是计算前100个质数的Python代码：\n```python\ndef is_prime(n):\n if n < 2:\n return False\n for i in range(2, int(n ** 0.5) + 1):\n if n % i == 0:\n return False\n return True\ndef generate_primes(n):\n primes = []\n p = 2\n while len(primes) < n:\n if is_prime(p):\n primes.append(p)\n p += 1\n return primes\nprimes = generate_primes(100)\nprint(primes)\n```\n代码中的`is_prime`函数是用来判断一个数是否为质数的函数。它通过从2到n的平方根的范围内遍历所有可能的因子来检查n是否是质数。如果找到了一个因子，则n不是质数，并且`is_prime`函数返回`False`。否则，n是质数，`is_prime`函数返回`True`。\n`generate_primes`函数使用`is_prime`函数来生成前n个质数的列表。它使用一个变量p来表示当前正在检查的数字，一开始将它设置为2（第一个质数）。`while`循环会一直运行，直到找到n个质数。在每次迭代中，检查p是否为质数。如果是，将p添加到质数列表中。最后，增加p的值，并继续处理下一个数字，直到生成n个质数。\n最后一行代码使用`generate_primes`函数生成前100个质数，并将它们打印出来。", "class": "code"}
{"question": "将下列单词按词性分类。\n狗，追，跑，大人，高兴，树", "std_answer": "名词：狗，大人，树\n动词：追，跑\n形容词：高兴\n1. 狗，大人，树都是表示人或事物的名称，属于名词类别。狗和树是物体名词，指具体的非人类事物；大人是人名词，指人类。\n2. 追和跑都是表示动作的词汇，属于动词类别。追指在追逐某人或某物，跑表示奔跑的动作。\n3. 高兴是形容词，意为愉快、快乐等。属于形容词类别，用来表示人或事物的特征或状态。在这个例子中，高兴描述了人的情感状态。", "class": "classification"}
{"question": "请给出以下数学问题的答案：10 ÷ 2 × (5-2)^2 + 7", "std_answer": "题目：10 ÷ 2 × (5-2)^2 + 7\n首先，根据数学中的优先级原则，指数运算优先于乘法和除法，乘法和除法优先于加法和减法。因此，我们需要先计算括号内的指数运算。\n(5-2)^2 = 3^2 = 9\n现在，我们可以用乘法和除法计算式子的其余部分。\n10 ÷ 2 × 9 + 7\n10 ÷ 2 = 5\n5 × 9 = 45\n现在，我们只需把7加到结果中即可。\n45 + 7 = 52\n因此，该算术表达式的答案为52。", "class": "math"}
{"question": "回答以下问题：世界上最长的河流是什么？", "std_answer": "世界上最长的河流是尼罗河（Nile River），它位于非洲大陆的东北部，涵盖了11个国家，流经乌干达、坦桑尼亚、肯尼亚、卢旺达、布隆迪、刚果（金）、埃及、苏丹、厄立特里亚和埃塞俄比亚。全长达6,650千米（4,130英里），是世界上最长的河流。\n尼罗河以其水源和流量分为两个分支，即白尼罗河和蓝尼罗河，两个分支在苏丹首都喀土穆合并，最终注入地中海。尼罗河是非洲文明的生命线，为埃及早期的人类文明提供了沃土和水源。\n尼罗河流经的区域是非洲最大的农业地区之一，为当地人提供了重要的灌溉和交通资源，河流还提供了丰富的水资源用于人类和动物饮用、农业、渔业和许多其他用途。\n尽管尼罗河在全球排名第一，但还有其他长河，如亚马逊河、长江和黄河。长河是地球上自然景观的杰出例子，它们为人类社会和自然生态系统提供了重要的贡献。", "class": "open qa"}
{"question": "以给定的主题为基础，为一组关键字编写一个短文。\n主题：旅游\n关键字：海滩、度假、美食、文化", "std_answer": "", "class": "generation"}
{"question": "请总结一篇长篇小说的内容，并包括主要角色的名称和情节转折点。", "std_answer": "", "class": "brainstorming"}
{"question": "回答以下问题：人类和猫之间的基因差异是多少？", "std_answer": "人类和猫之间的基因差异是相当大的，因为我们是两种不同的物种。然而，人类和猫的基因组都可以在一定程度上进行比较和对比。\n人类和猫的基因组的主要区别在于它们的大小和组成。猫的基因组要小得多，只有大约20,000个基因，而人类的基因组则包含大约20亿个碱基对，其中约20,000个基因编码蛋白质。\n此外，人类和猫之间的基因编码不同的蛋白质，这意味着我们的身体在功能和结构上有所不同。例如，人类必须合成大量维生素C，而猫可以从其食物中获取足够的维生素C。\n另一个区别是我们的染色体数量不同。人类拥有23对染色体，而猫拥有19对。这些染色体在大小、形状和组成上也有所不同。\n最后，在人类和猫的基因组中，还有大量的共同基因。这些共同基因反映了我们的共同祖先，并可能在某些方面表现出相似的生物学特征，如眼睛和皮毛的颜色。\n总体而言，人类和猫之间的基因差异是相当大的。这些差异反映了生物进化的不同路径和两种物种的不同适应环境。", "class": "open qa"}
{"question": "根据以下新闻提供其摘要。中国计划于2022年发射首款太空站核心舱，这是中国空间计划中的一个重要进展。这个名为“天和”的太空站将包括三个模块：核心舱、实验舱和天文舱。首次发射的核心舱将用于测试和验证太空站的基本功能，以及进行相关科学研究和技术试验。中国国家航天局表示，“天和”太空站的建设将继续进行，预计在2022年至2024年期间完成。该太空站的完工将为中国在太空中展开多个方面的科学研究提供平台，使中国成为继俄罗斯和美国之后拥有独立太空站能力的第三个国家。", "std_answer": "中国将于明年发射首款太空站核心舱。", "class": "summarization"}
{"question": "给出一段文本，为其中每一段落写一个标题。文本1：由于全球变暖，海平面正在上升。新的报告指出，下一个世纪内，海平面可能会上升超过3英尺。到那时，许多城市和国家将受到严重影响。文本2：在过去的十年中，风暴的强度和频率也持续增加。研究表明，这与温室气体的排放有关。随着时间的推移，这种情况还可能会加剧，导致更多破坏和人员伤亡。", "std_answer": "1. 全球变暖导致海平面上升的严峻警告\n2. 温室气体排放与风暴频率、强度上升的相关性", "class": "summarization"}
{"question": "将以下文本翻译为英语：“我最喜欢的季节是春天，因为可以看到美丽的花儿。”", "std_answer": "\"My favorite season is spring because I can see beautiful flowers.\"", "class": "rewrite"}
{"question": "请将下列电影按照发行年份排序：《肖申克的救赎》、《星际穿越》、《阿甘正传》", "std_answer": "根据电影的发行年份，下列电影的排序从早到晚为：\n1. 《阿甘正传》（1994年上映） \n2. 《肖申克的救赎》（1994年上映） \n3. 《星际穿越》（2014年上映） \n《阿甘正传》于1994年上映，讲述了主人公阿甘的故事，他的一生充满着奇迹和动人心魄的经历。 这部电影荣获了6项奥斯卡金像奖，包括最佳影片和最佳导演。 \n《肖申克的救赎》于1994年上映，讲述了银行家安迪的故事，他被错判为杀人犯并被关押在肖申克监狱。电影在上映后并没有获得很高的票房，但在DVD发行后受到了广泛的好评，成为了一部广受欢迎的经典电影。 \n《星际穿越》于2014年上映，由克里斯托弗·诺兰执导，马修·麦康纳和安妮·海瑟薇等明星主演。这部电影是以人类生存危机为背景，在寻找新家园的过程中，讲述了人类冒险家们的经历。这部电影获得了许多好评，特别是在视觉效果和音效方面。", "class": "open qa"}
{"question": "将下列五个词分为两个组别，每个组别都有一个共同点：狗、猫、鸟、鱼、蛇。", "std_answer": "这五个词可以分成两组：两个哺乳动物和三个非哺乳动物。\n共同点：\n- 组别一：狗、猫都是哺乳动物，属于哺乳纲（Mammalia）。\n- 组别二：鸟、鱼、蛇都不是哺乳动物。\n - 鸟属于鸟纲（Aves），其特征包括有羽毛、前肢成翼等。\n - 鱼属于鱼纲（Pisces），其特征包括有鳞、鳍、鱼鳔等。\n - 蛇属于爬行纲（Reptilia）或有鳞目（Squamata），其特征为身体长而细，无四肢。\n需要注意的是，鸟、鱼、蛇三者之间的生物学分类并不相同，它们只是在本题中都不属于哺乳动物这个分类群。", "class": "classification"}
{"question": "针对以下问题提供解决方案：如何最大化你的工作效率？", "std_answer": "", "class": "brainstorming"}
{"question": "列举三个种类不同的动物，并说明它们的特点。", "std_answer": "", "class": "brainstorming"}
{"question": "回答下面这个数学问题。如果有5个苹果和3个梨子，总共有多少个水果？", "std_answer": "5个苹果和3个梨子总共有8个水果。 \n这个问题可以通过简单的数学加法来回答。给定5个苹果和3个梨子，我们只需要将它们的数量相加，即 5 + 3 = 8。这意味着总共有8个水果。\n因此，回答此问题的方法是将苹果和梨子的个数相加，得到总共的水果数。这个问题的答案是8个水果。", "class": "math"}
{"question": "列出5种可以改善睡眠质量的方法。", "std_answer": "", "class": "brainstorming"}
{"question": "为一种智能手表编写用户手册，包括详细的使用说明和操作步骤。", "std_answer": "", "class": "generation"}
{"question": "回答以下问题：谁是美国第一位总统？", "std_answer": "美国第一位总统是乔治·华盛顿（George Washington）。他出生在弗吉尼亚州的一个种植园主家庭，曾在英国皇家海军服役。华盛顿在美国独立战争期间领导了大陆军，最终帮助美国取得胜利。他被认为是美国的开国元勋之一。\n1787年，华盛顿被选为宪法制定会议的主席，这次会议最终制定了美国宪法。1789年，他成为美国第一位总统，并担任了两届总统（1789-1797）。在他的领导下，美国政府开始建立起来，建立了联邦政府、银行和邮政系统。\n华盛顿在外交政策方面也取得了一些重要成果。他签署了《约翰·杰伊条约》（Jay Treaty），解决了美国与英国之间的贸易纠纷，并借此避免了战争。他还签署了《西班牙条约》（Pinckney's Treaty），解决了美国与西班牙之间的边界和贸易争端。他还发表了著名的告别演说，警告美国对政党派系的影响和对国际关系的影响。\n华盛顿的领导为美国建立了一个稳定的政府，并奠定了美国的国际声誉。他是一位崇尚公民美德和独立精神的领袖，在美国历史上留下了深远的影响。", "class": "open qa"}
{"question": "描述人类大脑的工作原理。", "std_answer": "人类大脑是身体最为复杂、功能最为重要的器官之一。它由数百亿个神经元（神经细胞）组成，这些神经元连接在一起，形成了一个高度互联的网络，通过电化学信号相互通信。大脑主要负责控制和协调我们的行为、思考、感知和情感等复杂的认知和情感过程。\n人类大脑的工作原理可以大致分为以下几个方面：\n1. 感觉输入和处理：大脑接收来自五个感官（视觉、听觉、触觉、味觉和嗅觉）的输入，并对这些输入进行处理和解释。这个过程主要发生在大脑皮层（cerebral cortex）等感觉处理区域中。\n2. 认知和决策：大脑对外部世界的感觉输入进行解释和分析，并基于这些信息做出决策。这个过程主要发生在大脑皮层的前额叶（frontal lobe）等认知和决策区域中。\n3. 运动控制：大脑通过控制肌肉和运动神经，控制我们的肢体运动和动作。这个过程主要发生在大脑皮层的运动区域和小脑（cerebellum）等运动控制区域中。\n4. 记忆和学习：大脑可以存储和处理各种类型的记忆，包括短期记忆和长期记忆。这个过程主要发生在大脑皮层的颞叶（temporal lobe）等记忆处理区域中。\n5. 情感处理：大脑可以处理和调节各种情绪和情感反应。这个过程主要发生在扣带回（cingulate cortex）等情感处理区域中。\n以上是大脑主要的工作原理，但是这些过程之间通常是互相交织和相互作用的。而且，大脑的工作原理还存在很多未知和不确定的领域，科学家和研究人员正致力于不断深入和探究人类大脑。", "class": "open qa"}
{"question": "给定一组文本，将文本分成正面和负面情感。\n举例文本:\n这部电影非常出色，值得推荐。我觉得导演做得很好。\n这场音乐会真是个灾难，我非常失望。", "std_answer": "第一句话：“这部电影非常出色，值得推荐。我觉得导演做得很好。”\n这句话中出现了“出色”、“值得推荐”和“做得很好”这些词汇，这些词汇都是正面情感的词语。因此，可以认为该文本是正面情感的，可得出一个整体情感得分。\n第二句话：“这场音乐会真是个灾难，我非常失望。”\n这句话中出现了“灾难”、“失望”等负面情感的词汇，因此可以认为该文本是负面情感的，可得出一个整体情感得分。\n综上所述，我们可以通过基于词典的情感分析方法，将这组文本分成正面和负面情感。其中，第一句话是正面情感，第二句话是负面情感。", "class": "classification"}
{"question": "介绍以下电影的情节和主题：\n《阿甘正传》", "std_answer": "《阿甘正传》是一部1994年上映的经典电影，由导演罗伯特·泽米吉斯执导，汤姆·汉克斯主演。\n影片讲述了一个名叫弗雷德里克·阿甘的男孩从小智力有限，体弱多病，到成为一位成功的商人和社会名人的传奇故事。影片以阿甘回忆过去的方式展开，讲述了他在南方小城的祖居长大，成为橄榄球能手，进入军队参与越南战争，回国后成为许多国际知名事件的见证者，最终历经种种遭遇，在华盛顿极力抗议越南战争，他的真挚情感感动了无数人，最终回到了自己的家乡。\n主题：\n1. 勇气和坚韧: 阿甘身体虚弱，但他克服了身体上的障碍，通过自己的努力和毅力，克服了生活中遇到的重重困难和挫折。\n2. 反战和和平：电影在越南战争时期背景下讲述，呈现了人类暴力和战争的恶果，让观众感受到战争中无辜人民受难的悲惨遭遇。\n3. 爱与友情：阿甘在他的人生旅程中经历了许多关系，包括他们之间的不完美，但最终所有的感情都是建立在真实和充满爱心的基础上的。", "class": "open qa"}
{"question": "回答下面的问题：电影《泰坦尼克号》中的主演是谁？", "std_answer": "电影《泰坦尼克号》中的主演是莱昂纳多·迪卡普里奥（Leonardo DiCaprio）和凯特·温丝莱特（Kate Winslet）。\n莱昂纳多·迪卡普里奥饰演了男主角杰克·道森（Jack Dawson），他是一个贫困的艺术家，乘坐泰坦尼克号前往美国，与凯特·温丝莱特饰演的女主角露丝·德维特·布坎南（Rose DeWitt Bukater）相遇并陷入爱河。露丝是一个年轻富有的女子，因为她的未婚夫卡尔·赛特勒（Caledon Hockley）的父亲在泰坦尼克号上拥有股份，所以她也在这艘船上旅行。\n《泰坦尼克号》是一部由詹姆斯·卡梅隆执导的史诗爱情灾难片，于1997年上映。该电影以船上真实事件为基础，讲述了两个年轻人在泰坦尼克号的航行中相遇、坠入爱河，以及随后发生的船舶撞击冰山而导致的灾难。电影获得了广泛的赞誉和成功，成为了电影史上最高票房的电影之一，并获得了11项奥斯卡奖。", "class": "open qa"}
{"question": "扩写下文：我打算去购物，然后去健身房锻炼身体。", "std_answer": "", "class": "rewrite"}
{"question": "将以下10个单词分类为动物或植物。\n树木、狮子、玫瑰、草地、松鼠、猴子、蘑菇、兔子、山羊、香蕉", "std_answer": "动物：狮子、松鼠、猴子、兔子、山羊 \n植物：树木、玫瑰、草地、蘑菇、香蕉 \n解释： \n1. 树木是植物，它们具有根、茎、枝和叶； \n2. 狮子、松鼠、猴子、兔子和山羊都是动物，具有生命和感知能力； \n3. 玫瑰是植物，是一种有刺的灌木； \n4. 草地是植物的群体，是一片由草类植物组成的区域； \n5. 蘑菇是真菌，通常被归类为植物，但不进行光合作用，并且具有特殊的生长方式； \n6. 香蕉是由植物产生的水果，是一种多汁的开花植物。", "class": "classification"}
{"question": "提出一个新的市场营销策略。", "std_answer": "", "class": "brainstorming"}
{"question": "根据一个提供的主题或关键词，为我创作一首诗歌。\n秋天", "std_answer": "", "class": "generation"}
{"question": "根据给定的问题，给出一个适当且准确的回答\n问题: 水的化学式是什么？", "std_answer": "水的化学式是H2O，这表示每个水分子由两个氢原子和一个氧原子组成。这个化学式可以告诉我们水分子的化学成分及其组成。\n氢原子是最简单的原子之一，只有一个质子和一个电子。氧原子也是非常常见的元素，它有8个质子和8个电子。当两个氢原子与一个氧原子结合时，它们共享电子，形成一个稳定的分子。\n水是非常重要的化学物质，因为它是所有生命形式所必需的。它是一种非常好的溶剂，许多物质可以在水中溶解。水也可以存在于三种形式，固态（冰）、液态和气态（水蒸气），这也使得它在许多地方有着广泛的应用，例如用于植物的生长、饮用、工业生产等等。", "class": "open qa"}
{"question": "为一个英语句子进行翻译，并输出中文翻译。\nI have a dream that one day this nation will rise up and live out the true meaning of its creed: We hold these truths to be self-evident, that all men are created equal.", "std_answer": "中文翻译：我有一个梦想，即有一天我们这个国家会站起来，实现其信条的真正含义：我们坚信这些真理不言而喻，即所有人生来平等。", "class": "rewrite"}
{"question": "回答这个问题。\n什么是伏羲八卦?", "std_answer": "伏羲八卦是中国古代的一种哲学、宗教和占卜系统，最早由中国传说中的神话人物伏羲所创造，被认为是中国古代最早的占卜系统。它由八个符号（称为卦）组成，每个卦由三个线组成。这些线可能是断的（表示阴）或完整的（表示阳），每个卦代表一个特定的意义。\n这八个卦是：\n1. 乾（qián）——天，由三个阳线组成。\n2. 坤（kūn）——地，由三个阴线组成。\n3. 震（zhèn）——雷，由初阳、阴、阳、阳、阳、阳组成。\n4. 艮（gèn）——山，由初阴、阳、阴、阳、阳、阳组成。\n5. 坎（kǎn）——水，由初阳、阳、阳、阴、阳、阳组成。\n6. 离（lí）——火，由初阳、阳、阴、阳、阳、阴组成。\n7. 巽（xùn）——风，由初阳、阴、阳、阳、阴、阳组成。\n8. 兑（duì）——泽，由初阴、阳、阳、阳、阴、阳组成。\n每个卦都代表一些特定的意义和象征，如乾卦代表刚强的意志、坤卦代表母亲般的柔顺、震卦代表迅疾如雷的动力、坎卦代表险阻、离卦代表激烈的火焰、巽卦代表顺应风势、兑卦代表潜藏不露的深处之物。\n伏羲八卦在中国古代哲学、文化、宗教、卜筮、医学等方面都有广泛的运用和影响。在中国文化中，它被认为是宇宙和人类之间的桥梁，可以帮助人们预测未来、探知天命、调节身心健康等。", "class": "open qa"}
{"question": "翻译以下句子：This book is very interesting.", "std_answer": "这本书非常有趣。", "class": "rewrite"}
{"question": "给出下列问题的答案：哪些食物富含维生素C？", "std_answer": "维生素C是人体必需的营养素之一，可以帮助身体进行抗氧化反应、增强免疫力、促进铁吸收等重要功能。以下是一些富含维生素C的食物：\n1. 柑橘类水果：柑橘类水果如橙子、柚子、柠檬等是富含维生素C的食物，一颗橙子中含有约70毫克的维生素C。\n2. 绿色蔬菜：绿色蔬菜如菠菜、甘蓝、羽衣甘蓝、花椰菜等都含有丰富的维生素C，一杯切碎的生菜中含有约30毫克的维生素C。\n3. 水果和蔬菜：其他含有高量维生素C的食物还有草莓、番茄、西兰花、草莓等。\n4. 坚果：坚果中的杏仁、开心果、核桃等种类，同样富含维生素C。\n在日常饮食中摄取这些食物有助于维持身体健康并预防各种疾病。如果某些人在饮食中无法获得足够的维生素C，可以考虑使用维生素C补充剂。", "class": "open qa"}
{"question": "给以下问题提供一个答案。\n为什么人们应该锻炼身体？", "std_answer": "人们应该锻炼身体有很多好处，包括：\n1. 改善身体健康：适度的体育锻炼可以增强心血管系统和呼吸系统的功能，改善血液循环，防止高血压、心脏病、中风和糖尿病等慢性疾病的发生。\n2. 提高身体素质：通过体育锻炼，人们可以提高身体的力量、速度、耐力和协调性，增强身体的稳定性和柔韧性，从而更好地承受各种身体负荷。\n3. 减少体重：适度的体育锻炼可以促进身体代谢，消耗能量，达到减肥的效果，提高身体形态美。\n4. 改善心理健康：体育锻炼可以促进人体内部的荷尔蒙分泌，减轻压力和紧张情绪，提高人的自尊心和自信心，延缓衰老和退化，让人变得更加快乐和积极。\n综上所述，体育锻炼对于人体健康非常重要，人们应该每天坚持锻炼身体，让身体更加健康、坚强和充满活力。", "class": "open qa"}
{"question": "回答以下问题。\n你最喜欢的旅行目的地是哪里？为什么？", "std_answer": "", "class": "brainstorming"}
{"question": "解释概念：大数据", "std_answer": "大数据是指越来越多的数据的组合，这些数据来自多种来源，包括但不限于传统的结构化数据（例如关系数据库、金融指标和经济统计数据）、非结构化数据（例如音频、视频、图片和文本）以及来自传感器和物联网设备的实时数据等。大数据通常需要高性能计算和存储系统来处理。\n随着技术的不断进步，现代社会相应的产生了越来越多的数字数据，数据的进一步计算和分析变得越来越重要。大数据技术旨在从大量数据中提取有用的信息，并以优化决策和解决问题的方式应用这些信息。\n运用大数据技术，可以驱动商业和科学的应用程序（例如在市场和制造中进行业务决策以及在生物医学和环境研究中进行数据挖掘）。大数据技术在人工智能、机器学习和深度学习等领域也有广泛的应用，为人类的科学和日常生活带来了极大的便利和改变。", "class": "open qa"}
{"question": "回答以下问题，确保答案准确无误。\n什么是免疫力？", "std_answer": "免疫力是指人体对于感染病原体或其他异物的自我保护能力。免疫力由免疫系统控制，它是一组高度复杂且相互协作的细胞、分子和器官的集合，旨在识别和消灭入侵的病原体。\n人体的免疫系统分为两个部分——细胞免疫和体液免疫——它们之间协调配合，确保人体抵抗病原体的攻击。\n细胞免疫通过使用特定的细胞，例如B细胞、T细胞和自然杀伤细胞等，对病原体进行直接攻击和消灭。细胞免疫可以识别和杀死针对自身的病原体，如癌细胞。\n体液免疫则通过使用特定的蛋白质，例如抗体和补体，来阻止病原体的侵入和生长。体液免疫可以对付那些进入细胞内部且难以被细胞免疫识别的病原体，例如病毒。\n免疫力的强度可以受到很多因素的影响，例如年龄、生活方式、饮食习惯、健康状况和外部环境。有些食物和营养素如维生素C和锌能够增强免疫系统的功能，而其他因素如吸烟、过度饮酒、压力和睡眠不足则可能降低免疫力。\n免疫力在预防和治疗疾病方面至关重要。合理的生活习惯和健康的饮食加上充足的休息和运动，都有助于增强免疫力。", "class": "open qa"}
{"question": "以以下文本为基础，编写一封邀请信。\n你好！我们很高兴地邀请你参加我们的婚礼，时间是2022年6月30日，地点是北京。", "std_answer": "", "class": "generation"}
{"question": "将以下文本翻译成英语语：我想去旅行并尽可能多地了解世界上的文化。", "std_answer": "I want to travel and learn as much as possible about the cultures of the world.", "class": "rewrite"}
{"question": "对以下主题提出3个开放式问题。主题：健康的生活方式。", "std_answer": "", "class": "brainstorming"}
{"question": "生成一段描述一个美丽自然风景的文章。", "std_answer": "", "class": "generation"}
{"question": "回答下面的问题。\n为什么植物需要光合作用？", "std_answer": "植物之所以需要进行光合作用，是因为它是维持植物生长和生存的主要途径之一。以下是光合作用的几个重要方面：\n1. 能量来源：光合作用是一种生化过程，利用光能将无机物转化为有机物，从而为植物提供能量，以支持各种代谢活动。光合作用中产生的能量还可以被储存下来，以供日后使用。\n2. 氧气改变：在光合作用中，植物通过光合作用产生氧气，这种氧气释放到空气中，是动物呼吸所需要的氧气来源之一。同时，光合作用也是植物中二氧化碳去除的主要途径，从而维护了空气中的气体组成。\n3. 有机物质来源：光合作用不仅产生能量，还可以产生有机物质，其中包括植物细胞所需要的葡萄糖等糖类化合物。这些有机化合物可以被植物用来构建新的细胞，并用来支持其他代谢反应。\n4. 植物生长：光合作用直接影响到植物生长的速度和质量。光合作用通过产生所需的能量和有机物质来促进细胞分裂和植物生长。缺乏足够的光合作用，将会导致植物叶片干枯并且凋谢。\n综上所述，植物需要光合作用以产生能量、氧气、有机物质，也需要光合作用来支持植物细胞的发育和生长，所以光合作用对于植物的生存至关重要。", "class": "open qa"}
{"question": "从以下选项中选择正确的词汇填空以完整下面的句子。 他喜欢去_______看电影。A) 邮局 B）超市 C）电影院 D）音乐会", "std_answer": "正确的词汇是C）电影院。\n句子意思是“他喜欢去电影院看电影”。\n选项A）是邮局，B）是超市，D）是音乐会，与句子的内容不符，因此不是正确答案。", "class": "closed qa"}
{"question": "针对一个产品的特点，为其撰写市场推广文案。", "std_answer": "", "class": "generation"}
{"question": "请列举5个适合在户外进行的锻炼运动。", "std_answer": "", "class": "brainstorming"}
{"question": "给出以下历史事件的日期。\n二战结束的日期是？", "std_answer": "二战的结束日期是1945年9月2日。\n在战争的最后阶段，德国在1945年5月7日签署了无条件投降书，这标志着欧洲战争的结束。但是，战争在太平洋地区仍然持续了几个月，直到日本发生两次原子弹袭击后才真正结束。\n1945年8月6日，美国投放了第一颗原子弹在广岛，这导致了数万人的死亡和重创了这个城市。8月9日，第二颗原子弹被投放在长崎。这两次原子弹袭击迫使日本政府开始考虑投降。\n在苏联加入战争并对日本发动侵略后，日本政府于1945年8月15日宣布接受《波茨坦公告》并同意无条件投降。但是，正式的投降仪式只是在几周后的1945年9月2日在美国船只上举行的，这被认为是二战的正式结束。这场战争是人类历史上最具规模和毁灭性的战争之一，共造成超过7000万人的伤亡和失踪。", "class": "open qa"}
{"question": "将下面的语句翻译成英语。\n巴黎圣母院（法语：Notre-Dame de Paris）是法国一座哥特式教堂，位于巴黎市中心塞纳河畔的圣母岛（île de la Cité）。它是巴黎市最著名的地标建筑之一，也是世界上最著名的哥特式建筑之一，是法国最具代表性的建筑之一。该建筑始建于1163年，历时200余年，是中世纪后期法国哥特式建筑的杰作之一。", "std_answer": "Notre-Dame de Paris is a Gothic church in France, located on Notre-Dame Island (île de la Cité) on the banks of the Seine in central Paris. It is one of the most famous landmarks of the city of Paris, one of the most famous Gothic buildings in the world, and one of the most representative buildings in France. The building was built in 1163 and lasted for more than 200 years. It is one of the masterpieces of French Gothic architecture in the late Middle Ages.", "class": "rewrite"}
{"question": "解释微生物学是关于什么的学科。", "std_answer": "微生物学是一门研究微生物的生物学学科，也被称为微生物生态学或微生物物种学。生命的基本单元是细胞，微生物学探究细胞级别最小的有生命的实体-微生物，这些生命体有时候也被称为微生物或微生物体。微生物可以是单细胞或多细胞，可以是真核细胞，也可以是原核细胞。微生物包括：细菌、真菌、病毒、原生生物和古菌等。微生物对我们的日常生活很重要，他们在环境保护、人类健康、食品和药物生产中发挥重要的作用。\n微生物学家解决从微观层面一直到宏观的整个系统层面微生态学问题。从区分微生物体的组成、结构和功能，到它们的遗传学，代谢学和生态学行为，以及它们在自然，工业和农业中的作用，每个方面都是微生物学家的研究重点。\n一些微生物学的具体研究方向包括：\n1. 微生物的分离和鉴定：研究各种不同的微生物种类，这是研究微生物生态系统的重要第一步。\n2. 微生物的代谢和生理：了解微生物的基本代谢途径和生理机制，以便了解它们对环境和环境中其他生物产生影响的方式。\n3. 微生物的遗传学：微生物是很容易繁殖和变异的，这意味着特定的微生物群体可以很快就在特定的环境适应。\n4. 微生物与宿主互动：细菌、病毒和其他微生物会与人类、动物和植物进行交互，了解这些相互作用是微生物学家的一个重要研究领域。\n总之，微生物学是研究微观生物，如细菌、真菌、病毒和古菌等的学科，涵盖各种研究领域，例如微生物的分离、鉴定、代谢和生理、遗传学和微生物与宿主互动等。微生物学对于人类健康、环境保护和工业生产等方面都具有重要的意义。", "class": "open qa"}
{"question": "给出五个原创的古诗或现代诗句子。", "std_answer": "", "class": "brainstorming"}
{"question": "根据所给的一组描述，生成一个复杂的、高质量的文本小说片段。\n小美独自一人探险，她感觉到了一种奇怪的气息，如释重负般的感觉从她身上落下。", "std_answer": "", "class": "generation"}
{"question": "回答下列问题。\n红绿灯的颜色分别代表什么？", "std_answer": "红绿灯是指路口交通信号灯，由红、黄、绿三种颜色循环交替发出，用于指示交通流向的变化和行车顺序。其中，不同颜色的灯光分别代表以下含义：\n1. 红灯：\n红灯代表“停车”，也是最为重要的一色交通信号灯，汽车、行人必须在红灯下停车等待，等待灯光变成其他颜色才可启动。此时若发生非常急迫的情况，可以在确保安全的情况下，经过判断后慢速通过交叉路口。\n2. 黄灯：\n黄灯代表“警示”，在绿灯和红灯之间变换的过渡信号灯。在交通信号灯由绿灯变为黄灯时，表示即将转红，此时车辆应减速而不是加速行驶，避免造成交通阻塞、车祸等问题。在红灯即将变为绿灯前的黄灯时，表示即将开启绿灯，行人可以慢步通过马路，而车辆则应尽快通过路口。\n3. 绿灯：\n绿灯代表“通行”，表示车辆与行人都可以通过道路。但行驶车辆需要注意的是，在交叉路口通过时，需要根据交通流量情况、满足让行规则，保持安全驾驶。此外，行人也需要根据交通规则信号灯指示，在绿灯亮起时在斑马线上安全通过道路。\n总而言之，红绿灯系统是为了维护道路交通秩序，保障道路交通安全，让车辆与行人保持协调互通的系统。而正确理解和遵守红绿灯信号灯，是每个人行驶或步行在道路上必须掌握的基本交通常识。", "class": "open qa"}
{"question": "思考一个关于社交媒体的主题并列举10个相关问题，用于市场营销的研究。", "std_answer": "", "class": "brainstorming"}
{"question": "描述一下如何制作一道有名的本地菜肴，并将步骤列出来。\n本地菜肴：麻婆豆腐", "std_answer": "", "class": "brainstorming"}
{"question": "根据以下资料，为公司编写一个招聘广告：公司名称：ABC科技，职位：软件工程师，要求：熟练掌握Java，有2年以上工作经验。", "std_answer": "", "class": "generation"}
{"question": "回答以下问题：为什么时间管理如此重要？", "std_answer": "时间管理非常重要，因为它有助于一个人更有效地利用时间，提高生产力并减少压力和焦虑。\n以下是时间管理的几个关键好处：\n1. 提高生产力\n时间管理可以帮助你优化你的工作流程并更好地组织您的日常任务。通过管理时间，您可以最大化生产力，并更好地完成任务，而不是在同一时间片段中拖延或懒散。当您更好地利用您的时间，您可以更快地完成任务，并无需加班或在短时间内处理大量工作量。这种更高效的方法可以提高生产力并获得更好的工作成果。\n2. 减轻压力\n不管理时间可能会导致紧急感，焦虑和压力的增加。在忙碌的工作日常生活中，您可能需要完成大量的任务，而无法同时完成这些任务可能会让您焦虑和不安。通过将任务管理成不同的时间段并制定优先级，时间管理可以减轻您的压力，并使您感到更轻松和有序。\n3. 提高自律性和自我管理能力\n时间管理可以帮助您在日常生活中发展自律性和自我管理的良好习惯。通过设定计划和目标，您可以更好地控制您的时间并注意自己的日常活动。这些习惯可以帮助您更好地掌握自己的生活，并更有效地处理事务。\n4. 获得更多时间进行自我发展和探索\n时间管理可以帮助您获得更多时间进行自我发展和探索。通过合理地安排优先级和战略性地安排您的时间来完成任务，您可以获得更多时间来学习新技能，进行个人项目，探索自己的兴趣爱好。这将有助于提高您的生活满足度和感受到更大的幸福感。\n总之，时间管理是生活和事业成功的关键。无论您是学生，工作人员还是企业家，都需要管理好时间，以便最大限度地发挥自己的潜力并实现成功。", "class": "open qa"}
{"question": "请根据以下给定的基本信息标准对产品进行分类。\n以下是一些鞋子的基本信息：\n- 品牌：Nike, Adidas, Puma, Converse\n- 颜色：黑色、白色、红色、蓝色、绿色、黄色\n- 尺码：34、35、36、37、38、39、40、41、42、43、44、45\n- 款式：休闲鞋、运动鞋、篮球鞋、跑步鞋\n请为以下三种鞋子分类：\n- Nike Air Max，黑色，43码，运动鞋\n- Adidas Superstar，白色，38码，休闲鞋\n- Puma Clyde Court，红色，41码，篮球鞋", "std_answer": "根据给出的标准，可以将这三种鞋子进行分类：\n1. Nike Air Max，黑色，43码，运动鞋\n- 品牌：Nike\n- 颜色：黑色\n- 尺码：43\n- 款式：运动鞋\n2. Adidas Superstar，白色，38码，休闲鞋\n- 品牌：Adidas\n- 颜色：白色\n- 尺码：38\n- 款式：休闲鞋\n3. Puma Clyde Court，红色，41码，篮球鞋\n- 品牌：Puma\n- 颜色：红色\n- 尺码：41\n- 款式：篮球鞋\n根据这些信息，将鞋子进行分类可以帮助消费者更容易地找到自己所需要的产品。例如，一个想要买篮球鞋的人可以直接在篮球鞋分类下找到Puma Clyde Court。一个想要买黑色运动鞋的人可以直接在运动鞋分类下找到Nike Air Max等。", "class": "classification"}
{"question": "根据给出的场景， 回答以下问题：\n场景：你的朋友骑自行车行驶在道路上。\n你的朋友在路上遭遇车祸，你应该采取哪些紧急措施？", "std_answer": "发生车祸时，你应该采取以下紧急措施来帮助你的朋友：\n1. 确保安全。如果你也在场，立即停下车辆，并确保自己和周围的其他人不会受到进一步的危险。在必要时，向其他车辆发出警告，喊叫或使用灯光等措施。\n2. 判断情况。检查你的朋友是否受伤，并找出是否需要其他人的帮助。如果有其他人附近，可以请求他们的帮助。\n3. 致电急救服务。如果你的朋友需要急救服务，拨打当地的紧急电话号码，并说明情况。准备好提供你的位置、你朋友的情况和其他必要的细节。\n4. 给予应急医疗援助。如果你有一些医疗知识或有急救包在手，尽量采取紧急措施帮助你的朋友。把伤员放在舒适安全的位置，按需要施行心肺复苏或止血等方法。\n5. 呼叫警察。如果车祸涉及到较大的损失或其他问题，必须立即联系当地警察局。聚集重要证人和信息，确保所有警察和救援队都知道发生了什么事情。\n总的来说，在发生车祸时，你应该尽可能的评估你的朋友的安全情况，采取紧急措施救助伤员，尽快拨打当地急救电话并与当地警察局联系，如果是需要的话，获取证人信息。 首先要保证自己的安全，因为现场环境可能是不安全的。然后按照上述步骤尽快帮助受伤的人，取得更多的常识，以帮助自己以及在这样的突发事件中能给予他人帮助。", "class": "open qa"}
{"question": "对以下两篇文章进行比较，确定它们是否讨论了相同的话题。输入两篇文章的文本内容，输出是“是”或“否”。\n文章1：Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。Python由Guido van Rossum创建，第一个公开发行版发行于1991年。目前，Python是一种流行的编程语言，被广泛应用于Web开发、科学计算、人工智能等领域。\n文章2：Java是一种高级程序设计语言和计算机平台。它的设计最初是由James Gosling在Sun Microsystems进行的。自从2009年Oracle收购了Sun以来，Java就成为Oracle的产品。Java可以在不同的计算机平台上编写一次程序，然后在这些平台上运行多次。", "std_answer": "是，这两篇文章讨论了不同的编程语言，Python和Java，它们描述了这些编程语言的特性和应用领域。虽然它们提到了不同的细节，但两篇文章都涉及高级程序设计语言，它们的应用和技术特点的描述。", "class": "closed qa"}
{"question": "回答问题：'哪种编程语言最常用？'", "std_answer": "", "class": "brainstorming"}
{"question": "给出一个主题，编写一个段落描述该主题。\n中国传统节日——中秋节", "std_answer": "", "class": "generation"}
{"question": "请组织一个有关工作流程的头脑风暴，并记录所有的步骤。", "std_answer": "", "class": "brainstorming"}
{"question": "为以下句子选择一个正确的分类：\n“汉堡王”是什么餐厅类型？\n快餐、家庭式、正式餐厅、自助餐厅等。", "std_answer": "“汉堡王”是一家快餐餐厅。\n在餐饮业中，餐厅类型是根据其服务模式、菜单种类、用餐氛围和价格等因素来区分的。快餐餐厅是以快捷、便宜、方便取餐为主要特点的餐厅类型。汉堡王的菜单以汉堡为主打食品，此外还提供薯条、炸鸡等小吃，服务方式是自助点餐、取餐和就餐。汉堡王的定位是以年轻消费者为主，提供价格实惠的快餐食品。\n与快餐餐厅相对应的其他餐厅类型包括：\n- 家庭式餐厅：通常拥有宽敞的用餐空间和较为全面的菜单。服务方式是由服务员点餐、上菜和送餐。\n- 正式餐厅：是提供高档餐饮服务的餐厅类型，通常菜单较为丰富、价格较贵。服务方式是由专业服务员负责接待、点餐、上餐帮助顾客。\n- 自助餐厅：主要特点是提供各种菜品自选和长时间的用餐，价格相对较为实惠。常常提供冷热饮料和甜点等。\n总之，根据其特征和服务模式，汉堡王应归类为快餐餐厅。", "class": "closed qa"}
{"question": "经纪人：您好，欢迎来到我们的房地产中介公司。我是经纪人李先生，有什么可以帮到您的？\n客户：您好，我正在寻找一套适合家庭居住的房子。我想了解一下您们的房源情况。\n经纪人：当然，我们有许多不同类型和价位的房源。请问您对房子的具体要求是什么？\n客户：我们需要三个卧室，最好有两个浴室。还要有停车位和一个小花园。\n经纪人：好的，我明白了。我们有一些符合您要求的房源。比如说，有一套在市中心的独栋别墅，有三个卧室、两个浴室，还有一个大花园和停车位。价格是350万人民币。\n客户：听起来不错。不过这个价位有点高，您还有别的选择吗？\n经纪人：当然。我们还有一些价格更为实惠的房源，比如说在郊区的联排别墅，也有三个卧室和两个浴室，还有一个小花园和停车位。价格是200万人民币。\n客户：那这个房子的交通和周边环境怎么样？\n经纪人：交通方便，附近有公交车站和地铁站。周边环境也很好，有超市、学校、医院等配套设施。\n客户：好的，我需要考虑一下。您能给我留下房源的资料和联系方式吗？\n经纪人：当然，这是房源的资料和我的名片。您可以拿去参考和联系我。如果您有任何其他问题，请随时联系我。\n基于以上对话回答：客户最终是否选择了其中一个房源？如果没有，经纪人是否向客户提供了更多的选择，或者继续与客户沟通以满足客户的需求？", "std_answer": "客户并没有在对话中最终选择其中一个房源，而是表示需要考虑一下。经纪人向客户提供了两个房源选择，并留下了房源资料和联系方式。经纪人表示如果客户有任何其他问题，可以随时联系他，所以经纪人愿意继续与客户沟通以满足客户的需求。", "class": "closed qa"}
{"question": "参与者1：大家好，欢迎来到今天的会议，我们的主题是讨论定价。\n参与者2：非常感谢主持人邀请我参加这个会议，我认为定价是一个非常重要的话题。\n参与者3：我同意，定价可以直接影响到产品的销售和利润。所以我们需要仔细讨论。\n参与者1：好的，那么我们先从了解我们的产品和市场需求开始。我们的产品主要是高端家电，市场需求也比较强。\n参与者2：那么我们应该考虑设置一个高价，以提高产品的质量感和品牌形象。\n参与者3：但是如果价格太高，会不会导致销量下降呢？我们需要考虑消费者的购买能力和竞争对手的价格。\n参与者1：确实如此，我们需要进行市场调查和分析，了解我们的目标客户和竞争对手的价格情况。\n参与者2：如果我们要设置一个较高的价格，我们需要在产品的质量、设计和功能上下功夫，以确保我们的产品与竞争对手有区别。\n参与者3：我们还需要考虑到季节性变化和促销活动对定价的影响，以便制定不同的定价策略。\n参与者1：好的，那么我们现在来总结一下。我们需要进行市场调查和分析，了解目标客户和竞争对手的价格情况，同时注重产品质量、设计和功能，以确保我们的产品与竞争对手有区别，制定不同的定价策略以适应季节性变化和促销活动。\n请问：会议TODO是什么", "std_answer": "会议TODO包括进行市场调查和分析，了解目标客户和竞争对手的价格情况，注重产品质量、设计和功能，制定不同的定价策略以适应季节性变化和促销活动。", "class": "closed qa"}
{"question": "姓名,年龄,性别,职业,教育程度,婚姻状况,所在城市\n张三,25,男,软件工程师,本科,未婚,北京\n李四,36,女,医生,博士,已婚,上海\n王五,42,男,律师,硕士,已婚,广州\n赵六,28,女,市场营销经理,本科,未婚,深圳\n刘七,31,男,金融投资顾问,硕士,已婚,杭州\n孙八,29,女,设计师,本科,已婚,成都\n钱九,27,男,职业选手,高中,未婚,武汉\n这7个人中，哪个人的职业与其教育程度最为匹配？", "std_answer": "从这7个人的职业和教育程度来看，李四的职业和教育程度最为匹配。李四是一名医生，拥有博士学位。在医学领域，博士学位的专业知识和技能对于医生这个职业是非常重要的。", "class": "closed qa"}
{"question": "客服：您好，欢迎拨打中国移动客户服务热线，我是10086客服，您有什么问题需要咨询？\n用户：您好，我想查询一下我的手机话费和流量使用情况。\n客服：好的，麻烦您告诉我一下您的手机号码。\n用户：我的手机号码是13812345678。\n客服：好的，让我查一下。您的话费余额是200元，已使用流量为2GB，剩余流量为8GB。\n用户：好的，那请问我的套餐是什么，包含多少话费和流量呢？\n客服：您的套餐是XX套餐，每月包含100元话费和10GB流量，超出部分将按照标准资费收取。如果您需要升级套餐或者办理其他业务，可以登录中国移动APP或者前往营业厅办理。\n用户：好的，我知道了。还有一个问题，我想取消一项业务，怎么办？\n客服：您可以登录中国移动APP或者前往营业厅取消相关业务，或者拨打10086客服热线咨询取消业务的具体流程。\n请问：用户想要查询的是什么？", "std_answer": "用户想要查询自己的手机话费和流量使用情况。", "class": "closed qa"}
{"question": "水果种类,1月销售量,2月销售量,3月销售量,1季度销售额\n苹果,200,180,300,$20,000\n香蕉,300,350,400,$23,000\n橙子,150,200,180,$12,000\n葡萄,120,90,100,$8,000\n草莓,80,100,120,$6,000\n樱桃,50,70,80,$4,500\n菠萝,60,80,100,$6,500\n柠檬,90,110,120,$7,500\n哪种水果在第一季度内销售最好？", "std_answer": "在第一季度内销售最好的水果是香蕉，因为它在第一季度的销售额为$23,000，超过了其他水果的销售额。", "class": "closed qa"}
{"question": "律师：你好，请问你是来咨询关于什么方面的法律问题？\n客户：嗯，我最近遇到了一个合同纠纷的问题，我想请问一下您的意见。\n律师：好的，请您简要地介绍一下这个合同纠纷的情况。\n客户：我是和一家公司签订了一份合同，他们承诺要在一个月内为我提供一定数量的产品，但是一个月过去了，他们却没有按照约定履行。\n律师：那么你们的合同中有没有明确的交付时间和方式？\n客户：有的，合同中明确规定了一个月内必须交付，交付方式是快递邮寄。\n律师：那么你是否在规定时间内向对方提出过交付的要求呢？\n客户：是的，我在最后一天向他们发了邮件提出交付的要求，但是他们并没有给我回复。\n律师：好的，根据你提供的情况，你可以向对方发一份正式的律师函，要求他们按照合同履行义务，并在一定期限内提供产品。\n客户：好的，那我需要准备哪些材料呢？\n律师：你需要提供合同、交付要求的邮件以及其他相关证据，如有必要，我们可以协助你进行进一步的取证工作。\n客户：好的，非常感谢您的帮助。\n基于以上对话回答：客户需要向对方提供哪些材料以支持他发出正式的律师函要求对方履行合同义务？", "std_answer": "客户需要提供以下材料以支持他发出正式的律师函要求对方履行合同义务：\n1.合同：合同是证明双方约定的主要依据，客户需要提供与对方签订的合同原件或复印件。\n2.交付要求的邮件：客户在规定时间内向对方提出交付要求的邮件证据，这可以证明客户按照合同约定的时间提出了交付请求。\n3.其他相关证据：如果有其他与本案相关的证据，如通话记录、短信记录、邮件往来等，客户也需要提供这些证据以支持他的主张。", "class": "closed qa"}
{"question": "根据提供的关键词列表，生成一篇描述这些关键词的段落。\n秋天、枫叶、北方、清寒", "std_answer": "", "class": "generation"}
{"question": "解释人类脑部如何处理语言信息。", "std_answer": "人类的语言能力是人类大脑的一个最为突出的特点之一。对于语言信息的处理主要涉及到两个主要领域，即：语言理解和语言产出。这两个领域不只涉及到不同区域的脑部功能，还涉及到不同的认知和神经现象。\n## 1. 语言理解\n人类的语言理解机制中涉及到很多不同的脑部区域，包括颞叶、顶叶、枕叶、前额叶和中央回。下面将简要介绍这些区域的功能以及在语言理解中的作用。\n### 1.1 颞叶（Temporal Lobe）\n颞叶位于大脑的侧面，主要负责处理听觉信息和语言信息。在语言理解中，颞叶的左侧区域对语言处理扮演着关键的角色。特别是，下面两个子区域在语言理解中的作用最为重要。\n- Wernicke's Area：位于颞叶的后部，是语言理解的主要中心。负责处理语言中的语义信息，并且在理解单词和句子时能够起到非常关键的作用。例如，当我们听到一个熟悉的单词时，Wernicke's Area中的神经元会被触发，从而让我们能够明白它的含义。\n- Angular Gyrus：位于颞叶的后上部，其功能包括理解语音、阅读和做数学运算等。在语言理解中，Angular Gyrus与Wernicke's Area之间有非常紧密的联系。在处理语言信息时，Angular Gyrus会帮助我们将听觉信息转换为书面语言，并且对于阅读和写作也起到非常重要的作用。\n### 1.2 顶叶（Parietal Lobe）\n顶叶位于大脑的顶部，主要负责了解语言信息和空间信息。在语言理解中，顶叶通过帮助我们处理语法信息和上下文信息来帮助我们解释语言。有关顶叶的两个重要区域是：\n- Supramarginal Gyrus：位于顶叶的后下方，主要负责语法处理。在我们处理语言信息时，这个区域会分析语言的结构，提取主语、谓语和宾语等语法信息。\n- Inferior Parietal Lobule：位于顶叶的后部，主要帮助我们理解宾语和动词之间的关系。这个区域与意念、记忆和视觉处理相关。\n### 1.3 前额叶（Frontal Lobe）\n前额叶位于大脑前部，主要涉及思考、决策和计划等高级认知功能。在语言理解中，前额叶协调不同区域之间的功能，从而帮助我们理解和表达语言。在脑部损伤的情况下，前额叶的受损可能导致言语障碍。在前额叶的两个子区域是：\n- Broca's Area：位于额叶的下部，是语言产出的中心。这个区域负责语音、音节、单词的编码和控制发音，帮助我们流利地说话。在脑损伤的情况下，这个区域的受损可能导致失语症，使人无法流利地说话。\n- Anterior Cingulate Cortex：位于前额叶中央区域，主要涉及情感和注意力。在语言理解中，这个区域可以帮助我们分析语言信息，注意到情感和语气。\n### 1.4 中央回（Central Sulcus）\n中央回位于大脑顶部，主要分隔顶叶和额叶。这个区域在语言理解中起到重要的作用，主要是监控不同区域之间的信息传递。这样，不同区域之间才能够协作，有效地处理语言信息。\n## 2. 语言产出\n语言产出涉及到人类大脑的不同子区域，包括Broca's Area、前额叶、颞叶和大脑皮层的其他区域。下面将简要介绍这些区域各自的作用。\n### 2.1 Broca's Area\n在语言产出中，Broca's Area是语音和语法信息的中心。这个区域负责编码语言信息，并且控制口齿清晰地讲话，帮助我们流利地说话。在动脉闭塞和外伤等原因导致这个区域损伤的情况下，人可能会出现失语和语言不流畅的问题。\n### 2.2 前额叶\n前额叶在语言产出中扮演着非常重要的角色，主要涉及思考、决策和计划等高级认知功能。这个区域对于选择单词、控制发音并且组织句子有决定性的影响。\n### 2.3 颞叶\n在语言产出中，左颞叶协助人们选择语言，并且将意思组织成单词、短语和句子形式。\n### 2.4 大脑皮层的其他部分\n在语言产出中，大脑皮层的其他区域也会发挥重要的作用。这些区域将各种感官信息整合到一起，帮助我们对语言产生更细致、深入的理解。同时，这些区域在大量练习后也能够帮助我们发展流利的说话技巧。", "class": "open qa"}
{"question": "回答下面这个问题。\n谁是哈利波特的好朋友？", "std_answer": "哈利波特有两个好朋友，他们分别是罗恩·韦斯莱和赫敏·格兰杰。\n罗恩·韦斯莱是哈利波特的最好的朋友之一。他是一个红头发、蓝眼睛的男孩，出生在一个魔法家庭，他们在韦斯莱家族魔法仓库里经营家族事业。罗恩的性格开朗，善良，有时也有些粗心大意。他非常崇拜哈利，并帮助哈利渡过了很多难关。两人之间的友情在整个系列里始终稳定并持久。\n赫敏·格兰杰是另一个与哈利波特很亲密的人。她是一个非常聪明的女孩，被描述为有着灰色的眼睛和卷曲的棕色头发，她的父母都是魔法非纯血统，但她自己在霍格沃茨里也表现出色。她对知识的渴望和对道德的坚持使得她在整个系列中扮演着非常重要的角色。她帮助哈利波特解决了很多难题，并成为了哈利波特的至好友之一。\n总而言之，哈利波特的好朋友罗恩和赫敏，在整个系列中发挥了至关重要的作用，成为了哈利的备友和支持者。", "class": "open qa"}
{"question": "请给我一些关于环保的建议。", "std_answer": "", "class": "brainstorming"}
{"question": "解释一下什么是反向传播算法（Backpropagation Algorithm）。", "std_answer": "反向传播算法（Backpropagation Algorithm）是一种用于训练人工神经网络的算法。该算法通过计算损失函数相对于每个参数的梯度，从而实现反向传播误差的目的，使得网络的权重能够逐步优化以最小化损失函数。\n反向传播算法一般用于训练多层前馈神经网络，由于网络中神经元的数量极其庞大，因此，计算网络的梯度需要进行大量的运算。为了加速这一过程，研究人员使用了自动微分（Automatic Differentiation）技术，通过链式法则将网络的每个层次的梯度计算出来，并将这些梯度附加到相应的层次上进行更新。\n具体来说，反向传播算法可以分为两个阶段：前向传播和反向传播。在前向传播阶段，网络通过输入数据进行前向运算，计算出网络的输出，并将输出结果与真实结果进行比较得到损失函数值。在反向传播阶段，误差会根据权重被“反向传播”回网络中，根据权重的梯度进行更新从而优化网络，并在下一轮前向传播中使用优化后的权重来计算输出结果。\n基于反向传播算法，我们可以实现许多深度学习任务，例如图像识别、自然语言处理等。然而，反向传播算法存在许多问题，例如梯度消失、梯度爆炸等问题，为了解决这些问题，研究人员提出了许多改进算法，例如对抗训练（Adversarial Training）、梯度裁剪（Gradient Clipping）等。", "class": "open qa"}
{"question": "根据提供的文章摘要写一篇200字的文章。\n文章摘要：一项新的科学研究表明，睡眠不足会导致肥胖和糖尿病等健康问题。", "std_answer": "", "class": "generation"}
{"question": "创造一个新的品牌名称，并说明它的价值主张。", "std_answer": "", "class": "brainstorming"}
{"question": "通过哪些方法可以减少塑料污染？", "std_answer": "", "class": "brainstorming"}
{"question": "请你描述一下自己的家乡，并提到家乡最出名的景点或特产。", "std_answer": "", "class": "brainstorming"}
{"question": "对给出的文本进行分类：是新闻报道、论文摘要还是小说章节：\n昨天，巨人小队在比赛中取得了胜利。这是巨人小队在本赛季主场的第三场比赛，也是他们取得的第三连胜。巨人小队在比赛中表现出色，运动员们充满斗志地奋战，最终赢得了比赛的胜利。他们的球迷也为他们加油助威，现场气氛非常热烈。这场胜利对于巨人小队来说非常重要，它将激励他们在接下来的比赛中继续保持良好的状态，争取更多的胜利。", "std_answer": "根据这段文本的内容，可以将其分类为新闻报道。\n1. 文本包含了一项具体的运动比赛结果，指明了巨人小队在昨天的比赛中获胜。\n2. 文本还给出了比赛是在本赛季主场的第三场比赛中取得的胜利，同时也表明了此前已经连胜两场。\n3. 这些信息表明了一项运动比赛的实际结果，具有新闻报道的特点。\n因此，根据文本所包含的信息，我认为这段文本是一则新闻报道。", "class": "classification"}
{"question": "描述一下如何制作草莓巧克力口味的蛋糕。", "std_answer": "", "class": "brainstorming"}
{"question": "请回答以下三个问题：\n1. 苹果的主要产地是哪里？2. 葡萄酒中有何种成分？3. 印度的首都是哪里？", "std_answer": "1. 苹果的主要产地是哪里？\n苹果是一种常见的水果，全球许多国家都有种植。但是，以下几个国家是全球苹果产量最大的国家：中国、美国、波兰、土耳其、意大利、印度、法国和智利等。\n中国是全球最大的苹果生产国，其南部地区的山东省是中国的主要苹果种植区。美国的苹果主要集中在华盛顿州，是该国最大的苹果生产地。波兰也是全球苹果生产的主要国家之一，擅长种植品种包括金冠、格雷斯顿等。\n2. 葡萄酒中有何种成分？\n葡萄酒是由葡萄果汁发酵而成的酒精饮料。除了水和乙醇，葡萄酒还包含了其它一些化学成分，其中一些对其风味和口感有很大的影响。以下是其中的一些主要成分：\n(1) 糖分：葡萄酒中的糖分主要来自于葡萄中的葡萄糖和果糖。这些糖分在发酵过程中被酵母菌转化成乙醇和二氧化碳。\n(2) 酸度：葡萄酒中的酸度主要来自于葡萄中的柠檬酸和苹果酸。这些有机酸对酒的口感和风味有很大的影响，可以使葡萄酒味道更加清新和酸爽。\n(3) 其它有机物：葡萄酒中还包含了一些其它的有机物，如酯类、酚类、甲醛和醛类等，这些物质对酒的香气和风味有很大的影响。\n(4) 酒石酸和果胶：这些物质主要存在于葡萄中，在葡萄酒的制作过程中也会留下一些。酒石酸可以使葡萄酒看起来更清澈，而果胶则可以增加葡萄酒的稠度。\n3. 印度的首都是哪里？\n印度的首都是新德里（New Delhi）。新德里是印度的政治中心和文化中心，也是印度人口最多的城市之一。它位于印度北部的德里特区，可以追溯到公元前8世纪的印度古代城市。\n印度的总统和总理都驻扎在新德里，此外，印度国会和最高法院也设在此地。新德里也是印度文化和旅游业的重要中心，有许多知名景点，如印度门、百池公园、泰姬陵等。", "class": "open qa"}
{"question": "提供一个话题并列举五个相关观点。", "std_answer": "", "class": "brainstorming"}
{"question": "思考并讨论一个新的社交媒体应用程序的特点和功能。", "std_answer": "", "class": "brainstorming"}
{"question": "分类以下物品，将它们分为可回收、不可回收和其他：手机、废纸、钢笔、茶杯、鸡蛋壳、电视机。", "std_answer": "可回收：废纸和鸡蛋壳\n废纸可以再循环利用，生产成新纸制品；鸡蛋壳可以用来做肥料，还可以用于制作艺术品或手工制品。\n不可回收：手机、钢笔和电视机\n手机、钢笔和电视机都含有许多不可分解的化学物质，废旧电子设备中可能含有重金属等有害物质，不能随意处理。需要进行专业的回收和处理。\n其他：茶杯\n茶杯通常由陶瓷等材料制成。虽然它们不能被循环利用，但由于它们通常不含有有害物质，因此可以被捐赠或作为废旧物品进行一般垃圾分类处理。", "class": "classification"}
{"question": "用一两句话描述著名的尼罗河是如何形成的。", "std_answer": "尼罗河形成于非洲东部高原的湖泊地区，主要由这些湖泊的水源汇聚而成。它是世界上最长的河流之一，流经11个国家，最终注入地中海。", "class": "open qa"}
{"question": "回答以下问题：在哪里可以找到最好的中式快餐？", "std_answer": "", "class": "brainstorming"}
{"question": "给我一些有关大熊猫的常识，如它们的生活环境、食物和保护状态。", "std_answer": "大熊猫（Ailuropoda melanoleuca）是一种濒临灭绝的大型陆地哺乳动物，被认为是中国的国宝。以下是有关大熊猫的一些常识：\n生活环境：\n大熊猫生活在中国的西南部，其分布范围包括四川、陕西和甘肃等省份的树冠罩、竹林和山地森林。高山竹子是大熊猫的主要栖息地，这些山区拥有充足的湿润气候和适宜的温度，以及足够的竹子和其他植物供大熊猫觅食。\n食物：\n大熊猫以竹子为主要食物。根据研究，大熊猫的日常饮食需要摄入30至40千克的竹子，占其总食量的99%。此外，大熊猫还会吃一些水果、坚果和小量的昆虫。大熊猫具有自我消化酶，它们能够消化竹子中难以消化的纤维素，但是这种饮食习惯意味着它们需要大量的草食物来维持生存。\n保护状态：\n大熊猫是一种濒临灭绝的物种。截至2019年，全球野生大熊猫的数量约为1864只，它们主要受到栖息地破坏和非法狩猎的威胁。由于大熊猫的珍贵性和重要性，中国政府和许多非政府组织致力于保护这种物种。中国增加了大熊猫保护区的数量，并对非法狩猎和栖息地破坏进行了打击。大熊猫还被列入世界自然保护联盟的濒危物种红色名录，并受到国际上的广泛关注。每年9月18日是全球保护大熊猫日，旨在提高公众意识和保护行动的重要性。", "class": "open qa"}
{"question": "对一段中文文本进行英文翻译。\n在经济快速发展的今天，旅游已经成为一种时尚，如果你感到工资压力颇大，不防背起背包，来场旅游，舒缓放松下心情，让你重拾对生活和工作的热情。", "std_answer": "Nowadays, with the rapid economic development, tourism has become a fashion. If you feel a lot of pressure on wages, you might as well pack your backpack and travel to relax your mind and regain your enthusiasm for life and work.", "class": "rewrite"}
{"question": "列出三个人名，其中两个是历史上的真实人物，第三个是虚构的人物。", "std_answer": "", "class": "brainstorming"}
{"question": "你喜欢哪种音乐类型？请用三个词来描述。", "std_answer": "", "class": "brainstorming"}
{"question": "将以下新闻标题翻译成英语。\n特朗普称巴黎气候协议对美国不利", "std_answer": "Trump says Paris climate deal bad for U.S.", "class": "rewrite"}
{"question": "针对以下文本生成一段新闻报道。\n公司CEO在一次新闻发布会上宣布，本公司拟于明年上市。", "std_answer": "", "class": "generation"}
{"question": "用提供的材料和信息回答问题：\n面粉、鸡蛋、砂糖、奶油、香草和烤箱是做哪种食品的主要成分？\n以下是一道食谱：预热烤箱，将面粉、鸡蛋、砂糖、奶油和香草混合在一起，搅拌均匀。将混合物倒入烤盘中，放入烤箱，烘烤30分钟。", "std_answer": "这些成分被组合在一起以制作一种糕点 - 蛋糕。\n食谱步骤：\n1. 预热烤箱至指定温度。\n2. 在一个碗中，将面粉、砂糖、鸡蛋、奶油和香草混合在一起，搅拌均匀，直到成为一个光滑的糊状。\n3. 将混合物倒入预先准备好了的烤盘中。\n4. 放入预热好的烤箱中，烘烤约30分钟或直到它被烤熟，表面呈金黄色。\n5. 从烤箱中取出烤盘，让蛋糕冷却一段时间，直到它可以轻易地从烤盘上脱离出来。\n6. 将蛋糕从烤盘上轻轻取出，可以点缀表面，如加一些水果、鲜奶油或巧克力酱。\n蛋糕通常是一种甜点，可以在任何场合享用。它的口感和形状可以根据个人的喜好和创意来制作不同款式的蛋糕。", "class": "open qa"}
{"question": "为以下两个主题提供至少一个可行的策划或解决方案：\n1. 如何在远程工作中维持生产力；2. 如何在社交媒体平台上建立品牌形象。", "std_answer": "", "class": "brainstorming"}
{"question": "设计一个简单的日历应用程序。", "std_answer": "", "class": "brainstorming"}
{"question": "将以下电子产品分类为手机、平板电脑或笔记本电脑：iPhone、iPad、MacBook Pro、Surface Pro、Samsung Galaxy Tab S7。", "std_answer": "iPhone - 手机\niPad - 平板电脑\nMacBook Pro - 笔记本电脑\nSurface Pro - 平板电脑（可转换为笔记本电脑）\nSamsung Galaxy Tab S7 - 平板电脑", "class": "classification"}
{"question": "请列举出三个加密方法及其优缺点。", "std_answer": "", "class": "brainstorming"}
{"question": "给定以下摘要，生成一篇完整的文章。摘要：最近发生的一次重大爆炸事件导致数十人死亡。警方正在调查。", "std_answer": "", "class": "generation"}
{"question": "使用以下句子作为初始观点，列出优点和缺点的清单，并总结出结论。\n社交媒体给我们带来了更多的互动和社交，也让我们更容易联系到远离我们的亲友。", "std_answer": "社交媒体给我们带来了更多的互动和社交，也让我们更容易联系到远离我们的亲友。\n优点：\n1. 增加社交互动：社交媒体提供了各种方式来与其他人交流，例如聊天、评论和分享内容等。这使得与其他人互动更加容易和方便，不需要面对面的交流也可以收获社交互动的快乐。\n2. 扩大社交圈子：社交媒体可以让我们认识新朋友、加入不同兴趣爱好群体、与遥远的亲友建立联系。这扩大了我们的社交圈子，让我们有更多的机会结交到不同背景和文化的朋友，学习新的知识和经验。\n3. 分享生活：社交媒体让我们能够随时随地分享我们的生活，发布照片和视频，记录我们的日常，增加了交流和互动的乐趣。这也让我们更容易保持联系，分享彼此的生活喜悦和困难。\n缺点：\n1. 社交比实际生活更多：过度使用社交媒体可能让我们脱离真实生活，失去与现实生活的联系和平衡，把大量的时间用在与虚拟社交平台交流而不是与真实人类社会互动。\n2. 私人信息泄露：社交媒体通常需要我们提供个人信息，并可能分享我们的数据，这可能导致对我们的隐私和安全构成威胁。我们需要注意我们的信息和数据的公开范围，以及与我们共享和交流的人员的身份真实性和信息安全性。\n3. 环境或是个体负面影响：过度依赖社交媒体可能导致不良行为习惯、焦虑、抑郁等身心健康问题，特别是当我们无法控制自己的使用行为时。此外，社交媒体可能给环境带来不良影响，如浪费时间、电力消耗增加等。\n结论：\n尽管社交媒体带来了更多的社交互动和联系，但过度使用社交媒体也可能导致不利影响。我们需要注意平衡社交媒体和现实社交之间的关系，以及我们的使用行为是否健康和明智，同时注意隐私和信息安全的问题。", "class": "open qa"}
{"question": "给出一些避免压力和焦虑的建议。", "std_answer": "", "class": "brainstorming"}
{"question": "给定一个名人，给出关于他们生活、事业或其他方面的某些事实。\n马克·扎克伯格", "std_answer": "马克·扎克伯格，出生于1984年，是一位美国企业家和慈善家。他是世界上最年轻的自我创业亿万富翁之一，也是Facebook的创始人和首席执行官。以下是他生活和事业方面的一些事实：\n1. 扎克伯格是哈佛大学的辍学生。 2004年，他在大学的宿舍房间里创立了Facebook社交媒体平台。\n2. Facebook在美国上市后，使得扎克伯格成为亿万富翁。 截至2021年，他的净资产已经超过1,000亿美元。\n3. 扎克伯格致力于将世界连接在一起。他的愿景是让人们通过Facebook相互连接，以促进更多的社交互动和信息交流。\n4. 扎克伯格的家庭背景非常强大。他的父母都是医生，并拥有许多科技企业的股份。他的姐姐还是一位成功的作家和酒店业企业家。\n5. 扎克伯格也是一位慈善家。他于2015年成立了也以他和妻子的名字命名的「Chan Zuckerberg Initiative」（简称：CZI）。 CZI 旨在支持以下几个领域的项目：教育、医疗和科学。\n6. 扎克伯格曾在2018年因Facebook的数据泄露问题和隐私问题而受到批评。尽管 Facebook采取了多项行动来改善其隐私和安全措施，但该公司仍然面临着批评和质疑。", "class": "open qa"}
{"question": "分析和优化代码。\n以下是一个冗长且效率低下的排序算法，请进行优化。\ndef sort(arr):\n for i in range(len(arr)):\n for j in range(i+1, len(arr)):\n if arr[i] > arr[j]:\n arr[i], arr[j] = arr[j], arr[i]\n return arr\nprint(sort([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]))", "std_answer": "这是一个非常基础的排序算法——冒泡排序。它的时间复杂度为O(n^2)，当数据量较大时，排序速度非常缓慢，且在最坏情况下，需要进行n(n-1)/2次交换操作。我们可以对这个算法进行一些优化来提高其性能：\n1. 添加标记。\n在冒泡排序的每一轮中，只有当存在交换操作时，数组才可能还未排序完毕。我们可以设置一个标志，如果在整个排序过程中没有发生任何交换操作，则说明数组已经排好序，可以提前退出循环，减少不必要的比较和交换次数。\n2. 减少循环次数。\n由于每一轮冒泡排序都会将当前未排序部分中最大的元素“沉”到底部，因此下一轮排序可以减少一次比较操作。在实现时，可以在每一轮排序前计算出当前未排序部分的尾部索引，避免对已经排序的元素进行多余的比较。\n3. 优化交换操作。\n交换操作是冒泡排序中最耗费时间的操作之一，我们可以通过添加临时变量来减少交换操作的次数。\n以下是经过上述优化后的冒泡排序算法：等。", "std_answer": "", "class": "rewrite"}
{"question": "如果你必须在一周内完成一项重大项目，你会如何安排时间和优先事项？", "std_answer": "如果我必须在一周内完成一个重大项目，我会采取以下步骤以尽可能高效地利用时间和资源：\n1. 明确任务目标：首先，我会仔细审查项目要求和目标，以确保我完全理解要完成的任务，并能够专注于最重要的部分。这有助于确保我在短时间内成功地完成项目。\n2. 确定时间表：在清晰了解项目目标后，我会制定一个周详的时间表，以便在一周内分配任务，包括充分的时间用于计划，主要任务的分解，检查进度等。\n3. 列出优先事项：接下来，我会将任务分类成不同的优先级别，以确保必须做的任务最先被完成。大多数情况下，有些任务更重要，需要优先解决，而其他任务可以推迟或通过其他人员处理。这有助于优化进度并确保不会在项目过程中遗漏要紧事项。\n4. 设定 checkpoint：我会在一定的时间点检查项目的进展情况来确保能够按时完成项目。这些检查点可以根据时间表的结构和任务的难度来排列。\n5. 设定具体计划：然后，我会制定一个具体的计划，包括每天要达成的目标、所需时间，以及如何解决可能出现的问题等。\n6. 消除干扰：为了确保我能够在给定的时间内尽可能高效地完成项目，我需要消除干扰。这可能包括治理时间，禁止或限制使用社交媒体、邮件或电话等带有干扰性的工具。\n7. 保持动力：最后，为了成功完成重大项目，我会一直保持动力和积极性，利用自己具备的经验和技能，观察和实时调整计划。\n以上是我的详细回答，我相信这些步骤可以帮助我在短时间内高效完成重大项目。", "class": "open qa"}
{"question": "为给定的一组数据生成摘要性描述。\n以下是一组地震数据，包括地震时间、震级、地震深度等：\n09/01/2021, 3.4级, 10公里深度\n09/02/2021, 5.2级, 20公里深度\n09/02/2021, 2.1级, 5公里深度", "std_answer": "这些数据是有关于三次地震的，发生的日期分别是2021年9月1日、2日和2日，三次地震的震级分别为3.4级、5.2级和2.1级。其中，第二次地震的震级为最高，为5.2级，地震深度也是最深的，为20公里。相比之下，第一次和第三次的地震深度分别为10公里和5公里。总体而言，这组数据提供了有关不同日期、不同震级和不同深度的地震信息，其中第二次地震是最强的。", "class": "summarization"}
{"question": "根据给定的主旨和若干关键词，撰写一篇有趣的新闻报道。\n主旨：三只猴子逃出动物园。关键词：猴子、动物园、逃跑", "std_answer": "", "class": "generation"}
{"question": "根据上下文，填写空缺的单词\n我正在学习一门课程，[空]是学习数据科学的必要条件。", "std_answer": "数学是学习数据科学的必要条件。", "class": "open qa"}
{"question": "请从以下词语中选择填空：......\n句子内容：电视机是一种___机。选项：A.通讯 B.视听 C.娱乐", "std_answer": "电视机是一种视听机。\n电视机是通过电子技术将视频信号转换为图像并输出到显示器上，同时通过声音技术将音频信号转换为声音并输出到扬声器上的电子设备。因此，电视机被称为视听机，可以提供高清晰度的图像和音频效果，用于观看各种类型的节目，包括电视节目、电影、音乐和体育比赛等，为人们的视听娱乐生活带来更多的乐趣和享受。", "class": "closed qa"}
{"question": "思考并列出你认为的十个有效的时间管理技巧。", "std_answer": "", "class": "brainstorming"}
{"question": "将一个长句拆分成多个短句，每个短句长度不超过15个单词。例如，将“在我看来，这个问题非常困难，因为我没有足够的信息来解决它。”转换为“在我看来，这个问题非常困难。因为我没有足够的信息。来解决它。”\n网络安全是我们必须非常重视的。因为它将直接影响我们的日常生活。比如说，银行账户被黑客攻击是一件很让人害怕的事情。", "std_answer": "", "class": "rewrite"}
{"question": "编写一份简历模板，着重强调工作经历和技能。", "std_answer": "", "class": "generation"}
{"question": "为以下三句话找到一个共同的主题/关键词。[句子1]古罗马建筑的独特之处在于其坚固和宏伟的建筑设计。[句子2]当地政府宣布禁止在公共场所吸烟。[句子3]在前往办公室的路上，我经常听音乐来缓解压力。", "std_answer": "三个句子的共同主题/关键词是“设计”或“设计特点”。虽然三个句子的主题非常不同，但是它们都包含某种设计方面的内容。句子1指的是古罗马建筑的坚固和宏伟的建筑设计，句子2提到的是当地政府对公共场所的吸烟进行设计和规定，而句子3涉及听音乐来缓解大家在日常生活中居住设计。因此，这三个句子都在它们的背景中涉及了设计特点。", "class": "extract"}
{"question": "根据以下场景编写一段对话\n场景：在医院里，一个患者向医生描述了自己的疼痛症状", "std_answer": "", "class": "generation"}
{"question": "为一个在线商店编写一篇关于夏季特惠活动的新闻稿。\n该在线商店是一家提供时尚衣物的网络购物平台。夏季即将来临，该商店决定推出一项盛大的特惠活动，以庆祝这个充满活力的季节。请为此撰写一篇包含以下内容的新闻稿：活动名称、优惠内容、参与方式、活动期限等。", "std_answer": "", "class": "generation"}
{"question": "请解释“博客”（Blog）的意义和作用。", "std_answer": "博客（Blog）是一个人或一组人在自己的网站或平台上发布文章、记录信息和感悟的一种交流形式。它是由两个词“weblog”合成而成的，最早出现在1990年代中期。随着数字技术的快速发展，博客在全球范围内得到了广泛的认可和使用。\n博客在现代社会中的作用和意义是多方面的：\n1. 交流和表达：博客是一个人随时随地可以表达自己观点、想法、经验和技能的平台。它脱离了传统媒体和机构对信息的控制，让每个人都可以发声。博客可以作为一个人的“心灵日记”，记录生活、工作和思想中的琐碎和感悟，也可以分享学习和工作上的经验和知识，帮助他人解决问题和提高能力。\n2. 建立个人品牌：博客可以成为一个人展示自己专业技能和行业见解的平台，通过发布有深度和有价值的内容，吸引潜在客户和雇主的关注，提高个人知名度和认可度。通过博客可以建立个人品牌，展示个人特色和价值，增强竞争力。\n3. 传播信息：博客可以作为传播信息和宣传产品、服务的渠道，通过博客发布的有关产品和服务的信息吸引潜在客户或用户对其购买或使用产生兴趣。此外，博客也可以作为一个媒体平台，发布时事新闻、信息和观点。\n4. 社交互动：通过博客可以建立和维护社交网络，与读者和同行进行互动交流，分享经验和知识，得到反馈和建议。通过博客可以认识新朋友，分享相同爱好的人，聚集形成兴趣社区。\n综上所述，博客在现代社会中扮演着重要的角色，不仅是一个人表达自己、建立个人品牌、传播信息和社交互动的平台，也是一个文章富有价值、思想深度的生态系统。", "class": "open qa"}
{"question": "解释人类自然睡眠周期的不同阶段。", "std_answer": "人类自然睡眠周期被分为五个不同的阶段，每个阶段都有不同的生理和神经活动。以下是这五个阶段的详细描述：\n1. 清醒阶段（Wakefulness）：\n这是人们完全清醒的状态。在这个阶段，大脑发出高频电信号，人们的思维和意识都非常清晰。这个阶段通常是在白天或早晨醒来时出现。\n2. 非快速眼动睡眠（Non-Rapid Eye Movement, NREM，也称为深度睡眠）：\nNREM分为三个子阶段：N1、N2和N3。整个NREM阶段通常占据整个睡眠时间的75％。\n- N1阶段：这个阶段通常是人们刚开始睡觉时出现的。大脑发出更慢的电信号，呼吸变慢，身体逐渐放松，但仍然有意识。这个阶段通常只持续几分钟。\n- N2阶段：这个阶段是睡眠中最常见的阶段，通常占据整个睡眠时间的50％到60％。在这个阶段中，大脑波变得更低，但有一些较高频率的快速波。人们的心率和呼吸率也减慢了。这个阶段的特点是出现嗜睡。 \n- N3阶段：也称为“三级非快速眼动睡眠”。在这个阶段中，大脑电信号变得更缓慢，人的身体变得非常疲惫和放松。这个阶段通常在深夜时分出现，并占据整个睡眠时间的10％到20％.\n3. 快速眼动睡眠(REM)：\n这个阶段是指出现在整个睡眠时间（平均为90分钟），也称为浅度睡眠。在这个阶段，大脑电信号类似于清醒时期，呼吸变快，心跳加速，眼球快速移动（这也是它的命名来源）等现象。这个阶段通常是人们做梦的时间，因为大脑的活动和思维过程类似于清醒时期。 \n4. 梦中期：对于一些学派而言，这个中间阶段其实可以看做是一种针对REM的参数设置，在注意力和神经活跃度上并没有过于显著的改变。只是因为它在夹杂着REM和非REM2的状态之间，所以将其单独提出了来。 结构上表现为，由于还陷入彻底意识模糊状态仍未完全醒来，及大量的高等神经元及基础神经元的疲劳度尚未恢复，身体各个器官仍然处于一种相对低迷甚至休息状态，若此时突然强刺激下，如“大声喊叫”、“电器噪声”等，也足以使人在突然间惊醒。\n5. 僵硬期：在某些情况下，一些人会在睡眠中经历一种类似于“醒来但无法动弹”的感觉。这种现象称为“僵硬期”。在这个阶段，人们的身体几乎无法动弹，但是大脑仍然很清醒。这个阶段通常只持续几秒钟到几分钟，但是对于那些经常经历这种“僵硬期”的人来说，这个阶段可能会破坏他们的睡眠质量。庆幸的是，这种现象并不会对健康产生任何不良影响。", "class": "open qa"}
{"question": "回答下列问题：现在是东部标准时间下午3点，那么英国伦敦现在是几点？", "std_answer": "根据世界时区的划分，东部标准时间属于美国和加拿大地区，而英国伦敦属于欧洲地区，处于格林尼治标准时间（也称为西欧时间）区域。因此，在计算英国伦敦现在的时间时，需考虑时区的差异。\n目前，东部标准时间与世界协调时（UTC）相差5个小时，也就是说，当东部标准时间下午3点时，UTC时间为下午8点。而英国伦敦与UTC时间相差1个小时，因为英国根据夏令时的变化会在夏季提高1小时。据此推算，当东部标准时间下午3点时，英国伦敦的时间应该是下午8点加1个小时，也就是晚上9点。 \n因此，如果已知在东部标准时间下午3点，想要知道英国伦敦的当前时间，需要将下午3点加上东部标准时间与UTC时间的时差5个小时，得到UTC时间为下午8点，再根据英国伦敦与UTC时间相差1个小时的情况，将UTC时间的8点增加1小时，就得到了英国伦敦现在的时间为晚上9点。", "class": "open qa"}
{"question": "请给我五个关于厨艺的提示。", "std_answer": "", "class": "brainstorming"}
{"question": "请写一篇关于青少年使用社交媒体的利与弊的文章。", "std_answer": "", "class": "generation"}
{"question": "解释以下缩写：\nJSON、CEO、PDF、HTML、NASA", "std_answer": "以下是这些缩写的详细解释：\n1. JSON: JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。它以文本形式表示数据，可以从一种程序语言传递到另一种程序语言，具有易于理解和快速解析的优点。JSON 常用于 Web 应用程序和 API 中的数据交换。\n2. CEO: CEO (Chief Executive Officer) 是一个英文词汇的缩写。在公司中，CEO 是最高级别的高管，负责管理和指导公司的日常运营和战略决策。 CEO 通常是公司的创始人或董事会任命的高管。\n3. PDF: PDF (Portable Document Format) 是一种由 Adobe Systems 创造的文档格式。它以文件形式保存，并可以跨平台交换，以确保文档在任何平台上的一致性。PDF 是一种流行的格式，用于保存文档、表格、图片等多种信息。\n4. HTML: HTML (Hypertext Markup Language) 是一种用于创建 Web 页面的标记语言。 HTML 允许开发人员定义文本、图片、链接、音频、视频等内容，并将其结构化为网页。 HTML 是 Web 技术栈的一个基础组成部分。\n5. NASA: NASA (National Aeronautics and Space Administration) 是美国政府机构，负责在和平时期进行航空和宇宙研究。NASA 成立于 1958 年，致力于推进科学和技术的发展，为人类探索宇宙提供支持。NASA 也是许多著名空间任务和探索项目的发起者和管理者，如太空人登月计划、国际空间站和火星探测器。", "class": "open qa"}
{"question": "回答以下问题：\n什么是牛津大学？", "std_answer": "牛津大学（University of Oxford）是世界著名的公立研究型大学，位于英国牛津市，成立于1096年，是世界上最古老的大学之一。牛津大学是英国顶尖的学府之一，也是世界上最好的大学之一，在世界的大学排名中常常名列前茅。它是英国著名的学习机构之一，拥有多项世界级的学科专业，享有“世界学术中心”的盛誉。\n牛津大学包含许多分校区和学院，其中包括300多个学院，超过20,000名本科生和研究生，以及超过12,000名教职员工。它的学科范围广泛，涵盖了艺术、人文、社会科学、自然科学、医学、工程和科技等众多领域。\n作为一所公立大学，牛津大学也是一个重要的科研机构，拥有多项开创性的贡献和发现，包括发现DNA双螺旋结构、万有定理等。其教育、研究和学术杰出成果不断地增强和推动了全球范围内的学术进展，对于社会和人类的整体进步做出了巨大贡献。\n总之，牛津大学是一个备受尊敬的高等教育机构，它的教育学术水平极高，是一个在全球范围内有巨大影响力的知识瑰宝。", "class": "open qa"}
{"question": "解决以下问题：\n什么是蛋白质？", "std_answer": "蛋白质是各类生命体中常见的一类有机分子，也是一种重要的生物分子。它们在细胞内发挥着重要的结构和功能作用，是细胞的基本组成部分之一。蛋白质是由氨基酸分子组成的，而氨基酸则是生命体中的基本分子之一。\n每个氨基酸都由一些共同结构的基本组成部分构成，包括一个氨基（NH2）基团、一个羧酸（COOH）基团、一个氢原子和一个侧链基团。侧链基团的结构在不同的氨基酸中是不同的，并且决定了每个氨基酸的特定性质和功能。\n在蛋白质的合成过程中，氨基酸通过肽键（一种共价键）连接在一起，形成多肽链，而多肽链则是蛋白质的基本结构。在多肽链的形成过程中，氨基酸的侧链基团可相互作用并形成不同的空间结构，如螺旋状、折叠状或者随机卷曲。\n这些不同的结构赋予了蛋白质不同的生物学功能，如结构性支撑、催化活性、运输、信号传递等。蛋白质中所含的氨基酸序列和空间结构的特定性是由其基因组成和环境条件所决定的。\n蛋白质在生命体中起着举足轻重的作用，因此对于了解生物学和医学等领域的学科，蛋白质的理解是至关重要的。", "class": "open qa"}
{"question": "请解释BERT是如何进行文本分类的。", "std_answer": "BERT即“基于 Transformer 的双向编码器表示”，是一种预训练模型，可用于各种下游自然语言处理任务，例如文本分类、命名实体识别、问答等。\n文本分类是一种下游任务，其中BERT可用于生成文本表征并将其传递给分类器。BERT将输入文本处理为表示其上下文的向量，然后将此向量送入分类器。文本分类是一个监督学习任务，意味着我们需要用已标记的示例数据训练分类器，以便它能够预测未标记数据的类别标签。\nBERT的文本分类过程包括以下步骤：\n1. 输入处理：BERT使用“[CLS]”和“[SEP]”代替符号，[CLS]是指固定句子的起始位置，[SEP]是指句子的分隔符。BERT需要接受输入文本的嵌入表示。BERT使用两个嵌入矩阵：一个用于单词嵌入，一个用于位置嵌入，以便在输入序列中标识位置。\n2. Pre-training：在分类任务前，BERT通过大量的未标记文本数据进行预训练。在这种情况下，BERT沿着文本中的两个方向（从左到右和从右到左）进行编码，并使用这些编码来生成与文本上下文相关的表示。\n3. Feeding text into Bert: 一旦输入文本被处理为嵌入表示，它将被输入到BERT中生成更好的上下文嵌入。BERT使用基于Transformer 的神经网络来生成这些向量。\n4. Attention mechanism: 在BERT中，自注意机制用于计算每个位置的向量，以便在输入文本中获取上下文信息。自注意机制可用于计算单词之间的关系，从而可以最大限度地维护词与词之间的连续性。\n5. Pooling layer：文本分类需要将整个文本序列提取其压缩标志。BERT使用汇聚层来压缩序列，以生成单一的表征向量。目前，BERT只支持两种汇聚操作：最大池化和加权平均池化。\n6. Classification：将汇集的特征向量输入到分类层中，以训练文本分类模型。这个模型是一个MLP，其中包括一个或多个全连接层。输出层的softmax函数将该向量分类到不同类别的概率上。\n7. Fine-tuning：在批量进行预处理并构建分类器后，需要对整个模型进行微调。这可以通过使用带有标签的文本数据进行监督学习来完成。此过程有助于调整模型的超参数，以提高其性能并使其适合用于特定领域的文本分类任务。\n总之，BERT使用Transformer编码器和解码器体系结构以产生文本的上下文相关表征。这种能力使它成为各种下游NLP任务的优秀候选者之一，其中包括文本分类。", "class": "open qa"}
{"question": "用你的想象力写一篇关于未来的故事，你可以自由发挥。", "std_answer": "", "class": "generation"}
{"question": "请简述海豚的特点和生活习性。", "std_answer": "海豚是一种被称为齿鲸科的哺乳动物，它们生活在海洋或淡水中，以鱼类、乌贼、虾和其他海洋生物为食。以下是海豚的一些特点和生活习性：\n1. 特点\n- 海豚身体呈流线型，具有极佳的游泳能力，可以飞快地在水中游动。\n- 海豚的体型大小不一，最大的虎鲸长达9米，而最小的黑海豚仅有1.2米。\n- 海豚的眼睛很小，但视力和听觉都非常敏锐，可以使用超声波进行定位。\n- 海豚的脑袋在左右两侧有二十多颗牙齿，牙齿非常锐利。\n- 海豚属于社会性动物，会形成非常紧密的群体，称为“海豚群”。\n2. 生活习性\n- 海豚通常在白天活动，晚上则靠近岸边休息，他们可以在水下停留约15分钟，最多可一次性憋气维持7-10分钟。\n- 海豚通常以鱼类和小型无脊椎动物为食，但也会吃鸟类、龟类等。\n- 海豚通过发出超声波进行通讯，可以进行长距离的定位和捕食。在群体中，海豚之间通过这种方式进行互动和交流。\n- 海豚群通常由雄性和雌性成员组成，其中雄性之间会进行一些社会性的活动，如拍打水面、跃出水面等，以达到显摆自己的目的。\n- 海豚的繁殖能力很强，雌性海豚通常每年可以生一个幼崽，幼崽出生后通常需要母亲照顾一段时间。", "class": "open qa"}
{"question": "回答下列问题：究竟是什么导致了科技泡沫破裂？", "std_answer": "", "class": "brainstorming"}
{"question": "提供几种解决某一问题的方案。\n如何减轻医学留学的经济负担。", "std_answer": "", "class": "brainstorming"}
{"question": "回答以下问题：\n茉莉花茶是用什么材料泡制的？", "std_answer": "茉莉花茶是一种非常受欢迎的茶类，是以茉莉花和绿茶为原材料酿制而成的。茉莉花属于茉莉花属，是一种香气怡人的花卉植物。而绿茶则是以嫩叶为原材料而制成的茶叶，具有绿叶的色泽、香气和滋味。在制作茉莉花茶时，新鲜的茉莉花要和嫩叶绿茶一起加工制作。\n具体来说，制作茉莉花茶的步骤如下：\n1. 选购优质绿茶。茉莉花茶一般使用绿茶作为茶底，所以需要选购优质的绿茶原料，不宜使用太老的绿茶。\n2. 种植茉莉花。茉莉花的花期在夏季，此时需要专人在绿茶园中种植茉莉花。\n3. 花香传味。使用新采的茉莉花，在晚上开花期间采摘，并加以处理熏香，使其花香能够深入到绿茶中。\n4. 和茶叶混合。将新鲜的茉莉花和绿茶混合后，一般在2-3次的熏香过程中，让茶叶充分吸取花香。\n5. 茶叶加工。经过熏香后的茶叶，需要进行筛选、绿干等工艺加工，这样茶叶才会有完整的鲜香。\n总之，制作茉莉花茶需要用到新鲜的茉莉花和优质的绿茶，并将茉莉花的香氛传递到绿茶中，这样才能制作出口感香醇、甘甜爽口的茉莉花茶。", "class": "open qa"}
{"question": "列出三种不同的方法来减轻压力。", "std_answer": "", "class": "brainstorming"}
{"question": "在给定的短文中找出三个关键词。\n西方的哲学历史可上溯至古希腊时期，最重要的哲学流派包括柏拉图学派、亚里士多德学派和斯多葛学派。", "std_answer": "1. 古希腊时期 - 给出了西方哲学历史的起源和时间背景。\n2. 柏拉图学派 - 是西方哲学历史中最重要的学派之一，由古希腊哲学家柏拉图创建。该学派的思想审美，形式美和理念哲学都具有非常重要的地位。\n3. 亚里士多德学派 - 也是西方哲学历史中最为重要的学派之一，由古希腊哲学家亚里士多德创建。该学派重视逻辑和实证主义，对于自然科学和形而上学方面的思考对于后来的哲学也产生了非常深远的影响。", "class": "extract"}
{"question": "描述如何将一个普通的座位变成一个舒适的办公椅，并提供相关建议和要点。", "std_answer": "", "class": "brainstorming"}
{"question": "在一个团队会议中，为解决一项挑战提出5个不同的解决方案。", "std_answer": "", "class": "brainstorming"}
{"question": "将给定的邮件分类为垃圾邮件或非垃圾邮件。\n您好，这是一封提醒您缴纳物业费的邮件。", "std_answer": "这封邮件似乎并不是垃圾邮件，因为它似乎是一封真实的邮件，提醒收件人缴纳物业费用。因此，如果你是该物业的业主或租户，则应该定期缴纳物业费用。如果你不确定此邮件的真实性，请确认它是否来自你所居住的物业公司或管理人员，并通过他们的正式渠道进行缴纳。", "class": "classification"}
{"question": "对以下几家公司的股票进行价格预测：\n苹果公司，亚马逊公司，微软公司，谷歌公司。", "std_answer": "", "class": "brainstorming"}
{"question": "解释“市场定价”是什么，并列出三个市场定价策略。", "std_answer": "市场定价是指企业为其产品或服务制定价格时，参考市场需求和竞争对手的价格水平以及自身成本等因素，最终确定的定价策略。市场定价的目的是在实现利润最大化的同时，满足市场需求和客户的购买能力。\n以下是三种常见的市场定价策略：\n1. 市场导向定价（Market-Oriented Pricing）：该策略是以市场需求为导向，根据市场反应和需求进行定价。它是一种以顾客和市场为中心的定价策略。该策略的优势是能够更好地适应消费者需求，增强产品市场竞争力。例如，企业将定价策略调整为更适合市场的价格水平，以满足消费者的资金承受能力。\n2. 成本加成定价（Cost-Plus Pricing）：这一策略是以企业成本为基础，加上一定的利润率来制定价格。该策略的优势是容易理解和实施，因为成本可以计算，并且可以预测利润。但是，它可能会低估顾客的需求。\n3. 差异化定价（Differential Pricing）：这项策略是根据客户不同的需求和购买能力，在不同的市场或客户中采用不同的价格。这使企业可以更好地利用其不同产品或服务的市场优势，同时最大化收益。例如，航空公司根据旅行日期，订票时间和乘客需要付费的服务等差异化因素，调整不同的票价给不同的消费者。 \n总之，市场定价是阐述产品及其服务合适的价格来满足客户需求，并同时达到企业利润的目标。企业可以根据自身情况和市场环境选择适当的定价策略，这也是市场营销中非常重要的一个方面。", "class": "open qa"}
{"question": "根据以下描述给出一个合适的职业名称。\n描述：这个人在医院中处理和照顾病人，包括测量和记录体温，给药物，处理伤口等。", "std_answer": "这个职位的名称是护士。护士是医院中非常重要的医疗专业人员之一，负责照顾病人的身体和情感需要。护士在病人的日常护理过程中扮演着关键的角色，他们可以帮助病人恢复健康并提高病人的舒适程度。\n护士的职责包括收集病人的病史和症状，以帮助医生对病人进行诊断和治疗。他们必须测量和记录体温、脉搏和呼吸，检查病人的心率和血压，并根据医嘱给病人服药。护士还负责更换和处理病人的敷料和管道等。\n除了照顾病人，护士还需要与其他医疗专业人员合作，确保病人在医院中得到全方位的护理。他们必须与医生、医疗助理、社工和营养师等人紧密合作，以确保为病人提供综合性的，高质量的医疗服务。\n总之，护士是医院中非常重要的医疗专业人员之一。他们需要具备专业知识和技能，同时具有同情心和情感稳定性，以帮助病人和他们的家人应对疾病和治疗的过程。", "class": "closed qa"}
{"question": "提供包含以下所有球员的曼联足球俱乐部历史上的最佳11人阵容：博比·查尔顿、乔治·贝斯特、丹尼斯·劳、雷恩·伯格、金利·加密、威廉·皮琴、洛伊德·梅斯、内维尔·斯托克斯、布莱恩·罗布森、加里·贝利和埃里克·坎东。", "std_answer": "曼联足球俱乐部历史上最佳11人阵容如下：\n1. 雷恩·伯格 (GK) - 这位荷兰守门员曾经是一名出色的门将，代表曼联出场了从1955年至1973年间共233次。他曾经获得了欧洲冠军联赛冠军，以及曼联历史上的三次联赛冠军。\n2. 埃里克·坎东 (RB) - 这位曼联右后卫代表球队出场超过400次，被誉为曼联历史上最好的后卫之一。他曾经帮助曼联赢得过三座英超联赛冠军，并且还代表英格兰国家队出场过90次。\n3. 威廉·皮琴 (CB) - 这位中后卫是曼联历史上最具标志性的球员之一。他代表曼联出场了超过600场比赛，并帮助球队赢得了五次英格兰足总杯冠军和一次欧洲冠军联赛冠军。\n4. 加里·贝利 (CB) - 这位中后卫是曼联历史上最优秀的球员之一。他代表曼联出场564次，并协助球队赢得了两次欧洲冠军联赛，三次英格兰足总杯冠军以及多次英超联赛冠军。\n5. 内维尔·斯托克斯 (LB) - 这位曼联左后卫代表球队出场超过300次，帮助球队赢得过英格兰足总杯和英超联赛。他同样也代表了英格兰国家队出场过18次。\n6. 布莱恩·罗布森 (RM) - 这位曼联右中场代表球队出场了468次，打进了99个进球。他曾经帮助曼联赢得过两次欧洲冠军联赛和7次英格兰足总杯冠军。\n7. 博比·查尔顿 (CM) - 这位曼联传奇球员是俱乐部历史上最好的球员之一，并被认为是英格兰足球历史上最优秀的球员之一。他在曼联效力了22个赛季，出场758次，并打进了249个进球。他帮助球队赢得过三次英格兰联赛冠军、一次欧洲冠军联赛冠军和一次世界俱乐部杯冠军。\n8. 丹尼斯·劳 (CM) - 这位中场球员是曼联历史上最出色的球员之一，代表俱乐部出场了406次并打进了168个进球。他帮助曼联赢得过八次英格兰足总杯、三次英格兰联赛冠军、一次欧洲冠军联赛冠军和一次世界俱乐部杯冠军。\n9. 乔治·贝斯特 (LM) - 这位左边锋是曼联历史上最好的球员之一，被称为“毕业生”和“银河战舰”。他在曼联效力了11个赛季，出场474次，并打进了211个进球。他帮助曼联赢得过两次英格兰联赛冠军，一次欧洲冠军联赛冠军以及一次世界俱乐部杯冠军。\n10. 洛伊德·梅斯 (CF) - 这位前锋是曼联历史上最出色的射手之一，代表俱乐部出场超过400次并打进了180个进球。他帮助曼联赢得过两次英格兰联赛冠军和一次欧洲冠军联赛冠军。\n11. 金利·加密 (CF) - 这位前锋是曼联历史上最好的球员之一，在效力曼联期间，他代表球队出场超过550次，并打进了249个进球。他帮助曼联赢得过六次英格兰联赛冠军、一次欧洲冠军联赛冠军、两次英格兰足总杯冠军和一次世界俱乐部杯冠军。\n以上是曼联足球俱乐部历史上最佳的11人阵容，这支球队拥有着一系列出色的球员和传奇人物，并取得了丰硕的成果。", "class": "open qa"}
{"question": "请测试以下代码，并给出输出结果。\nfunction greeting(name) {\n console.log(`Hello, ${name}!`);\n}\ngreeting('Alice');", "std_answer": "这段代码定义了一个名为`greeting`的函数，该函数接受一个`name`参数，然后将其替换为`Hello，${name}！`的字符串，并将结果打印到控制台。函数被调用并传入`'Alice'`作为参数，因此控制台将输出`Hello, Alice!`。\n输出结果：\n```\nHello, Alice!\n```", "class": "code"}
{"question": "根据以下段落，对其中的关键信息进行提取：“2019年，苹果公司发布了一款备受期待的新型Macbook Air笔记本电脑。这款电脑的最大特点是其轻巧的设计，重量仅有2.75磅（约合1.25千克），非常适合携带出行使用。除此之外，新款Macbook Air还拥有非常出色的电池续航能力，可以使用长达12个小时。这意味着用户可以在一天中的大部分时间内不需要进行充电，从而更加方便地使用电脑。此外，新款Macbook Air还采用了更快的处理器和更高的内存容量，以提供更强大的性能和更快的响应速度。这使得它成为一款非常适合用于高效工作和多媒体制作的电脑。总的来说，苹果公司在这款新型Macbook Air中集成了许多出色的技术和设计，使其成为了一款非常强大、便携、耐用的电脑，受到了广大消费者的热烈欢迎。”", "std_answer": "发布日期：2019年\n产品名称：新型Macbook Air笔记本电脑\n产品特点：轻巧设计，重量仅2.75磅（约合1.25千克）；电池续航能力长达12小时\n产品性能：更快的处理器和更高的内存容量，适合高效工作和多媒体制作\n反馈评价：成为一款强大、便携、耐用的电脑，受到广大消费者的欢迎", "class": "extract"}
{"question": "为什么大部分科幻小说都发生在未来？", "std_answer": "大部分科幻小说都设定在未来，这是因为科幻小说的本质就是探索和展示未来可能的科技、社会和文化等方面的作品。同时，科幻小说也是对当代和历史文化和技术的反思，并试图预测未来的发展方向，因此才被称为“科学幻想”。\n以下是更多的详细解释：\n1. 透过未来的镜头展现现在\n科幻小说大多发布发生在未来的原因之一是，这样可以透过未来的“窗口”（比现在的时间点更晚的时间点）展示当前的社会、政治和文化等问题。例如，一个科幻小说可能会设定在未来的超级城市，通过对这个城市中发生的事情的描述，向读者展示现代城市所面临的问题，如越来越多的人口密集、环境破坏和资源短缺等问题。\n2. 推理和预测未来的发展方向\n另外一个科幻小说被设定在未来的原因是试图推理、探究和预测未来可能发展的方向和趋势。在研究过去和现在的社会、科技和文化等方面的基础上，科幻小说作家可以通过逻辑推断想象未来可能会变成什么样子，制造出未曾有过的场景和设备，从而让读者探险未来。\n3. 添加科幻元素以塑造故事世界\n此外，科幻小说还通常包含很多科技和想象元素，如太空旅行、智能机器人、超速飞行器和高级生物科技等等，这些元素可以深度塑造小说中的世界观和故事内容。科技和想象元素的存在和进步可以催生出新的社会和政治结构，从而为故事增添一些戏剧性和惊险感。\n总结来说，大部分科幻小说都发生在未来，因为这样可以通过未来的观察角度来反映当前的世界，也可以通过未来的想象来推理和探索未来可能的发展方向，同时加入科技和文化元素以丰富故事性。", "class": "open qa"}
{"question": "请描述如何向一个陌生人介绍自己以建立联系。", "std_answer": "向一个陌生人介绍自己是建立联系的一个关键步骤，以下是一些详细的介绍自己的建议：\n1. 打招呼并引出自己的姓名\n你可以开始用一个简单的打招呼，例如“您好”或“你好”，然后告诉他们你的名字。说出自己的名字，这会让对方更容易记住你并建立联系。\n2. 给出你的背景和工作\n将你的背景和工作介绍给对方，例如，“我是一名学生，正在攻读计算机科学学位”或“我是一位工程师，正在ABC公司工作”。这个介绍将让对方更好的了解你和你的生活状态。\n3. 提及你的兴趣爱好\n谈论你的爱好可以让对方更好的认识你，以及找到相关话题进行交流。例如：“我喜欢打网球，你呢？”\n4. 开放式问题\n开放性问题可以建立联系并提供有趣的交流话题。例如：“你喜欢在业余时间做什么？”这种问题可以让对方回答自己感兴趣的话题，并逐渐建立联系。\n5. 尊重对方\n在介绍自己时，一定要注意表现出对对方的尊重和关注。确保你的态度和语气友善，耐心地倾听他们的回答，并给予积极的反馈。\n6. 记住对方的名字\n当对方介绍自己之后，确保记住他们的名字，并在以后的交流中使用它们。这是建立联系的重要一步，让对方感受到你对他们的关注和尊重。\n7. 表达愿意建立联系\n在你的介绍结束时，表达你的愿望建立联系，例如：“很高兴认识你，如果您有时间的话，我们可以一起喝一杯咖啡或者进行业余爱好。”这将确保你介绍自己的目的达到，并能够建立联系。", "class": "open qa"}
{"question": "对图书馆的评价评分应该如何计算？", "std_answer": "", "class": "brainstorming"}
{"question": "描述以下概念的定义和应用：虚拟现实（VR）。", "std_answer": "虚拟现实（Virtual Reality，缩写VR）是一种计算机技术，将用户沉浸在计算机生成的虚拟环境中，为用户提供身临其境的感觉。在虚拟现实世界中，用户可以与虚拟环境中的物体、场景或人物进行交互，这种交互可以是视觉、听觉、触觉等多种形式，使用户感受到一种与现实世界完全不同的体验。\n虚拟现实在许多领域都有广泛的应用。以下是一些示例：\n1. 游戏：虚拟现实技术已被广泛使用于游戏开发中。游戏开发者可以使用虚拟现实技术为玩家提供一个完全沉浸的游戏体验，让玩家进入游戏世界，尽情享受游戏。\n2. 市场营销：虚拟现实也可以用于产品的市场营销。通过与用户的交互，虚拟现实技术可以使用户更好地了解产品，从而提高销售量。\n3. 教育：虚拟现实技术可以在教育中有广泛应用，如军事、医疗、科学等领域。通过虚拟现实，学生可以参加模拟实验、观察物种、了解历史事件等等，从而获得更丰富的教育经验。\n4. 医疗：在医疗领域，虚拟现实可以用于模拟手术、治疗和障碍物体验等领域。通过虚拟现实技术，医生可以更好地了解手术过程或疗效，从而提高治疗准确性，减少手术和治疗风险。\n虚拟现实技术正快速发展，未来可能会在更广泛的领域中应用。虚拟现实可以提供超越现实世界的令人兴奋的体验，并为用户带来新的感官体验，从而增强学习效果、游戏体验和工作效率等方面的体验。", "class": "open qa"}
{"question": "为以下公司名称选择最合适的行业类别：Apple，Amazon，Facebook，Walmart。\n行业类别：科技、零售、媒体、超市", "std_answer": "Apple - 科技\nApple (苹果公司) 是一家以设计和制造电子产品为主的公司，如iPhone、iPad、MacBook 等等。它也经营 App Store 和其他数字服务，并因其创新和设计而闻名于世界。因此，其最合适的行业类别是科技。\nAmazon - 零售\nAmazon (亚马逊) 是全球最大的在线销售商之一，其产品线包括书籍、电子设备、家电、生鲜食品等等。虽然 Amazon 也在科技、娱乐和其他领域发展，但其主要业务是以销售和物流为中心的零售业务，因此，最合适的行业类别是零售。\nFacebook - 媒体\nFacebook (脸书) 是全球最大的社交媒体网络之一，为用户提供了分享和交流信息的平台。它也拥有 Instagram 和 WhatsApp 等其他社交媒体平台，并在视频和虚拟现实等领域逐渐扩张。由于其业务的性质，Facebook 最适合的类别是媒体。\nWalmart - 超市\nWalmart (沃尔玛) 是一家全球超市巨头，其主要业务是以销售商品为中心的零售业务。其业务范围涵盖了从食品到家电等广泛的商品种类。虽然 Walmart 已经在电子商务和金融等领域成长，但其核心业务仍然以销售物品为主导，因此超市是其最合适的行业类别。", "class": "classification"}
{"question": "请解释什么是RESTful API，以及它的优点是什么。", "std_answer": "RESTful API （Representational State Transfer Application Programming Interface）是一种设计风格和架构模式，用于创建 Web 服务，这些服务可以从互联网上的任何地方访问并获取资源。它是一种轻量级、灵活、可扩展的架构，遵循基于 HTTP 规范的一组原则，使得客户端和服务器之间的通信变得可预测且易于理解。\nRESTful API 通过使用 HTTP 的不同方法（GET、POST、PUT、DELETE等）来访问和修改资源。客户端（如浏览器或移动应用程序）通过 URL 请求特定资源，然后服务器以 XML、JSON 或其他格式返回所需数据。\nRESTful API 的优点包括：\n1. 灵活性：RESTful API 使得客户端和服务器可以独立地演化和扩展，因此他们可以使用最适合自己的编程语言和工具。这种灵活性也使得 RESTful API 易于与新技术和平台集成。\n2. 可伸缩性：由于 RESTful API 的分布式本质，它可以轻松地扩展到处理大量请求和增加的数据负载。\n3. 可扩展性：RESTful API 的设计使得添加新资源和修改现有资源变得容易。它也使得实施新的功能和数据类型更加容易。\n4. 可靠性：RESTful API 使用 HTTP 安全协议，这意味着数据在传输过程中是受保护的，并且可以通过使用标准 HTTP 方法来减少网络流量和数据传输时间。\n5. 可移植性：由于 RESTful API 使用了标准的 HTTP 方法和 MIME 数据类型，它可以被几乎所有的开发平台和语言支持，并且它可以使用标准 Web 浏览器和网络工具进行测试和调试。\n总之，RESTful API 是一种基于 HTTP 协议的灵活、可扩展、可移植和可靠的架构，使得客户端和服务器之间的通信变得简单、可预测和易于理解。", "class": "open qa"}
{"question": "将下列一段文本翻译成中文：\nThe Mona Lisa is a 16th century portrait painted by Leonardo da Vinci.", "std_answer": "《蒙娜丽莎》是达芬奇在16世纪创作的一幅肖像画。", "class": "rewrite"}
{"question": "给我两个公司名，一个是制造商，一个是零售商。", "std_answer": "", "class": "brainstorming"}
{"question": "根据以下条件，为以下客户推荐最合适的产品。\n客户年龄：35岁；收入：10万美元/年；已婚，有两个孩子。", "std_answer": "", "class": "brainstorming"}
{"question": "回答以下问题：版权法是什么？为什么它很重要？", "std_answer": "版权法是一种法律制度，其目的是保护创作者的知识产权，确保他们可以获得对其作品的独有权利，并为此获得利益。这些作品包括文学、音乐、电影、电视节目、绘画、照片、软件等。\n版权法很重要的原因如下：\n1. 保护版权所有者的权利：版权所有者可以获得关于其作品的独有权利，这可以包括决定是否以及如何使用和传播他们的作品和获得收益。这些权利可以在商业和非商业上使用。\n2. 保护创造力和创新：版权法的另一个目的是鼓励创作和创新。通过给创作者提供保护，他们可以确保他们的努力不会被盗用或剽窃，这鼓励他们将更多的时间和精力投入到创作当中，并创造出更多高质量的作品。\n3. 保护消费者权益：版权法可以确保消费者得到高质量的作品，因为它们不会被没有授权的人进行修改或复制。这也可以使消费者更容易获得访问以前未发布的作品的权利。\n4. 为知识经济赋能：随着世界经济的发展，知识已成为重要的经济和贸易资产。版权法为这个经济提供了基础和保护，使得作品成为了一个可作价格的资产。它鼓励投资者和企业家利用知识产权来发掘新机遇、发展新产品和服务。\n总之，版权法是非常重要的，它不仅保护创作者的利益，而且也有助于促进创新和创造力的发展，增强消费者权益，同时为知识经济提供了保护，以利于全球经济的可持续发展。", "class": "open qa"}
{"question": "请总结以下对话。\n客户: 你好，我正在寻找一个设计师来设计我的新房子。你能帮我吗？\n房屋设计师: 当然可以。我们可以先讨论一下你的预算和你对这个房子的期望。\n客户: 我的预算是100万左右，我希望我的房子有四个卧室和三个浴室。我还想要一个开放式的厨房和客厅，以及一个带壁炉的起居室。\n设计师: 这听起来像是一个不错的计划。你是否有任何特别的要求，例如可以容纳多少人或者需要额外的储藏空间？\n客户: 我们的家庭有五口人，所以需要足够的空间。此外，我希望有一个带车库的车道，可以容纳两辆车。我还希望有一个带独立浴缸的主卧室套间。\n设计师: 我完全理解你的要求。我们可以为你设计一个非常实用且现代化的房子，以最大化你的生活质量。我们可以用一些高端的材料和设备来装修房子，以确保它的价值和可持续性。\n客户: 非常感谢你的建议。你有什么样的设计理念或者建议吗？\n设计师: 我们可以考虑使用一些环保的材料，例如太阳能电池板、可再生材料和高效能的隔热材料。我们还可以在客厅里添加一些大型的落地窗，以提供更好的自然光线和通风。我们可以设计一个现代化的开放式平面图，以最大化空间利用率和功能性。同时，我们还可以为您提供一些优美的景观设计，例如花园和水景。\n客户: 非常感谢你的建议和建议。听起来这将是一个非常完美的家园。我们期待着看到你的设计。", "std_answer": "该对话是一位客户在寻找一位房屋设计师来设计其新房子。设计师首先询问了客户的预算和期望，包括卧室、浴室、厨房、起居室、车库等要求。然后，设计师询问了任何特别的要求，例如家庭成员人数和额外的储藏空间。设计师建议使用环保材料、大型落地窗和现代化开放式平面图，以提高生活质量和空间利用率，并提供优美的景观设计。客户感谢设计师的建议和建议，并表示期待看到设计。", "class": "summarization"}
{"question": "提供五个拥有高质量音乐内容的在线音乐平台。", "std_answer": "", "class": "brainstorming"}
{"question": "提供一个公司简介，包括公司名称、使命、主要产品或服务以及其成功之处。", "std_answer": "", "class": "brainstorming"}
{"question": "为以下问题提供答案：\n你认为是否应该让学生在校内使用手机？", "std_answer": "是否应该允许学生在校内使用手机是一个备受争议的话题。有些人认为允许学生使用手机可以提高他们在学校中的表现，而其他人认为手机会对学习产生负面影响。在我看来，这个问题并没有简单的答案，它需要综合考虑许多因素。\n首先，让学生在校内使用手机可能会导致分心和注意力不集中。这是因为学生可能会习惯于时刻检查社交媒体、发送短信以及玩游戏，从而分散了他们的精力。这不仅会让他们错过重要的课堂内容，而且可能影响他们的学习成绩和未来的职业发展。\n其次，让学生在校内使用手机也可能有一些实际的问题。学生可能会不小心受到手机诈骗、欺诈和其他互联网风险的影响。他们可能会收到欺凌短信或其他不良信息。另外，手机可能会分散学生的关注力，使他们的社交技能减弱。\n但是，让学生在校内使用手机也有一些优点。首先，学生有时需要用手机进行紧急通信。例如，如果有紧急情况，他们可能需要通知家长或医生。其次，手机可以提供学生与教师之间的便捷沟通，学生可以随时发送疑问或请求帮助的短信或电子邮件给老师。\n最后，是否允许学生在校内使用手机还取决于具体情况。如果学校持续管理、监督和控制学生的手机使用，并提供良好的网络安全、保护学生隐私，那么学生使用手机的风险减少，其中一些问题可以得到缓解。\n综上所述，让学生在校内使用手机并没有简单的答案，需要充分考虑设施、家长、教师和学生的意见，以及有公正又平衡的监督和管理，以确保在需要时学生可以利用手机帮助他们，但不会影响他们的学习和安全。", "class": "open qa"}
{"question": "针对以下问题，提供您的个人意见和看法。\n您认为在学校里是否应该开设更多的艺术课程？", "std_answer": "", "class": "brainstorming"}
{"question": "回答以下问题：\n哪一种花色的扑克牌最多？", "std_answer": "标准扑克牌由52张牌组成，分为四种花色：黑桃（Spades）、红桃（Hearts）、方块（Diamonds）和梅花（Clubs）。\n每种花色都有13张牌，其中包括Ace、2、3、4、5、6、7、8、9、10、Jack、Queen和King。\n因此，每种花色都有13张牌，而扑克牌总共有4种花色，所以每种花色都有13张牌，共计52张牌。\n因此，每种花色的扑克牌数量相等，都为13张。所以答案是每种花色牌数一样多，没有任何一种花色的扑克牌最多。", "class": "open qa"}
{"question": "设计一款用于远程团队协作的应用程序，具有跨平台功能。", "std_answer": "", "class": "brainstorming"}
{"question": "编写python程序，查找特定的关键词，并返回与之相关的段落。\n文档是一份公司报告，共有100页，关键词为“收益”和“市场份额”。", "std_answer": "下面是一种简单的方法来编写程序，在给定的文档中查找特定的关键词，并返回与之相关的段落：\n1. 将文档加载到程序中。可以使用Python中的“open”函数打开文档，然后使用“read”函数读取所有文本。\n```python\nwith open('company_report.txt') as f:\n document = f.read()\n```\n2. 将文档分割为段落。可以使用Python中的“split”函数，以换行符（“\\n”）为分界符分割文本，得到一个段落列表。\n```python\nparagraphs = document.split('\\n')\n```\n3. 遍历每个段落，查找关键词。可以使用Python中的“in”关键字查找关键词是否存在于段落中，如果存在，则将该段落添加到结果列表中。\n```python\nresults = []\nfor paragraph in paragraphs:\n if '收益' in paragraph and '市场份额' in paragraph:\n results.append(paragraph)\n```\n4. 返回所有包含关键词的段落。可以使用Python中的“join”函数将结果列表中的段落合并为一个字符串，并在每个段落之间添加两个换行符作为分隔符。\n```python\nreturn '\n'.join(results)\n```\n完整的代码如下：\n```python\ndef find_paragraphs_with_keywords(document, keywords):\n paragraphs = document.split('\\n')\n results = []\n for paragraph in paragraphs:\n if all(keyword in paragraph for keyword in keywords):\n results.append(paragraph)\n return '\n'.join(results)\n \nwith open('company_report.txt') as f:\n document = f.read()\n \nkeywords = ['收益', '市场份额']\nresults = find_paragraphs_with_keywords(document, keywords)\nprint(results)\n```\n这个程序假设文档中的每个段落用换行符分隔。如果段落之间用其他字符或字符串分隔，则需要相应地修改代码。另外，还可以添加参数来控制结果中返回的段落数量等。", "class": "code"}
{"question": "回答以下问题。您应该写下推理步骤。\n如果小明有6颗糖果，他想分给他的朋友们。他有3个朋友，他想给每个朋友1颗糖果。他还有几颗糖果剩下来？", "std_answer": "根据问题描述，我们可以运用以下推理步骤来得出答案：\n1. 小明有6颗糖果。\n2. 小明有3个朋友。\n3. 小明想要给每个朋友1颗糖果。\n4. 如果小明给每个朋友1颗糖果，那么总共要分出3颗糖果（即1颗糖果 * 3个朋友）。\n5. 因此，小明剩下的糖果数量应该是6颗糖- 3颗糖 = 3颗糖。\n综上所述，小明还剩下3颗糖果。", "class": "math"}
{"question": "解释以下职业的社会刻板印象。\n医生", "std_answer": "医生是指熟悉医学理论和技术，并在医疗机构或私人诊所中提供医疗服务的专业人士。\n然而，社会上对医生的刻板印象往往包括以下几个方面:\n1.权威性：医生被认为是权威的代表，拥有高学历和专业技能，能够掌握其他人无法理解的专门知识和技术。因此，他们被视为在医学领域拥有极高的地位和威望。\n2.高收入：医生通常被视为一群高收入的职业人群，生活水平高且经济状况稳定。这是因为，医生所从事的工作需要接受高水平的教育和培训，且在实践过程中承担很高的风险，因此他们可以期待更高的薪酬。\n3.高压工作：医生面对着每天需要处理紧急情况和高压工作的压力。由于医生的工作直接涉及到人们的生命健康，这种职业需要医生保持极高的注意力和应急反应，即使在劳累和累人的工作日程下也要坚持。\n4.冷漠无情：与高威望的形象相反，医生被认为是冷漠无情的代表，因为他们的工作往往需要处理死亡和疾病问题。他们经常要面对痛苦和恐惧，这些情感压力可能导致医生产生疏离和冷淡的态度。\n5.医疗误诊：尽管医生的工作需要接受高水平的培训并且非常谨慎，然而在某些情况下，医生的医疗误诊问题Or不当行为，成为媒体报道焦点，强化了公众对此类事件的刻板印象。\n需要注意的是，这些印象并不一定适用于所有的医生，因为每个人都有自己独特的职业经验和专业背景。同时，适当的职业认知和理解也应该是双向的，即医生也应该了解公众趋向从医生那里寻求什么样的服务和建议。", "class": "open qa"}
{"question": "重新写下这段段落，100字以内，使其更简明易懂。\n对于每一个人来说，了解保险的知识都是非常重要的。保险的作用是为了帮助我们在不可预见的情况下，减轻我们所面临的风险和损失。无论是在道路上开车，还是在家中居住，甚至在经营企业时，保险都扮演了至关重要的角色。在道路上，汽车保险是必不可少的。它可以帮助您支付任何可能发生的车祸所造成的损失。您可以选择不同的保险计划，以满足您的个人需求和预算。例如，您可以选择全保险计划，它可以帮助您支付任何可能发生的事故，包括损坏，盗窃，甚至是自然灾害造成的损失。在家中居住，住房保险是必不可少的。它可以帮助您支付任何可能发生的火灾，地震，水灾等自然灾害造成的损失。此外，如果您的家中被盗，住房保险也可以帮助您支付任何可能的损失。在经营企业时，商业保险是必不可少的。它可以帮助您支付任何可能发生的商业损失，例如盗窃，自然灾害，责任事故等。除此之外，人寿保险也是非常重要的。它可以为您和您的家人提供长期的保障，并为您的家人提供财务保障，以应对您的不幸离去。无论您需要哪种类型的保险，我们的专业团队都将为您制定最佳计划，以满足您的特定需求和预算。在这个不确定的世界里，保险是您必不可少的一部分。与我们联系，让我们帮助您为您和您的家人提供安全保障。", "std_answer": "", "class": "rewrite"}
{"question": "编写一个python程序，将给定文本中的所有问句用问号分隔并输出。\n你知道Bob在哪里吗？他买了什么？他今天晚上在做什么？", "std_answer": "给定的文本是：\n你知道Bob在哪里吗？他买了什么？他今天晚上在做什么？\n我们可以通过简单的字符串操作，将问句用问号分隔并输出，代码如下：\n```python\ntext = \"你知道Bob在哪里吗？他买了什么？他今天晚上在做什么？\"\nquestions = text.split(\"？\") # 使用中文问号分隔\nfor q in questions:\n print(q + \"？\") # 输出时加上问号\n```\n运行结果：\n```\n你知道Bob在哪里吗？\n他买了什么？\n他今天晚上在做什么？\n```", "class": "code"}
{"question": "将英文文章翻译成中文，注意保持原文内容和风格。\nArticle: The benefits of meditation \nMeditation is a technique that has been practiced for centuries, and it has been shown to have many benefits for both the mind and body. Research has shown that meditation can reduce stress, lower blood pressure, and improve focus and concentration. It can also help with anxiety, depression, and insomnia. Some people use meditation as a tool for spiritual growth and self-discovery. Overall, meditation is a valuable practice that can improve overall well-being.", "std_answer": "文章：冥想的益处\n冥想是一种有数百年历史的技巧，已证明有许多对身心健康的好处。研究表明，冥想可以减轻压力，降低血压，提高注意力和集中力。它还可以帮助缓解焦虑、抑郁和失眠。有些人将冥想作为精神成长和自我发现的工具。总的来说，冥想是一种有价值的实践，可以提高整体健康状况。", "class": "rewrite"}
{"question": "为以下所述的课程设计教学大纲，该课程适用于第八年级学生。\n地理：小行星与太阳系", "std_answer": "", "class": "brainstorming"}
{"question": "回答以下数学问题。您应写出完整的解决方案。\n你有一个容量为3升和一个容量为5升的量杯，现在问你如何量出4升水。", "std_answer": "这道题目是一道著名的数学谜题，被称为“水壶问题”或“杯子问题”，可以用数学方法解决。\n1. 先倒满容量为5升的杯子，再将其倒入容量为3升的杯子中，此时容量为5升的杯子中还剩2升水。\n2. 接下来将容量为3升的杯子中的水倒掉，然后把5升杯子中的2升水倒入3升杯子中。\n3. 再将容量为5升的杯子重新倒满，然后将其中的一升水倒入已经有2升水的3升杯子中，此时容量为5升的杯子中还剩下4升水。\n因此，最终可以用这两个杯子测量出4升水。", "class": "math"}
{"question": "简述下面这段代码的功能：'for i in range(1, 11): print(i)'", "std_answer": "这段代码定义了一个 `for` 循环，它会在整数范围内迭代。在这种情况下， `range(1, 11)` 生成一个包含1到10的整数列表供循环使用，但不包括11。\n在每一次循环中，变量 `i` 存储当前的整数值。然后， `print()` 函数将 `i` 的值打印到控制台上，即在每次循环中打印从1到10的整数，包括1和10。\n所以，该代码的功能是打印出1到10的整数，包括1和10。输出将如下所示：\n```\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n```", "class": "code"}
{"question": "描述什么是区块链技术，以及它被广泛应用的领域。", "std_answer": "区块链技术是一种去中心化的数据库技术，它允许在不需要信任第三方的情况下，实现数据和价值的传递和交换。它的主要特点是数据的透明性、可审计性、不可篡改性和安全性。\n区块链技术通过将交易记录分发到网络中的许多节点上，并使用密码学技术对交易进行验证和加密，从而实现了去中心化的可信任系统。这个网络中的每个节点都维护着整个数据库的完整副本，因此，当一笔交易被记录在区块链上时，它将被广播到网络中的每个节点，从而实现了去信任的交易方式。\n区块链技术被广泛应用于许多领域，包括但不限于:\n1.数字货币：比特币是第一个成功应用区块链技术的数字货币，现在已经有许多其他的数字货币也在运用区块链技术。\n2.金融服务和银行业：区块链技术是银行、贸易、保险等金融领域中最广泛使用的技术之一。区块链可以帮助金融机构简化操作、降低成本、提高安全性，并提供更加高效的交易过程。\n3.物联网：区块链技术可以帮助设备间直接交互，从而创建一个更加安全和私密的物联网网络。\n4.医疗健康领域：区块链技术可以为医疗健康领域提供更加安全的病历记录、血统记录、药品管理和药品溯源等服务。\n5.社交网络和媒体公司：利用区块链技术可更好的保护用户数据和隐私，并帮助用户控制自己的数据和内容。\n6.政治和投票：区块链技术可以帮助选民更安全地将投票记录在可靠且透明的系统中，从而提高了选举的公正性和透明度。\n总之，区块链技术具有广泛的应用前景，正被越来越多的行业和领域所接受和采用。", "class": "open qa"}
{"question": "将以下文本翻译成英语。\n我看见国旗正在慢慢的向空中升起，国旗在风中迎风飘扬，大家都在唱着国歌。", "std_answer": "I saw that the national flag was slowly rising into the sky, the national flag was fluttering in the wind, and everyone was singing the national anthem.", "class": "rewrite"}
{"question": "将以下文字从英文翻译成中文：Natural language processing (NLP) is a field of computer science, artificial intelligence, and computational linguistics concerned with the interactions between computers and human languages.", "std_answer": "自然语言处理（NLP）是计算机科学、人工智能和计算语言学领域，关注计算机与人类语言之间的交互。", "class": "rewrite"}
{"question": "描述法国大革命的影响。", "std_answer": "法国大革命是世界历史上最重要的事件之一，它持续了从1789年到1799年的10年的时间。它彻底颠覆了当时的旧制度，将西方现代民主价值观的基础从思想层面上建立起来。\n以下是法国大革命对世界的影响：\n1. 民主政治的出现：法国大革命结束了君主制度的统治，并且带来了民主制度的新时代。法国大革命的成功传递了一个强烈的信息，那就是人民有权参与到政治决策中。这启发了其他国家要推行民主制度，如美国和英国。\n2. 人权意识的崛起：法国大革命提出了“自由、平等、博爱”的口号，这些口号强调了人的尊严和平等。这些概念得到了广泛的认可，并成为了全球人权运动的基础。因此，法国大革命被认为是全球人权运动的先驱。\n3. 框架内的革命：法国大革命不仅是一个社会政治的大变革，还是一个理念上的革命。那个时代里，约束个人行动的规则是固定的、铁的，但大革命揭示了这些规则是可以改变的，对社会文化的影响深远。法国大革命为人们提供了一种自我实现的自由和尊严，它推动了新自由主义和自由市场资本主义形成。\n4. 民族主义的兴起：法国大革命激发了民族主义思想在全球各地的兴起。在法国大革命之前，人们心中的欧洲联合优越于国家，当法国成为一个强大独立的民族国家后，欧洲的政治景象发生了巨变，崛起了别的民族国家。\n5. 物质文明的发展：法国大革命成功于17世纪的工业革命，并为自由市场经济奠定了基础。法国大革命让全国发动自我实现，其贡献了动力，探索了科学、技术和社会改革的美好前景，最终实现了经济繁荣和增长。\n法国大革命发生了两个世纪前，但它所产生的辐射还在继续，直到今天，在世界各地，法国大革命的理念词汇以及法国大革命的意义继续发挥巨大的影响，这种影响将会继续给世界人民带来正面的影响。", "class": "open qa"}
{"question": "请解释计算机网络中TCP和UDP协议之间的区别。", "std_answer": "TCP（传输控制协议）和UDP（用户数据报协议）是计算机网络中最常用的传输层协议。它们都用于将数据从一个应用程序传输到另一个应用程序，但它们在可靠性、速度和应用场景等方面存在区别。\nTCP是一种面向连接的协议，它通过在通信双方建立连接并持续跟踪数据包传输的状态，确保了数据传输的可靠性。TCP在传输数据之前使用三次握手建立连接，发送数据时使用序列号来标识每个数据包，接收方会发送确认消息确认接收，如果数据包丢失，TCP会重新发送该数据包，从而确保所有数据都被正确传输。TCP还可以进行拥塞控制和流量控制，以避免网络拥塞和过载。\nUDP则是一种无连接的协议，它不需要建立连接或维护状态跟踪，因此速度比TCP更快。UDP直接将数据包发送到目标，但不能保证数据包到达目标，也不能确保顺序，因此不适合传输大量数据或需要可靠传输的应用程序。UDP适用于实时应用程序，如视频和音频流，其中丢失一些数据包并不会对最终结果产生重大影响。\n总之，TCP和UDP具有不同的适用场景和特点。如果您需要保证数据的完整性和可靠性，应该使用TCP。如果您需要更快的速度和实时性，并且可以容忍一些数据包丢失，则应使用UDP。", "class": "open qa"}
{"question": "从以下选项中，选出不属于哺乳动物的动物。\n(a) 蛇\n(b) 河马\n(c) 豹子\n(d) 海豚", "std_answer": "答案是 (a) 蛇。\n蛇不属于哺乳动物，它属于爬行动物。爬行动物和哺乳动物都属于脊椎动物，但它们有很多不同之处。例如，蛇没有乳房，不能哺育幼崽。相比之下，哺乳动物通过产生乳汁来喂养他们的幼崽。\n(b) 河马，也称河马，是哺乳动物。它有四肢，身体肥胖，面部宽阔，属于草食性动物。\n(c) 豹子，也称黑豹，是哺乳动物。它是一种食肉动物，有四条强壮的腿和可伸缩的爪子。\n(d) 海豚也是哺乳动物。它属于鲸目动物的海豚科，是智商最高的动物之一。海豚有光滑的皮肤，善于展开他们的舵和各种花式跃出水面。", "class": "closed qa"}
{"question": "给出一个关于文化差异的例子，解释为什么差异是存在的。", "std_answer": "", "class": "brainstorming"}
{"question": "设计一个新产品并列出该产品的优点和缺点。", "std_answer": "", "class": "brainstorming"}
{"question": "给定一篇文章，为文章写一篇总结。《追风筝的人》这本畅销书的故事发生在阿富汗，以讲述一个阿富汗男孩与他的好友为主线。男孩与好友同龄，却来自两个不同的社会阶层，他们之间的友情超越了社会差异。男孩为了证明自己的勇气，在市集上追逐风筝，并赢得了胜利，但在这个胜利的过程中，他的好友发生了不幸的意外，永远改变了他们的人生。男孩长大后，他逃离了战争的阿富汗，并在美国开始了新的生活，但他内心深处一直承受着过去的痛苦和罪恶感。随着时间的推移，男孩回到阿富汗去寻找他对好友的痛苦的解脱，并希望能够用自己的力量改变那里的社会现实。《追风筝的人》不仅记录了一个男孩成长的故事，还从侧面描绘了阿富汗战争和社会现实的残酷。这本书向我们展示了友情与爱的珍贵，以及一个人如何在面对困境和挑战时保持希望和勇气，去寻求自我救赎和改变社会的责任感。", "std_answer": "《追风筝的人》是一本畅销书。 故事发生在阿富汗，主要是关于一个阿富汗男孩与他的好友的故事。", "class": "summarization"}
{"question": "描述一个完整的哈密尔顿回路是什么。", "std_answer": "哈密尔顿回路是从一个点出发，通过路径走遍图中所有点，并最终回到起点的一条路径。一个完整的哈密尔顿回路应包括以下几个特征：\n1.图：哈密尔顿回路所属的图，可以是有向图或无向图，但必须是连通图，即每两个点都有至少一条路径连接。\n2.起点：哈密尔顿回路开始的节点，即从哪个点出发开始遍历整个图。\n3.路径：连接起点和终点的路径，必须包括图中所有节点，且每个节点只被遍历一次，或者称为简单回路。\n4.终点：回路的最后一个节点，必须和起点重合，以形成完整的回路。\n所有的哈密尔顿回路都属于哈密尔顿图，即每个节点都有一条边与其相连。哈密尔顿回路是一种特殊的欧拉回路，即每条边只经过一次的回路。因此，哈密尔顿回路的存在性往往比欧拉回路更难证明。\n应用广泛，例如可以应用于以一个运货员为出发点将城市逐个遍历的旅行商问题。近年来，由于计算机算法的发展，我们能够在相对较短的时间内找到哈密尔顿回路，这对于解决复杂的问题有很大帮助。", "class": "open qa"}
{"question": "解释抽象概念“爱情”的意义和意味。", "std_answer": "爱情是一种抽象概念，通常被描述为强烈的情感和感情，可能包括亲近感、关心、支持、忠诚、尊重、信任和热情。它是一种人类关系的核心，可以表现为很多形式，例如亲密的个人关系，友谊，浪漫关系，家庭关系和社会联系。爱情是一种深刻的情感，与性、追求快乐、自我满足和承诺等概念有区别。\n爱情可以在不同的环境中有不同的意涵。它被广泛认为是人类生存和繁荣的必要条件之一，它能够让人们感到包容、相互尊重、给予关怀和支持，从而促进自我成长和发展。在爱情中，人们可以变得更为坦诚，更易于接受批评和反思自己，这能够帮助人们更好地与他人相处，并在个人和社会中实现更高的理想。\n然而，爱情也有它自身的挑战。它可能会产生失望、痛苦、嫉妒、恐惧和不满足等负面情绪，这些情绪可能会破坏人际关系。此外，爱情也经常受到文化、宗教、政治和社会背景等因素的影响，这些因素会塑造我们对爱情的看法、需求和期望，从而给我们带来矛盾和冲突。\n总的来说，爱情是一种强大而复杂的情感，它在个人和社会的层面上都具有重要的意义和福祉效应。然而，要真正理解这一概念，必须考虑到它的复杂性和多维性，从而在人际关系中实现最佳的平衡和发展。", "class": "open qa"}
{"question": "回答以下问题：发动机如何运转？", "std_answer": "发动机是一种内燃机，可以将能量转换成机械动力，以驱动车辆或机器。发动机通常由多个部件组成，包括气缸、活塞、曲轴、配气机构、燃油系统和点火系统等。\n发动机的运转过程可以分为四个步骤：吸气、压缩、燃烧和排放。\n第一步：吸气。在发动机进气道里，空气与燃油一起进入气缸内。这是由活塞的向下运动和气门的打开而实现的。\n第二步：压缩。活塞随后开始向上移动，将进入气缸内的混合气体压缩。这旨在创造一个可燃气体的混合区域，其中燃油和空气达到最佳比例。\n第三步：燃烧。当混合物被压缩到最小空间时，点火器开始产生火花，并在活塞靠近上止点时点燃混合物。这将产生一道爆炸性火焰，在气缸内部产生高压，将活塞推向下方。这便是发动机的主要推力输出。\n第四步：排放。最后，废气在活塞再次向上移动时，通过排气门被推出发动机。这个过程是由曲轴运转带动活塞完成的。\n这个过程一直不断地重复，从而使发动机源源不断地运行。同时，还需要燃油系统提供燃油和空气的混合物，和点火系统提供需要的点火和时间，以保证发动机的正常运转。\n综上所述，发动机的运转既快速又复杂。这需要各种精密的机械和电子部件的成功协同工作，才能产生可靠的高效能源。", "class": "open qa"}
{"question": "请描述以下主题的优缺点：在线学习。", "std_answer": "在线学习是一种通过互联网或其他数字技术来授课和学习的方式，通常涉及在线课程、学习管理系统和其他在线资源。该方法可以提供许多优点和缺点，如下所述：\n优点：\n1. 灵活性：在线学习允许学生根据自己的时间表自主学习，无需按照某个固定的时间表参加课程。这可以使学习的过程更加灵活和方便。\n2. 可访问性：在线学习可以让学生在全球范围内选择他们感兴趣的课程。学生不必为了参加课程而搬家或花费大量时间和金钱来旅行。这种方法还对那些身体上或身体上有残疾，不能前往传统的课堂教学的学生来说是一个可行的选择。\n3. 个性化学习经验：在线学习可以提供定制的学习经验，可以帮助学生专注于特定的学科或技能，并以最有效的方式学习知识。学习过程因人而异，在线课程可以为学生提供基于个人兴趣和需求的自定义课程。\n4. 成本效益：在线学习通常比传统课程便宜，因为它们不需要建立和维护大量的课堂和设施。学生也不必为交通、住宿和其他费用支付高额的费用。这可以使在线学习成为一种更具成本效益的选择。\n缺点：\n1. 缺乏面对面互动：在线学习通常无法提供传统课堂教学中的面对面互动。学生可能会因此感到孤独和缺乏社交支持，这可能会影响他们的学习体验和表现。\n2. 技术要求：在线学习需要一定的技术知识和设备，例如电脑、网络和软件，这些都要求学生能够轻松地访问和使用这些技术设备。\n3. 缺少监督和反馈：在线学习通常需要学生独立学习，缺乏实时的监督和反馈。这可能会导致学生采取不良的学习习惯，或不能及时发现和纠正自己的错误。\n4. 必须有自我驱动力：在线学习需要学生具有足够的自我驱动力。学生需要自主安排时间和计划，以保证学习进程的顺利进行。有些学生可能会因此而感到压力过大，或无法有效地管理时间。", "class": "open qa"}
{"question": "请提供至少5个社交媒体平台的名称。", "std_answer": "", "class": "brainstorming"}
{"question": "翻译给定的句子为中文。\n原文：It is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want of a wife.", "std_answer": "这是一条广为流传的真理，拥有丰厚财富的单身男子，必定需要一个妻子。", "class": "rewrite"}
{"question": "针对一家新餐厅，给出一个家庭套餐菜单。", "std_answer": "", "class": "brainstorming"}
{"question": "列举三种不同的口语表达方式，可以代替“我不知道”。", "std_answer": "", "class": "rewrite"}
{"question": "根据一段描述，给出一个人物的性格评价，并提供相关的证据。\n张三是一个善良、有爱心的人。在地震灾难发生后，他义无反顾地冲进了废墟中去搜寻受困的人们，并为他们提供帮助和鼓励。", "std_answer": "", "class": "brainstorming"}
{"question": "回答下列问题：为什么火车轮子是圆形的？", "std_answer": "火车轮子为圆形的主要原因是因为圆形形状的轮子在运行时可以提供更平稳的运动和更少的摩擦。以下是详细解释：\n1. 圆形的轮子使得火车可以保持平衡：当火车转弯时，所有车轮必须旋转以适应铁轨的曲线。这就需要轮子能够转动自由并灵活地改变方向。由于圆形的轮子在所有方向上都是一致的，因此它们可以更好地适应曲线轨道，这使得火车能够更容易地保持平衡。\n2. 圆形的轮子可以减少摩擦：当火车行驶时，车轮必须抵抗地面的摩擦力。如果车轮是平直形状，则一侧的轮子与地面的摩擦力会更高，这会导致车轮损坏和能源损失增加。相比之下，圆形的轮子可以均匀分布这种摩擦力。这使得轮子的行驶更加顺畅，从而减少了磨损和能源的浪费。\n3. 圆形的轮子减少了噪音和振动：火车的行驶会产生很多噪音和振动，这会对旅客和附近居民造成不便。圆形的轮子在行驶时更加平稳，可以减少车轮与铁轨之间的摩擦，进而减少振动和噪音的产生。\n总之，火车轮子是圆形的原因是因为这种形状可以使行驶更加平稳、减少能源的浪费和磨损、以及减少噪音和振动的产生。", "class": "open qa"}
{"question": "回答以下问题：如何使花朵更加鲜艳？", "std_answer": "要使花朵更加鲜艳，需要采取以下行动：\n1. 选用新鲜、优质的花材：选择健康、无虫害、没有受损的花，提供充足的养分、水分和阳光照射。\n2. 定期修剪：定期修剪会刺激花朵的生长，促进花的开放并使其更加健康。要注意花朵的类型，有些需要频繁剪枝，而有些需要保持原状。\n3. 恰当的浇水：不要让花受到过度或不足的浇水，要根据具体情况来浇水，通常情况下至少每周一次，并避免浇水到花朵上。\n4. 借助肥料：施肥可提供花朵所需的养分，使其保持鲜艳的颜色和茂盛的状态。然而应避免过度施肥，因为这可能会导致花朵过度生长或出现烧伤。\n5. 避免过度曝晒：有些植物可能会受到过度曝晒的影响，导致花朵变得苍白或褪色。因此，要在过度曝晒的情况下将花移动到阴凉的地方。\n6. 保持足够的空气流通：如果花受到任何形式的通风不良，容易受到外界的微生物感染，甚至会出现腐烂等问题。因此，需要保持适度的空气流通。\n总之，以上是使花更加鲜艳的一些方法，进一步了解植物学和相关技巧可能有助于更好地照顾和培育您所喜欢的花卉。", "class": "open qa"}
{"question": "询问国际货币基金组织的成立时间是什么时候？", "std_answer": "国际货币基金组织(IMF)成立于1944年，其官方成立日期为1945年12月27日。IMF的成立是根据布雷顿森林体系协议而实现的，布雷顿森林体系是一个旨在稳定国际货币体系的协议，旨在避免类似于第一次世界大战时期出现的金本位制度破裂导致的经济灾难。\nIMF的成立是为了解决战后复苏阶段出现的国际金融危机以及各国之间的贸易问题。它的主要职责是监管国际货币体系、支持国际贸易和援助国家在资金方面的问题。作为一家国际性组织，IMF的总部设在美国华盛顿特区，并拥有189个成员国。\nIMF实行的主要机制包括为成员国提供贷款、提供技术援助、制定国际货币政策和监督成员国的经济政策。同时，IMF在国际货币体系和全球金融体系中扮演着重要角色，它可以通过调整汇率和利率等手段来协调国际经济发展，并在全球金融危机时期提供额外的支持和援助。\n总之，IMF是一个旨在促进国际货币合作以及维护全球金融稳定的重要国际组织。", "class": "open qa"}
{"question": "假设你是一名电话销售人员，你需要向潜在客户推销一款保险产品。请列出一些可能用到的开场白和销售话术。", "std_answer": "", "class": "generation"}
{"question": "请下面这段英文文本翻译成中文。\nThere is no one who loves pain itself, who seeks after it and wants to have it, simply because it is pain.", "std_answer": "没有人爱上痛苦本身，主动寻求它，或者仅仅因为它是痛苦而想要拥有它。", "class": "rewrite"}
{"question": "将其翻译成中文。\nAt the end of the street, there was an old house with a large garden. The house had been abandoned for many years, and the garden was overgrown with weeds and ivy.", "std_answer": "在街道的尽头，有一座带大花园的老房子。这所房子已经废弃多年了，花园里长满了杂草和常春藤。", "class": "rewrite"}
{"question": "将英文电子邮件翻译成中文。\nDear John, Thank you for your email regarding the upcoming conference. Could you please provide more information on the topics being covered? Best regards, Emily", "std_answer": "亲爱的约翰，感谢您关于即将举行的会议的电子邮件。请问您是否能够提供更多有关论题方面的信息？最好的祝福，艾米丽", "class": "rewrite"}
{"question": "解释以下成语：\n意兴阑珊。", "std_answer": "意兴阑珊 (yì xìng lán shān) 意思是指意思或兴致到了某个程度，却因为某种原因而萎靡不振，没有继续下去的兴致。也可以形容一个人的创作没有灵感或进展，无法继续开展。", "class": "open qa"}
{"question": "根据所提供的文本，提取其中出现频率最高的三个名词，并计算出其出现次数。在这本小说中，主人公是一个名叫亚当的富有商人，他在城市中经营着一家成功的公司。他的事业很成功，他住在一座气派十足的豪宅里，拥有许多物质财富，但是他却感到自己的生活缺乏了什么。尽管他有一个美丽的妻子，但是他觉得自己在情感上非常孤独。他的妻子艾丽丝是一个出色的女人，她非常聪明、善良、美丽而且温柔。然而，她经常忙于自己的事业，只有在工作完成后才有时间陪伴丈夫。而且亚当经常出差，这使得他们的时间更加短缺。亚当发现，他的富有和地位并不能让他感到真正的满足和幸福。他开始思考人生的意义，他想找到一种能够让他感到真正快乐的方法。他试图在工作之余去寻找其他的爱好，例如读书、旅游、参加慈善活动等，但是这些活动并不能真正填补他内心的空虚。最终，亚当决定去寻找真正的爱情和情感上的满足。他开始在社交场合认识各种人，包括一些女性。尽管他有很多机会与其他女性发展感情，但他发现他们并不能让他感到真正的满足和幸福。最终，他明白了一个道理：真正的幸福和满足并不在于拥有更多的物质财富，而是在于拥有一个真正的爱人，能够分享生活中的点滴，一起经历生命中的各种挑战和美好的时刻。", "std_answer": "出现频率最高的三个名词分别是 \"亚当\"、\"生活\"和 \"爱人\"，分别出现了6次、5次和3次。", "class": "extract"}
{"question": "回答以下问题：如果一个人在亚洲和非洲之间旅行，他/她会穿越哪个洲际标志？", "std_answer": "如果一个人在亚洲和非洲之间旅行，他/她会穿越苏伊士运河。\n苏伊士运河位于埃及，连接红海和地中海。它是一个重要的国际航运通道，其中包括许多油轮和其他商船。运河是一条大约100英里（165公里）长的水道，是连接亚洲和非洲的重要纽带。\n当旅行者穿过苏伊士运河时，他们会穿过这个标志性的洲际标志，标志着他们离开亚洲进入非洲，或者离开非洲进入亚洲。这也是许多人将苏伊士运河当作“世界的十字路口”的原因之一。\n值得注意的是，虽然苏伊士运河是一个重要的洲际标志，但有时也被视为连接亚洲和非洲的一种环路，因为它不是在两个洲的具体边界线上。", "class": "open qa"}
{"question": "对以下五本书进行分类：\n《百年孤独》、《人类简史》、《时间简史》、《钢铁是怎样炼成的》、《三体》。", "std_answer": "以下是我对这五本书的分类：\n1. 文学作品：《百年孤独》\n《百年孤独》是加夫列尔·加西亚·马尔克斯的经典巨作，获得了普利策文学奖，是一部融合了神秘主义、现实主义和幻想主义的现代文学杰作。这本书以马孔多家族为主线，通过多代人的命运变迁和家族的历史，展现了拉丁美洲社会政治、历史、文化等各方面的风貌。因此，我认为这本书可以被归类为文学作品。\n2. 科普读物：《人类简史》、《时间简史》\n《人类简史》和《时间简史》都是由以色列历史学家尤瓦尔·赫拉利和英国理论物理学家史蒂芬·霍金所著的科普读物。《人类简史》探讨了人类文明的演进，从人类的进化、语言的发展到农业革命、宗教、科技和资本主义等方面具体论述了人类历史上的一些关键事件和概念。而《时间简史》则用平易近人的语言描述了一些前沿的物理理论，如爱因斯坦的相对论和黑洞理论等，用通俗易懂的方式为读者揭开了宇宙的奥秘。因此，我认为这两本书都可以归类为科普读物。\n3. 小说：《钢铁是怎样炼成的》、《三体》\n《钢铁是怎样炼成的》是苏联作家尤里·奥列维奇·安德烈耶夫的小说，是一部反映苏联工业化进程的现实主义小说。小说通过描述一个铸造厂的历史，生动地展现了从计划经济到市场经济转型的过程中，社会各阶层人物的命运和变化。而《三体》是中国科幻小说作家刘慈欣的代表作之一，该小说设定了一个外星文明与地球文明之间的互动故事，涉及到物理学、哲学和宇宙的多个方面。因此，我认为这两本书都可以被归类为小说。", "class": "classification"}
{"question": "翻译文本 - 翻译以下英文句子为汉语：\n One small step for man, one giant leap for mankind.", "std_answer": "个人的一小步，人类的一大步。", "class": "rewrite"}
{"question": "选择三种与食品相关的厨房电器，并描述它们各自的功能。", "std_answer": "", "class": "brainstorming"}
{"question": "列出5个你认为有趣的无人驾驶车辆应用场景。", "std_answer": "", "class": "brainstorming"}
{"question": "提供一份商业公司的SWOT分析报告，你可以选择任何一家公司。\n公司名：XXX；SWOT分析报告：\n- Strength: 公司创新能力强，拥有强大的品牌影响力；\n- Weakness: 公司市场份额萎缩，缺乏新市场开发能力；\n- Opportunity: 相关行业增长迅速，公司有机会进一步扩大市场份额；\n- Threats: 局部竞争加剧，大量新进入企业对公司造成挑战。", "std_answer": "", "class": "generation"}
{"question": "回答所给的开放问题，并尽可能提供详细的解释。\n沙漠中如何生存？", "std_answer": "", "class": "brainstorming"}
{"question": "从给定的文本中识别关键信息并提出相关的问题。\n这篇文章介绍了贝壳找房在中国的扩张过程和策略。其中的关键信息包括贝壳找房是一家互联网房产经纪公司，成立于2017年，并于2019年在美国上市。此外，它使用了人工智能技术来提高房源匹配和房产顾问的效率。", "std_answer": "", "class": "generation"}
{"question": "回答以下问题并提供一些详细的背景信息：\n我该怎样准备一份面试材料？", "std_answer": "在准备面试材料时，以下是您可以遵循的步骤：\n1.仔细阅读招聘公告或职位描述：首先，您需要仔细阅读公司的招聘公告或职位描述，以了解他们在寻找什么样的人才，并确定您是否符合这些要求。\n2.了解公司和行业：您应该尽可能了解公司的文化、愿景、使命和价值观，以及行业趋势和挑战。\n3.准备您的简历：仔细编写和审核您的简历，以确保它清晰、简洁明了，并突出您最重要的技能和经验。\n4.准备面试问题和答案：研究并准备回答可能的面试问题。您还可以编制问题，以了解有关公司和职位的更多信息。\n5.准备案例：提供能够展示您在过去工作中所学到的技能和经验的案例，这样您可以通过具体的实例展示您的能力。\n6.联系参考人：您应该询问一些可信赖的人是否愿意做您的参考人，并将其联系信息带到面试中。\n7.准备面试材料：根据您的职位和公司，可能需要准备不同的面试材料。例如，您可能需要带上您的工作样本、项目成果、证书和其他支持材料。\n8.熟悉面试流程：在面试前研究和熟悉公司和职位的面试流程，了解会面的人员并了解会议的时间和地点。\n总的来说，准备一份面试材料需要花费一些时间和精力。你应该尽可能了解公司和职位，并将你的技能和经验与招聘公告或职位描述相匹配。您还应该准备案例，以阐明您在过去的工作经历中所学到的技能和经验。最后，您应该熟悉面试过程并准备适当的材料。", "class": "open qa"}
{"question": "请分析说明下列历史事件：\n文艺复兴", "std_answer": "文艺复兴是一次从14世纪开始，从意大利迅速传播到欧洲的文化和知识复兴。在这一期间，人们对古希腊和古罗马文化的兴趣增加，科学、文学以及艺术也得到了前所未有的发展。\n以下是有关文艺复兴的一些重要事件：\n1. 莱昂·巴蒂斯塔·阿尔伯蒂（Leon Battista Alberti）于1404年至1472年之间发表了他的《建筑学》论文，建立了现代建筑学的基础。\n2. 文艺复兴时期的艺术家们对人体的认识更加深入，塞尔吉奥·达·里戈蒂（Sergio da Mercatello）是最早进行人体解剖学研究的医生之一，他的学生安德里亚·维泰利（Andrea Vesalius）出版了一部关于人体解剖学的重要著作。\n3. 在文艺复兴时期，欧洲的商业和贸易逐渐发展，促进了知识和文化的交流。意大利的佛罗伦萨、威尼斯、热那亚等城市是商业和文化的中心。\n4. 哥白尼和伽利略的天文学和物理学研究，成为文艺复兴时期最伟大的科学成就之一。哥白尼开创了以太心理学，在他的著作《天体运行论》中，首次提出了日心说科学理论。\n5. 威廉·莎士比亚是文艺复兴时期最伟大的文学家之一。他的作品《哈姆雷特》被认为是世界文学的顶峰之一。\n6. 文艺复兴的发展，也推动了宗教改革的兴起。马丁·路德发起了宗教改革的运动，反对天主教会的一些教义和实践。这场运动最终导致欧洲基督教的分裂，形成了新教和天主教两大教派。\n这些事件表明文艺复兴时期，艺术、科学、文化和宗教等各个领域都获得了巨大的进展和发展。这个时期对欧洲历史和文化发展产生了深远的影响。", "class": "open qa"}
{"question": "解释以下口号的含义：\n身体是革命的本钱。", "std_answer": "这个口号来自于20世纪中国的革命者毛泽东的思想。它的含义是指人们的身体健康和体能是实现革命胜利所必需的。这个口号可以被理解为一种强调身体锻炼、健康和良好体力状况的口号。\n正如毛泽东所说：“心情好，头脑灵，身体棒，干劲足。否则，脑子迟钝，做事没力气，容易生病，革命就要吃亏。” 这就是说了保持身体健康的重要性，身体好了才能够拥有精力去做事情。\n毛泽东用这个口号激励长征途中的红军战士坚韧不拔，是历史上一个著名的例子。在长征过程中，吃不饱穿不暖，面对困难和危险的情况下，红军战士们却能够坚持不懈，为了实现胜利而奋斗。而他们之所以能够做到这一点，部分原因是因为他们的身体状况得到了充分的重视和保护。\n在日常生活中，这个口号也提醒我们要注重身体健康。一个人如果身体状况不好，就会面临各种麻烦，甚至会影响日常工作的完成和生活的质量。因此，在日常生活中，我们应该养成良好的锻炼习惯，坚持符合身体状况的锻炼方式，保证充足的休息和足够的营养，这样才能更好地应对生活中的挑战。", "class": "open qa"}
{"question": "张伟（Z）、李婷（L）、王刚（W）\nZ：大家好，今天我们来讨论一下如何提高编程效率。首先，我想请教一下大家，你们平时在编程过程中遇到什么问题，导致效率降低？\nL：我觉得编程过程中最影响效率的是代码的可读性。如果代码结构不清晰，函数命名不明确，就会花费大量时间去理解代码逻辑。\nW：我同意李婷的看法。另外，我觉得代码重用性也很重要。如果每次都要写重复的代码，那么效率自然就会降低。\nZ：很好的观点。那么针对这些问题，我们应该采取什么措施来提高编程效率呢？\nL：为了提高代码的可读性，我们可以遵循一些编程规范，比如命名规范、注释规范等。同时，我们还可以使用一些工具，如代码美化工具，来帮助我们更好地组织代码。\nW：对于代码重用性，我们可以采用模块化的思想，将重复使用的功能封装成函数或类，这样就可以提高代码的复用性。另外，我们还可以使用版本控制工具，如Git，来管理代码，避免重复劳动。\nZ：很好。那我们接下来讨论一下如何在团队协作中提高编程效率。有什么建议吗？\nL：我认为代码审查是一个非常重要的环节。通过同事之间相互审查代码，可以发现潜在的问题，提高代码质量。同时，这也有助于团队成员之间共享经验，形成统一的编程规范。\nW：我觉得我们可以采用敏捷开发的方法，将项目划分为多个短期的迭代周期。每个周期内，团队成员可以紧密合作，快速响应需求变更，从而提高整体的开发效率。\nZ：非常好的建议！那我们就按照这些建议进行实践，共同努力提高编程效率。感谢大家参加今天的会议，我们下次再见！\n请总结以上对话中，每个人的观点。", "std_answer": "张伟（Z）：引入话题，询问编程过程中遇到的问题，以及如何提高编程效率，提出团队协作中的建议。\n李婷（L）：认为代码可读性对编程效率有很大影响，提出遵循编程规范和使用代码美化工具来提高代码可读性。在团队协作方面，提倡代码审查，以提高代码质量和团队成员之间的经验共享。\n王刚（W）：同意李婷的观点，并补充认为代码重用性也很重要，提议采用模块化思想和版本控制工具。在团队协作方面，建议采用敏捷开发方法，将项目划分为多个短期迭代周期以提高开发效率。", "class": "summarization"}
{"question": "请描述一下在过去和现在，儿童是如何上学的。", "std_answer": "在过去，儿童上学的方式因时代和地域而异。以下是一些关于儿童上学的历史背景：\n古代\n在早期的文明中，儿童通常是在家中或与家人一起被教育。一些古代文化重视教育，例如希腊、罗马和印度文化。在这些地方，年轻男孩通常只有家庭能够承担得起负担时，才会被送到学校受教育。在其他文化中，如古埃及文化，上学只是富裕家庭的特权。\n中世纪\n在中世纪，基督教教育非常重视，许多教堂学校和修道院学校在欧洲各地诞生。在这些学校里，学生们通常需要学习拉丁语以及神学、哲学和其他学科。\n文艺复兴和启蒙时期\n文艺复兴和启蒙时期是欧洲历史上的一段时期，出现了一些显著的教育变化。在意大利和荷兰，出现了一些类似于现代小学的学校，目的是为了向儿童提供基本的读写能力和计算能力。\n18世纪和19世纪\n在18世纪后期和19世纪，欧洲和美国出现了现代公立学校的概念。这些学校通常由政府资助，旨在为每个儿童提供教育，并使其适应社会。在这个时期，上学变得更加普遍，但仍然存在性别和种族歧视。\n20世纪至今\n随着全球文化的发展和技术的迅猛发展，儿童教育的方式也发生了巨大变化。现今，大多数国家都有义务教育法律，并建立了公立学校系统，许多私立学校也有机会。此外，联合国教科文组织促进了全球教育的发展，以消除教育差距和不平等现象。随着互联网技术的迅猛发展，在线教育和家庭学校也变得越来越普遍。\n总的来说，随着教育观念的变革和技术的进步，儿童上学的方式已经发生了巨大变化。虽然过去可能存在不平等和选择的问题，但现在有更多的机会和选项，为每个儿童提供受教育的机会。", "class": "open qa"}
{"question": "从以下选项中选择最佳答案。\n什么是数据挖掘？\nA.数据可视化\nB.数据分析\nC.数据库管理\nD.机器学习", "std_answer": "机器学习是数据挖掘的一种技术，因此D选项是最佳答案。\n数据挖掘涉及从大量数据中提取有用信息和模式的过程。它是在不同领域应用的一种技术，包括商业，医学，金融等。\n机器学习是数据挖掘中最常用的技术之一，它使用算法和数学模型来自动识别数据中的模式和规律。它利用计算机学习从数据中获得知识或经验，并在未来的数据中做出预测和决策。机器学习算法可以归为监督学习，无监督学习，半监督学习和强化学习。\n因此，数据挖掘不仅涉及数据可视化和数据分析，还包括使用机器学习算法从数据中提取有用的信息和模式。", "class": "closed qa"}
{"question": "叙述地球是如何运动的。", "std_answer": "地球是绕着太阳以近似圆形的轨道运动的。这个轨道被称为地球的公转。地球公转的周期为365.24天，这也是一年的长度。\n地球的公转运动是由万有引力定律控制的，这个定律由英国物理学家牛顿提出。太阳的质量和地球的质量以及它们之间的距离决定了地球围绕太阳的运动。大约每24小时，地球还会自转一次，绕着自己的轴心旋转。这个自转的运动引起了白天和黑夜的交替，对地球表面的气流和气候也有影响。\n地球的自转轴有一个倾斜角度，导致了季节的变化。当太阳照射到南半球时，北半球就是冬季；当太阳照射到北半球时，南半球就是冬季。这导致了大量不同种类的气候和生态系统，随着季节变换而不断变化。\n总的来说，地球的公转和自转运动是地球上发生的自然现象之一，也是我们了解日常生活和科学知识的重要方面。", "class": "open qa"}
{"question": "回答问题并解释原因：\n在大部分国家中，为什么必须在16岁以上才能获得驾照？", "std_answer": "在大部分国家中，必须年满16岁以上才能获得驾照的规定是源于以下原因：\n1. 性别和年龄限制: 在过去，驾车被认为是男性和成年人的专属领域。因此，为了反映这种观念，并防止年轻或不成熟的人在情绪或判断上受到过多的影响，年龄限制被设定为16岁或更高。\n2. 生理和认知限制： 驾车需要一定的身体和认知能力。这包括手眼协调能力、反应速度、注意力、空间感知和计划能力等。尤其是对于年轻人，他们的大脑和身体还没有完全发育，缺乏足够的成熟度和认知能力来应对驾驶危险。\n3. 保险和法律责任：在许多国家，开车需要保险和承担法律责任。青少年驾驶者往往缺乏驾驶和生活经验，因此，他们更容易发生事故，这可能导致高额的车险费用和法律诉讼费用。\n4. 暴露环境限制: 青少年通常缺乏驾驶机会和练习驾驶所需的时间和机会。他们可能没有自己的车，也没有家庭成员或朋友愿意给他们提供驾车机会。因此，许多国家规定年龄限制，以确保驾驶者在生活和驾驶经验方面具备足够的准备，以在驾驶环境中更加安全。\n综上所述，年龄限制是在保证驾驶者身心健康及驾驶知识技能成熟的前提下，对驾驶人员的安全和公共利益的考虑，也是许多国家制定的法规与规定。", "class": "open qa"}
{"question": "从给定的问题列表中筛选出与餐厅有关的问题。\n1. 为什么要学习数学？\n2. 如何安排适当的学习时间？\n3. 该怎么选好的餐厅？\n4. 什么是人工智能？", "std_answer": "3. 该怎么选好的餐厅？ 是与餐厅有关的问题。 \n解释：\n这个问题涉及到餐厅选择，包括餐厅的质量、价格、口味、服务等方面。选择一个好的餐厅可以让人吃得更愉快，同时避免遭受到不必要的麻烦和不满意的体验。", "class": "closed qa"}
{"question": "请你从下面的文段中提取出所有的数字，并按照从小到大的顺序排列。\n据数据显示，这座海拔超过8800米的山峰，被世人称为珠穆朗玛峰。这座位于尼泊尔与中国的边界上的山峰，不仅仅是全球海拔最高的山峰，也是世界上最难攀登的山峰之一。据统计，珠穆朗玛峰登顶成功率仅为30%左右，而每年尝试登顶的人数却高达数千人。为了攀登珠穆朗玛峰，登山者需要经历非常困难的登山路线。其中最著名的是从南坡进入珠峰大本营，全长约70公里。这条路线最大的难点是海拔高度，其中包括一段被称为“死亡地带”的路段，海拔高度超过8000米，氧气含量只有海平面的三分之一，非常危险。据悉，每年尝试登顶珠穆朗玛峰的人数高达5000人左右，其中有不少登山者因氧气不足、体力不支、天气突变等原因而死亡。除了高海拔，珠穆朗玛峰还有其他令人震惊的数字。比如，它的顶峰被冰雪覆盖的面积高达29000平方公里，约等于比利时的总面积；珠穆朗玛峰山脚下的人口密度非常低，尼泊尔境内海拔超过3000米的地区人口仅有不到50万人，而中国境内的藏区更是人迹罕至，仅有极少数的牧民在此生活。总的来说，珠穆朗玛峰是一个神秘而又充满挑战的地方，其海拔高度和自然景观吸引着众多冒险家和探险者前来挑战。然而，登顶珠穆朗玛峰的道路危机重重，需要极高的体力、勇气和耐心，才能够攀登成功。", "std_answer": "按照从小到大的顺序排列：3, 70, 3000, 5000, 30, 8000, 8800, 29000, 50,000.", "class": "extract"}
{"question": "使用陈述句描述如何解决以下问题：\n什么是无人机？", "std_answer": "无人机是一种可以通过遥控或预设路线自主飞行的机器人飞行器。它们可以在许多不同的方式中被使用，包括航空摄影，农业，环境监测，灾难响应，安全巡逻，物流运输等。无人机可以根据使用需求进行个性化设计，例如有些无人机拥有高度稳定技术可以精准的驾驶，而其他一些则可以携带载荷传送物品。\n在解释无人机的概念时，我们首先需要定义什么是机器人和飞行器，并将二者相结合。接着我们阐述它们如何被操纵，是通过远程遥控还是自主进行预设路线控制，并讲述无人机可以在哪些领域中应用。此外，我们还需要强调无人机个性化可定制的特性，使其更适应不同的使用需求。这样，我们可以给出一个全面的、准确的对于无人机概念的解释。", "class": "open qa"}
{"question": "为一份硕士申请撰写一封推荐信。\n姓名：王小明；专业：电子工程。", "std_answer": "", "class": "generation"}
{"question": "比较并总结三种不同款式的蓝色衬衫的优点和缺点：\n衣服款式1：牛仔衬衫，衣服款式2：法式衬衫，衣服款式3：T恤衫", "std_answer": "衣服款式1：牛仔衬衫\n优点：\n1. 耐用性强，牛仔面料通常比较厚实且耐用。\n2. 牛仔衬衫款式非常丰富，可以有不同的领型、袖型和剪裁方式等，非常适合搭配不同的服装造型。\n3. 可以在多种场合穿着，既可以穿到日常生活中，又可以穿在休闲或较为正式的场合。\n缺点：\n1. 肩部或领口不够柔软，有些款式的牛仔衬衫由于面料比较厚实，肩部或领口可能会感觉比较硬。\n2. 容易磨损（尤其是深色款式），牛仔衬衫容易受到磨损，特别是深色款式，需要更多的保养和保护。\n3. 不太适合在夏季穿着，牛仔衬衫的布料通常较重，因此在夏季天气较热时，可能会感到过于闷热。\n衣服款式2：法式衬衫\n优点：\n1. 非常适合正式场合穿着，法式衬衫的视觉效果非常清爽、干净，给人留下了正式、专业的印象。\n2. 剪裁更为优雅，法式衬衫有着非常优雅的剪裁方式，传统的法式衬衫廓形宽松，可以轻松配搭西装和裤装，以及更加正式的服装造型。\n3. 面料柔软，法式衬衫通常采用比较柔软和轻盈的面料制作，穿着起来特别舒适。\n缺点：\n1. 不是很适合作为日常着装，法式衬衫的形象过于正式，可能不适合在日常生活中穿着。\n2. 配色单一，相对于其他衬衫来说，法式衬衫的配色比较单一，一般以白色或浅蓝色为主。\n3. 可选择性较少，相对于其他衬衫来说，法式衬衫的种类和样式相对较少，不够丰富。\n衣服款式3：T恤衫\n优点：\n1. 轻便舒适，T恤衫的布料比较轻便，穿着舒适，非常适合在休闲场合、户外活动和运动中穿着。\n2. 款式丰富，T恤衫的款式和样式非常丰富，可以选择不同的颜色、图案和印刷方式等，搭配性强。\n3. 价格实惠，相较于其他衬衫，T恤衫的价格相对较低，可作为低成本选项来穿着。\n缺点：\n1. 穿着场合有限，T恤衫的穿着场合相对较为有限，只适合休闲、户外和运动等场合。在正式场合穿T恤衫可能会显得不够得体。\n2. 不够干净整洁，相较于其他衬衫，T恤衫的氛围比较休闲随意，适合于不需要显得过于正式和整洁的场合。\n3. 耐久性较差，相对于其他衬衫，T恤衫的面料通常比较容易损坏和磨损，需要更多的保养和保护。", "class": "open qa"}
{"question": "审查并编辑以下文章，使其语法正确并且通顺易懂。\n大家知道，作为辅助生殖方式之一，试管婴儿技术已经被广泛应用于世界各地，旨在帮助有生育问题的夫妻。", "std_answer": "", "class": "rewrite"}
{"question": "对给定的一段文本进行分类，判断它是新闻、评论还是广告。\n本周末，美国总统特朗普计划前往佛罗里达州进行竞选集会。", "std_answer": "根据这段文本，可以判断它属于新闻类别。下面是我分析的理由：\n1. 第一句话提到一个关于美国总统特朗普的行动：计划前往佛罗里达州进行竞选集会。这是一个新的、即将发生的事情，因此可以被归类为新闻类别。\n2. 没有任何倾向性：这段文本旨在传达事实信息，没有表达任何主观的情感态度或观点，也没有试图说服读者去支持或反对特朗普总统的决定。因此，可以排除评论或推广的可能性。\n综上所述，这段文本可以被归类为新闻类别。", "class": "classification"}
{"question": "解释一下哥白尼的日心说是什么，以及它如何影响我们对天文学的理解。", "std_answer": "哥白尼的日心说是一个天文学的假设，它于16世纪提出，代替了传统的地心说。在日心说中，太阳而不是地球是宇宙的中心，而行星包括地球则绕太阳以椭圆轨道运行。该观点由波兰天文学家尼古劳斯·哥白尼最先提出，但它在十七世纪中期才被接受。\n哥白尼的日心说对天文学和科学研究产生了重大影响。它首先挑战了传统主义者对中心论的认识，这导致人们更加开放的思考宇宙运行的方式。哥白尼的日心说证明了在天空中看到的一些现象可以用简单的科学法则解释与描述，使科学从迷信的黑暗时代走向了现代自然科学的时代。它促进了科学方法的使用和重视观察，或实验在科学研究中的地位。\n此外，日心说还有利于太阳系行星的运动，它能够更加准确地预测太阳和行星的位置、运动和距离。因此日心说通过简化和统一太阳系模型使观测和预测更容易。日心说还推动了望远镜的发展和使用，使科学家们能够进一步观察和探索宇宙。\n总的来说，哥白尼的日心说消除了以往宇宙观的错误、迷信，推动了科学、技术的进步，帮助科学逐步地发掘、揭示自然之谜，使天文学成为了研究之所长。", "class": "open qa"}
{"question": "生成可以与陌生人分享的三个生活小故事。", "std_answer": "", "class": "generation"}
{"question": "请从以下文本中抽取出物体属性：这款手表是一款非常轻巧的设计，戴起来几乎没有重量感，完全不会让人感到压迫或不适。同时，这款手表的绑带也非常容易调节，可以轻松适应不同大小的手腕，让你无需担心戴上去后过紧或过松的问题。除了这些舒适的特性，这款手表还具有许多其他的优点。它的表盘采用了最新的技术，可以清晰地显示时间、日期和其他的相关信息，而且还配备了多种功能，例如闹钟、秒表、计时器等，非常实用。另外，这款手表的设计也非常时尚，它的造型简约而不失优雅，无论是搭配休闲装还是正式服装都非常适合。无论是运动爱好者还是商务人士，这款手表都是一个绝佳的选择。它的轻巧和舒适性能够让你在各种场合轻松佩戴，同时其多种功能和时尚的设计也能满足你的各种需求。所以，如果你正在寻找一款高性能、时尚的手表，这款手表绝对是一个不错的选择。", "std_answer": "物体属性：\n轻巧\n舒适\n绑带易调节\n可适应不同大小的手腕\n表盘清晰\n可显示时间、日期和其他相关信息\n配备多种功能（例如闹钟、秒表、计时器等）\n时尚的设计\n简约而不失优雅", "class": "extract"}
{"question": "请问2019年中国猪肉价格同比上涨了多少？", "std_answer": "2019年中国猪肉价格同比上涨了约110%左右。\n2018年以来，中国即开始经历着猪瘟疫情的重创，以至于导致了大量的猪只死亡和出栏。同时，随着中国经济的快速发展以及越来越高的生活水平和消费质量要求，对于猪肉等肉类的需求持续高涨，使得猪肉价格持续上涨。这一情况一直持续至今。\n根据国家统计局发布的数据，2018年11月至2019年10月，中国居民消费价格同比上涨4.5%，而其中猪肉涨幅高达69.3%。具体来看，2019年1月份猪肉价格同比上涨了16.1%。随着春节临近，囤猪潮的逐步增多以及猪瘟持续影响，猪肉价格不断飙升。2019年11月，猪肉同比价格上涨了110.2%，较高点前相差近一倍。\n这一猪肉价格大涨现象对中国社会经济和民生带来较大的影响，不仅给人民生活带来了巨大的经济负担，也对国家的经济和稳定产生了影响。为此，中国政府也采取了一系列政策措施来稳定猪肉市场的供应和价格，并积极推进猪肉替代品的研发。", "class": "open qa"}
{"question": "解释泰坦尼克号沉没的原因。", "std_answer": "泰坦尼克号是一艘英国的邮轮，于1912年首航时在大西洋航行，但在不幸的事故中沉没。这场灾难造成1,500多人死亡，是现代历史上最严重的海难之一。以下是造成泰坦尼克号沉没的主要原因：\n1. 设计缺陷：泰坦尼克号被认为是不可沉的，但它的设计存在缺陷。它的船体被分成16个船舱，但它们之间只有短小的隔板，这导致如果其中几个舱室取水，它们不能隔水，水会流入其他舱室。\n2. 冲撞冰山：4月14日深夜，泰坦尼克号在大西洋航行时撞上了一座巨大的冰山。这个结冰的巨块撞向了船体的右侧，造成了约100米的划痕。这个划痕引起了多个船舱的破损，迅速开始进水。\n3. 缺乏足够的救生艇：救生艇的数量是泰坦尼克号上的一项严重问题。尽管船上有生命舱，但它们只能保存很少的人，并不足以救所有人。在撤离船舱时，船员们错失了多个救生艇，并且没有足够的时间把所有人都安全地运离船舱。\n4. 人员疏忽：船员和船长也承担了泰坦尼克号沉没的责任。许多人没有足够重视局势，船员们没有立即采取行动，船长也没有发出撤离指令。一些船员甚至不了解如何使用逃生设备，没有向乘客提供逃生指南。\n尽管这些因素中的每一个都可能造成灾难，但是联合在一起造成了泰坦尼克号沉没。这次悲剧迎来了全球的关注，触发了50多年来对船舶安全的一系列改进措施。", "class": "open qa"}
{"question": "解释创建一个比较两个不同数据库类型的数据库的基本步骤。", "std_answer": "创建一个比较两个不同数据库类型（如SQL和NoSQL）的数据库的基本步骤如下：\n1. 确定比较目的：首先需要明确比较的目的，是为了选择一个更适合特定应用程序的数据库类型，还是为了了解两种数据库类型之间的不同。\n2. 确定比较的参数：确定用于比较两种数据库类型的参数。例如，可以比较性能、可伸缩性、数据一致性、安全性、支持的数据结构和查询选项等。\n3. 创建测试用例：创建测试用例来评估每个参数和数据库类型的不同。测试用例应该代表实际应用程序的使用情况，并且需要考虑到不同的负载情况和使用模式。\n4. 准备测试环境：为每个数据库类型设置测试环境，并确保每个环境在相同的硬件和软件配置下运行。例如，可以在不同的服务器上安装两种数据库类型，并使用相同的测试数据集和查询设置。\n5. 运行测试用例：执行测试用例，并记录每个参数的结果。可以使用自动化工具来执行测试用例，并记录性能指标等详细信息。\n6. 分析测试结果：分析测试结果，并比较两种数据库类型在不同参数上的性能表现。例如，可以比较查询响应时间、吞吐量、并发性能等。\n7. 提出结论：综合以上测试结果和分析，得出关于两种数据库类型的结论。如果比较的目的是为了选择一个更适合特定应用程序的数据库类型，那么应该选择最符合该应用程序需求的数据库类型。\n总的来说，通过以上步骤，我们可以深入了解不同类型数据库的特点和优缺点，以便更好地选择和使用适合的数据库类型。", "class": "open qa"}
{"question": "请描述大蒜在中国历史和文化中的重要性。", "std_answer": "大蒜在中国历史和文化中有着重要的地位和作用。以下是一些关于大蒜在中国的历史和文化中的重要性的详细说明：\n1. 营养价值：大蒜不仅具有独特的味道和香气，还具有高营养价值。它富含维生素C、B6和锌，可以增强免疫系统，预防感冒和其他疾病。\n2. 草药治疗：在中国的传统医学中，大蒜被广泛用于治疗许多疾病。它被认为具有抗菌和抗病毒作用，可以治疗感冒、支气管炎、肺炎和其他呼吸道疾病。它也有助于降低血压、血脂和血糖水平，并对心血管健康有益。\n3. 美食文化：大蒜在中国的美食文化中也扮演着重要的角色。它被广泛用于调味菜肴，加强口味和风味。例如，在中国北方的菜肴中，大蒜是一个非常常见的调味料，它可以用于烹饪肉类和蔬菜。\n4. 历史传承：在中国历史上，大蒜也被广泛使用。在古代，它被用来治疗和预防疾病，同时也被认为有妖魔驱散和祛邪避灾的作用。在中国传统文化中，大蒜也被视为神奇的植物，具有很高的价值和信仰力。\n5. 民间传说：在中国的民间传说中，大蒜被认为是镇压吸血鬼和鬼魂的有效工具。人们相信，吸血鬼和鬼魂会被大蒜的味道所驱逐，因此人们会在房屋门窗、水罐和床边挂上大蒜，以保护自己和家人的安全。\n总的来说，大蒜在中国的历史和文化中具有广泛的应用和意义，既是一种有益的草药，也是美食文化的重要组成部分和民间信仰的象征。", "class": "open qa"}
{"question": "请将以下文章中的每一段落更改为批判性思维。\n虽然这种新型防晒霜听起来很不错，但是我们仍需要更多的研究来确定它的有效性。只有一项研究不能证明它的功效。此外，这种新型防晒霜也可能会引起皮肤敏感或其他问题。因此，我们需要更多的研究来确定使用它的安全性和有效性。", "std_answer": "", "class": "rewrite"}
{"question": "使用下列关键字编写一段议论文：\n体罚赛马", "std_answer": "", "class": "generation"}
{"question": "请根据以下提示，对一段话进行改写。\n性格是人的稳定性格，它与环境和遗传因素都有关。", "std_answer": "", "class": "rewrite"}
{"question": "对于文本中的所有数字，将它们转换为文字形式。例如，将2转换为'二'。\n李丽的年薪是2500000美元。", "std_answer": "", "class": "rewrite"}
{"question": "对于一个银行账户，创建一个密码应该遵循哪些规则？", "std_answer": "创建一个银行账户密码时，你应该遵循以下规则：\n1. 使密码足够长：至少要使用8个字符的密码。一个更长的密码会变得更强壮，因为更长的密码会使破解时间变得更加困难。\n2. 使用复杂的密码：你应该使用混合字母、数字和符号的密码。这样可以确保密码更为复杂和难以破解。\n3. 不要使用与账户信息相关的信息：避免使用账户信息、手机号码或生日等与你账户相关的信息作为密码。这种类型的密码是很容易被黑客猜测的，因为他们可以在许多途径上追踪到这些信息。\n4. 定期更新密码：如果你已经使用了一段时间的密码，那么你应该定期（推荐每三个月）更新密码。这将确保你的账户不受到黑客的攻击。\n5. 不要重复使用密码：使用同一个密码在多个网站或账户中是不安全的。因为如果一个黑客已经破解了你的密码，他们可以在其他账户中使用相同的密码登录你的账户。\n6. 使用密码管理器：使用密码管理器可以使你更容易创建和管理复杂的密码。密码管理器可以随机生成密码并将它们储存在加密的数据库中，以便在将来登录时使用。\n总之，银行账户密码应该是长而强壮，复杂而不易猜测，并且定期更换。同时，不要在多个账户中重复使用相同的密码。使用密码管理器可以帮助你管理你的密码。", "class": "open qa"}
{"question": "根据提供的提示，重新写一段话，使其更加简明扼要。\n因为他们需要多种技能，所以很难找到这样一群人。", "std_answer": "", "class": "rewrite"}
{"question": "根据英文文本翻译成汉语，并尽可能保持原文的风格和意思。\nThe greatest glory in living lies not in never falling, but in rising every time we fall.", "std_answer": "生命中最伟大的荣耀并不在于从未跌倒，而是每次跌倒之后能够重新站起来。", "class": "rewrite"}
{"question": "给定一段文本，将与主题不相关的句子删除。\n原文段落：在海尔公司，我们始终坚持以用户价值为中心的服务理念。这就是我们与众不同的地方。我们不只是在卖产品，我们更注重为用户的满意度提供专业贴心的售后服务。此外，我们还在不断创新，推出更加高效、智能的智能家电产品，让用户的生活更加便捷。但是，我们的发展过程中也曾遇到困难。比如，某些销售人员出现了不诚信行为，向用户隐瞒产品质量问题。这种行为不仅违反了企业规范，也伤害了用户利益。", "std_answer": "", "class": "rewrite"}
{"question": "给我列举一些具有创造力的工作岗位。", "std_answer": "", "class": "brainstorming"}
{"question": "请问儿童图书分类中，哪一类书在国内销量最高？请给出相应统计数据。", "std_answer": "儿童图书是指面向儿童的图书，通常被归为儿童文学。根据分类标准的不同，儿童图书可以分为很多类别，比如分年龄段分类（如0-3岁，3-6岁，6-9岁等）、分主题分类（如故事类、科普类、诗歌类等）等。其中，在国内销量最高的儿童图书分类是比较难以确定的，因为它涉及多个方面，例如年龄段、出版社、作家、推广和宣传等等。\n不过，根据近期的市场分析报告，可以知道在国内儿童图书市场中，最受欢迎的类别之一是绘本类。绘本是指以图为主，图文并茂的书籍，其读者面向0-6岁儿童。绘本是儿童文学中的一类，相比于其他类型的书，绘本的特点是图文并茂，寓教于乐，读起来更为亲切、生动有趣。绘本类图书涉及到的主题非常广泛，比如自然界、人物传记、艺术、科技等等。\n根据中国图书市场行情分析师介绍，自2018年起，绘本类图书销售额已经连续三年位居中国儿童图书榜单销售之首。2021年上半年，绘本类图书销售额增长了7.04%。这充分说明了绘本类图书在国内儿童图书市场中的地位和影响。\n值得一提的是，并非所有的绘本都能迅速打开市场。市场上成功绘本品牌不仅在内容上有特色、画风新颖，更重要的是有与之相匹配的产品线和宣传促销力度。\n总的来说，虽然在国内的儿童图书市场中，随着经济发展和教育水平提高，各类儿童图书都受到一定程度的欢迎，但据目前市场数据分析，绘本类图书是目前销量最高的儿童图书分类之一。", "class": "open qa"}
{"question": "描述以下电视剧的悬疑情节。\n《权力的游戏》", "std_answer": "《权力的游戏》是一个充满悬疑的史诗性幻想电视剧。以下是其中一些最为引人注目的悬疑情节：\n1. 雪诺的出身：在本剧第一季中，我们被引入了围绕琼恩·雪诺的悬疑。雪诺是一位可爱的年轻人，但他的来历却是不清楚的。我们的主人公和观众都无法得知雪诺的真正身份，直到第六季的结尾揭晓，揭示了一个令人震惊的真相。\n2. 谁是琼恩·艾林？在第一季中，我们也遇到了一个名为琼恩·艾林的人。观众被引导去思考琼恩·艾林是谁以及他的意图。琼恩·艾林最终被揭示为是在伊利莎白港的一个化名，他是为了抵御一支野蛮人军队而动员临时军队的人。\n3. 史塔克家族的命运：《权力的游戏》充满了关于史塔克家族命运的悬疑情节。从妮莎·史塔克的神秘死亡和她儿子布兰·史塔克的非凡超能力到艾德·史塔克在调查变异人的死亡时的神秘消失，每一个情节都让人猜测下一步会是什么。\n4. 三眼渡鸦：通过布兰的视角，观众发现三眼渡鸦有着强大的力量。这些神秘的生物可以看到时间和空间之外的东西，包括过去和未来。这使他们成为了一个神秘，令人兴奋的成分，同时也增加了许多悬念和谜团。\n5. 龙的性命：权力的游戏中充满着与龙有关的悬念和秘密，这是一个古老的神话极大地影响了《权力的游戏》剧情。观众们正在努力揭开龙的贤者之石式的秘密，而该系列的创作者让这一切变得更加复杂，通过引入诸如龙石岛和龙深渊之类的组织来增加深度。\n总之，《权力的游戏》以其大量的悬疑情节和意外的剧情转折而成为了一个塑造复杂世界的范例，这使得观众时刻都保持着警惕状态，永远无法确定最终会发生什么。", "class": "open qa"}
{"question": "从以下文本中抽取有关天气的信息：据当地气象部门的最新数据显示，北京时间X月X日稍晚，哈尔滨市将迎来一次大风天气，这也引起了市民们的关注。根据气象部门发布的消息，该市区将有6级到7级的大风，伴随着扬沙或浮尘天气。这种情况下，人们应当注意防范大风带来的不利影响，如出行时应注意防范被飞沙或飞尘的侵袭，同时也要注意防范树枝、广告牌等高空物品被大风吹倒的可能性。为了保障市民的安全，当地政府已经启动了相关的应急预案，并呼吁市民们要密切关注气象部门发布的天气预警信息，及时做好防风、防沙措施，减少不必要的出行，确保自己和家人的生命安全。同时，政府也在加强城市环境卫生工作，确保城市内的道路、广场等公共场所能够及时清理，保持干净整洁的环境。相信在政府和市民共同的努力下，这场大风天气也不会对当地的正常生活和工作造成太大的影响。", "std_answer": "有关天气的信息：\n大风天气\n时间：X月X日稍晚\n风力：6级到7级\n大风伴随扬沙或浮尘天气\n提醒人们注意防范大风带来的不利影响\n呼吁市民密切关注气象部门发布的天气预警信息\n加强城市环境卫生工作，确保城市内的道路、广场等公共场所能够及时清理，保持干净整洁的环境。", "class": "extract"}
{"question": "问答任务：\n香蕉能不能当早餐吃？", "std_answer": "香蕉完全可以作为早餐的一部分来食用，并且在许多情况下是一个很好的选择。以下是为什么香蕉是一个不错的早餐食品的原因：\n1. 香蕉是营养丰富的食物——它们富含多种维生素和矿物质，如维生素C、维生素B6、钾、镁和纤维素。它们还含有少量蛋白质和脂肪，使其成为健康而均衡的早餐的一部分。\n2. 香蕉是易于消化的——相对于其他高纤维食品，香蕉的纤维素含量较低，也更容易消化。这意味着香蕉在早上可以更容易的被身体吸收利用，不太可能导致胃部不适或消化不良。\n3. 香蕉还是快速便捷的早餐选择——香蕉作为一个“手持式”食品是非常方便的，它们不需要切割或加工，也不需要额外的烹饪时间。这使得它们成为早上“抓起来就走”的快速早餐的完美选择。\n然而，需要注意的是，香蕉不能成为一顿完整的早餐。将香蕉作为早餐的一部分需要搭配其他食物一起食用，以确保摄入充足和均衡的营养。也就是说，如果您选择以香蕉作为早餐的一部分，最好搭配一些蛋白质和健康脂肪，例如燕麦、坚果或酸奶。这样搭配就能更好的平衡营养，让早餐更加营养丰富，满足身体所需。", "class": "open qa"}
{"question": "根据给出的示例和指导原则，编辑一份比较优秀的论文。\n给定的指导原则：1.使用简单、清晰的语言；2.避免长句；3.避免使用过于主观的描述。", "std_answer": "", "class": "generation"}
{"question": "请根据以下文本撰写一份新闻稿。\n上海迪士尼乐园将于本月29日正式开放一个全新的主题区域——星球大战：银河边缘。该区域将再现星球大战系列电影中的经典场景，包括著名的超级巨型星际战舰、漫游沙漠星球塔图因等。此外，该区域还将有以《曼达洛人》为灵感的全新互动体验。", "std_answer": "", "class": "generation"}
{"question": "分析以下公司的财务状况，提出建议：\n公司A的收入在过去一年持续增长，但其成本也在同期增长，导致净利润未能增长。", "std_answer": "根据提供的信息，公司A在过去一年内经历了收入增长但净利润未能增长的情况。这可能是由于成本持续增长所致。下面是分析公司财务状况的建议：\n1.分析成本结构：公司应该对其成本结构进行更深入的分析，特别是需要检查哪些成本导致了成本的增长。这将有助于公司了解哪些方面需要改进。\n2.考虑减少固定成本：固定成本是公司每个月都必须支付的费用，例如房租和员工工资。如果这些费用超过了公司收入的增长，那么公司的净利润将受到影响。为了减少这些成本，公司可以采取措施，例如协商房租减免，减少过多员工工作时间等。\n3.优化供应链：公司可以考虑优化其供应链，以降低采购成本。这包括与供应商进行协商，寻找新的供应商，优化采购流程等。\n4.削减不必要的开支：公司还可以削减不必要的开支。这可能是一些无关紧要的费用，例如不必要的商务旅行或订阅服务等。\n5.增加收入来源：除了降低成本，公司还可以考虑增加收入来源。这可能包括尝试销售新产品或服务，拓展业务渠道等。\n综上所述，要改善公司A的财务状况，公司应该深入分析成本结构，减少固定成本，优化供应链，削减不必要的开支，同时寻找增加收入的机会。这些措施将帮助公司提高净利润，实现可持续的增长。", "class": "open qa"}
{"question": "基于给定的文本和问题，提供文本的答案。\n文本：科学家们发现，大约有80%的人经历过雪茄形毒素中毒，而不自知，其症状包括头痛、视力模糊和呕吐等。\n问题：雪茄形毒素中毒的症状是什么？", "std_answer": "雪茄形毒素中毒的症状包括头痛、视力模糊和呕吐等。\n据科学家们的研究表明，大约有80%的人曾经经历过雪茄形毒素中毒，但可能没有自知。这些症状可能在接触雪茄形毒素后数小时或数天后出现，具体时间取决于暴露的剂量以及个体的敏感程度。因此，如果有这些症状的人曾经接触过雪茄形毒素，应该意识到他们可能已经有中毒的风险，并寻求医疗帮助来确诊和治疗中毒。", "class": "closed qa"}
{"question": "填写一个短文：我的未来职业规划。", "std_answer": "", "class": "generation"}
{"question": "写出在进行秋季户外活动时需要注意的十条安全小贴士。", "std_answer": "", "class": "generation"}
{"question": "请回答以下问题。\n猴子能不能站在长颈鹿的头上？", "std_answer": "猴子可以站在长颈鹿的头上，但具体取决于长颈鹿的大小和猴子的重量。\n长颈鹿是世界上最高的陆生动物之一，其颈部长度可以达到2-2.4米。而猴子的种类有很多，它们的大小和重量差异也很大。一些小型猴子，例如松鼠猴和狨猴的重量大约为1-2千克。而大型的猴子，例如黑猩猩和猕猴，其重量可以达到60-70千克不等。\n因此，如果猴子的重量适中，且能够找到一个适合猴子站立的长颈鹿头部平台，猴子是可以站在长颈鹿的头上的。但是，这种情况在自然界中可能不太常见，因为长颈鹿通常不是猴子的栖息地，猴子对于要站立的平台需要非常敏锐的感知和细致的判断能力。\n此外，猴子站在长颈鹿头上的行为是一种罕见的异常行为，且可能会对长颈鹿产生压力和不适。所以即使发生这种情况，我们也应该警觉保护动物和生物多样性，尤其是生态研究专家和拍摄人员需要谨慎使用这种方式获取数据或拍摄照片。", "class": "open qa"}
{"question": "回答以下问题。\n为什么洛杉矶被称为天使之城？", "std_answer": "洛杉矶是美国加利福尼亚州南部的一座城市，被称为“天使之城”，有以下几个原因：\n1. 传统的起源：洛杉矶的“天使之城”之名最早可追溯到18世纪末，当时该地区被西班牙探险家加利福尼亚眼科医生帕布罗·塞拉，以及圣加布里埃尔·阿奎纳·圣塞拉教士们称为“El Pueblo de Nuestra Señora la Reina de los Ángeles de Porciúncula”，即“我们的圣母天后之城”，简称“Los Angeles”（天使），因此洛杉矶的“天使之城”之称具有传承性和历史文化的背景。\n2. 宗教的象征：天使是圣经中的精神使者，常常被描绘成翼展的天使，传统上象征着慈悲、宽恕和神圣降福。作为美国西海岸最大的天主教堂之一的洛杉矶天主教大教堂，以及其他许多基督教和非基督教宗教场所，都在此传递着这个象征性的语境。\n3. 艺术和文化：洛杉矶是美国文化中心之一，拥有广泛的艺术和文化活动。在1984年夏季奥林匹克运动会期间，为了突显洛杉矶的特色和历史背景，松林庄园内的14尊天使雕像被标上不同的号码，每个号码都代表一个运动项目。自那以后，天使成为洛杉矶独特的艺术和文化象征之一，称为“天使之城”。\n4. 电影和娱乐业：洛杉矶是好莱坞电影的中心，在电影业和娱乐业中扮演着主要的角色。许多电影和电视作品都以洛杉矶为背景，这些作品也在全球范围内传播着洛杉矶的文化特征和地标。\n因此，总的来说，洛杉矶被称为“天使之城”，不仅是因为它的历史渊源和宗教象征，也因为它在艺术、文化和娱乐领域的影响力。", "class": "open qa"}
{"question": "阅读以下短文，并回答问题：\n“人生就像一盒巧克力，你永远不知道下一颗是什么。”这句话出自哪部电影？", "std_answer": "这句话来自于1994年上映的电影《阿甘正传》（Forrest Gump）。\n电影讲述了一个智商不足但心地善良的阿甘（Forrest Gump）从小镇男孩到越战英雄再到亿万富豪的传奇经历。这句著名的台词是由阿甘母亲告诉他的：“生活就像一盒巧克力，你永远不知道下一颗是什么。”\n这句台词的意思是说，生活像一盒巧克力，每颗巧克力都不同，你永远不知道下一颗巧克力是什么味道。同样地，生活中的每一刻都是新的，有时充满惊喜，有时则会让你失望。人不能预测未来，但却可以承担风险并享受生命的旅程。\n这句话成为了电影《阿甘正传》的标志性语言，也因为这个经典的比喻，让人们更好的理解生命的不确定性以及生活的美好。", "class": "open qa"}
{"question": "根据以下文本，回答以下问题：帕瑞夫和邦尼·班尼领导了什么类型的运动？\n帕瑞夫和邦尼·班尼领导了一个名为“为了科学和理性”的反疫苗运动，这个运动旨在反对接种疫苗的做法。他们声称，疫苗是危险的，并且会导致各种疾病和不良反应，包括自闭症和神经系统疾病。然而，这些声称并没有得到科学界的广泛认可和支持。大多数专家认为，疫苗是预防传染病最有效的方式之一，而且接种疫苗是保护个人和社区免受疾病侵害的最佳途径之一。事实上，由于接种疫苗的广泛普及，一些传染病已经被消灭或大大减少了发病率。虽然帕瑞夫和邦尼·班尼的反疫苗运动在某些社区中获得了一定的支持，但大多数人仍然认为接种疫苗是必要的和正确的做法。政府和卫生机构也一直在积极推广疫苗接种，以保护公众的健康和安全。", "std_answer": "帕瑞夫和邦尼·班尼领导了一个反疫苗运动，这个运动旨在反对接种疫苗的做法。他们声称疫苗是危险的，并且会导致各种疾病和不良反应，包括自闭症和神经系统疾病。", "class": "closed qa"}
{"question": "根据给定的例子，为一个人物设计一个人物档案。\n请为一个叫做“李华”的14岁男孩设计一个人物档案。他是一个学校的游泳队队员，喜欢读书和打电子游戏。", "std_answer": "", "class": "rewrite"}
{"question": "在10分钟内生产出5个创意网站名称。", "std_answer": "", "class": "brainstorming"}
{"question": "为以下问题提供解答：颠簸的乘车经验可能导致什么？", "std_answer": "颠簸的乘车经验可能会导致以下几种问题：\n1. 肌肉疲劳和疼痛：颠簸的乘车经验可能会让乘客的肌肉处于不断地张力和松弛之间，从而导致肌肉疲劳和疼痛。\n2. 头痛：颠簸会让头部不断晃动，引起头痛、偏头痛等问题。\n3. 晕车和恶心：颠簸的乘车经验可能会让一些人晕车和恶心，这是由于平衡感受器和眼部感受器之间的矛盾导致的。当人处在颠簸的环境中，平衡感受器会感受到不断变化的位置和运动，而眼部感受器则会感受到固定的环境，这种矛盾可能导致晕车和恶心。\n4. 精神压力：颠簸的乘车经验也可能对乘客的精神造成压力。长期的颠簸可能导致焦虑、失眠等问题，影响身体健康。\n5. 伤害：在严重的颠簸情况下，乘客可能会摔倒、碰撞等，导致身体受伤。\n总体来说，颠簸的乘车经验可能对身体和心理健康造成负面影响，因此应尽量减少颠簸的情况，让乘车变得更加平稳和安全。", "class": "open qa"}
{"question": "提供一个简短的方法来防止黑客访问您的电子邮件账户。", "std_answer": "", "class": "brainstorming"}
{"question": "提供一篇有关动物保护的随笔。", "std_answer": "", "class": "generation"}
{"question": "以罗密欧和朱丽叶为例，探讨爱情的定义和表现形式。", "std_answer": "", "class": "generation"}
{"question": "给定一篇英文科技新闻文章，将其翻译为中文。\nA team of researchers at Stanford University has developed a tiny wireless implant that can monitor the oxygen levels in blood vessels.", "std_answer": "斯坦福大学的研究团队开发了一种微型无线植入物，可监测血管中的氧气水平。", "class": "rewrite"}
{"question": "根据描述生成一个与描述相关的故事梗概。\n描述：一个年轻人在经过艰难的训练后成为了一名优秀的士兵。", "std_answer": "", "class": "generation"}
{"question": "对以下两个商品描述进行相似性比较：\n1. 原装正品，时尚设计，适合年轻人使用\n2. 优质产品，流线型外形，适合多种场合使用", "std_answer": "这两个商品的描述都强调了它们的设计和适用性，但是每个描述侧重的方面略有不同。让我们来逐个分析一下：\n1. 描述1中强调的是“原装正品”，这意味着此产品保证是来自制造商的真正产品，没有任何假冒伪劣的可能性。同时，它还强调了“时尚设计”，这表明此产品的设计是符合现代潮流和年轻人的审美标准的。\n2. 描述2中强调的是“优质产品”，这意味着此产品有更高的质量标准，比较稳定的性能和较长的使用寿命。此外，它还指出此产品有“流线型外形”，这表明它们的设计注重减少不必要的方式或构造，或者具有更加简单的外观，使其在多个场合中表现良好。\n在比较这两个描述时，我们可以看到它们的重点不同。描述1主要强调产品的时尚设计，适合年轻人使用，而描述2则更关注产品的优质性能和适用性。因此，我们难以做出更具体的比较，因为这两个描述之间的要点不同，更多的是针对不同的受众和用途进行定位的。", "class": "classification"}
{"question": "请描述“自由意志”的含义及其在哲学中的作用。", "std_answer": "“自由意志”是指人类在行动和选择方面的自由和能力，即对自己的行为负责，没有被外部强制因素和前定命运所限制，可以自主地做出决定并承担相应的后果。\n哲学中，自由意志一直是一个复杂和有争议的概念。柏拉图和亚里士多德讨论了该主题。古希腊哲学家伊壁鸠鲁则认为，自由意志等同于意愿的动力，并认为所有事物都由不可避免的原因控制。类似的，伏尔泰也认为人只是环境因素及自身遗传基因决定的受制者，而没有任何能力控制他们的行为。\n然而，伊曼努尔·康德和芝加哥学派等思想家则认为，自由意志是一种根据道德原则自主选择和控制行动的能力。他们认为，只有具有自由意志的人才能为自己的行为负责，这样才能在道德上被认为是有价值的个体。\n在哲学中，自由意志的作用非常重要，因为它涉及到我们对自己和他人的行为是否负责、我们所拥有的道德责任以及我们应该如何选择和行动的问题。自由意志还涉及到伦理和道德思考的问题，因为我们必须考虑自己的行为对他人的影响以及我们对他人的行为进行评价的标准。\n总之，自由意志是一个复杂和有争议的概念，但它在哲学中占据了重要地位，因为它涵盖着人类在道德、伦理和行为方面的自由与责任等问题。", "class": "open qa"}
{"question": "提出以下问题的答案。\n信用卡逾期会对个人信用产生什么影响？", "std_answer": "信用卡逾期是指在信用卡账单的还款截止日之后，未能及时还款的行为。而信用卡逾期会对个人信用产生各种负面影响，如下所述：\n1.信用记录受损\n信用记录是金融机构衡量一个人信用风险的重要依据，而信用卡逾期会对信用记录造成极大的伤害，将使信用分数下降。信用分数是金融机构评估个人信用风险的重要指标，信用分数下降会导致个人信用风险加大，从而影响日后享受各种信用服务。\n2.影响贷款和信用卡申请\n在申请贷款或新的信用卡时，银行或金融机构会通过查询信用记录来评估一个人的信用状况。如果信用记录上有逾期记录，会引起银行或金融机构的不良印象，从而大大增加贷款或信用卡申请的难度。\n3.利率上升\n在将来申请贷款或信用卡时，因为信用记录不良，银行或金融机构有可能提高个人的贷款或信用卡利率，这将使负债变高，还款压力增大。\n4.通信、银行等机构拒绝服务\n由于逾期导致信用记录受损，这同样会对一些服务机构产生影响，如通信公司和银行等。如果个人信用记录不良，这些企业可能会拒绝提供某些服务，从而影响个人日常生活。\n总之，信用卡逾期会严重影响个人信用，而信用又是个人能力的重要体现之一，因此，请大家在使用信用卡时注意还款截止日期，保持良好的信用记录。", "class": "open qa"}
{"question": "回答以下问题。\n蜘蛛有几只脚？", "std_answer": "大部分的蜘蛛有八只脚。它们的脚通常都是相同长度，并且有足爪来协助它们爬行和控制猎物。蜘蛛的脚分布在它们的腹部和头部之间的躯干节上。在它们的腹部上还有两个类似于触须的器官，被称为螯肢，用于捕获和处理猎物。虽然大多数蜘蛛都有八只脚，但是某些蜘蛛物种会在不同发育阶段和性别之间的腿数上有所变化。例如，一些幼年蜘蛛只有六只腿，而一些雌性蜘蛛会丧失一只或多只腿，通常是因为战斗或被掠食者攻击而导致的。", "class": "open qa"}
{"question": "请介绍一位在计算机科学领域有着卓越成就的女性科学家。", "std_answer": "", "class": "generation"}
{"question": "2023-04-14T08:15:35.499Z [INFO] 用户查看商品详情 - 用户ID: 1234567890, 页面: 商品详情, 商品ID: 10001, 商品名称: 电子书阅读器\n2023-04-14T08:15:42.623Z [INFO] 用户加入购物车 - 用户ID: 1234567890, 商品ID: 10001, 商品名称: 电子书阅读器, 数量: 1\n2023-04-14T08:15:45.892Z [INFO] 用户返回首页 - 用户ID: 1234567890, 页面: 首页\n2023-04-14T08:15:50.213Z [INFO] 用户点击搜索框 - 用户ID: 1234567890, 页面: 首页\n2023-04-14T08:15:55.788Z [INFO] 用户输入搜索关键词 - 用户ID: 1234567890, 关键词: 无线耳机\n2023-04-14T08:16:02.144Z [INFO] 用户点击搜索结果 - 用户ID: 1234567890, 商品ID: 20001, 商品名称: 无线蓝牙耳机\n2023-04-14T08:16:07.956Z [INFO] 用户查看商品详情 - 用户ID: 1234567890, 页面: 商品详情, 商品ID: 20001, 商品名称: 无线蓝牙耳机\n2023-04-14T08:16:12.713Z [INFO] 用户加入购物车 - 用户ID: 1234567890, 商品ID: 20001, 商品名称: 无线蓝牙耳机, 数量: 1\n2023-04-14T08:16:16.322Z [INFO] 用户查看购物车 - 用户ID: 1234567890, 页面: 购物车\n2023-04-14T08:16:22.527Z [INFO] 用户提交订单 - 用户ID: 1234567890, 订单ID: 987654321, 订单金额: 1200.00\n2023-04-14T08:16:30.689Z [INFO] 用户支付成功 - 用户ID: 1234567890, 订单ID: 987654321, 支付方式: 微信支付, 支付金额: 1200.00\n请三句话以内总结一下以上日志信息。", "std_answer": "1. 用户1234567890先后浏览并将电子书阅读器和无线蓝牙耳机加入购物车。\n2. 用户查看购物车后提交了订单，订单ID为987654321，订单金额为1200.00元。\n3. 用户使用微信支付成功完成了订单支付，支付金额为1200.00元。", "class": "summarization"}
{"question": "给我3个可以展示时间的表达方式。", "std_answer": "1. 时钟/钟表- 时钟/钟表是测量时间最常见的方式之一。它们可以是电子时钟，也可以是经典机械时钟。时钟可以显示小时，分钟和秒，也可以精确到毫秒。现代数字时钟可能会附带功能，例如闹钟，倒计时，计时器等等，而传统机械时钟则需要手动上发条来保持时间准确。\n2. 时刻表/行程表 - 时刻表是一种表格，用于列出特定旅行的车次，班次和交通工具的出发和到达时间。时刻表也用于列出经由某个城市到达目的地的所有航班/火车班次的时间表，航班/火车班次的起飞和着陆时间，旅行时间和停留时间。\n3. 日历 - 日历是测量时间和日期的另一种方式。它们通常包含12个月份和365天（或366天），以显示一年中的所有日期。除了日期之外，日历还可以显示特殊的假期，例如圣诞节或国庆节，或者某些文化或宗教的重要日子。有些日历还可以提供有关天文事件（例如月食或日食）的信息，以及各种天气预报和星座图表。", "class": "open qa"}
{"question": "将文本内容重新写成另一种风格，例如将新闻报道转换为小说的形式：\n李华是一名高中生，她每天使用自己的电脑完成作业，然后浏览知乎上的有趣问题。", "std_answer": "", "class": "rewrite"}
{"question": "为介绍一款新产品撰写一篇完整文档。\n产品名称: AirPods\n产品介绍: AirPods是一款无线耳机，它提供出色的音质和长达5小时的音乐播放时间。\n产品配件: AirPods充电盒，Lightning充电线，说明书", "std_answer": "", "class": "generation"}
{"question": "以自己的话解释一个概念或术语。\nConcept: 持续集成\nExplanation: 持续集成是软件开发中的一种实践，它要求开发人员在整个开发周期中不断地将代码合并和测试，以保证开发出高质量的代码。", "std_answer": "持续集成是指在软件开发过程中，开发者不断地将代码进行整合和测试的一种实践。这种实践可以帮助开发团队及时发现和修复代码缺陷，保证软件的稳定性和质量。持续集成的主要目标是提高软件开发的效率和质量，减少开发过程中的风险和错误，提高团队的协作效率。它要求开发人员在整个开发生命周期中不断地进行代码更新和测试，以便及时发现和解决问题，保证代码的可靠性和稳定性，使软件的质量达到最佳状态。", "class": "open qa"}
{"question": "请以下的活动进行头脑风暴，以便我们将其推广到更广泛的受众群体中。\n在公共图书馆举办儿童读书提高活动。", "std_answer": "", "class": "brainstorming"}
{"question": "对以下问题做出回答。\n问题：你如何看待当今社会中充满的虚假信息？", "std_answer": "当今社会中充满虚假信息。我认为这是一个非常严重的问题，对我们的社会和我们的个人生活都造成了深远的影响。以下是我关于这个问题的详细回答：\n1.虚假信息对我们的信任造成了破坏\n在当今社会中，我们无法确定我们所接收的信息是否是真实的。虚假信息的存在已经使得我们的信任受到了破坏。我们不再相信社交媒体或新闻中的信息，因为我们无法判断其中哪些是真实的，哪些是虚假的。这使得我们的决策变得更加困难，也降低了我们对世界的理解程度。\n2.虚假信息对我们的健康产生了负面影响\n虚假信息对我们的身体健康和心理健康都造成了负面影响。例如，在社交媒体上流传着各种假冒的医疗信息，这些信息可能会误导人们采取错误的医疗决策，从而严重影响他们的健康。此外，由于许多人通过互联网接收信息，如果该信息是虚假的，那么这将直接影响到人们的心理健康。\n3.虚假信息使我们的社会变得更加分裂\n虚假信息也会导致我们的社会变得更加分裂。虚假信息的传播往往会导致人们的政治观点和态度变得更加极端化，这会使整个社会变得更加分裂。这仅仅是因为我们同意或不同意不同来源的信息而形成的分歧，但它已引起了全球政治不稳定的现象。\n4.我们需要采取行动来应对虚假信息\n应对虚假信息是我们所有人的责任，而非只是新闻机构或社交媒体平台的责任。我们可以采取以下措施：\n- 加强社交媒体平台的自我监管，以确保错误的信息得到及时纠正和警醒;\n- 学习如何鉴别虚假信息，避免被误导。\n- 支持团体与机构通过非打击措施来消除虚假信息，例如提供正确的信息予公眾、建立更严格的在线信息发布规范、提高对媒体素养的重视、鉴赏力等等。\n综上所述，虚假信息是非常严重的问题，我们需要采取积极措施来应对它。我们必须意识到找到真相的重要性，不要轻易相信任何我们看到和听到的东西，以免影响我们的判断力和行动。同时，新闻机构和社交媒体平台也必须承担起自己的责任，积极对虚假信息进行打击，同时致力于提供更多的准确、公正和有用的信息给大众。", "class": "open qa"}
{"question": "阅读以下句子，并回答问题：\n句子：这个社区的人总是彼此了解并互相扶持。\n问题：“社区”在这里是什么意思？", "std_answer": "在这句话中，“社区”指的是一群住在同一地区或拥有共同利益的人。这个社区的人在这里被描述为互相了解并互相扶持的。这意味着他们之间建立了密切的联系和互助关系，可能是因为他们分享共同的价值观、文化或兴趣爱好。这种社区凝聚力往往比较强，能够带来实际的帮助和支持，同时为成员提供安全感和归属感。在今天充满着日益增长的疏离感和孤独感的社会中，这种社区感十分重要。", "class": "closed qa"}
{"question": "写一个工作场所不道德行为的例子，并解释为什么不道德。", "std_answer": "", "class": "brainstorming"}
{"question": "对以下段落进行语言模型的生成，生成一段类似的新文本。\n约翰尼·德普（Johnny Depp）是一位著名的好莱坞电影演员，他曾经在《加勒比海盗》系列电影中扮演过杰克船长的角色。", "std_answer": "", "class": "rewrite"}
{"question": "根据提供的文本生成一篇类似的文章，风格和语气一致：\n今天很有趣，我们看到了很多美丽的景色。", "std_answer": "", "class": "generation"}
{"question": "根据以下文本内容，将其分类到相应的新闻类别中。\n据报道，近日一场监狱暴动事件在印度发生。死亡人数已经达到了100人，其中包括一些监狱警察。报告显示，该监狱的囚犯发起了一次严重的反抗行动，试图逃脱监禁。事件还在进一步调查中。", "std_answer": "该新闻可以归类为“社会新闻”或“犯罪新闻”。\n作为社会新闻，这场监狱暴动影响了社会治安和公共安全，导致多人死亡和伤害。这种暴力事件可能引起公众的关注，可能引起政府对于监狱管理的重视，并督促相应的改善。\n作为犯罪新闻，该事件涉及囚犯的逃脱行为和监狱警察被杀害的情况。这是一种犯罪行为和暴力行为，需要调查和追究责任。这种新闻可能对于警方、检察院等司法部门有重要借鉴或参考价值。", "class": "classification"}
{"question": "请用简洁的语言说明婚礼策划的完整流程。", "std_answer": "婚礼策划的完整流程包括以下步骤：\n1. 确定婚礼预算\n2. 筹备起始阶段，选择婚礼日期、地点、主题、婚礼风格\n3. 定义婚礼规模，确定婚礼的宾客数量\n4. 策划婚礼仪式，包括婚礼仪式程序和内容，拟定邀请函，确定证婚人和主婚人，拟定结婚誓言等等\n5.选定婚礼场地、婚礼布置、音乐、婚车、餐饮、服装、发型、化妆、摄影、摄像等供应商，并在最终确定的供应商中签订合同\n6. 管理婚礼日程表并至少提前一个月开始婚礼计划\n7. 确认婚礼仪式和物品的排布，如大小道具、音响、屏幕、座位等\n8. 确定婚礼当天的工作流程，安排职责以及与相关人员的沟通\n9. 进行婚礼彩排，并确认是否需要调整任何步骤\n10. 最后进行婚礼的实际执行\n以上是婚礼策划的主要流程。婚礼策划需要足够的时间，以确保一切完美无缺地进行。", "class": "open qa"}
{"question": "给定一个段落，将其简化为一个句子。\n空气净化器对空气中的颗粒物进行过滤、吸附和分解，以提高室内空气质量。", "std_answer": "", "class": "rewrite"}
{"question": "根据提供的问题，回答问题。\n在哪里可以找到开发者社区的最新消息？", "std_answer": "开发者社区的最新消息可以在如下地方找到：\n1. 开发者社区网站：很多开源社区会有自己的网站，例如GitHub、Stack Overflow等，这些网站上通常有最新的社区消息、讨论区、文章、代码等资源。\n2. 社交媒体平台：许多开源社区也会有自己的官方社交媒体账号，例如Twitter、Facebook、LinkedIn等，通过这些账号可以了解到最新的公告、活动、讨论等信息。\n3. 论坛和邮件列表：很多开源社区会有相应的论坛和邮件列表，通过这些渠道可以参与到社区的讨论、提问和回答问题。\n4. 活动和会议：许多开源社区会举办各种活动和会议，例如Hackathon、Meetup等，这些活动不仅是了解最新社区动态的好机会，也可以与其他开发者交流、分享经验和互相学习。\n总之，要想了解开发者社区的最新消息，我们可以把握多种渠道，积极参与社区，与其他开发者建立联系和交流，不断更新知识和技能。", "class": "open qa"}
{"question": "对下列英文对话进行翻译。\nA: How was your day?\nB: It was pretty good. I had a lot of meetings, but they were all productive. How about you?\nA: It was alright. I had a lot of work to finish, but I managed to get everything done.", "std_answer": "A: 你今天过得怎么样？\nB: 还不错，我参加了很多会议，但是都很有成效。你呢？\nA: 还好啦，我有很多工作要完成，但是我最终都完成了。", "class": "rewrite"}
{"question": "给定一组句子，将它们整合为一个段落。\n第一句话：昨天晚上，我去看了一场演唱会，感觉非常棒。\n第二句话：我非常喜欢这个歌手的音乐，他的声音非常动听。\n第三句话：演唱会上的氛围也非常好，所有人都非常投入。", "std_answer": "", "class": "rewrite"}
{"question": "回答以下问题：如何在Windows 10中设置局域网？", "std_answer": "如果你想在Windows 10中设置局域网，可按照以下步骤进行：\n1. 查看IP地址\n在开始菜单中搜索并打开“命令提示符”，输入“ipconfig”命令，查看您的IP地址。IP地址可能是192.168.x.x或10.0.x.x，这是局域网的标准IP地址。\n2. 配置网络设置\n右键单击任务栏上的网络图标，选择“打开网络和Internet设置”。然后选择“更改适配器选项”，找到您要连接的以太网适配器。右键单击它并选择“属性”。双击“Internet协议版本4（TCP / IPv4）”，然后将其设置为“使用以下IP地址”。\n3. 输入IP地址和子网掩码\n在“IP地址”字段中输入您的IP地址，然后在“子网掩码”字段中输入“255.255.255.0”。\n4. 配置网关\n在同一个窗口中，单击“高级”选项卡，然后单击“添加”。在窗口中输入您的网关地址。通常，这是本地的路由器IP地址，例如192.168.1.1或10.0.0.1。\n5. 配置DNS服务器\n在同一个窗口中，单击“Internet协议版本4（TCP / IPv4）”下面的“属性”按钮，然后单击“高级”选项卡。选择“使用以下DNS服务器地址”并输入您的DNS服务器地址。您可以使用Google DNS服务器“8.8.8.8”和“8.8.4.4”或您的互联网服务提供商的DNS服务器地址。\n6. 确认设置\n单击“确定”按钮保存您的设置。现在您应该已经成功设置了局域网连接。同时，您还需要确保所有计算机都连接到同一个路由器，并拥有唯一的IP地址。如果您有网络连接方面的其他问题，您可以在Windows 10帮助文档中查找解决方案。", "class": "open qa"}
{"question": "您是否同意以下陈述：\n医疗保健是每个国家应为其公民提供的基本权利之一？为什么？", "std_answer": "我完全认同这个陈述，以下是详细的解释。\n首先，医疗保健是每个国家应该为其公民提供的基本权利之一，这是因为维护人民健康是国家最基础的职责之一。国家的发展离不开每一个公民的健康。如果公民缺乏医疗保健，他们将面临许多疾病和健康问题，这将不仅对他们自己的生活造成不可逆转的损害，同时也将对国家的整体健康和经济带来重大风险和养老负担。\n第二，医疗保健是保障社会公平与正义的体现。不是每个人都生于一个健康状况良好的家庭，因此，确保医疗保健对每个人都开放很重要，这样每个人才能够在疾病或健康问题出现时平等获得治疗和关注。如果只有一部分人可以得到医疗保健而其他人不能，这将导致社会不平等和不稳定。\n第三，医疗保健有助于预防疾病和减轻疾病负担。通过定期体检和及时治疗，疾病可以被早期发现和治疗，避免发展成为严重疾病。更重要的是，公民的健康和基本需求得到了妥善关注，这将减轻他们和他们家庭的经济和卫生负担，也将减轻国家的医疗负担。\n最后，医疗保健是促进社会和谐稳定的重要体现。一个健康的国民对于国家的进步发展起着重要的推动作用，而公民获取良好医疗保健也可以在一定程度上减少他们的焦虑和压力，从而促进社会和谐稳定。\n综上所述，医疗保健是每个国家应该为其公民提供的基本权利之一。通过提供可及的医疗保健，我们可以维护人民健康和基本需求，促进社会公平与正义和促进社会和谐稳定，同时也有助于推动国家的可持续发展。", "class": "open qa"}
{"question": "根据以下文字，回答问题：\n在中国古代历史中，王昭君被誉为四大美女之一，她的美貌和才华闻名于世。她也因被和亲到匈奴而被称为“和亲美人”。据史书记载，王昭君是汉武帝为了维护边疆稳定而选派的公主之一。她被选中后，成为了中国历史上最著名的和亲公主之一。然而，和亲并没有让王昭君得到幸福。在途中，她流落民间，经历了无数的艰辛和磨难。她甚至被迫嫁给了匈奴王，成为了他的妻子。然而，尽管生活在异国他乡，王昭君却从未放弃对祖国的思念和忠诚。她不断地劝说匈奴王与汉朝和好，为两国人民带来和平。王昭君的美貌和才华不仅让她成为了历史上的传奇人物，也让她的故事流传至今。她的形象经常出现在文学、音乐、电影等各种艺术形式中，成为了中国文化中不可或缺的一部分。她的故事也启示人们要坚定信念，勇敢面对逆境，不屈不挠地追求自己的梦想和理想。\n王昭君被称为什么？", "std_answer": "王昭君被称为“四大美女之一”和“和亲美人”。", "class": "closed qa"}
{"question": "回答以下问题：\n提供各自职业道德守则并比较医生和记者的不同之处。", "std_answer": "医生和记者是两个非常不同的职业。他们的职业道德守则的不同之处反映了他们的工作本质和责任的不同。\n首先，医生的职业道德守则强调医生的责任是寻求病人的福祉。医生的职业道德守则包括遵守 HIPAA 法案，保护病人的隐私，不使用自己的职位谋取私利等等。医生必须保持道德标准和专业责任，向病人提供最好的医疗保健服务。医生的职业道德守则还要求医生保持知识和技能的最新状态，及时参加相关讲座、研讨会和课程，以保证其知识和技能的质量。\n相比之下，记者的职业道德守则强调记者的职业责任是准确、客观地报道新闻事实。记者的职业道德守则包括不编造、不歪曲事实、不伪造证据、不拿收买等等。记者必须保持道德标准和专业责任，为公共编辑提供准确、透明的新闻报道，揭示社会现象，向公众传递真实信息。记者的职业道德守则还包括保护新闻来源和信息，并有责任与公众合作以促进诚信和道德可持续性的公共讨论等等。\n总的来说，医生和记者的职业道德守则的不同之处在于，医生的职业道德守则重点在于保护病人权益、提供最好的医疗保健服务，而记者的职业道德守则则强调准确、客观地报道新闻事实、保护新闻来源和信息的可信度。", "class": "open qa"}
{"question": "设计一个能够评估树木健康状况的算法。", "std_answer": "", "class": "brainstorming"}
{"question": "给定一段英语新闻报道，将其翻译成中文。\nBritish Prime Minister Boris Johnson faces renewed pressure from lawmakers in his own party for his handling of the pandemic, just as the government rolls back on some Covid-19 restrictions in England. Some Conservative Party MPs are uneasy about the prospect of returning to a tiered system -- which was widely criticised for being confusing and failing to curb transmission -- once the national lockdown ends on December 2.", "std_answer": "英国首相鲍里斯·约翰逊面临着来自自己政党议员的新一轮压力，这是因为政府正在取消一些在英格兰实行的新冠病毒限制措施。一些保守党的议员对于回到分区系统感到不安，这种系统曾因为很难理解和未能遏制病毒传播而受到广泛批评，一旦全国封锁措施于12月2日结束后可能会重新使用。", "class": "rewrite"}
{"question": "将以下段落中的重要信息提取出来。在这场庆祝活动中，公司精心安排了各种节目和活动，以表彰那些业绩出色的员工并展示公司的未来计划。庆祝活动现场热闹非凡，到场的员工们纷纷欢呼雀跃，表达着他们对公司的热爱和支持。在活动中，公司领导发表了精彩的讲话，对业绩出色的员工们表示感谢和祝贺，并表示公司将继续发扬优秀的企业文化和价值观，为员工们提供更好的发展机会和发展空间。在表彰环节中，公司表彰了那些在工作中表现出色的员工，他们为公司的发展和壮大作出了重要贡献。颁奖环节中，获奖员工们纷纷上台领取奖品和证书，并发表了热情洋溢的感言，表达了对公司和同事们的感激之情。最后，全体员工一起唱起了公司的歌曲，展现了他们对公司的归属感和团结力。整个活动在欢声笑语中结束，为公司带来了更多正能量，也为员工们留下了难忘的回忆。", "std_answer": "公司举行了一场庆祝活动。\n公司精心安排了各种节目和活动。\n活动表彰了业绩出色的员工。\n公司领导发表了讲话，感谢和祝贺员工，表示将继续发扬企业文化和价值观。\n庆祝活动现场热闹非凡，员工们表达了对公司的热爱和支持。\n公司表彰了在工作中表现出色的员工，颁奖并发表感言。\n全体员工一起唱了公司的歌曲，展现了归属感和团结力。\n活动为公司带来了更多正能量，为员工留下了难忘的回忆。", "class": "extract"}
{"question": "请基于以下采访内容帮助记者整理一份采访总结：\n记者: 您好，感谢您抽出时间接受我们的采访。首先恭喜您在最近的比赛中表现出色，您能告诉我们一下您是如何做到的吗？\n体育明星: 您好，谢谢您的祝贺。我认为最重要的是团队合作和努力训练。我们整个团队一直在为比赛而努力工作，而且我们的教练也给了我们很多支持和指导。\n记者: 您似乎在最近的几场比赛中表现得更为出色，您是否有任何特别的准备或策略来提高自己的表现？\n体育明星: 我一直在不断地努力训练和提高自己的技能。此外，我还会研究对手的比赛录像，以找出他们的弱点和策略。我认为每个比赛都是一次新的挑战，我会尽力发挥自己的最佳水平。\n记者: 您在您的职业生涯中经历了许多重要的比赛和时刻，您最难忘的是什么？\n体育明星: 对我来说，最难忘的时刻就是在某个比赛中获得胜利，并为我的团队带回了冠军奖杯。这是我职业生涯中最重要的时刻之一，我非常感谢我的队友和教练们一直以来的支持。\n记者: 最后一个问题，您有任何未来的计划或目标吗？\n体育明星: 我希望能够继续提高自己的技能和表现，为我的团队和球迷们带来更多的胜利和荣誉。我也希望能够为我的社区和慈善事业做出一些贡献，让更多的人受益。谢谢你的采访。", "std_answer": "这位体育明星强调了团队合作和努力训练对于比赛表现的重要性。他们还提到了研究对手的录像以及尽力发挥最佳水平来应对每个新的比赛挑战。当被问及职业生涯中最难忘的时刻时，体育明星提到获得某个比赛的冠军奖杯，并感谢了队友和教练的支持。最后，他们表达了继续提高自己的技能和表现，为团队和球迷带来更多胜利和荣誉的愿望，同时希望为社区和慈善事业做出贡献。", "class": "summarization"}
{"question": "描述一个人类可以做到的最令人印象深刻的事情。", "std_answer": "", "class": "brainstorming"}
{"question": "请描绘以下场景的细节和氛围。\n一间老旧的书店，有一排排书架和一个老店主。", "std_answer": "", "class": "generation"}
{"question": "用python编写一个简单的计时器程序，在5分钟后发出通知提醒。", "std_answer": "为了设置一个简单的计时器，在5分钟后发出通知提醒，可以使用Python的time模块和plyer模块。\n1. 首先，导入需要的模块：\n```\nimport time\nfrom plyer import notification\n```\n2. 接下来，设定等待5分钟的时间（以秒为单位）：\n```\ntime.sleep(5 * 60)\n```\n3. 最后，使用plyer模块的notification方法发送通知：\n```\nnotification.notify(\n title='计时器提醒',\n message='5分钟已经过去了！',\n app_name='简易计时器',\n timeout=10\n)\n```\n将以上代码整合到一起，如下所示：\n```\nimport time\nfrom plyer import notification\ntime.sleep(5 * 60)\nnotification.notify(\n title='计时器提醒',\n message='5分钟已经过去了！',\n app_name='简易计时器',\n)\n```\n注意，这里的timeout参数为通知显示的时间，以秒为单位，默认值为10秒。在代码中没有会使通知一直显示，直到手动关闭通知。\n如果需要在计时器结束后再次触发计时器，可以将以上代码放在while循环中，并设置一个变量来控制循环次数，如下所示：\n```\nimport time\nfrom plyer import notification\ncount = 0\nwhile count < 5: # 计时器触发次数\n time.sleep(5 * 60)\n count += 1\n \n notification.notify(\n title='计时器提醒',\n message='5分钟已经过去了！',\n app_name='简易计时器',\n )\n```\n这样，计时器将在5分钟后、10分钟后、15分钟后等等触发通知提醒。", "class": "code"}
{"question": "请根据以下几个单词的定义，写出它们的汉语翻译。\nAnthropology - Study of human societies and cultures; Geology - Study of physical structure and substance of earth; Botany - Study of plants", "std_answer": "Anthropology - 人类学：研究人类社会和文化的学科。\nGeology - 地质学：研究地球物理结构和物质组成的学科。\nBotany - 植物学：研究植物的学科。", "class": "rewrite"}
{"question": "从下列选项中选择最佳答案：戴上手套的原因是什么？\nA. 保持手部清洁\nB. 保护手部不受伤害\nC. 使手部保温", "std_answer": "手套是一种穿在手上的衣物，用于不同的目的。手套可以有不同的形状、尺寸和材料，并可以用于各种用途。以下是一些戴上手套的主要原因:\n1. 保持手部清洁：在某些工作中，手可能会与污垢、化学物质或其他有害物质接触，戴手套可以保护手部免受这些物质的污染和伤害。在医学和食品服务行业中，戴上手套通常是義務的，以确保手是干净的，从而防止疾病通过接触而传播。\n2. 保护手部不受伤害：戴上手套可以保护手部免受割伤、撞击和其他伤害。在体育运动中，手套可以保护手部免受碰撞和刮擦的伤害。在工业和建筑领域，戴上防护手套可以提供额外的保护，防止手部受到化学品和其他危险物质的损伤。\n3. 使手部保温：在寒冷的环境中，戴手套可以保持手部温暖。手套可以有不同的级别的绝热能力，可以保持手部在低温环境下的温度。\n综上所述，戴手套的原因是多种多样的，并且取决于使用场景。无论是为了保持手部清洁、保护手部不受伤害还是使手部保温，戴手套都可以提供额外的保护。", "class": "closed qa"}
{"question": "根据以下输入，回答问题。\n帝王葬礼中，有些坟墓是直接掩埋的，有些坟墓则会建造陵墓。为什么会出现这两种不同的葬法？", "std_answer": "古代帝王的葬礼历史悠久，通常伴随着诸如祭祀、文化、政治等方面的重大意义。在中国和其他古代文明中，针对不同的皇帝、国王和贵族存在不同的葬礼方式，其中包括直接掩埋和建造陵墓两种方式。这些不同的葬法背后有着悠久的历史背景和文化传统。以下是更详细的解释：\n1. 直接掩埋\n直接掩埋通常也被称为“土葬”，是指将遗体埋在深埋的坟墓中，再经过覆盖和填平，使遗体得以保存并保护。这种葬法主要存在于早期的时代，例如在古代的商、周、秦等朝代中，因为当时的工具和技术不够精细，无法建造更加复杂的墓室或陵墓。\n此外，相对于陵墓的高昂费用和长时间的建造过程，直接掩埋的葬法更加简易，不需要耗费过多的时间和资源，可以更快地完成。并且，一些古代文化中认为，直接掩埋也可以将逝者的身体化归于自然，符合一些崇尚自然的文化传统。\n2. 建造陵墓\n建造陵墓是指在一定的技术基础上，将葬礼具体化为一种以陵墓为中心的文化产物。\n举例来说，中国历史上皇帝的陵墓建造非常注重规划、设计、建设和雕刻，根据皇帝的社会地位和地域环境，需要建造具有不同规模、不同结构和不同装饰的陵墓。陵墓通常包括许多漂亮而精致的石雕、浮雕和器物，具有非常高的文化价值。\n同时，建造陵墓不仅仅是建造一个葬身之地的过程，更是政治、文化和艺术的一个表现。陵墓的建设过程，通常需要供奉和购置许多贵重的物品，需要动用大量的人力、物力和财力，因此可以形成一个针对皇帝的文化产业链。陵墓的规模和装饰也纪念了皇帝及其统治期间的许多历史事迹，以至于某些陵墓的价值超越了皇帝本人的名誉。\n总结\n综上所述，直接掩埋和建造陵墓是两种不同的葬法，它们存在着文化、技术和历史等方面的不同因素。而陵墓在皇帝的葬礼中具有重要的地位，通常可以反映出历史，政治、文化和艺术等多个方面的价值。在当今的社会中，随着技术和文化的进步，葬礼方式和陵墓的建设已经发生了很大的变化，但历史的学习和研究却始终没有停止。", "class": "open qa"}
{"question": "请问谁获得了2020年图灵奖？", "std_answer": "2020年图灵奖由美国计算机协会（ACM）颁发给了艾伦•米希尔斯(Ales Michels)和理查德•兹曼克(Richard E. Zuckerman)，表彰他们在计算机科学方面的杰出贡献。\n具体来说，这两位科学家被认为是发展了可靠的算法来解决计算机科学中的一些最重要的问题，特别是在计算机代数和计算机几何领域。他们开发了新的理论和实际工具，让计算机科学家和工程师能够更好地应对实际问题，并最终促进了计算机科学的发展。\n艾伦•米希尔斯是麻省理工学院（MIT）计算机科学和人工智能实验室（CSAIL）的研究员。他在多项科学研究领域中都有杰出的成就，包括计算机几何和计算机代数。他是计算机代数系统Maple的共同创建者，并参与了众多项目的设计和实现。\n理查德•兹曼克是美国密歇根大学计算机科学与工程系的教授。他主要的研究方向是计算机几何，他的成就在于将几何问题转化为了算法问题，并发明了一些优秀的算法解决这些问题。他具有丰富的研究经验和广泛的学术影响力，也是ACM院士和IEEE院士。\n获得图灵奖被认为是计算机科学领域最大的荣誉之一，该奖项的创立至今已有50多年。该奖项得名自计算机科学的奠基人之一阿兰·图灵（Alan Turing），旨在表彰他的贡献和鼓励继承他的遗志，推动人工智能和计算机科学的发展。", "class": "open qa"}
{"question": "回答以下问题：\n为什么日本的高铁速度很快？", "std_answer": "日本的高铁系统，也被称为新干线，以其高速运行和准时的声誉而闻名于世界。以下是日本高铁速度快的原因：\n1. 强大的技术支持：日本是一个高度发达的技术国家，拥有许多国际知名企业，如三菱、丰田和索尼等。这些公司的创新成果促进了日本高铁技术的发展，使其成为全球领先的高速铁路系统之一。\n2. 高级自动化系统：日本的高铁采用先进的自动化系统，包括高级信号和控制系统、轮轨监测系统和列车自动驾驶系统等。这些系统使得高铁能够以更高的速度运行，并且在不同的气候和地形条件下都能保持准确和精确的运行。\n3. 高品质的基础设施：日本高铁的轨道、电力、电子信号和通讯等基础设施建设非常先进。高速线路建设采用了创新技术，如地震补偿技术、钢轨焊接技术和高精度铺轨技术等。这些技术能够提高高铁的运行速度和准确性，并且能够承受更高的重量和各种自然灾害。\n4. 高度优化的列车设计：日本的高铁列车设计非常优化，包括外部流线型设计和内部座位组织等，这些都减少了空气阻力和能源消耗。列车在拐弯和经过高架桥等特殊条件下相当平稳，确保了旅客的舒适性。\n总的来说，日本的高铁速度之所以如此之快，是由于技术、高级自动化系统、高品质的基础设施以及强大的列车设计等多种因素的综合作用。这使得新干线成为全世界最好的高速铁路之一，也造福了日本国内的企业和旅游业。", "class": "open qa"}
{"question": "回答以下问题，并提供支持性证据。\n绿色草坪真的可以减少城市热岛效应吗？", "std_answer": "绿色草坪可以在一定程度上减少城市热岛效应，但其效果可能因多种因素而有所不同。\n首先，城市热岛效应是指城市地区的气温比周围的农村地区高出许多。这种现象是由各种城市发展和友环境影响因素引起的，包括建筑和其他硬质地面的热量吸收和释放、交通和人群带来的热量、以及城市缺乏植被，从而减少了自然的阴凉和蒸发散热等等。\n绿色草坪通常可以很好地解决其中一些问题。草坪可以吸收部分太阳辐射并把它转化为植物物质，同时也不像硬质地面那样容易 conduct 和 radiate 热能，从而减少了周围的温度。 有研究表明，草坪的阴凉和蒸散散热效应可以在某些情况下将当地气温降低3至5摄氏度。\n例如，2019年的一项研究表明，鹿特丹市的草坪和树木可以在一定程度上缓解城市热岛效应。研究者在当地不同的绿色空间中放置了温度计，结果显示，温度最低的区域通常是草坪和树木覆盖的区域，而没有植被覆盖的地区的温度最高。\n虽然绿色草坪可能会缓解城市热岛效应，但其具体效果可能取决于多种因素，如草坪的大小、位置和周围环境的影响等。此外，使用草坪还需要更多的水和维护成本，并且可能无法在所有城市环境中使用。\n因此，我们需要进行更多的研究来确定绿色草坪对城市热岛效应的确切效果，同时也需要探索其他方法来缓解城市热岛效应。", "class": "open qa"}
{"question": "从以下诗句中提取人物名称：两个黄鹂鸣翠柳，一行白鹭上青天。", "std_answer": "这句诗出自唐代诗人杜甫的《绝句》，并没有明确提到人物名称。这句诗主要是在描绘自然景色，通过形象生动的语言来表现春天的美丽景象。\n诗中提到“两个黄鹂”，“一行白鹭”，他们是动物而非人物名称。黄鹂是一种鸟类，它们身体鲜黄色，嘴巴呈钩形，叫声清脆悦耳；白鹭是另一种水鸟，身体白色，嘴巴细长，善于捕捉鱼类等。\n杨婉这句诗意境深远，很好地表现了大自然的美丽和神奇。", "class": "extract"}
{"question": "为以下事件提供一个合理的解释：\n公共汽车抵达时，没有人下车，但很多人却上车了。", "std_answer": "", "class": "brainstorming"}
{"question": "将以下文本翻译成中文。\n原句：The company was founded with the goal of providing better customer service than its competitors. It has since expanded to include a wide range of products and services.", "std_answer": "该公司成立的目标是为顾客提供比竞争对手更好的客户服务。此后，该公司已经扩展了包括各种产品和服务。", "class": "rewrite"}
{"question": "写一个可以检测电子邮件地址是否有效的python函数。\n输入示例：example@example.com", "std_answer": "好的，我可以为您提供一个Python函数来检测电子邮件地址是否有效。我们可以使用正则表达式来检查电子邮件地址的格式是否正确。下面是代码和解释：\n```python\nimport re\ndef is_valid_email(email):\n # 正则表达式模式，用于匹配电子邮件地址\n pattern = r'^[a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+\\.[a-zA-Z0-9_-]{2,}$'\n # 使用re模块进行匹配\n match = re.match(pattern, email)\n # 如果匹配成功，match对象将不返回None\n if match:\n return True\n else:\n return False\n```\n在这个函数中，我们使用re模块来编译一个正则表达式模式，该模式用于检查电子邮件地址的格式是否正确。正则表达式模式的解释如下：\n- `^` - 匹配字符串的开始\n- `[a-zA-Z0-9._-]+` - 匹配一个或多个字母、数字、点、下划线或破折号\n- `@` - 匹配电子邮件地址中的@符号\n- `[a-zA-Z0-9._-]+` - 匹配一个或多个字母、数字、点、下划线或破折号\n- `\\.` - 匹配电子邮件地址中的一个点\n- `[a-zA-Z0-9_-]{2,}` - 匹配两个或更多字母、数字、破折号或下划线\n- `$` - 匹配字符串的结尾\n如果电子邮件地址与该模式匹配，则该函数将返回True，否则将返回False。 \n使用示例：\n```python\n# 测试有效的电子邮件地址\nprint(is_valid_email('example123_456@example.com')) # 输出：True\n# 测试无效的电子邮件地址\nprint(is_valid_email('example.com')) # 输出：False\n```\n希望这可以帮助您检测电子邮件地址是否有效！", "class": "code"}
{"question": "给我写一篇500字的文章，介绍在你看来，人与自然是如何相互作用的。", "std_answer": "", "class": "generation"}
{"question": "对以下文本进行重新写作，以适应特定受众。\n粮食储备是国家宏观调控的重要手段之一，在全国人民代表大会和政协的支持下，我国采取了一系列措施来加强和完善对储备粮和储备油的管理和监督。", "std_answer": "", "class": "rewrite"}
{"question": "根据给定的文章大纲生成一篇文章\n第一章：介绍\n第二章：背景知识\n第三章：研究方法\n第四章：结果与分析\n第五章：结论\n第六章：未来工作计划", "std_answer": "", "class": "generation"}
{"question": "请从以下文本中提取出列车编号、出发站点、到达站点、出发时间和到达时间。编号为K8732的列车是一趟从南方到北方的长途列车。它将从广州南站出发，穿过中国南部的美丽风景线路，一路向北行驶。旅客可以欣赏到壮丽的山脉和沿途的风景。列车计划在4月20日早上6点30分准时从广州南站出发，全程预计需要经过多个站点，其中包括长沙、武汉、郑州和石家庄等城市。经过长途的行驶后，列车预计将于4月21日下午3点15分准时到达北京西站。在整个旅途中，旅客可以在列车上享受舒适的座位和设施，例如空调、餐车、卫生间和WiFi等服务，以保证旅途的舒适和愉悦。无论是商务出行还是度假旅游，这趟列车都是一种安全、快捷和舒适的出行选择。", "std_answer": "列车编号：K8732\n出发站点：广州南站\n到达站点：北京西站\n出发时间：4月20日早上6点30分\n到达时间：4月21日下午3点15分", "class": "extract"}
{"question": "阅读以下段落，并回答问题：哪种动物受到保护？\n白色犀牛是一种濒危的哺乳动物，被认为是世界上最臭名昭著的保护动物之一。在过去的几十年里，由于非法狩猎、栖息地破坏和环境污染等多种原因，它们的数量急剧下降，面临着灭绝的威胁。\n为了保护白犀牛，采取了大规模且成功的保护活动。其中，主要的措施包括加强法律保护、建立野生动物保护区、开展宣传教育和加强监测等。在这些措施的共同作用下，白犀牛的数量开始逐渐恢复。\n据报道，南非是白犀牛数量恢复最为显著的地区之一。自从保护活动开展以来，南非的白犀牛数量已经从几乎灭绝的状态恢复到了20世纪60年代的水平。这一成果离不开南非政府和各方力量的共同努力，也为全球野生动物保护事业注入了信心。", "std_answer": "白犀牛是受到保护的动物。在南非，白犀牛的数量已经恢复到20世纪60年代的水平，这说明保护措施已经收到了效果，并且白犀牛已经从濒危物种种群中得到了保护。值得注意的是，尽管在南非的保护工作取得了一些成功，但白犀牛在其他地区仍然受到威胁，因此需要持续不断的全球保护努力。", "class": "closed qa"}
{"question": "将以下英文文章进行分类。\nComputer Science is a rapidly growing field with job opportunities in software development, data analysis and cybersecurity.", "std_answer": "分类: 职业、计算机科学、技术领域\n解释： \n该文章涉及了三个不同的主题。第一个主题是职业，文章提到了计算机科学为快速增长领域，并提供了就业机会。第二个主题是计算机科学本身，它是一个技术领域，包括软件开发、数据分析和网络安全等领域。第三个主题是具体的职业机会，即软件开发、数据分析和网络安全。\n因此，该文章可以分类为职业、计算机科学和技术领域。", "class": "classification"}
{"question": "在以下文本中，找到第一个意外出现的词：这是一段讲述广告行业发展历程的草地螟虫文章，其中包括了广告的种类，它们的来源和流行程度。请注意，前方出现了一个巨大的紫色陨石，砸在了广告业的中心地带。", "std_answer": "意外出现的词是\"紫色陨石\"，因为这个词和文章主题——广告行业的发展历程没有直接联系。", "class": "extract"}
{"question": "根据以下现象，解释发生了什么：\n用肥皂水洗手后，手上的细菌数量减少了。", "std_answer": "当我们用肥皂和水洗手的时候，可以有效的减少手上的细菌数量，主要原因有以下两点：\n1. 肥皂的化学性质\n肥皂中有一种成分叫做“表面活性剂”，它能够分解手上的皮脂、油脂和蛋白质等污垢，使其变得容易被水冲洗掉。这个过程中，细菌也会因为这些污垢的去除而被清洗干净，从而减少手上的细菌数量。\n此外，表面活性剂的分子结构包含亲水头部和疏水尾部，这种结构使得肥皂在水中能够产生大量的泡沫，从而进一步容易地将细菌带走。\n2. 摩擦和彻底冲洗\n另外，我们在用肥皂和水洗手的时候往往会较长时间地摩擦双手，这种摩擦的力量会将细菌从手表面磨掉，从而进一步减少手上的细菌数量。此外，我们也会用清水彻底地冲洗手，这种冲洗的过程也会冲掉细菌，从而使得手上的细菌数量更少。\n因此，我们平常洗手时使用肥皂水而非仅用清水，这是因为肥皂水能够更有效地去除手上的污垢和细菌，从而保持我们的手部清洁和卫生。", "class": "open qa"}
{"question": "请提供一个龙舟节的相关信息。", "std_answer": "龙舟节是中国传统文化的重要节日之一，也是世界范围内受欢迎的文化节庆之一。以下是有关龙舟节的详细信息：\n1. 节日时间：龙舟节是农历五月初五，也被称为端午节，通常在公历6月份左右的日期。\n2. 节日起源：龙舟节起源于中国的一个传说故事，相传在战国时期，楚国的屈原因忧国忧民，痛心疾首，最终在五月五日投江自尽。百姓们得知后纷纷划船捞救，但无功而返。为了纪念屈原，人们开始在这一天划船竞渡，以表抗争以及纪念屈原的忠诚精神。\n3. 节日庆祝方式：龙舟节的主要庆祝方式是划龙舟比赛，由12到20个篙手划龙舟前进，船头上还会装饰龙头，非常壮观。在比赛前，船队成员会在龙舟前表演舞蹈或敲击发鸣金鼓的仪式。此外，也有吃粽子的传统，在节日期间，人们会互送粽子以示关爱和团圆之意。\n4. 节日意义：龙舟节不仅仅是一个传统的节日，更是一个展现中国文化和精神的场合。划龙舟比赛代表了传统的团队合作精神和奋力拼搏的精神，吃粽子则代表了中国人的崇尚团圆和家庭美德的情感表达，更是一个重要的文化遗产。\n5. 节日传承：龙舟节已经成为了世界各地的文化交流和活动之一，越来越多的国家和地区开始庆祝这个节日。与此同时，中国政府也加大了对龙舟节传承的力度，保护和发扬中华传统文化，促进传统文化的融合和发展。", "class": "open qa"}
{"question": "判断以下陈述是否正确：\n当两个波的波峰和波谷重叠时，它们会形成一个新的波形。", "std_answer": "这个陈述不是很准确。当两个波重叠时，它们不会形成一个完全新的波形，但它们会通过叠加相互影响彼此的形状和强度。\n这种现象称为波的干涉，它可以分为两种类型：构造干涉和破坏干涉。构造干涉发生在两个波的峰和谷重叠的区域，增强了波的振幅。而破坏干涉发生在一个峰和一个谷的重叠区域，导致波的振幅降低或甚至完全消失。\n以光波为例，当两束光波相遇，它们产生的干涉现象称为光学干涉。这种现象可以被观察到，在实验中可以使用干涉仪测量。\n此外，在物理学中还有其他形式的波干涉，如声波干涉和水波干涉等，它们也遵循相似的原理。总的来说，当两个波相遇时，它们会互相影响并产生干涉，这种干涉可以产生许多有用的应用和现象。", "class": "open qa"}
{"question": "对一篇新闻文章进行翻译：将下面的英文文章翻译成中文。\nMajor tech companies are now considering the use of artificial intelligence tools to help filter out extremist content from the internet. This comes after increased pressure from politicians and governments to prevent the spread of extremist ideas online.", "std_answer": "主要的科技公司现在正在考虑使用人工智能工具来帮助过滤互联网上的极端主义内容。这是在政治家和政府为防止极端思想在网上传播施加了更大压力之后出现的。", "class": "rewrite"}
{"question": "请根据以下范文，写一篇关于家乡风景的短文。\n范文：我家乡位于凉爽的高山之中，四季分明。春天，万物复苏，红花绿树丛生，彩蝶纷飞；夏季，峡谷里绿树成阴，溪水潺潺，凉风习习；秋天，山峦绚丽多彩，野果飘香，红叶满山；冬天，白雪皑皑，冰挂梅花，银装素裹。", "std_answer": "", "class": "generation"}
{"question": "根据以下文本生成一个问题。\nVGG16是一种卷积神经网络架构，由几个卷积层和池化层组成，以及三个完全连接的层和一层softmax分类器。它是ImageNet ILSVRC-2014比赛中最出色的模型之一。", "std_answer": "VGG16是哪个比赛中的最出色模型？", "class": "closed qa"}
{"question": "根据以下文本生成开放式问题：\n2019年4月15日晚，法国巴黎圣母院遭遇了一场可怕的大火，这一事件在全球范围内引发了极大的关注和哀悼。火灾导致圣母院的屋顶和尖塔严重受损，这座800多年历史的宗教建筑的大部分结构也面临着严重的损失和破坏。当时，全球的民众和媒体都对这起事件感到震惊和悲痛，许多人也表达了对巴黎圣母院的情感和历史价值的关注和重视。法国政府随即启动了大规模的救援和修复工作，调动了大量的人力和物力资源，以确保圣母院能够尽快得到恢复和重建。经过多方努力和长时间的修复工作，巴黎圣母院的修缮工作取得了显著的进展。建筑师、艺术家、工匠和专业修缮团队们合作，采用了最先进的技术和方法，致力于保护和恢复这座历史悠久的建筑。目前，巴黎圣母院的修复工作仍在进行中，预计将会历时多年。这场火灾让全球更加关注文化遗产的保护和修缮工作的重要性，也让人们更加珍惜和重视历史文化遗产的珍贵性和不可替代性。圣母院大火虽然带来了巨大的损失和痛苦，但也促使人们更加积极地投入到文化遗产的保护和修缮事业中，以确保历史遗产能够永久地流传下去。", "std_answer": "1.2019年4月15日晚发生在法国巴黎圣母院的大火具体造成了哪些损失？\n2.巴黎圣母院大火对全球民众和媒体产生了怎样的影响？\n3.法国政府在巴黎圣母院大火后采取了哪些紧急措施？\n4.巴黎圣母院修复工作的主要参与者有哪些？\n5.在修复巴黎圣母院过程中，人们采用了哪些先进的技术和方法？\n6.预计巴黎圣母院的修复工作需要多长时间才能完成？\n7.巴黎圣母院大火如何影响了全球对文化遗产保护和修缮工作的关注？\n8.这场火灾对人们对历史文化遗产的珍视和重视产生了哪些积极影响？", "class": "closed qa"}
{"question": "提出一些能够改善智商的方法。", "std_answer": "", "class": "brainstorming"}
{"question": "根据给出的文本片段，回答下列问题：文中提到了哪些国家？\n李华从小就喜欢研究地理，他自己玩儿的时候总是试图想出新方法来记忆各国名字和首都。他读到一篇新闻报道，里面提到了“欧洲联盟”、“法国”和“德国”，李华很快就记住了这些国家名字。", "std_answer": "文中提到了三个国家：欧洲联盟、法国和德国。", "class": "closed qa"}
{"question": "从以下内容生成一篇文章：战争是一件毁灭性的事情，常常带来无尽的痛苦和困难。", "std_answer": "", "class": "generation"}
{"question": "回答问题：“蚊子吸血时为什么会发出嗡嗡声？”", "std_answer": "蚊子吸血时发出的嗡嗡声是由其翅膀的震动引起的。蚊子翅膀通过迅速的上下扇动来产生飞行，这种运动产生的压力激起了周围空气的震动，进而产生了嗡嗡声。当蚊子飞行或吸血时，其翅膀的速度会更快，所以嗡嗡声也会更响亮。同时，蚊子靠翅膀的震动来感知周围环境和其他蚊子的存在，这也使得其容易找到宿主并异地在宿主身上吸血。\n值得注意的是，只有雄性蚊子才会发出更响亮的嗡嗡声。这是因为雄性蚊子的翅膀结构和次序比较特殊，会产生更强的空气震动。母蚊声音较小，这种情况通常也有利于其避免被寄主发现。\n总之，蚊子吸血时发出的嗡嗡声是由其翅膀震动产生的，这种声音具有很重要的生物学意义，也使蚊子的生存和繁殖变得更加容易。", "class": "open qa"}
{"question": "阐述自己的人生理念或信仰。", "std_answer": "", "class": "brainstorming"}
{"question": "写一个python代码提取输入中的所有时间段（小时：分钟）。\n我们下午2点要开会，然后我会在5点之前到家。", "std_answer": "从这个输入中提取时间段是非常简单的，因为句子中已经明确提到了两个时间段：\n- 下午2点\n- 5点之前\n所以，我们只需要提取这两个时间段并将它们呈现给用户。\n我们可以使用正则表达式来提取时间，具体的表达式取决于你使用的编程语言和情况。 以下是一些示例:\n- 在 Python 中，可以使用 re 模块: \n``` python\nimport re\ntext = \"我们下午2点要开会，然后我会在5点之前到家。\"\ntime_pattern = '\\d{1,2}:\\d{2}'\ntimes = re.findall(time_pattern, text)\nprint(times) # ['2:00', '5:00']\n```\n- 在 JavaScript 中，可以使用正则表达式: \n``` javascript\nconst text = \"我们下午2点要开会，然后我会在5点之前到家。\";\nconst time_pattern = /\\b\\d{1,2}:\\d{2}\\b/g;\nconst times = text.match(time_pattern);\nconsole.log(times); // ['2:00', '5:00']\n```\n因此，我们可以使用以上代码提取出输入中的所有时间段：下午2点和5点之前。", "class": "code"}
{"question": "回答以下问题：在哪些情况下，你通常会感到紧张？", "std_answer": "人们通常在面临一些挑战、压力或不确定性时会感到紧张。以下是一些常见的情况，可能会让人感到紧张： \n1. 公开演讲或演出：在公众场合演讲或演出时，可能会因为对自己的表现是否能够取得成功而感到紧张。这种情况下，许多人都感到紧张、不安和不自信，因为他们担心自己可能会犯错误或者在表达上出现问题。\n2. 面试：面试是一种形式化的环境，人们在这种环境下会有一定的紧张感。这种紧张可能是因为担心自己无法回答问题、表现不佳或者无法给招聘者留下好印象。尽管许多人都指望通过面试来实现自己的职业目标，但面试仍然是一种紧张的情境。\n3. 考试：接受考试是校园生活中不可避免的一部分，但它会让许多人感到紧张和担忧。不管是面对高中考试还是大学考试，人们都可能担心自己无法通过考试，或者在考试中犯错。\n4. 社交场合：许多人在社交场合中也可能感到紧张和不安。在这种情况下，人们担心自己无法与他人交流或者无法与他人建立联系。这种压力可能会尤其严重，特别是当人们感到社交场合能够决定人际关系或者事业发展时。\n5. 重大决策：面对一些需要做多项决策的时刻，人们很可能感到焦虑、紧张或者不安。这种情况下，人们可能担心他们做出的决策是否正确或者他们的决策会带来其他不良后果。\n6. 竞争中：在竞争中，例如在一项运动比赛中或者知识竞答中，人们也可能感到紧张。这种压力可能来自于竞争对手，对自己表现的期望以及对胜利的追求。\n总的来说，人们通常在情境中需要承担一些压力、不确定性或者挑战时会感到紧张不安。然而，人们可以通过一些方法来应对这种紧张，例如放松和专注自己的感受、深呼吸或者寻求他人支持。", "class": "open qa"}
{"question": "如何在电脑上安装浏览器扩展程序。", "std_answer": "", "class": "brainstorming"}
{"question": "提供故事的一部分并要求继续剩余的部分。\n李明在森林中散步时突然发现了一条让他吃惊的大蛇。", "std_answer": "", "class": "generation"}
{"question": "请对给定的一组关键词进行分类，以显示它们之间的关系。\n关键词：科比·布莱恩特、篮球、洛杉矶湖人队、NBA、退役", "std_answer": "这组关键词都与职业篮球员科比·布莱恩特相关。科比·布莱恩特是NBA的一名退役职业篮球员，他最著名的球队是洛杉矶湖人队。以下是这些关键词的分类：\n1. 科比·布莱恩特：这个关键词是指科比本人，是这个关键词集的核心。\n2. 篮球：这个关键词提示与科比相关的活动——职业篮球。科比是职业篮球运动员，篮球是他所从事的运动。\n3. 洛杉矶湖人队：科比最著名的球队，也是他职业生涯的主要工作地点。科比在洛杉矶湖人队效力了20年，赢得了许多荣誉和奖项。\n4. NBA：国家篮球协会，是科比作为职业篮球员的联赛。科比在NBA中度过了他的整个职业生涯。\n5. 退役：这个关键词表示科比于2016年宣布退役，之后他结束了他的职业篮球生涯。", "class": "classification"}
{"question": "判断以下陈述的真伪：“大熊猫不仅出现在中国，也出现在印度。”", "std_answer": "这个陈述是不准确的，大熊猫只存在于中国，而不是印度。\n大熊猫是一种熊科动物，是中国国宝级动物，也是全球野生动物保护重点对象。大熊猫的天然栖息地在中国的中西部地区，主要分布在四川、陕西、甘肃等省份。这些地区通常被称为大熊猫的故乡。\n虽然中国一直致力于大熊猫的保护，但大熊猫的栖息地遭受了森林砍伐，生态破坏和人类干扰等多种威胁。由于这些原因，大熊猫数量已经大幅减少，目前仅存于中国的野生和圈养繁殖中心。\n因此，大熊猫只存在于中国的自然环境和圈养环境中，而没有在印度或其他任何国家的野外或圈养环境中发现。这也使得大熊猫成为了珍贵的、极为稀有的物种。", "class": "closed qa"}
{"question": "将给定的一组文本重新排列，使它们形成一个连续的故事。\n请重新排列以下文本片段：第一段是一个男人，他找到了一张宝藏地图。第二段是他的旅程，到达目的地。第三段是他在地下室中找到宝藏。", "std_answer": "以下是重新排列后的文本片段，形成了一个连续的故事：\n第一段：一个男人找到了一张宝藏地图。\n第二段：他开始了旅程，并最终到达了目的地。\n第三段：在地下室中，他成功地找到了宝藏。\n在这个故事中，这位男子在找到了一张宝藏地图后，开始了一段旅程，跋山涉水到达了目的地，最后在地下室中成功地找到了那个被隐藏的宝藏。这个故事激发着我们一颗追求探险的心，不断追求我们生活中的目标。", "class": "closed qa"}
{"question": "回答一个通识问题。\n解释一个人类习惯的起源，例如为什么把戒指戴在无名指上。", "std_answer": "戴戒指的习惯可以追溯到古埃及文明，大约在公元前2800年左右的时期。当时，人们发现在无名指上戴上戒指可以将“Vena amoris”血管连接到心脏，据传言可以增加情感和爱情的力量。\n这种习惯随着时间的推移逐渐传到了古希腊和古罗马，后者是使用婚戒的重要早期文化之一。在罗马帝国的婚礼仪式中，新娘会戴上铁环，这是一种象征她的新地位和忠诚的象征。这种习惯随着时间的推移也渐渐传到了欧洲各地。\n在基督教文化中，这种习惯得到了进一步的发扬光大。基督教徒在婚礼时常常戴上金色或银色的戒指，这些戒指也在很大程度上成为婚姻的象征。在欧洲，这种习惯很快就蔓延到了其他地区，在与基督教婚姻相关的文化中，无名指都被认为是传统的戴戒指的位置。\n此外，无名指相对于其他手指比较独立，使用其他手指通常需要握紧拳头的作用。这种习惯无论是在文化上还是实用上都得到了很好的发展，因此戴戒指的习惯现在已经成为了固化的文化传统。", "class": "open qa"}
{"question": "美国白宫的地址是什么？", "std_answer": "美国白宫位于华盛顿特区的宾夕法尼亚大道1600号，邮政编码为20500。 它是美国总统的官邸和工作地点，也是美国政府的中心。白宫占地18英亩，有132个房间和35个浴室。建于1792年，它是美国的历史遗产和国家地标。每年有数百万人参观白宫，可以通过预约或参加常规游览来参观。", "class": "open qa"}
{"question": "解释与水污染有关的术语：生化需氧量(BOD)、化学需氧量(COD)、总固体(TSS)、总悬浮物(TDS)。", "std_answer": "生化需氧量(BOD)、化学需氧量(COD)、总固体(TSS)和总悬浮物(TDS)都是与水污染相关的术语，用于评估水中的污染程度。\n1. 生化需氧量(BOD)\n生化需氧量(BOD)是指水中有机物质被微生物分解消耗氧气的速度，通常用来衡量水体中的有机物质含量。生物在分解有机物质时需要氧气，如果水中存在大量的有机物质，就需要更多的氧气，从而减少水中的氧气含量，使水体变得富含污染物。BOD值通常用毫克氧气在升水中被消耗的时间(n日BOD)表示，常用5天的时间来测定。水中的BOD值越高，表示水中有机物质的含量越高，污染程度也越高。\n2. 化学需氧量(COD)\n化学需氧量(COD)是综合检测水体中的有机物、无机物和微量元素等化学物质的数量和质量的一种化学指标。COD值表示水中的有机物质与氧气结合反应的能力，以毫克氧气每升水的消耗量来表示。COD值越高，表示水中有机物质的含量越多，水体污染也越严重。相对于BOD，COD更适合检测水中富含难以降解有机物质的情况。\n3. 总固体(TSS)\n总固体(TSS)是指水中悬浮状态的颗粒物和沉淀物的总和。TSS可以是有机的，也可以是无机的，在水污染中表明了水中悬浮物质的含量。 TSS值通常用毫克每升表示。悬浮物质的含量越高，水体的透明度越低，也就越容易造成水质降低和水生物生命周期的影响。\n4. 总悬浮物(TDS)\n总悬浮物(TDS)是所有悬浮物，无论大小都被计算在内，包括细胞，病毒，细菌，矿物颗粒和其他杂质。 TDS值通常用毫克每升表示。与TSS不同，TDS包括更细小的悬浮体，并且不能通过常规的过滤方法去除。通常，TDS不是常规的评估水质的指标，但在特定的应用场合下仍然有用。\n总之，BOD、COD、TSS和TDS等指标是用来量化水质中污染物质的含量和质量的，可以帮助评估水体的污染程度，监测水源是否受到污染。水质监测有利于预防和治理水污染，保障人民健康和环境的可持续发展。", "class": "open qa"}
{"question": "解释甲骨文的历史和用途。", "std_answer": "甲骨文是指中国商朝（约公元前16世纪至公元前11世纪）时期在龟骨、兽骨等动物骨头上刻划的文字，也称为“龟骨文字”、“兽骨文字”。这些文字被用于卜辞、记录历史事件、墓志铭等用途。\n这些甲骨文最初是被商朝当权者用来进行祈祷或预测未来。他们相信通过卜筮可以获得神的指引和启示。在卜筮之后，祭司会将问题和预测的结果刻在龟骨或兽骨上。这些骨头上刻的文字称为甲骨文。\n除了卜筮，甲骨文还被广泛地用于商朝的行政和宗教活动。商朝的政治制度非常集中，国王掌握了所有的权力。作为国家管理机构的一部分，甲骨文被用于记录政府的文件，包括土地、人口、官僚的职位等信息。此外，甲骨文还被用于记录祭祀活动和宗教信仰，包括神庙的建造、祭神的仪式等等。\n甲骨文对于研究古代中国的历史、文化和语言具有重要的意义。通过研究甲骨文，我们可以了解到商朝时期人们生产和生活的方式，政治和社会制度的运作，宗教信仰和祭祀活动的形式，以及古代汉语的演化。因为甲骨文是中国最早的文字之一，它的出现也标志着中国进入了文明社会。\n此外，甲骨文的破解过程其实也是一项具有挑战的研究工作，甲骨字繁杂、图案纷繁，需要具备丰富的历史、语言及考古、计算机等学科知识，加以深入研究才能让甲骨文真正被解译出来，这对于现代中国及全人类的文化与历史研究都有着极为深远的影响。", "class": "open qa"}
{"question": "解释用于评估机器翻译性能的常见指标。", "std_answer": "", "class": "brainstorming"}
{"question": "给定一份工作的职责和要求清单，解释你为什么是最适合这份工作的人选。\n清单：1.精通区块链技术；2.拥有3年以上的工作经验；3.能够工作自主且具备解决问题的能力。", "std_answer": "", "class": "brainstorming"}
{"question": "为以下五个名称写一个简短的解释。\na. 蒙娜丽莎 b. 股票 c. 人工智能 d. 深度学习 e. 量子力学", "std_answer": "a. 蒙娜丽莎：\n蒙娜丽莎是意大利文艺复兴时期著名画家达芬奇的一幅画作，也被称为“笑容的女士”。这幅画以半身像的形式描绘了一个女性的形象，她微笑着，同时注视着前方的观众。这幅画具有很高的艺术价值和文化价值，在很长的一段时间内一直是世界著名的艺术珍品之一。\nb. 股票：\n股票是指一份公司的所有权证明，代表着其持有者对于这家公司的部分所有权。股票市场是一个开放的市场，持有者可以在市场上自由买卖股票，根据市场供求关系决定股票价格的涨跌。股票市场的投资风险和回报都比较大，是一种成熟的投资方式。\nc. 人工智能：\n人工智能是模仿人类智能和思维的一种技术和学科领域。它涉及到计算机科学、数学、语言学、哲学等多个学科领域。人工智能技术可以使计算机系统具有感知、推理、学习、自动化等一系列人类智能思维的能力，可以在多个领域应用，例如医疗保健、智能制造、交通运输等。\nd. 深度学习：\n深度学习是人工智能领域的一个分支，主要关注如何将神经网络模型应用到具体问题中。它以多层神经网络为基础模型，通过大量的数据训练模型参数，让模型逐步学习到对输入数据在低层次、中层次和高层次的抽象表示，并利用这些抽象表示做出准确的预测和判断。\ne. 量子力学：\n量子力学是一门研究微观粒子的行为规律和性质的学科，研究对象主要是原子、分子、基本粒子等微观领域中的物理规律。量子力学提出了一种与经典物理完全不同的描述物质运动的数学方法，它突破了经典物理学的框框，引领人类认识自然界的新思路和轨迹，也是现代普遍的科学基础之一。", "class": "open qa"}
{"question": "根据给定的情境，重写下面的句子，使其更加礼貌：你写下的代码很难懂。\n场景示例：老板正在评估员工提交的代码", "std_answer": "", "class": "rewrite"}
{"question": "请将以下英文文章翻译成中文。\nThe ability to communicate effectively is an essential skill in today's world. Whether it's in business, education, or personal relationships, being able to convey information clearly and accurately is key to success.", "std_answer": "在当今社会，有效沟通的能力是一项必不可少的技能。无论是在商业、教育还是个人关系中，能够清晰准确地传达信息对于成功都至关重要。", "class": "rewrite"}
{"question": "基于下面的这个故事，总结其中最重要的三个事件。\n小明是一个好学生，每天早上都要起得很早去上学。有一天，他迟到了，因为他的家里来了一个客人。晚上，他参加了一次班级会议，会议主题是如何提高学习效率。回到家后，他又花了一些时间复习功课。", "std_answer": "小明故事中最重要的三个事件是：\n1. 小明迟到了。这个事件突出了小明平日里的好学生形象被打破，因此非常重要。\n2. 参加班级会议并学习提高学习效果的方法。这个事件突出了小明在学习方面非常有自觉性，主动寻求进步的态度，也是故事中最有建设性的一部分。\n3. 花时间复习功课。在家里花时间复习功课，突出了小明在学校或家庭都非常重视学习的态度，是小明努力学习的佐证。", "class": "summarization"}
{"question": "提供互联网搜索公司的历史和主要发展阶段。", "std_answer": "互联网搜索公司的历史可以追溯到20世纪90年代的早期互联网时代，但是最著名的搜索引擎公司都是在2000年代初期兴起的。以下是一些主要的搜索引擎公司及其发展阶段：\n1. Yahoo!（1994年成立）：Yahoo!成立于1994年，最初是一个网站目录服务。在1995年，Yahoo!推出了其搜索引擎服务，该引擎使用自己的爬虫来索引网页。自成立以来，Yahoo!不断发展壮大，成为互联网最大的门户之一。然而随着Google的兴起，Yahoo!在2000年代初期开始逐渐失去市场。\n2. Google（1998年成立）：Google成立于1998年，最初是两个斯坦福大学研究生创建的搜索引擎。Google的搜索引擎采用 PageRank 算法来确定页面的重要性，并使用更好的搜索算法将搜索结果呈现给用户。Google的成功远远超过了其竞争对手，成为现今全球最大的搜索引擎公司之一。\n3. Baidu（2000年成立）：Baidu成立于2000年，是中国规模最大的搜索引擎之一。Baidu最初是一个免费MP3下载网站，但在2001年改变战略，开始提供搜索引擎服务。Baidu在中国境内很快成为了最受欢迎的搜索引擎，主要原因在于其更好的本土化服务以及社交功能。\n4. Bing（2009年成立）：Bing是微软在2009年借助自己的搜索技术打造出来的搜索引擎，其最初定位是一个“决策引擎”，个人认为是在将搜索结果呈现给用户时，融合他们可能需要的更多相关信息。Bing在英语国家以外的很多地方实际上都是主要搜索引擎，这与其较好的本土化策略有关。\n5. DuckDuckGo（2008年成立）：DuckDuckGo成立于2008年，是一家以隐私保护为基础的搜索引擎公司。DuckDuckGo专注于在保护用户隐私的同时提供更好的搜索结果呈现，其模式和Google的模式相比是完全相反的。\n总的来说，互联网搜索公司的发展离不开先进的技术和搜索算法，以及更好的本土化服务和用户体验。随着技术的不断进步和用户需求的不断变化，我们可以相信未来的搜索引擎市场会越来越丰富和多元化。", "class": "open qa"}
{"question": "基于以下文字，抽取相关信息，包含时间（Time）、地点（Location）、人物（People）、事件（Incident）、观点（Idea）。并格式化表示为：{\"Time\":\"<抽取出的时间>\",\"Location\":\"<抽取出的地点>\",\"People\":\"<抽取出的人物>\",\"Incident\":\"<抽取出的事件>\",\"Idea\":\"<抽取出的观点>\"}，其中如果没有相关信息，则表示为null。抽取出来的信息用中文表示。\nSophie独自一人在海滩上散步，思绪万千。她想到了自己过去的种种经历，包括曾经的爱情和失落。突然，一只小海豚从海水中跃出来，引起了她的注意。它开始在水中跳跃，好像在邀请Sophie一起玩耍。Sophie不禁笑了出来，跟着海豚一起跳跃着。她感到心情渐渐明朗起来，仿佛这个小小的生命在向她传递着某种信息。在这个海滩上，Sophie找到了新的希望和活力，她决定要以全新的态度面对未来。", "std_answer": "{\"Time\":null,\"Location\":\"海滩\",\"People\":\"Sophie\",\"Incident\":\"Sophie在海滩上散步，看到小海豚跳跃，并跟着它一起玩耍。Sophie找到了新的希望和活力，决定要以全新的态度面对未来。\",\"Idea\":\"Sophie从小海豚身上得到了某种信息，让她的心情变得明朗起来。\"}", "class": "extract"}
{"question": "根据以下文本，生成一段100字的文章，反映该事件的前因后果以及应对措施。\n最近，某市发生了一起食品安全事件，一名女性在食用坊市场购买的熟食后不久就出现了食物中毒症状。调查发现，熟食中含有有害物质，该市政府已经采取了严厉措施，并迅速查处了罪犯。", "std_answer": "", "class": "generation"}
{"question": "将以下句子恢复成完整的篇章。\n半夜三更，他收到了一封神秘的邮箱。", "std_answer": "", "class": "generation"}
{"question": "描述一个完美的周末计划。", "std_answer": "", "class": "generation"}
{"question": "根据所提供的信息，为一个商品或服务写一份优秀的广告文案。\n商品：新的口红系列。关键卖点：颜色持久，适合所有肤色。", "std_answer": "", "class": "generation"}
{"question": "根据以下场景描述，分类出该事件属于哪种证券欺诈类型。\n公司A推出了一种虚拟货币，在社交媒体上承诺高额回报，但实际上该货币不存在。", "std_answer": "该事件属于欺诈发行行为中的虚假宣传类证券欺诈。\n具体来说，公司A在虚构一种虚拟货币产品并宣传其高额回报的同时，并未提供真实的信息以证实该货币的存在和合法性，从而误导投资者进行投资行为。这种行为涉嫌虚假陈述或者误导，属于欺诈发行行为中的虚假宣传类证券欺诈。\n此类欺诈行为严重影响了投资者的判断，损害了公众的利益，如果被发现，投资者可以向当地证券监管机构投诉，也可以向当地法院提起诉讼。同时，投资者在进行投资前应该认真查看相关信息，了解其是否存在和合法性，提高对投资风险的认知，以保护自己的利益。", "class": "classification"}
{"question": "描述一个适合初学者的学习曲线，用于学习大数据分析。\n学习的目标和学习路径", "std_answer": "", "class": "brainstorming"}
{"question": "阐述一种新的商业模型，使团队更能够有效地协作。", "std_answer": "", "class": "brainstorming"}
{"question": "从大众的角度，解释如何防范网络诈骗。", "std_answer": "", "class": "brainstorming"}
{"question": "根据所提供的问题，回答一个逻辑思维问题\n你只有一把小刀，如何在三次尝试之内切断一根木棍？", "std_answer": "首先，要想在三次尝试之内切断一根木棍，就需要在第一次尝试时进行一个有效的切割，以便在后续的两次尝试中进行调整和完善。因此，下面给出两种可能的策略：\n策略一：\n1. 确定切割点：观察木棍，找到一处比较脆弱，或者比较细小的地方，作为第一次切割点，以便在第一次尝试中切断木棍。 \n2. 将刀子插入木棍：将小刀插入所选的切割点，其插入角度应该是垂直于木棍的方向，这样可以更容易地断开木棍。 \n3. 用力切割：用足够的力气将小刀从木棍的一侧刺到另一侧，直到木棍被切断。 \n如果第一次尝试失败，则必须在接下来的两次尝试中找到一个新的切割点。 \n策略二：\n1. 绕木棍布置陷阱：先在木棍的某个地方搭建陷阱，让木棍受到压力，而在陷阱处抵抗力较小，这样在第一次尝试中，木棍会在陷阱处断裂。\n2. 用力切割：在木棍断裂的部位再次用小刀切割，这样可以更加方便和容易地将木棍切断。 \n策略二的优势在于可避免在第一次尝试失败时浪费尝试次数，但也需要相对更多的实验时间和物资才能成功，因此需要在具体情况下根据需要选择合适的策略。", "class": "open qa"}
{"question": "根据提供的文本重写其中的一段，使之更加简明扼要，同时不丢失原文本的主要信息。\n纽约市，简称“纽约”，通常被称为“大苹果”，是美国最大的城市，也是全世界最大的城市之一。位于美国东海岸，东北部边界是大西洋，在新泽西州的东南部。", "std_answer": "", "class": "rewrite"}
{"question": "为可口可乐饮料撰写评论。", "std_answer": "", "class": "generation"}
{"question": "按照以下要求，写一个SQL查询语句：从表中查找所有性别为女性的学生的姓名和学号。\nSELECT name, id FROM students WHERE gender = '女性'", "std_answer": "这是一个简单的SQL查询，目标是从名为“students”的数据表中提取“姓名”和“学号”列中的数据，这些数据来自符合特定条件的行，即“性别”列等于“女性”。\n下面是详细的SQL语句：\n```\nSELECT name, id \nFROM students \nWHERE gender = '女性'\n```\n- SELECT指令中包含两个元素，名称和ID。\n- FROM指令用于指定要从哪个表中提取数据。\n- WHERE指令用于筛选满足特定条件的行。在这个例子中，条件是“性别”列等于“女性”。\n执行此SQL查询，将返回“名字”和“学号”列中的数据，这些数据都来自于符合条件的行，即性别是“女性”的学生。", "class": "code"}
{"question": "根据一段对话提取关键信息。\n客户：我需要一台笔记本电脑，可以玩游戏。 \n售货员：我们这里有一款Alienware笔记本电脑，适合用于游戏。\n客户：哇，Alienware？听说这个品牌很好，但是价格也很贵吧？\n售货员：是的，Alienware的产品一向以高性能和高价格著称，但是它们也非常耐用，可以让您长时间享受游戏体验。\n客户：那这款笔记本电脑的配置怎么样？\n售货员：这款Alienware笔记本电脑配备了Intel Core i7处理器、16GB DDR4内存、512GB SSD存储、NVIDIA GeForce RTX 3070显卡等高端配置，可以运行各种大型游戏。\n客户：听起来很不错，但是我还是想知道它的价格是多少？\n售货员：这款笔记本电脑的价格是5000美元，但是我们可以提供一些优惠，让您可以享受到更好的价格。\n客户：好的，我想了解一下这些优惠。\n售货员：我们可以提供一些折扣和礼品，比如免费延长保修期、降低价格等等。您可以根据自己的需求和预算选择合适的优惠方式。\n客户：好的，我需要考虑一下，谢谢你的介绍。\n售货员：不用客气，如果您有任何其他问题或需要进一步的咨询，请随时联系我们。", "std_answer": "客户需要一款适合玩游戏的笔记本电脑，售货员推荐了Alienware品牌的笔记本电脑，它具有高性能的配置，包括Intel Core i7处理器、16GB DDR4内存、512GB SSD存储和NVIDIA GeForce RTX 3070显卡。这款笔记本电脑的价格为5000美元，但是售货员表示可以提供一些优惠，比如延长保修期和降低价格等。客户需要考虑一下并决定是否购买。", "class": "extract"}
{"question": "为以下文本分类：\n最新研究结果表明，经常使用手机的人很容易出现头痛、颈痛和手部疼痛等不适症状。使用手机时，人们通常会低头看屏幕，这会导致颈部肌肉长时间处于紧张状态，从而引发颈痛；同时，长时间使用手机也会导致手部疲劳和肌肉酸痛。此外，过度使用手机还会导致眼睛疲劳和干涩感，甚至会影响睡眠质量。因此，我们应该适度使用手机，注意调整坐姿和使用时间，避免过度使用手机带来的身体不适症状。", "std_answer": "这段文本是有关健康和生活方式的话题。更具体地说，它讨论了使用手机可能会导致头痛、颈痛和手部疼痛这一主题。因此，针对这段文本的分类可以是“健康”或“生活方式”。\n具体来说，这段文本提供了新的研究结果，这意味着它提供了有关现有知识的新信息。使用手机可能会成为导致头痛、颈痛和手部疼痛的原因。这一信息可能会引起人们的注意，并促使他们考虑如何减少手机使用的时间或采取其他预防措施。\n总之，这段文本表明对我们的身体和生活方式有影响的话题。分类可以是“健康”或“生活方式”，具体取决于分类系统的目的和上下文。", "class": "classification"}
{"question": "提供一段说明请求，以解释一项特定技术的使用方式。\n文本内容：解释如何使用Github进行版本控制。", "std_answer": "Github是一个支持版本控制的在线代码托管平台，它允许用户将自己的代码网上存储，并与其他人合作开发代码。\n在使用Github进行版本控制之前，需要先创建一个Github账户并登录。接下来，用户需要在本地计算机上安装Git工具，这是一个用于管理版本控制的工具。Github还提供了一个名为GitHub Desktop的桌面应用程序，可以帮助用户在本地使用Git。\n一旦安装好Git，用户可以在本地计算机上创建一个项目文件夹，在该文件夹内使用Git命令初始化版本控制，然后创建一个本地分支。用户可以将这个分支视为独立于主分支的临时分支，用于开发新特性或修复错误。\n当代码本地修改后，用户需要使用Git提交这些更改到本地分支中。这些更改可以包括添加，修改或删除文件等操作。每次提交更改时，用户需要给提交附上描述性的注释，以便其他开发人员查看。\n当用户完成局部工作并准备将代码推送到GitHub服务器时，可以使用Git命令将本地分支推送到服务器上的远程分支。在推送之前，用户可以先将本地分支与主分支进行合并，确保代码在推送到远程服务器上后不会发生冲突或错误。\n当多个开发人员使用Github进行开发时，他们可以通过在Github上fork一个项目来克隆主项目，对该项目进行修改并提交更改请求（pull request）。项目维护者可以查看pull request并将更改合并到主项目中。这种开发和协作方式让多人同时修改代码成为可能，避免了代码混乱和错误。", "class": "open qa"}
{"question": "按照以下要求撰写一篇简答。\n人造光源的历史及其发展", "std_answer": "", "class": "generation"}
{"question": "为一个自闭症患者编写一份个性化的治疗计划。\n患者是一个12岁的男孩，最喜欢的玩具是乐高积木。", "std_answer": "", "class": "generation"}
{"question": "描述一个人造卫星的用途、构成和工作原理。", "std_answer": "人造卫星是一种在轨道上运行的人工飞行器，由地球上的科学家和技术人员制造。它的主要用途是提供各种通信、导航、科学研究和军事应用等服务。接下来，我们将探讨人造卫星的构成、用途以及工作原理等方面的详细信息。\n一、构成\n1.控制系统：人造卫星必须能够在空间中精确地控制其运动和定位。因此，它需要一个高度精确的控制系统，用来控制它的航向、位置和速度等参数。\n2.能源系统：人造卫星需要能够持续提供电力，以维持其所有的功能和系统。因此它通常配备太阳能电池板，通过太阳能将能量转化为电力。\n3.通讯系统：卫星必须能够与地面站进行通信，以便传递信息。通信系统通常由天线和发射器等组成。\n4.传感器：卫星需要搭载各种传感器，如照相机、气象仪器、地球物理仪器、监视器等等。\n二、用途\n1.通信：人造卫星是一种重要的通信方式，通过卫星通信可以实现远距离通信，使得人们可以在全球任何位置进行无障碍通信。\n2.导航：许多国家使用人造卫星作为全球定位系统（GPS）等导航服务的重要组成部分，以提供人们进行航行、飞行和旅行之类的方向指导。\n3.气象观测：人造卫星可以用于气象观测，监测天气预报、气候变化和自然灾害等。\n4.科学研究：人造卫星可以用于科学研究，探索宇宙、地球、太阳系和宇宙物理学等领域。\n5.国防安全：人造卫星也可用于侦察、军事通信等目的，可以提供战场情报和战争支持。\n三、工作原理\n1.发射：人造卫星首先需要在地面被发射入轨道。发射过程需达到极高的速度和高度以才能逃离地球的引力，进入预定的轨道。\n2.轨道：人造卫星在轨道上保持匀速旋转，同时高速运行及惯性原理使得其始终保持原有轨道。轨道的方向和高度都是根据卫星的功能来设计的。\n3.定位：卫星通过从地面航空监视系统获取自己的位置，依靠惯性系统及控制系统对其进行校准，以始终保持在预定的轨道上。\n4.通信：卫星上的控制系统及电子设备通过使用特定频率的电波与地面上的控制系统进行通信，然后再将信息传送到指定的接收器。\n5.能源：人造卫星使用太阳能电池板进行充电，以供电子系统、通信和传输设备的运作。在太阳能供能不足时，卫星上安装的电池则负责维持其正常运行。\n总结：人造卫星是一种在轨道上运行的人造飞行器，它由许多不同的设备组成，用于进行通信、导航、气象观测、科学研究和国防等方面的任务。它的工作原理包括发射、定位、通信和能源等方面。", "class": "open qa"}
{"question": "编写一个python程序，完成从raw文本数据集中提取出整数的任务，输出这些整数的总和。\n数据集：\n今天是21号，天气很好。我有两个苹果和三个橘子。这个电脑屏幕大小是15.6寸。这次旅行大约花费了800元，我们住了两晚酒店。总共有10个人参加了聚会。", "std_answer": "可以使用Python编写程序来完成这项任务，步骤如下：\n1.读取原始文本文件。\n2.定义一个列表来存储所有提取出来的整数。\n3.对于文本文件中每一行，使用正则表达式来匹配所有的整数，提取出来并加入列表中。\n4.将列表中的所有整数求和。\n5.输出总和的结果。\n下面是示例代码实现：\n```python\nimport re\nsum = 0\nints = []\nwith open('raw_data.txt', 'r') as f:\n for line in f:\n nums = re.findall(r'\\d+', line)\n for num in nums:\n ints.append(int(num))\nsum = sum(ints)\nprint(\"所有提取出整数的和为：\", sum)\n```\n输出结果为：所有提取出整数的和为： 831\n解释：程序读取原始文本文件，使用正则表达式来匹配出所有整数并将其加入列表中，最后将列表中的所有整数求和，输出求和的结果。在此数据集中，共有5个整数，它们的和为 21+2+3+15.6+800+2+10=831。", "class": "code"}
{"question": "文化艺术报讯 国务院办公厅发布关于2023年部分节假日安排的通知，具体内容如下：元旦：2022年12月31日至2023年1月2日放假调休，共3天。春节：1月21日至27日放假调休，共7天。1月28日（星期六）、1月29日（星期日）上班。清明节：4月5日放假，共1天。劳动节：4月29日至5月3日放假调休，共5天。4月23日（星期日）、5月6日（星期六）上班。端午节：6月22日至24日放假调休，共3天。6月25日（星期日）上班。中秋节、国庆节：9月29日至10月6日放假调休，共8天。10月7日（星期六）、10月8日（星期日）上班。\n基于以上信息回答：2023年五一假期怎么放假。", "std_answer": "4月29日至5月3日放假调休，共5天。", "class": "extract"}
{"question": "根据输入的问题，填写下面的空格。\n四川人喜欢吃___。", "std_answer": "四川人喜欢吃辣味食物。四川被称为中国的“天府之国”，这里的饮食文化源远流长，尤其是以辣味风味而著称。四川人嗜辣程度之高，使得“辣”成为了四川菜肴最鲜明的特色之一。在四川菜肴中，各色辣椒（如泡椒、郫县豆瓣等）被广泛运用于各式四川招牌菜（如水煮鱼、麻婆豆腐、酸辣粉等），形成了独具特色的麻辣口感和风味。除了辣味食物外，四川菜肴也以色香味俱佳、重视用料的特点著称，涵盖了多种口味和风格，如麻辣、酸辣、鲜香、清淡等等。", "class": "open qa"}
{"question": "请说出三种常用的前端框架。", "std_answer": "前端框架是一种能够帮助开发者提高前端开发效率、强化网站交互性和可维护性的工具。以下是三种常用的前端框架：\n1. AngularJS：AngularJS 是 Google 开发的一款基于 MVC 的前端框架。 它将应用程序、数据和 DOM 元素相互分离，前端开发者可以更容易地使用数据来驱动用户界面和应用程序行为。使用 AngularJS，开发者可以通过一个清晰的、可重复使用的代码库来创建丰富的客户端应用程序。\n2. React：React 是 Facebook 声明的一个构建用户界面的 JavaScript 库（不是一个框架）。 React 使用虚拟 DOM 的概念来实现快速的UI更新，同时也能够将复杂的UI分解成可组合的组件，从而极大地提高了代码的可重用性和可维护性。React 可以被用来与其他库或框架(如 Flux 或 Redux)一起搭配使用。\n3. Vue.js：Vue.js 是一个轻量级易学的前端框架。 Vue.js使得开发者可以轻松地集中精力于应用程序的核心功能，在组件化方面也有许多的优势。 在 Vue.js 中，每个组件都被抽象成一个独立的模块，可以方便地进行复用和组合。这使得Vue.js 是非常适合快速开发中小规模的应用程序，同时也具有良好的扩展性。", "class": "open qa"}
{"question": "给定一篇文章，创建一个摘要，限制长度为三句话。\n文章：根据新闻报道，随着气温的升高，草地上的野花开始陆续绽放，缤纷的色彩让人心情愉悦。微风吹拂，花瓣轻轻摇曳，飘散出迷人的芬芳。这时，草地变成了一个绚烂多彩的世界，吸引了许多人前来欣赏这美丽的景象。特别是小孩子们，他们在花丛中尽情嬉戏打闹，捧着鲜花玩耍，充满着童趣和活力。他们的欢笑声在草地上回荡，将整个夏天的氛围变得更加欢快。这样的美好景象预示着即将到来的夏天将会充满无限的希望和美好。草地上的野花将持续绽放，让人们感受到大自然的美妙和生命的蓬勃。", "std_answer": "这篇新闻报道描述了随着气温的升高，草地上的野花开始绽放，色彩斑斓，气氛变得更加欢快。特别是小孩子们在花丛中嬉戏打闹，让整个夏天充满了童趣和活力。这样的景象预示着即将到来的夏天将会充满无限的希望和美好，草地上的野花将持续绽放，让人们感受到大自然的美妙和生命的蓬勃。", "class": "summarization"}
{"question": "根据给定文本，将文章分类为新闻、广告或文学作品。直接输出分类结果。\n今天的新闻报道了一场气旋袭击了印度东部的一个州，导致至少20人死亡。在丝绸之路上，我们推出了一个全新系列的产品。汤姆·索亚的冒险是一部经典的儿童文学作品。", "std_answer": "新闻", "class": "classification"}
{"question": "使用创意思维方法来产生尽可能多的使用口红的场景。", "std_answer": "", "class": "brainstorming"}
{"question": "描绘一幅海滩的画面，包括天空，海浪和沙滩。", "std_answer": "", "class": "brainstorming"}
{"question": "翻译一篇简短的新闻报道，翻译成中文。\nText: Japan's economy shrank for the first time in two years in the quarter of July-September, as natural disasters hit consumer spending and disrupted exports.", "std_answer": "日本经济在7月至9月季度首次萎缩，原因是自然灾害影响了消费支出和出口。", "class": "rewrite"}
{"question": "阅读下列文本，回答问题：在中国古代，什么是科举制度？\n科举制度是中国古代选官制度，从唐朝开端，至清朝末年废止。管辖地区由国家设立的行省，即省境内的读书院、府、州、县所属，派出官吏组织考试，考察文、理商等科目的考生来选拔官吏。", "std_answer": "科举制度是中国古代的一种选官制度，它的历史可以追溯到唐朝。该制度通常由国家聘请的官员组织，在各个省份设立的读书院、府、州、县，主要考察考生的文学、理学和商业知识等方面的能力，这些科目具体包括诗词、文章、经史、孝、礼、乐、射等文化和礼仪方面的知识。考试分为三个阶段，分别是府试、会试和殿试。\n首先，考生需要通过府试来筛选的过程。府试的培训由各地派出官员负责，它主要寻求的是考生的基本文化知识，如字、句、章、文学修养等，以及应验诗、文章或商业事业能力的程度。\n完成府试之后，考生还需要进行会试，这是一个更高级别的考试。会试中，考生从全国各地集中在中国的东南部，如江南和福建。考生必须在几天内完成一系列的写作和口试，这些写作和口试通常比较难，能力要求更高。会试结束后，考生能否被推荐参加殿试取决于考试官员。殿试是科举制度最终的考试环节，也是最具权威性的一部分，由皇帝主持，面向全国人才选取官员。\n科举制度在中国古代存在了大约1,300年，历经唐、宋、元、明、清五个朝代。它为拥有知识和才能的人提供了一个进入政府和社会的机会。并且科举制度也大大提高了中国的国家治理能力，为官员的选拔提供了客观标准和严密流程。在科举制度的影响下，中国的文化和文学在历史上也达到了新的高度。", "class": "closed qa"}
{"question": "请根据以下提示回答问题：据说哪种食物可以帮助改善睡眠？\n提示：这种食物富含一种名为三色酚的物质，可以消除体内催眠物质的分解。", "std_answer": "据说富含一种名为三色酚的食物可以改善睡眠。三色酚是一种天然的化合物，常见于某些植物中，如桉树、胡桃、葡萄饮品等。三色酚具有抗氧化、降血压和消炎等多种健康作用。同时，研究表明三色酚可以帮助改善睡眠。\n三色酚被称为一种“自然的催眠剂”，它能够消除体内催眠物质的分解，从而促进睡眠。催眠物质是指一种名为腺苷的化合物，它是人体内的一种神经递质，能够帮助身体放松并入睡。当腺苷分解时，人体会感到清醒和精力充沛。但是，三色酚可以阻止腺苷的分解，从而使它在体内积累，有助于缩短上床后入睡的时间和提高睡眠质量。\n因此，可以选择富含三色酚的食物来改善睡眠。一些研究表明，饮用葡萄酒可以提高睡眠质量，因为它含有丰富的三色酚。此外，其他富含三色酚的食品还包括坚果，如核桃和杏仁。\n然而，需要注意的是，虽然三色酚可以帮助改善睡眠，但如果过度饮酒或摄入过多的坚果等富含三色酚的食品，可能会引起其他健康问题，应当适量食用。此外，如果患有睡眠障碍或其他健康问题，请在改变饮食习惯之前咨询医生。", "class": "open qa"}
{"question": "给定一组文章，提取其中的关键词，并将它们按频率从高到低排序。\n有一天，美丽的公主独自从森林里走过。她听到有人在喊救命，顺着声音找到了一个金发的王子，他的手被一根荆棘刺伤了。公主急忙将伤口清洗干净，并用自己的手帕为王子包扎。王子非常感激公主的帮助，但公主并没有留下姓名，就这样离开了。\n不久之后，困难时期到来了，公主的王国陷入了战争和贫困。公主为了保护自己的国家和人民，毅然决定向邻国求援。她身着朴素的衣服，独自一人踏上了漫长而危险的旅程。\n在路上，公主遇到了各种困难和危险，但她勇敢地面对，坚定地前行。她为了让自己的国家走出困境，不惜冒险，甚至牺牲自己的生命。\n最终，公主成功地获得了邻国的援助，帮助她的国家走出了困境。她成为了人民心目中的英雄，被后人铭记和敬仰。", "std_answer": "按频率从高到低排序为：公主、王子、困难、王国、荆棘、伤口、清洗、包扎、森林、感激、战争、贫困、求援、旅程、困境、英雄、人民、后人、铭记、敬仰、衣服。", "class": "extract"}
{"question": "根据以下短文摘要主旨，并将摘要输出。\n杭州市城管部门派出7名巡查员来到西湖边，开展整治行动。在一处游船对面停着的几艘游艇上，执法人员发现了大约200人进行的私人聚会活动。这些人在船上BBQ、喝酒，环节琳琅满目，欢声笑语不断。根据《浙江省公共场所卫生管理规定》，执法人员要进行处罚。", "std_answer": "主旨：杭州城管部门在西湖进行整治行动，发现一处非法私人聚会，对违规人员进行处罚。", "class": "summarization"}
{"question": "阅读下方简短故事后，回答问题。\n石头剪子布是一个古老的游戏，两个人通过比划各自张开的手势来对决。石头胜于剪刀，剪刀胜于布，布胜于石头。如果两个人同时出相同的手势，就是平局。小明和小红玩石头剪子布，小明出了石头，小红出了布。谁赢了？", "std_answer": "小红赢了。\n在石头剪子布游戏中，布胜于石头，因此当小明出石头时，小红出布，小红的布覆盖住了小明的石头，意味着小红赢了这个游戏。", "class": "closed qa"}
{"question": "解释以下术语：“印第安斯瓦拉气候法则”", "std_answer": "印第安斯瓦拉气候法则是指南美洲的印第安斯瓦拉山脉周围地区气候变化规律的一个概括性描述。该气候法则表明，随着海拔高度的升高，温度下降，但是降水量也随之增加，形成了一种高原气候特征。这一气候特征表现为大约每上升100米，平均气温降低1℃，同时每100米高度增加，年平均雨量增加100毫米。\n这种气候区域通常有冷山地和亚高山草原，而高原地带则呈现出冷涡、干旱和荒漠气候特征。此外，印第安斯瓦拉气候法则的另一个重要特征是其季节性，随着南半球的季节变化，这一地区的降水量和温度也会相应地变化。\n印第安斯瓦拉气候法则被认为是自然科学的基础，为生态学和生物地理学提供了一个重要框架。它也提供了人们在这一地区进行自然资源管理和生态系统修复的指南。", "class": "open qa"}
{"question": "描述发生在你家乡的一件有趣的事情。", "std_answer": "", "class": "brainstorming"}
{"question": "回答问题，给出详细的答案。问题：用USB如何将计算机连接到打印机？", "std_answer": "将计算机连接到打印机通常可以通过USB连接完成，该连接过程包括以下几个步骤：\n1. 首先确定计算机和打印机都有可用的USB端口，USB端口通常是方形的。\n2. 打开计算机和打印机并确保它们都处于开机状态。\n3. 确保USB电缆的一端连接到计算机的USB端口，另一端连接到打印机的USB端口。大多数USB电缆都只能在一端插入，因此在连接之前要检查两端的接口。\n4. 如果打印机需要电源，则将其插入电源插座并开启电源。\n5. 计算机将自动检测到新的设备，并尝试安装打印机驱动程序。如果计算机已经安装了打印机驱动程序，则可以跳过此步骤。\n6. 在一些情况下，计算机可能会提示您选择打印机驱动程序。如果是这种情况，请选择正确的驱动程序并按照安装程序中的指示进行操作。\n7. 驱动程序安装完成后，可以打印测试页面来确保打印机与计算机正确连接。在打印选项卡中选择“打印测试页面”或使用打印机上的控件。\n请注意，上述步骤可能会因计算机和打印机的型号和不同品牌而略有不同，但大多数情况下都是类似的。在连接计算机和打印机时，请确保电缆连接牢固，并确保正确选择打印机驱动程序，以便打印机能够与计算机正常通信。", "class": "open qa"}
{"question": "针对以下故事提供一个标题。杰克一直以来都在苦苦寻找自己的人生目标，但却总是无从下手。他曾试着找到一份好工作，努力赚钱，但始终觉得生活缺乏一些什么重要的东西。他也曾寻找爱情，但在多次恋爱失败后，他感到越来越迷茫，不知道该往何处去。直到有一天，他遇见了一个神秘的老人。这个老人看上去非常普通，但言语之间透露出一种深邃的智慧，令杰克十分钦佩。在老人的引导下，杰克开始思考自己的内心世界，并且发现了很多以前从未意识到的问题。随着时间的推移，杰克渐渐明确了自己的人生目标，并且开始朝着这个目标努力前行。他体会到了人生的意义和价值，也深深感悟到了“活着”的真正含义。从那以后，杰克的人生轨迹开始发生了翻天覆地的变化，他开始变得更加自信、坚定，也更加勇敢地面对生活的挑战。", "std_answer": "改变命运的相遇：一位神秘老人如何帮助杰克找到自己的目标", "class": "summarization"}
{"question": "给我以下文本的摘要，并分别提取文本中的关键字和实体：根据这则消息，共有四所学校和五名学生将获得该奖项。这些奖项的设立将有助于促进更多人对中南民族文学遗产的研究和保护。西南大学的少数民族文学研究中心的荀常谦教授认为，这样的奖项将起到激励作用，鼓励更多人参与到中南民族文学的研究和保护中来。希望通过这样的举措，能够增强人们对中南民族文学的重视和关注，进一步推动中南民族文学事业的发展和繁荣。", "std_answer": "摘要：四所学校和五名学生将获得该奖项，以鼓励更多人关注中南民族的文学遗产。西南大学少数民族文学研究中心教授荀常谦表示，该奖项将有助于激励更多人参与中南民族文学的研究和保护。\n关键字：奖项、中南民族、文学、遗产、鼓励、激励、研究、保护、教授、参与。\n实体：西南大学、少数民族文学研究中心、荀常谦。", "class": "extract"}
{"question": "根据提供的资料，为研究某种疾病的科学家提供相关的背景信息和疾病治疗方案的建议。\n疾病名称：肺癌，提供的资料：临床病例和医学报告", "std_answer": "", "class": "generation"}
{"question": "给定一段话，用相反含义的话来重述原话。\n她很快乐，因为收到了一份礼物。", "std_answer": "", "class": "rewrite"}
{"question": "针对一些公益活动提供建议和方案，例如如何为儿童健康保驾护航、如何推广垃圾分类等。", "std_answer": "", "class": "brainstorming"}
{"question": "翻译一篇文章或一些句子到特定的语言。\n以下是一段英文文章：Despite repeated warnings from their parents and teachers, children often take risks. Although this can result in injury or other negative consequences, it helps children learn about themselves and the world around them. They gain confidence and resilience that will serve them well in adulthood. Translate to Spanish 。翻译成中文。", "std_answer": "尽管父母和老师一再警告，孩子们还是经常冒险。尽管这可能会导致伤害或其他负面后果，但它有助于孩子们了解自己和周围的世界。他们会获得自信和韧性，这对他们成年后很有帮助。翻译成西班牙语", "class": "rewrite"}
{"question": "写一篇关于教育的短文，包括你对雨果的名言的看法：“看一本好书就好像给你的人生开了一个窗户”", "std_answer": "", "class": "generation"}
{"question": "有哪些方法可以用来减少细颗粒物(PM 2.5)的排放。", "std_answer": "", "class": "brainstorming"}
{"question": "列出5个常见的网页浏览器。", "std_answer": "以下是5个常见的网页浏览器：\n1. 谷歌浏览器（Google Chrome）- 谷歌浏览器是由谷歌公司开发的一款网页浏览器，其目的是为了提供更快、更安全，更简单的网络体验。它由多个标签组成，支持单独的扩展程序和应用程序，可以让用户直接在浏览器窗口内执行操作而不必打开其他应用程序。\n2. 火狐浏览器（Mozilla Firefox）- 火狐浏览器同样是一个常见的免费开源网页浏览器，它的设计旨在提供更快的速度、更好的隐私保护和更先进的安全功能。它提供了丰富的扩展程序、插件和主题，可让用户自定义浏览器窗口的外观和功能。\n3. 苹果Safari浏览器（Apple Safari）- Safari是苹果公司推出的一款网页浏览器，它旨在提高Web体验，改善浏览器性能和速度。它被广泛用于苹果电脑和移动设备中，可以工作在macOS和iOS上。\n4. 微软Edge浏览器（Microsoft Edge）- 微软Edge浏览器是微软公司在2015年推出的一款网页浏览器，作为Windows 10操作系统运行的默认浏览器。它被设计为更轻量、更快速和更安全，支持扩展程序和集成了许多实用工具。\n5. 中国国产浏览器 - 包括360浏览器、搜狗浏览器、QQ浏览器、UC浏览器等。这些浏览器都主张为中国用户提供更好的广告拦截和网络安全保护的功能。同时，它们还提供方便快捷的在线服务和丰富的网页应用程序，如在线视频、音乐和游戏。", "class": "open qa"}
{"question": "最常见的癌症类型有哪些？", "std_answer": "最常见的癌症类型可以根据不同的国家和地区而有所不同。全球范围内，以下是最常见的癌症类型：\n1. 乳腺癌：女性乳腺癌是最常见的癌症类型之一。这种癌症发生在乳腺组织中，主要影响女性，但也会影响男性。\n2. 肺癌：肺癌是导致癌症死亡的主要原因之一。它通常与吸烟有关，但也可能出现在不吸烟者身上。\n3. 大肠癌：大肠癌是侵蚀结肠和直肠中的细胞，并且是邻近器官中最常见的癌症之一。\n4. 前列腺癌：与男性有关，前列腺癌在一些国家中是最常见的癌症类型。通常易于早期发现和治疗。\n5. 胃癌：胃癌影响胃的组织，通常在发展中国家最为常见。\n这些类型的癌症占据了全球癌症患者的大部分，占所有癌症案例的一半以上。其他常见的癌症包括肝癌、甲状腺癌、子宫颈癌、子宫内膜癌和黑色素瘤。", "class": "open qa"}
{"question": "请解释为什么在人造卫星发射时，火箭发射台会点燃火箭底部的发动机。", "std_answer": "在人造卫星发射时，火箭发射台会点燃火箭底部的发动机是因为这是将火箭送上太空所必需的步骤。\n火箭发射离不开牛顿第三定律，也就是“作用力与反作用力相等且方向相反”。火箭发射时底部发动机会产生大量的火箭推进力，产生火箭推进力背后的原理就是牛顿第三定律。底部的发动机推出的火箭燃气向下喷射，并且火箭底部也对着火箭发射台产生了相反的力，即向上的推力，使得火箭能够从地面开始起飞。\n事实上，火箭发射时的火箭推进力必须要超过重力，才能将火箭送入空中。发动机的推进力只有在螺旋桨或火箭喷管后面产生。当燃料在火箭底部的燃烧室中燃烧时，产生的高温高压燃气会不断地往外喷出，形成底部的推进力，从而将火箭推向高空。\n因此，火箭发射时点燃火箭底部的发动机，是为了产生足够的推进力，以克服地面重力，让火箭进入太空轨道。另外，火箭的发射是一项非常复杂的任务，任何一步的差错都可能导致失败，因此必须仔细检查每一个发射系统和部件，确保火箭可以安全起飞。", "class": "open qa"}
{"question": "翻译下面这个句子：I will always remember the day we met for the first time.", "std_answer": "我会永远记得我们第一次见面的那一天。", "class": "rewrite"}
{"question": "给出一个你认为很有用的生活技巧。", "std_answer": "", "class": "brainstorming"}
{"question": "根据给定的条件，提供一个日程安排。\n需要完成的工作：A）提交报告，B）安排会议，C）回复一封电子邮件，D）练习游泳。", "std_answer": "", "class": "generation"}
{"question": "从已知的常识信息中推断答案：“一只鸟有没有牙齿？”", "std_answer": "根据已知的常识信息，一只鸟通常没有牙齿。这是因为鸟类的嘴巴和消化系统适应于其食物的特殊需求，大部分的鸟类吃的食物是不需要咀嚼的，而是通过嘴巴里的鸟喙抓住食物然后送入胃中消化，而牙齿在咀嚼食物方面起主要作用。此外，鸟类的嘴巴有独特的咀嚼肌肉，称为喉肌，有利于鸟类消化食物。鸟类之中确实存在少数种类会拥有牙齿，如鸟恐龙，但是鸟类和鸟恐龙之间有重要的区别，鸟恐龙是已灭绝的爬行动物的后代，现代的鸟类则是恐龙的远亲。因此，一般情况下我们认为一只鸟是没有牙齿的。", "class": "open qa"}
{"question": "解决以下问题：如果您在电梯中卡住，应该怎么办？", "std_answer": "如果您在电梯中卡住，可能是由于电梯停电、故障、堵塞等原因导致的。这种情况下，不要惊慌，您可以采取以下步骤来解决问题。\n1.保持冷静：首先要保持冷静，不要惊慌，这样可以帮助您更好地应对紧急情况。\n2.按电梯紧急按钮：电梯内通常都有紧急按钮，按下按钮可以呼叫维修人员或其他紧急救援机构的帮助。\n3.使用手机呼叫帮助：如果您携带手机，可以使用手机联系电梯故障维修或紧急救援机构，告知您的位置、情况和需要的帮助。\n4.不要试图自行打开电梯门：如果电梯停电或发生其他安全问题，电梯门可能会无法打开，您不应该试图强行打开电梯门，以免导致更危险的情况发生。\n5.等待救援人员：一旦您使用了电梯内的紧急按钮或联系了机构寻求帮助，您应该耐心等待救援人员的到来，不要试图自行脱险。\n总之，在电梯被卡住的紧急情况下，您应该保持冷静，按下紧急按钮或使用手机呼叫帮助，并等待救援人员的到来，不要试图自行打开电梯门或脱险。", "class": "open qa"}
{"question": "列举三个所有职场人都应该具备的技能。", "std_answer": "", "class": "brainstorming"}
{"question": "根据以下描述，为一件商品编写一则广告文案：这个吸尘器吸力超强，适用于各种不同的地面和表面，还自带消毒功能。", "std_answer": "", "class": "generation"}
{"question": "提出TF-IDF算法的5种用途。", "std_answer": "", "class": "brainstorming"}
{"question": "根据给定的材料，对以下问题进行答案的匹配：介绍中提到了哪些谷物？\n材料：这家烘焙店是一家注重品质和味道的店铺，它使用优质的全麦面粉、小麦和大麦粉来制作各种美味的面包和蛋糕。这些精心挑选的原材料来自于有机农场，确保了食材的新鲜和纯度。每个产品都经过精细的工艺制作，从混合、搅拌到烘焙，都充分体现了师傅们对于制作美食的专注和执着。在这里，你可以品尝到各种不同口味和形状的面包，包括经典的法棍面包、意大利面包和德国黑麦面包等，还有各种口感酥脆、软糯、香甜的蛋糕，例如椰子巧克力蛋糕、红丝绒蛋糕和芝士蛋糕等。除了这些传统的面包和蛋糕，这家烘焙店也不断创新推出一些新口味，例如蔬菜饼干、果仁蛋糕和无麸质面包等，让人们可以更加多样化地享受美食的乐趣。此外，这家烘焙店也注重环保和可持续发展，所有的包装和用具都采用可回收和可生物降解的材料，尽可能减少对环境的影响。无论是从味道、健康还是环保方面考虑，这家烘焙店都是一个绝佳的选择。", "std_answer": "根据所提到的材料，介绍中提到了两种谷物：小麦和大麦。", "class": "closed qa"}
{"question": "将以下短句翻译成中文：\nShe is running in the park.\nHe is playing soccer with his friends.", "std_answer": "她正在公园里跑步。\n他正在和他的朋友踢足球。", "class": "rewrite"}
{"question": "根据以下给出的信息，为一座城市编写一个旅游宣传语。城市位于海滨，有美丽的风景和历史悠久的博物馆。\n城市名：Brighton\n坐落于英国南部海滨\n夏天海滩人山人海\n历史悠久的皇家游乐场和一些博物馆", "std_answer": "", "class": "generation"}
{"question": "根据给定的故事大纲，编写一篇两页长的小说\n大纲: 主人公是一个退休的警察，他在家中度过平静的日子，直到有一天，他接到了一个陌生人的电话，说他必须在24小时内拯救被绑架的人质。然后，一个惊心动魄的行动开始了。", "std_answer": "", "class": "generation"}
{"question": "列举10个日常用品，并对其功能进行解释。", "std_answer": "", "class": "brainstorming"}
{"question": "回答以下问题：马默斯将军在哪场战争中担任美国陆军总参谋长？", "std_answer": "马默斯将军（George C. Marshall）在二战期间担任了美国陆军总参谋长。他从1939年到1945年一直担任这个职务。在这个职位上，他在整个战争中起着至关重要的作用，为盟军战胜纳粹德国做出了重要贡献。\n作为陆军总参谋长，马默斯将军的职责包括指挥和协调陆军的行动，并与其他盟军协调战略。在这个角色中，他领导了许多重要的决策，包括在诺曼底登陆中的决策，以及在战争晚期的决策，如在太平洋战争中取得胜利。他也与其他盟军领袖进行交涉，包括英国首相丘吉尔和苏联领袖斯大林。\n马默斯将军的职业生涯一直与军队紧密联系。在他的整个职业生涯中，他担任了多个职位，包括部队指挥官、作战参谋和部长。在这些角色中，他积累了丰富的经验和知识，最终成为美国历史上最杰出的军事将领之一。", "class": "open qa"}
{"question": "列出5个世界排名前十的高等教育机构。", "std_answer": "以下是2021年世界排名前十的高等教育机构：\n1. Massachusetts Institute of Technology (MIT)\n麻省理工学院坐落在美国马萨诸塞州剑桥市，是一所专注于科学、工程和技术的私立研究型大学。该校创建于1861年，以其在科技创新和创业领域的领导地位而闻名于世，培养出许多杰出的发明家、企业家和科学家。\n2. Stanford University\n斯坦福大学位于美国加州帕罗奥多市，是一所私立研究型大学。1876年创立的该校是“硅谷”地区之一，不仅在高科技创新和创业方面卓越，而且在文科、社科和商科等领域也广受赞誉。\n3. Harvard University\n哈佛大学位于美国马萨诸塞州剑桥市，是一所私立研究型大学。该校成立于1636年，是美国最古老的高等教育机构之一。哈佛大学是文科、社科和自然科学方面最为杰出的学术企业之一，校友包括许多美国总统、政要和诺贝尔奖获得者。\n4. California Institute of Technology (Caltech)\n加州理工学院位于美国加州帕萨迪纳市，是一所私立研究型大学。该校成立于1891年，以其在工程、科学和技术领域的卓越研究而著名。加州理工学院是全球领先的科学和工程教育机构之一。\n5. University of Oxford\n牛津大学位于英国牛津郡牛津市，是一所古老的公立研究型大学。牛津大学成立于1096年，是全球闻名的高等教育机构之一。该校在文科、社科、理科和医学等领域都拥有强大的学术实力和声誉，校友包括许多英国政要、文化名人和诺贝尔奖获得者。\n以上是2021年世界排名前五的高等教育机构的简介，它们在学术实力、创新能力和教学质量等方面都拥有很高的声誉和影响力。", "class": "open qa"}
{"question": "列出一些有趣的职业", "std_answer": "", "class": "brainstorming"}
{"question": "列举出组成地球大气层最多的前三种气体。", "std_answer": "组成地球大气层最多的前三种气体是氮气(N2)、氧气(O2)和氩气(Ar)。\n氮气(N2)占据了大气层78%的比重，是地球大气层中含量最多的气体。它的主要来源是火山活动和细菌固氮。氮气的分子很稳定，化学性质不活泼，不易反应，不影响生物生产和人体健康。\n氧气(O2)占据了大气层21%的比重，是支持生命存在的重要气体。它的主要来源是植物光合作用，但也可以从大气层的其他反应中形成。氧气对于维持动物和植物生物代谢过程至关重要，同时也是火焰燃烧的支持气体。\n氩气(Ar)占据了大气层0.93%的比重，是地球大气层中第三多的气体。氩气的主要来源是太阳辐射对大气中氢的作用，这些氢原子聚集在大气层中形成氦和氩气。氩气不活泼，很稳定，只和极少数元素发生反应，不对生命和环境造成直接的危害。\n此外，大气层中还有少量的二氧化碳、氢气、氖气、甲烷等气体。它们虽然数量不多，但对地球的气候与生态环境有着重要的作用，如二氧化碳是温室气体之一，促进地球表面温度上升；甲烷则是一种比二氧化碳更强的温室气体，在温室效应中也发挥着很重要的作用。", "class": "open qa"}
{"question": "根据给定的文本生成一个主题词列表。\n人类早在4000年前就开始了清明节的祭祀活动。清明节是中国传统节日之一，时间在每年的公历4月4日或5日，是祭祀祖先、扫墓、祭奠逝者的日子。在清明节这一天，人们会到祖先的墓地扫墓、献花、烧纸钱、祭奠逝者，并且还有一些地方会进行悬挂柳条、踏青等民俗活动。清明节是中华民族传统文化的重要组成部分，也是中华民族丧葬文化的重要节日之一。", "std_answer": "", "class": "generation"}
{"question": "对所给的英文文本进行中文翻译。\nGiven the current situation, it's crucial that we remain vigilant and continue to follow health guidelines.", "std_answer": "鉴于当前的形势，保持警惕并继续遵守健康指引非常关键。", "class": "rewrite"}
{"question": "简要解释什么是核磁共振成像（MRI）技术，并描述其如何工作。", "std_answer": "核磁共振成像（MRI）是一种非侵入性的医学成像技术，它利用磁共振现象来生成人体的高对比度图像。MRI技术可以提供拍摄器官、软组织和骨骼的高质量图像，这些图像通常比X射线、CT和超声等其他成像技术提供的图像更清晰、更详细，并且并不会暴露人体组织等传统成像技术中的有害射线。\nMRI的基本工作原理是通过使用强磁场和电磁波来生成图像。在一个MRI机器中，强磁场是由一个大型、超导的磁体产生的。在这个磁体内部，磁场的强度可以达到20000至30000高斯，比地球表面磁场强度高约100万倍。由于人体组织不同的化学成分具有不同的磁性，因此当一个人放入强磁场中时，它会影响到人体内的原子核磁矩（比如氢原子核）的方向和能量状态。\n接下来，MRI仪器将放出一组频率为1MHz至30 MHz的无线电波，以激发人体内的原子核并使其发生共振。在这个过程中，身体内的氢原子核会受到无线电波的影响，并且会吸收这些无线电波的能量。当无线电波停止时，氢原子核便释放出该能量，同时它们所释放出的能量的量将与其周围组织中水的含量、水分子的运动方式等有关。\n这些能量信号被一个磁共振接收器接收到，并通过一组复杂计算方法处理，以使用计算机生成体内的高清图像。这些图像可以显示有关人体内部组织结构和生物化学过程的细节，例如脑脊液、脑灰和脑白质、心脏、肌肉和关节等。\n总之，MRI技术工作的过程是通过利用强磁场和电磁波来产生信号，这些信号由计算机转化为人体内部的清晰图像。它广泛用于医学领域，对医疗诊断、监护和治疗方案制订等非常重要。", "class": "open qa"}
{"question": "请描述一下作为一名AI语音助手的日常工作流程是如何进行的。", "std_answer": "作为一名AI语音助手的日常工作流程通常分为以下几个步骤：\n1. 声音接收：\n首要任务是识别来自用户的声音或语音命令。 该过程通常是通过麦克风或其他语音输入装置来进行的。语音助手需要检测和识别语音特征，并将其转换为文本。这个过程被称为语音识别。\n2. 语音转文本：\n音频转文本技术是将语音转换为可读文本的过程。在这个过程中，语音助手使用自然语言处理技术来生成文本表示语音命令。语音助手可以使用字典、模型和机器学习算法来进行语音转文本的处理。\n3. 理解命令：\n一旦语音转换为文本，AI语音助手需要理解命令的含义以进行下一步操作。在这一阶段，语音助手需要使用自然语言处理技术进行命令分析和语音理解。这通常涉及到文本缩略语、同义词和情境分析。\n4. 执行操作：\n一旦命令被理解，AI语音助手可以开始执行命令。 操作通常包括搜索互联网、操纵设备和应用程序，例如暂停歌曲、更换电视频道、设置闹钟等等。\n5. 输出结果：\n最后一个步骤是输出结果，这通常是通过语音或文本，以回答用户命令或执行请求后所需通知用户的信息均可。语音助手在特定的情况下可以使用合成语音来回复用户的请求。\n总体而言，AI语音助手的日常工作流程就是接收用户的语音或声音命令，转换为可读文本，理解命令并执行操作。 不断优化的语音技术让这个过程越来越高效和准确。", "class": "open qa"}
{"question": "用户: 你好，我想聊聊关于旅游的话题。\nBot: 你好，我很乐意和你聊旅游。你有什么具体的问题或者想法吗？\n用户: 是的，我想知道你对于旅游的看法。你觉得旅游对于人们来说有什么好处？\nBot: 旅游可以给人们带来很多好处。首先，旅游可以让人们放松身心，减轻压力，放松心情。其次，旅游可以让人们了解不同的文化、风俗和历史，拓展人们的视野和思维方式。此外，旅游还可以促进人们的健康和锻炼，比如徒步旅行、滑雪、游泳等等。\n用户: 真的吗？我从来没有想过旅游还有这么多好处。那么，你有什么旅游的建议吗？\nBot: 当然了！如果你想旅游，我建议你先制定一个旅游计划，包括目的地、预算、时间等等。在选择目的地时，你可以考虑自己的兴趣爱好和偏好，比如文化、自然风光、美食等等。在旅行过程中，你可以尝试当地的特色美食、参加当地的文化活动、和当地人交流等等。最后，记得带上足够的现金和旅行保险，以应对不可预测的情况。\n用户: 好的，非常感谢你的建议！我会认真考虑的。\nBot: 不用客气，我很高兴能够帮助你。祝你旅途愉快！\n基于以上对话，请问：旅游对于人们有哪些好处？", "std_answer": "旅游对于人们有以下好处：\n1.放松身心，减轻压力，放松心情。\n2.了解不同的文化、风俗和历史，拓展人们的视野和思维方式。\n3.促进人们的健康和锻炼，比如徒步旅行、滑雪、游泳等等。", "class": "extract"}
{"question": "将以下文本翻译为英语。\n美国总统在新闻发布会上谴责最近发生的一系列恐怖袭击事件。", "std_answer": "At a news conference, the US President condemned the recent series of terrorist attacks.", "class": "rewrite"}
{"question": "使用生成模型生成一段描述一件艺术品的文本。\n一幅著名的油画“星夜”。", "std_answer": "", "class": "generation"}
{"question": "根据以下描述，分类这个物体属于什么类型。\n这个物体有四个轮子，可以用来代步。", "std_answer": "这个物体属于交通工具的分类。具体来说，它属于带有四个轮子的个人交通工具的子类。根据上下文可以推断，这个物体可能是一辆自行车、滑板车、轮滑鞋、电动滑板车或者是滑轮鞋等。需要更多的上下文信息才能确认具体属于哪种类型。", "class": "classification"}
{"question": "回答一个开放性问题：你认为使用电子设备会对人的眼睛造成伤害吗？为什么？", "std_answer": "使用电子设备会对人的眼睛造成伤害。电子设备的使用已经成为我们日常生活中不可或缺的一部分，但是长时间的使用电子设备已经被证明会对我们的眼睛造成伤害并可能导致眼睛疲劳、干燥、视力下降等问题。\n造成这些问题的原因是多方面的，首先是我们在使用电子设备的时候需要不断地注视着电子屏幕，这时我们的眼睛就需要不断地对着屏幕中不断闪烁的LED光和蓝光进行聚焦并调整，这比看书、看报等其它常见的活动对眼睛更加具有挑战性，经常长时间处于这种状态会对我们的眼睛造成疲劳。\n其次，还有一个问题是大多数电子设备通常发出大量的蓝光，这种蓝光比其它成分的光线更加聚焦和刺激强烈，这种蓝光也被称为“高能蓝光”或“紫罗兰色光”，其波长在400-500纳米之间，这种光会受到角膜、晶状体以及玻璃体的过多吸收，从而透过角膜和晶状体，最终进入到眼底。如果长时间暴露在这种光线下，可能会导致眼睛疲劳、干燥，过敏甚至损伤到视网膜的细胞，从而导致眼睛的视力下降，轻则只是暂时的近视等问题，重则会导致失明。\n最后，使用电子设备的时候，人的习惯通常比较容易导致眼的疲劳，例如我们需要尽量保持屏幕距离我们的眼睛35cm以上，并且要注意保持正常姿势，避免长时间低头看屏幕的习惯。同时经常休息、多喝水也可以缓解眼睛的疲劳问题。\n综上所述，使用电子设备确实会对人的眼睛产生伤害。但是我们可以通过一些措施来减少和预防这些问题的出现，例如使用防蓝光屏幕，经常休息的间隔，保持正常姿势等，从而让我们的眼睛得到更好地保护。", "class": "open qa"}
{"question": "列出解决以下问题的三个办法。\n吃坚果时怎样才能更容易地剥开外壳？", "std_answer": "", "class": "brainstorming"}
{"question": "根据下列品牌特点，提供一些提升品牌知晓度的建议。\n品牌：大象汽车\n特点：环保、安全、实用。", "std_answer": "", "class": "brainstorming"}
{"question": "想出十个不同的应用场景来使用一个夹子。", "std_answer": "", "class": "brainstorming"}
{"question": "对于给定的问题，提供详细的答案和支持材料。\n解释亚当·斯密的“看不见的手”理论，并给出一个实际的例子。", "std_answer": "亚当·斯密的“看不见的手”理论是关于市场经济自我调节能力的一种理论。斯密认为，市场是自我调节的，并可以通过价格信号和自发行为实现经济和社会福利的最大化。斯密相信，个体的自利行为不必通过中央计划或政策，而是可以通过市场交换来促进经济效率和最大化福利。\n更具体地说，斯密认为，市场的调节是由一个看不见的手引领的。他说，当个人追求自己的自利时，他们的行动将产生积极的外部效应，从而促进整个市场系统的繁荣。这意味着当一个人做出某种经济决策时，他或她的行动会对其他人产生正面的结果。这种连锁反应最终会导致整个市场获得更大的经济效益。\n例如，考虑一家面包店。假设该店位于繁华的商业区，那么可能会有很多人经过并感到饥饿。如果该店降低价格并提供高质量的面包，那么可能会有很多人购买他们的面包。这将促进经济发展，催生新就业机会、税收增加以及周边其他商家受益。这种自我调节过程会在市场中反复进行，通过人们的自身决策来调整市场，最终带来全社会的效益。\n当然，对于斯密的“看不见的手”理论，也有一些不同的质疑。一些人认为，这不适用于所有市场，特别是在市场力量较弱的市场上，它在保障公正平等方面存在明显的缺陷。不过，斯密的“看不见的手”理论仍然是经济学领域的一个重要概念，可以帮助我们更好地理解市场经济中的自我调节过程。", "class": "open qa"}
{"question": "指定一组文本，并将它们按照给定关键字进行分类\n文本集: 武侠小说《天龙八部》的作者是金庸，该书的主要角色有乔峰，段誉等。唐代白居易所作的《琵琶行》是一首较为著名的诗歌，而且许多人都通过网络听说过这首诗。杨绛是一位著名的女作家，她的代表作是《洛水诗集》。\n关键字: 武侠小说，诗歌，女作家", "std_answer": "根据给定的关键字，可以将上述文本分成以下三组：\n1. 武侠小说\n - 武侠小说《天龙八部》的作者是金庸，该书的主要角色有乔峰，段誉等。\n2. 诗歌\n - 唐代白居易所作的《琵琶行》是一首较为著名的诗歌，而且许多人都通过网络听说过这首诗。\n3. 女作家\n - 杨绛是一位著名的女作家，她的代表作是《洛水诗集》。\n注意：有些文本可能可以同时被多个关键字所分类，例如《洛水诗集》既可以被归为诗歌，也可以被归为女作家。但在这里，我们按照关键字的优先顺序进行分类，因此《洛水诗集》被归为女作家这一类别。", "class": "classification"}
{"question": "给定以下文本，将这段文本压缩成一句话，长度不能超过100个字符。在这座城市的中心地带，我们发现了一家新开业的烘焙店。当我们走进店内时，热腾腾的香气扑鼻而来，使得我们的胃口顿时大开。烤炉里刚刚出炉的面包和蛋糕散发出诱人的香味，让我们感觉好像置身于一个甜蜜的梦境中。店内的菜单上展示着各种口味的面包和糕点，包括柔软的法式面包，酥脆的可颂面包，还有诱人的蓝莓饼干和香草松饼等。在这里，我们可以享受到最新鲜的烘焙美食，让人垂涎欲滴。", "std_answer": "这座城市中心有家新烘焙店，香气四溢，各种面包和糕点应有尽有，美食让人垂涎。", "class": "summarization"}
{"question": "为下一场比赛写一篇赛前演讲。\n下一场比赛的对手是战斗力强劲的火焰队。", "std_answer": "", "class": "generation"}
{"question": "将以下两个句子标记为并列，还是因果关系，还是无关。\n我在学习中得到了好成绩。我参加了辅导班。", "std_answer": "这两个句子是因果关系。\n因为第二个句子说明了第一个句子的原因，也就是参加辅导班这个行为，导致了学习成绩的提高。因为参加辅导班这个原因成为了学习成绩的结果，所以这两个句子之间存在因果关系。\n可以将这两个句子重构为因果关系的形式：“我参加了辅导班，因此在学习中得到了好成绩。”", "class": "classification"}
{"question": "为以下描述的商品分类：红提子葡萄酒、哇哈哈红牛、宝之谷园艺土、华为手机", "std_answer": "红提子葡萄酒和宝之谷园艺土属于食品与饮料类商品，而哇哈哈红牛和华为手机则属于不同的类别。\n1. 红提子葡萄酒属于食品与饮料中的饮料类商品，由葡萄发酵制成，具有酸甜可口的口感。它通常作为一种消遣酒，适合用于晚餐、聚会等场合。它通常被认为是一种高级的饮料，因为它的价格相对较高，适合那些在享受生活中不介意为高品质食品支付高价钱的顾客。\n2. 哇哈哈红牛属于食品与饮料中的能量饮料类商品，具有提供能量的功效。这种类型的饮料通常带有一定的咖啡因和其他成分，以增加人体的兴奋和警觉性。这种类型的饮料通常是针对具有高度活动量的人群，例如体育运动员，工作需要长时间集中注意力的人等等。\n3. 宝之谷园艺土属于园艺类商品，是一种可以增加土壤肥力的有机物质。它通常由动植物的废料和其它的生物质原料混合而成，以供给植物生长所需的养分。这种类型的商品通常是为园艺爱好者和种植爱好者设计的，因为它能够有效地促进植物的生长和健康。\n4. 华为手机是一种电子产品类商品，属于手机硬件和软件的范畴。它能够执行各种不同的计算任务，包括通信、数据存储、文档处理和娱乐等多种方面。这种类型的商品通常是为全年龄段、各种生活方式的用户设计，因为智能手机已成为人们生活不可或缺的一部分。", "class": "classification"}
{"question": "将一篇英文新闻摘要翻译成中文。\n请翻译以下英文新闻标题：Tesla Model S Plaid debuts with new motor tech, 0-60 mph in less than 2 seconds", "std_answer": "特斯拉Model S Plaid配备全新电机技术，0到60英里/小时加速少于2秒。", "class": "rewrite"}
{"question": "给以下描述匹配一个适当的标题。布拉格是位于中欧的捷克共和国首都，是一个拥有悠久历史和文化遗产的城市。布拉格不仅是欧洲历史和文化的中心，也是艺术、文学和哲学的聚集地，许多文化名人曾在这里留下了深刻的印记。布拉格的建筑风格独具特色，古老的城堡、教堂、桥梁和广场都散发着浓厚的中世纪和文艺复兴气息。这里还拥有许多世界闻名的博物馆和艺术展览馆，其中包括充满异域风情的斯特拉科维斯宫、珍藏了世界各地艺术珍品的国家美术馆，以及保存着捷克共和国历史文化遗产的国家博物馆。布拉格是一个充满活力和创意的城市，它孕育了许多杰出的文化名人，如毕加索、达利、约瑟夫•康拉德、米兰•昆德拉、高尔基、哈维尔•维特克等。这些文化名人的作品和思想都对布拉格的历史和文化产生了深远的影响。总之，布拉格是一个充满魅力和吸引力的城市，它的历史和文化遗产值得人们前来一游。无论是欣赏古老建筑的魅力，还是探索文化名人的足迹，布拉格都会让人留下难忘的记忆。", "std_answer": "探索布拉格：中世纪与文艺复兴的遗产和文化名人的足迹", "class": "summarization"}
{"question": "请将以下动物分类为哺乳动物或非哺乳动物:鲨鱼，老虎，乌龟，猫头鹰，鸟类", "std_answer": "鲨鱼：非哺乳动物\n老虎：哺乳动物\n乌龟：非哺乳动物\n猫头鹰：非哺乳动物\n鸟类：非哺乳动物", "class": "classification"}
{"question": "以下代码有什么问题？\n```python\\ndef add_numbers(num1, num2):\\n result = num1 + num2\n result = add_numbers(5, 10)\\n print(result)\\n```", "std_answer": "这段代码没有问题，但是最后两行应该缩进到函数外面。现在的结果是函数调用在函数内部，因此永远不会产生输出。应该这样写：\n```python\ndef add_numbers(num1, num2):\n result = num1 + num2\n return result\nresult = add_numbers(5, 10)\nprint(result)\n```", "class": "code"}
{"question": "请分类以下电影:The Shawshank Redemption, The Godfather, The Dark Knight, Titanic", "std_answer": "犯罪剧情片：The Shawshank Redemption, The Godfather, The Dark Knight\n爱情剧情片：Titanic", "class": "classification"}
{"question": "回答以下问题:谁是美国第一位女性宇航员？", "std_answer": "美国第一位女性宇航员是萨利·莱德利（Sally Ride）。她于1983年6月18日乘坐挑战者号航天飞机进入太空，成为第一个在太空中的美国女性。", "class": "open qa"}
{"question": "请回答以下问题:“世界上最大的沙漠是哪个？”", "std_answer": "撒哈拉沙漠", "class": "open qa"}
{"question": "请根据以下描述，将以下物品分类为水果或蔬菜:黄瓜、苹果、西红柿、香蕉、胡萝卜", "std_answer": "黄瓜、西红柿、胡萝卜属于蔬菜，苹果和香蕉属于水果。", "class": "classification"}
{"question": "一块长方形地的长是35米，周长是120米。这块地的面积是多少平方米?", "std_answer": "解题步骤如下：\n1. 根据题目中的信息，我们知道长方形地的长为35米，周长为120米。用周长公式 C=2(l+w) 计算可得：120=2(35+w)，化简得 w=25。\n2. 知道长（l）和宽（w）后，我们可以计算出该地的面积（A）：A=lw=35×25=875平方米。\n3. 因此，该长方形地的面积为875平方米。\n答案：875平方米。", "class": "math"}
{"question": "请将以下句子分类为正面或负面:“这部电影真是太精彩了，我已经看了三遍了！”", "std_answer": "正面", "class": "classification"}
{"question": "请列出5个最近的电影，并对每个电影提供一段简短的介绍。", "std_answer": "", "class": "brainstorming"}
{"question": "请给我推荐一些适合初学者的编程语言", "std_answer": "", "class": "brainstorming"}
{"question": "请给我推荐一些适合健身的食谱", "std_answer": "", "class": "brainstorming"}
{"question": "如何在Python中读取和写入CSV文件？", "std_answer": "读取CSV文件：\n可以使用Python内置的csv模块来读取CSV文件。以下是读取CSV文件的示例代码：\n```python\nimport csv\nwith open('file.csv', 'r') as file:\n reader = csv.reader(file)\n for row in reader:\n print(row)\n```\n上面的代码打印CSV文件中的每一行数据。\n写入CSV文件：\n同样，可以使用csv模块来写入CSV文件。以下是写入CSV文件的示例代码：\n```python\nimport csv\nwith open('file.csv', 'w', newline='') as file:\n writer = csv.writer(file)\n writer.writerow(['Name', 'Age', 'Gender'])\n writer.writerow(['John', '25', 'Male'])\n writer.writerow(['Jane', '30', 'Female'])\n```\n上面的代码将数据写入CSV文件。在这个例子中，我们向文件中写入标题行和两行数据。注意，我们使用`newline=''`来防止在Windows操作系统中出现额外的空行。", "class": "code"}
{"question": "请回答以下问题:“中国的首都是哪里？”", "std_answer": "中国的首都是北京。", "class": "open qa"}
{"question": "请给我推荐一些适合在家健身的训练计划", "std_answer": "", "class": "brainstorming"}
{"question": "根据以下文章回答下面问题：新公司的目标是什么？文章内容\\n据报道，英特尔公司首席架构师拉加·柯杜力（Raja Koduri）日前离职，他计划创办一家新的人工智能应用软件公司，新公司直指图形芯片巨头英伟达，柯杜力希望通过软件和工具渠道、能打破英伟达处理器在数字电影和游戏行业的主导地位。当地时间周二，英特尔首席执行官帕特·基尔辛格（Pat Gelsinger）披露了柯杜力离职的消息。柯杜力表示，新创办的半导体公司还没有命名，他准备开发目前处于热潮中的生成式人工智能软件工具，这些创意工具可以配合英特尔、苹果、AMD公司的处理器一起使用，他还准备将来支持根据开放源码RISC-V技术开发的处理器。", "std_answer": "新公司的目标是通过软件和工具渠道打破英伟达处理器在数字电影和游戏行业的主导地位。", "class": "closed qa"}
{"question": "根据以下文章回答下面问题：比赛的局势如何？哪个队领先？文章内容：北京时间3月21日消息，CBA常规赛展开第38轮的争夺，坐镇主场的辽宁队105-77大胜苏州肯帝亚队取得3连胜。辽宁队李晓旭14分5篮板，郭艾伦15分9助攻2抢断，张镇麟14分6篮板4抢断，弗格15分，桑普森12分2抢断，莫兰德13分8篮板，赵继伟13分6助攻5抢断。肯帝亚队赵率舟14分5篮板，刘志轩8分5篮板4助攻，布莱克尼28分10篮板5助攻，吴冠希9分5篮板。首节比赛，双方比分交替上升，先后5次战成平分，辽宁22-20领先。次节，比赛局势依然焦灼，辽宁最多只领先6分，肯帝亚队在节中一度实现反超，郭艾伦上篮得手，随后又助攻赵继伟命中三分，半场结束辽宁50-46领先。", "std_answer": "比赛局势焦灼，尤其是第二节，辽宁队最多只领先6分，苏州肯帝亚队在节中一度实现反超，但最终辽宁以105-77大胜。", "class": "closed qa"}
{"question": "小胖要看一本300页的故事书，计划每天看10页，实际每天看12页．实际比计划少看多少天？", "std_answer": "首先计算出小胖计划看完这本书需要的天数：\n300页 ÷ 10页/天 = 30天\n然后计算出小胖实际看完这本书需要的天数：\n300页 ÷ 12页/天 ≈ 25天\n实际比计划少看的天数为：\n30天 - 25天 = 5天\n因此，小胖实际比计划少看了5天。", "class": "math"}
{"question": "生成一句关于环保的口号", "std_answer": "", "class": "generation"}
{"question": "基于以下表格，请问张三的考勤情况\n员工姓名,日期,上班时间,下班时间,是否迟到,是否早退,是否请假\n张三,1月1日,8:30,17:30,否,否,否\n李四,1月1日,9:00,18:00,是,否,否\n王五,1月1日,8:00,16:30,否,是,否\n赵六,1月1日,8:30,17:00,否,否,是\n张三,1月2日,8:00,17:00,否,否,否\n李四,1月2日,8:30,17:30,否,否,否\n王五,1月2日,9:00,18:00,是,否,否\n赵六,1月2日,8:30,17:00,否,否,是", "std_answer": "张三的考勤情况如下：\n1月1日：上班时间8:30，下班时间17:30，未迟到、未早退、未请假。\n1月2日：上班时间8:00，下班时间17:00，未迟到、未早退、未请假。", "class": "extract"}
{"question": "根据以下文章回答下面问题：腾讯控股2022年第四季度的净利润同比增长了多少？文章内容：3月22日下午消息，腾讯控股今日发布2022年第四季度及全年财报。财报显示，该公司第四季度营收1449.5亿元，同比增长1%；净利润1062.7亿元，同比增长12%，非国际财务报告准则下，净利润297.1亿元，同比增长19%。整个2022年，腾讯营收5545.5亿元，同比下滑1%；净利润1882.4亿元，同比下滑16%，非国际财务报告准则下，净利润1156.5亿元，同比下滑7%。", "std_answer": "2022年第四季度腾讯控股的净利润同比增长了12%。", "class": "closed qa"}
{"question": "请回答以下问题:在哪个国家举办了2018年世界杯足球赛？", "std_answer": "2018年世界杯足球赛在俄罗斯举办。", "class": "open qa"}
{"question": "请输出世界上最高的山峰是什么", "std_answer": "世界上最高的山峰是珠穆朗玛峰，海拔8848.86米。", "class": "open qa"}
{"question": "请将以下英文句子翻译成中文:Hello, how are you today?", "std_answer": "你好，今天过得怎么样？", "class": "rewrite"}
{"question": "请问什么是太阳系中离太阳最近的行星？", "std_answer": "太阳系中离太阳最近的行星是水星。", "class": "open qa"}
{"question": "编写一个名为`get_average`的函数，接收一个包含数字的列表并返回它们的平均值。", "std_answer": "```python\ndef get_average(lst):\n return sum(lst) / len(lst)\n```\n这个函数的思路很简单：首先将列表中所有数字相加，然后计算列表中数字的数量，并将两者相除以得到平均值。", "class": "code"}
{"question": "根据以下文章回答下面问题：为什么学习外语可以为你的职业生涯打下坚实的基础？文章内容：学习外语是一项极其重要的技能，它不仅可以帮助你更好地了解世界，还可以为你的职业生涯打下坚实的基础。以下是为什么要学习外语的几个原因1. 获得更广泛的工作机会和职业发展在全球化的今天，知道多种语言可以为你的职业生涯开启更广阔的大门。许多公司都在寻找能够流利使用多种语言的员工，他们可以与客户和合作伙伴进行更好的交流，并更好地处理跨文化事务。2. 增强你的智力学习外语可以促进你的认知能力和思维能力。学习新语言不仅可以增加你的词汇量，还可以帮助你更好地理解其他文化的背景和思维方式。3. 了解其他文化学习外语可以让你更好地了解其他国家和文化的背景。当你学习一门新的语言时，你会了解到其他国家的历史、文化和社会背景，这有助于你更好地理解和尊重其他文化。4. 改善你的旅行经验当你旅行时，知道其他语言可以让你更好地沟通和理解当地的文化。你可以更好地了解当地的美食、文化和历史，并与当地人更好地交流。5. 增强你的自信学习外语可以帮助你更好地理解其他人，并在与他人交流时更加自信。你会感到更加舒适和自信，因为你知道你可以在任何语言环境下与他人交流。", "std_answer": "许多公司都在寻找能够流利使用多种语言的员工，他们可以与客户和合作伙伴进行更好的交流，并更好地处理跨文化事务。", "class": "closed qa"}
{"question": "请回答以下问题:地球的大小是多少？", "std_answer": "地球的直径约为12,742公里，周长约为40,075公里。其表面积约为510,072,000平方公里，体积约为1.08321×10¹²立方公里。", "class": "open qa"}
{"question": "根据以下文章回答下面问题：零跑公司的毛利率是什么情况？ 文章内容：造车新势力二梯队中，唯一成功上市的零跑汽车，发布了2022年财务业绩。零跑的年收入从2021年的31亿元，翻三倍至124亿元，但同时净亏损也从29亿元扩大至51亿元。公司的毛利率依然是负数，短期内赚钱不太现实，不过相比之前已经有很大程度改善。截至去年底，零跑公司的账上有88亿元现金，数量不算多，但也够它再跑一段时间了。在香港上市以来，零跑的股价在挂牌首日即跌破发行价，大跌33.5%，至今半年累计跌去37.5%，市值350亿港元。", "std_answer": "零跑公司的毛利率依然是负数。", "class": "closed qa"}
{"question": "请编辑以下段落，使其更具可读性，并确保所有语法正确:\"虽然寒冷，但我喜欢户外运动。我和朋友经常晨跑，即使天气不好也不会放弃。\",", "std_answer": "", "class": "rewrite"}
{"question": "请回答以下问题:猫头鹰属于哪一种动物类别？", "std_answer": "猫头鹰属于鸟类动物。", "class": "open qa"}
{"question": "请为以下主题写一篇总结:人工智能在医疗领域的应用现状。", "std_answer": "", "class": "generation"}
{"question": "父亲：儿子，你高中毕业了，现在打算上哪个大学？\n儿子：爸爸，我已经准备好了申请资料，想申请一个好的本科专业。\n父亲：那你已经想好申请哪些大学了吗？\n儿子：是的，我计划申请几所排名靠前的大学。我已经做了很多研究，准备在学业、社交和职业规划等方面全面提升自己。\n父亲：很好！你一直都很努力，爸爸妈妈一直都很自豪。上大学是一个新的起点，你需要面对更多的挑战和机会。你有什么打算？\n儿子：我计划尽早适应大学生活，参加各种社团和课外活动，拓宽自己的视野和人际圈。同时，我会认真学习专业知识和技能，努力取得好成绩，争取获得奖学金和其他荣誉。\n父亲：非常好！你的计划很明智，爸爸相信你一定会有一个充实而有意义的大学生活。爸爸会一直支持你的决定，希望你取得好成绩，为你的未来打下坚实的基础。\n儿子：谢谢爸爸！我会加倍努力，不辜负您对我的期望。\n这段对话中，儿子打算上大学后有哪些计划和打算？", "std_answer": "根据对话内容，儿子上大学后有以下计划和打算：\n1.全面提升自己在学业、社交和职业规划等方面；\n2.尽早适应大学生活；\n3.参加各种社团和课外活动，拓宽自己的视野和人际圈；\n4.认真学习专业知识和技能，努力取得好成绩；\n5.争取获得奖学金和其他荣誉。", "class": "extract"}
{"question": "请给我推荐一些适合儿童观看的动画电影", "std_answer": "", "class": "brainstorming"}
{"question": "将以下文本分类为新闻、广告、还是论坛帖子:“最新款iPhone 13现已上市，速来选购！”", "std_answer": "广告", "class": "classification"}
{"question": "请提供一个简洁的描述，解释机器学习是什么", "std_answer": "机器学习是一种人工智能的分支，它利用大量数据和统计算法，让计算机从中自动学习并改进算法，从而完成某种任务，而无需明确的指令或程序。简而言之，机器学习是让计算机从数据中学习，进而自我调整和优化。", "class": "open qa"}
{"question": "请将以下文本分类为正面、负面或中性情感:这家餐厅的食物非常好吃，但服务有待改善", "std_answer": "中性", "class": "classification"}
{"question": "请推荐一本关于人工智能的书籍，需要提供书名和作者", "std_answer": "", "class": "brainstorming"}
{"question": "给我推荐一本关于人工智能的好书，应该包含最新的研究和发展，适合初学者和专业人士。", "std_answer": "", "class": "brainstorming"}
{"question": "分类以下电影，是喜剧还是恐怖片？\\n电影《逃出绝命镇》", "std_answer": "恐怖片。", "class": "classification"}
{"question": "将以下电影作品归类为喜剧或惊悚片:小丑、疯狂动物城、窃听风暴、恐怖游轮、超能查派、惊声尖叫", "std_answer": "喜剧：疯狂动物城\n惊悚片：小丑、窃听风暴、恐怖游轮、惊声尖叫、超能查派", "class": "classification"}
{"question": "以下代码运行后输出什么？\\n```\\ndef add(x, y):\\nreturn x + y\nresult = add(2, 3, 4)\\nprint(result)\\n```", "std_answer": "该代码将会抛出一个 `TypeError` 异常，因为 `add()` 函数只接受两个参数，但是在调用该函数时给了三个参数。", "class": "code"}
{"question": "给出以下问题的答案:“什么是全球变暖？”", "std_answer": "全球变暖是指地球表面温度上升的现象，这是由于人类活动导致的大气中温室气体如二氧化碳、甲烷、氟氯碳化合物等的大量排放，引起了地球大气层中的温室效应加强，导致全球气温上升。全球变暖会引起海平面上升、气候变化、生态系统破坏等问题。", "class": "open qa"}
{"question": "编写python函数sum_digits(num)，计算一个数的所有数字的和。", "std_answer": "算法步骤：\n1. 初始化变量sum为0\n2. 将num转成字符串类型，遍历字符串中的每一个字符\n3. 将每个字符转成整数类型并加到sum中\n4. 返回sum\nPython代码实现：\n```python\ndef sum_digits(num):\n sum = 0\n for digit in str(num):\n sum += int(digit)\n return sum\n```\n测试代码：\n```python\nprint(sum_digits(123)) # 6\nprint(sum_digits(12345)) # 15\nprint(sum_digits(987654321)) # 45\n```", "class": "code"}
{"question": "写一个python函数，函数名为addition，有两个参数a和b，返回它们的和。", "std_answer": "下面是一个 Python 的函数，名为 `addition`，它接收两个参数 a 和 b，并返回它们的和。\n```\ndef addition(a, b):\n return a + b\n```\n可以将这个函数保存在一个 Python 脚本文件中，比如 `my_functions.py`，然后在另一个 Python 文件中导入并使用它，如下所示：\n```\nfrom my_functions import addition\nresult = addition(2, 3)\nprint(result) # 输出 5\n```\n上面的代码中，我们首先从 `my_functions` 模块中导入 `addition` 函数，然后使用它计算 2 和 3 的和，并将结果保存到 result 变量中，最后将结果打印出来。", "class": "code"}
{"question": "请根据以下输入内容，生成一篇关于环保的文章:垃圾分类、节约用水、减少碳排放、可持续发展", "std_answer": "", "class": "generation"}
{"question": "编写一个名为 `count_vowels` 的python函数，接收一个字符串并返回其中元音字母的数量", "std_answer": "def count_vowels(string):\n vowels = ['a', 'e', 'i', 'o', 'u']\n count = 0\n for letter in string:\n if letter.lower() in vowels:\n count += 1\n return count\n# 测试\nprint(count_vowels('hello')) # 2\nprint(count_vowels('world')) # 1\nprint(count_vowels('aeiou')) # 5\nprint(count_vowels('')) # 0", "class": "code"}
{"question": "请提供三个最流行的电影类型，以及每个类型中最受欢迎的电影的名称。", "std_answer": "", "class": "brainstorming"}
{"question": "请提供一篇关于机器学习的文章", "std_answer": "", "class": "brainstorming"}
{"question": "安迪：我觉得，时间太宝贵了，不应该浪费在报复上。当然，如果有人伤害了你的朋友，你就可以想方设法让他付出代价。但是，这只会让你变得跟他一样，而且还会把你关在一种无法自拔的心态中。\n瑞德：你听起来好像有点被他们洗脑了。\n安迪：我可能是，不过至少我还有自己的想法。\n瑞德：你知道，我一直在想这个问题，如果一个人可以真正的变得自由，那他会不会像你一样对待别人？\n安迪：我不知道，也许会，也许不会。我想关键在于是否能够在自己的心里找到真正的自由。\n瑞德：真正的自由？\n安迪：是的，我想，真正的自由是在你内心找到自己的位置，无论你身在何处，都可以自由自在地生活。\n瑞德：（微笑）那我想我还有一段路要走。\n这段对话中，安迪和瑞德各自持有什么样的态度，他们对报复和自由的看法有何不同之处？", "std_answer": "在这段对话中，安迪和瑞德对待报复和自由的态度有所不同。安迪认为时间很宝贵，不应该浪费在报复上，而且报复只会让人变得跟伤害自己的人一样。他认为真正的自由是在内心找到自己的位置，无论身在何处都能自由自在地生活。相比之下，瑞德则更加怀疑安迪的看法，认为他可能被伤害者洗脑了。但是在谈到真正的自由时，瑞德也认识到了自己还需要走一段路才能达到。因此，安迪和瑞德在对待报复和自由的态度上存在差异，但他们都在思考自己的处境和人生，试图寻找自己的自由。", "class": "extract"}
{"question": "请为以下电影推荐一部类似的电影:“肖申克的救赎”", "std_answer": "", "class": "brainstorming"}
{"question": "为什么公司的销售额下降了？", "std_answer": "作为AI语言模型，我无法确切地回答这个问题，因为涉及到具体的公司情况和市场环境。但一般来说，公司销售额下降可能有以下原因：\n1.市场竞争激烈，同类产品价格过低，导致销售额下降。\n2.产品质量下降，用户口碑差，导致销售额下降。\n3.公司经营策略不当，导致市场份额下降，销售额下降。\n4.市场需求变化，公司产品无法满足市场需求，导致销售额下降。\n5.公司管理不善，员工士气低落，导致销售额下降。\n针对这些原因，公司可以采取不同的措施来提高销售额，比如加强产品研发、提高产品质量、改善经营策略、开拓新市场等。", "class": "open qa"}
{"question": "请将以下句子改写为间接引语。他说“我今天很忙。”", "std_answer": "", "class": "rewrite"}
{"question": "根据以下文章回答下面问题：为什么汇丰银行要试行一星期7天营业？文章内容：近日，一则与“大量富豪正在把钱从美国、瑞士转回香港和新加坡”、“香港银行员工不放假”相关的图片被大量转发。恰逢汇丰银行宣布3家分行试行一星期7天营业，该消息持续发酵。不过，汇丰银行最新回应称，该行持续相关分行的7天营业，是与自香港与内地全面通关后到访人数暴涨有关。根据汇丰公告，此次试点分行包括海洋中心汇丰尚玉及卓越理财中心、柏宁卓越理财中心及观塘分行。这三家分行分别位于尖沙咀广东道5号海洋中心三阶351-60号；铜锣湾告士打道310号柏宁酒店地下A、B、D、E及F铺；观塘开源道71号王子大厦1楼。", "std_answer": "汇丰银行试行一星期7天营业是因为香港与内地全面通关后到访人数暴涨，需要更多的银行服务。", "class": "closed qa"}
{"question": "请告诉我什么是区块链技术，以及它的应用领域有哪些？", "std_answer": "区块链技术是一种基于去中心化、分布式和加密的数据库技术。它是一种新型的数据存储和传输方式，可以实现数据的安全性、可追溯性和透明性。\n区块链技术的应用领域非常广泛，包括但不限于以下几个方面：\n1. 数字货币：比特币、以太坊等数字货币是区块链技术的最早应用之一。\n2. 金融领域：区块链技术可以用于金融领域的交易清算、跨境支付、资产证券化等方面。\n3. 版权保护：区块链技术可以用于保护数字版权，确保知识产权的合法性和不可篡改性。\n4. 物联网：区块链技术可以用于物联网设备之间的安全通信和数据交换，保障物联网的安全性和可靠性。\n5. 政府管理：区块链技术可以用于政府管理领域，如公共安全、投票系统、社会福利等方面。\n总之，区块链技术的应用领域非常广泛，未来还有很多新的应用场景将会涌现。", "class": "open qa"}
{"question": "根据以下文章回答下面问题：为什么比尔·盖茨认为OpenAI的GPT AI模型是技术上最具革命性的进步？文章内容：联合创始人比尔·盖茨表示，自1980年他第一次看到现代图形用户界面（GUI）以来，OpenAI的GPT AI模型是技术上最具革命性的进步，这是他67年的人生中第二次被科技真正震撼到。盖茨周二在自己的博客GatesNotes上写道，第一次是在1980年，当时他接触到了图形用户界面，这成为他创建微软Windows操作系统的基石。他说，第二次是在2022年年中，当时他向OpenAI及其生成式人工智能ChatGPT提出了挑战，让它做一些没有经过训练或编程的事情。盖茨选择高等生物学考试作为挑战，并估计这将需要大约两到三年的时间，结果在几个月的时间里，ChatGPT就通过了考试，60道选择题中有59道答对了，6道开放式题的答案也“非常出色”。盖茨说“当它通过测试后，我们问了它一个非科学的问题‘你会对一个孩子生病的父亲说什么？’它写了一个经过深思熟虑的答案，可能比我们在场的大多数人都会给出的答案要好。”“整个经历令人震惊，我知道我刚刚看到了自图形用户界面以来最重要的技术进步。”", "std_answer": "因为他认为这是自1980年他第一次看到图形用户界面以来，最令他震惊的技术进步，这次是他人生中第二次被科技真正震撼到。", "class": "closed qa"}
{"question": "为什么一个垂直向下的物体落地前会加速？", "std_answer": "一个垂直向下的物体落地前会加速，是因为它受到了重力的作用。重力是地球对物体施加的吸引力，它的大小与物体的质量成正比，与物体与地球的距离平方成反比。当一个物体被释放时，它受到的重力是不断增加的，因为它离地球的距离在减小。这就导致了物体的速度不断增加，直到它落到地面。因此，一个垂直向下的物体落地前会加速。", "class": "open qa"}
{"question": "服装加工厂要做980套衣服，已经做了320套。如果剩下的衣服要6天做完，平均每天要做多少套?", "std_answer": "首先需要计算出还需要制作的衣服数量。这可以通过用总数减去已经完成的数量来得出：\n980 - 320 = 660\n现在我们知道还需要制作660套衣服，并且需要在6天内完成。为了计算每天需要制作的衣服数量，我们可以将总数除以天数：\n660 ÷ 6 = 110\n因此，这家服装加工厂每天需要制作110套衣服，才能在6天内完成剩下的660套。", "class": "math"}
{"question": "为什么铁比木头更容易被磁化？", "std_answer": "铁比木头更容易被磁化的原因是因为铁是一种铁磁性材料，它具有自旋和轨道角动量的相互作用，导致磁矩的生成和定向。在外加磁场的作用下，铁内部的磁矩会重新排列，从而形成一个强磁场，这使得铁更容易被磁化。而木头不是一种铁磁性材料，它不具有自旋和轨道角动量的相互作用，因此木头不容易被磁化。", "class": "open qa"}
{"question": "请将以下文本进行分类:3月17日，“第三届世界苜蓿大会”隆重召开，优然牧业受邀出席大会，优然牧业副总经理井志伟做了《规模化优质苜蓿产业实践及展望》的主题演讲，并与来自国内外牧草领域的权威专家，共同交流分享全球苜蓿产业最新成果、种植经验和案例，旨在推进中国苜蓿产业高质量发展。", "std_answer": "产业会议/论坛/交流会", "class": "classification"}
{"question": "将以下句子改为反义疑问句。他喜欢吃巧克力。", "std_answer": "", "class": "rewrite"}
{"question": "请为以下新闻标题编写一篇100字的摘要:“新研究表明，喝咖啡可能会增加长寿风险。”", "std_answer": "", "class": "generation"}
{"question": "请根据以下语境改写句子。原句我昨天买了一本新书。语境我想强调这本书非常好看。", "std_answer": "", "class": "rewrite"}
{"question": "请生成一篇关于太空探索的文章，至少500个单词", "std_answer": "", "class": "generation"}
{"question": "请根据以下文章摘要，生成一篇300字的新文章：人工智能在医疗领域的应用。", "std_answer": "", "class": "generation"}
{"question": "下面的代码有什么错误？如何修复？\\n```python\\nclass Rectangle:\\ndef __init__(self, width, height):\\nself.width = width\\nself.height = height\\ndef area(self):\\nreturn self.width * self.heigh\\nrect = Rectangle(5, 10)\\nprint(rect.area())\\n```", "std_answer": "代码中的错误是在 area 方法中，self.heigh 应该是 self.height。修复方法是将 self.heigh 改为 self.height。\n修复后的代码如下：\n```python\nclass Rectangle:\ndef __init__(self, width, height):\n self.width = width\n self.height = height\ndef area(self):\n return self.width * self.height\nrect = Rectangle(5, 10)\nprint(rect.area())\n```", "class": "code"}
{"question": "请给我推荐一本自助成长书籍。", "std_answer": "", "class": "brainstorming"}
{"question": "从一个长8分米，宽5分米的长方形木板上锯下一个最大的圆，这个圆的面积是多平方分米？", "std_answer": "首先，我们可以画出这个长方形木板和圆的示意图：\n\n我们可以看到，在长方形中心画一条对角线，将其分为两个直角三角形。由于圆的直径等于长方形的较短边，因此我们可以将直径的长度设为5米。\n接下来，我们可以使用勾股定理计算出长方形的对角线长度：\n$$\n\\sqrt{8^2 + 5^2} = \\sqrt{89}\n$$\n由于圆的直径等于长方形的较短边，因此圆的半径等于2.5米。因此，我们可以使用圆的面积公式计算出这个圆的面积：\n$$\n\\pi \\times (2.5)^2 \\approx 19.63\n$$\n因此，在这个长方形木板上锯下的最大圆的面积约为19.63平方分米。", "class": "math"}
{"question": "请分类下面这些单词:狗、篮球、橙汁、电视、蓝色、石头、苹果、橙子。", "std_answer": "动物类：狗\n水果类：苹果、橙子\n运动类：篮球\n饮料类：橙汁\n家电类：电视\n颜色类：蓝色\n自然界物体类：石头", "class": "classification"}
{"question": "请分类以下电影:“阿甘正传”，“泰坦尼克号”，“霸王别姬”", "std_answer": "“阿甘正传” - 剧情片、传记片、情感片\n“泰坦尼克号” - 爱情片、灾难片、历史片\n“霸王别姬” - 戏剧片、历史片、文艺片", "class": "classification"}
{"question": "请回答以下问题:“蚂蚁是哪个大陆的特有动物？”", "std_answer": "蚂蚁是世界范围内广泛分布的昆虫，而不是某个大陆的特有动物。不同种类的蚂蚁在各个大陆和地区都有分布。", "class": "open qa"}
{"question": "请根据以下问题，重写以下句子我最喜欢的水果是苹果，因为它又甜又好吃。问题你为什么喜欢苹果？你平时都在哪里买苹果？。", "std_answer": "", "class": "rewrite"}
{"question": "请写一句话描述你最喜欢的电影，包括电影的类型和主要角色。", "std_answer": "", "class": "brainstorming"}
{"question": "根据以下文本内容，生成一篇文章的概要:以下是一段文本内容未来的世界里，人工智能将会扮演着越来越重要的角色，人们需要学习如何与AI进行合作，而不是抗争。", "std_answer": "", "class": "generation"}
{"question": "根据以下输入生成电影推荐:我喜欢科幻电影和动作电影", "std_answer": "", "class": "brainstorming"}
{"question": "请回答以下问题:印度尼西亚的首都是哪里？", "std_answer": "印度尼西亚的首都是雅加达。", "class": "open qa"}
{"question": "请根据以下输入的电影名称，给出一些相关的电影推荐:阿甘正传,", "std_answer": "", "class": "brainstorming"}
{"question": "根据以下文本生成一篇同义文章:“人工智能正在改变我们的生活方式。它正在推动医疗保健、能源和金融等各个领域的发展，同时也在创造新的就业机会。”", "std_answer": "", "class": "generation"}
{"question": "请用一句话总结以下段落：保护环境的重要意义随着我国经济的发展，有效利用能源、减少环境污染、降低安全生产事故频次，防止突发环境事件，确保生命安全的重要性日益凸显。制定并执行环保政策和措施，致在保护环境的同时改善人民的生活质量，已经成为我国民生工程的关注点。保护环境不仅关乎人们的生存环境，也影响着经济发展。", "std_answer": "保护环境对于经济发展和人民生活质量的重要性日益凸显。", "class": "summarization"}
{"question": "请根据以下文本的主题为其添加一个标题:随着大数据、云计算、互联网、物联网等信息技术的发展，泛在感知数据和图形处理器等计算平台推动以深度神经网络为代表的人工智能技术飞速发展，大幅跨越了科学与应用之间的“技术鸿沟”，诸如图像分类、语音识别、知识问答、人机对弈、无人驾驶等人工智能技术实现了从“不能用、不好用”到“可以用”的技术突破，迎来爆发式增长的新高潮。", "std_answer": "", "class": "generation"}
{"question": "A：您好，老师，我有一个问题想请教您。我现在是大学生，但是对我的未来职业规划感到有些困惑。我不确定自己应该做什么。\nB：你好，A同学。职业规划是一个非常重要的问题，我可以帮助你想一想。你有任何职业方向的想法吗？\nA：我有一些想法，但都没有特别明确。我有时候想成为一名教师，但有时候也想尝试做一些其他的工作，比如从事商业或者技术方面的工作。\nB：这些都是非常不错的职业方向。但是，你需要先弄清楚自己的兴趣爱好和技能，才能找到最适合自己的职业。\nA：我明白了。但是我不知道怎样才能找到自己真正的兴趣爱好和技能。我不想选错了方向。\nB：这是一个非常好的问题。你可以开始探索一些你感兴趣的领域，例如参加一些社团活动、课外活动或者志愿服务，来了解自己的兴趣爱好和技能。此外，你也可以尝试一些实习或者兼职，来锻炼自己的实践能力和职业技能。\nA：好的，我明白了。谢谢您的建议，老师。\nB：不用客气。职业规划是一个长期的过程，需要不断地探索和尝试。只要你保持积极的心态和不断地努力，你一定能找到最适合自己的职业。\n基于以上对话，请问：大学生应该如何找到自己真正的兴趣爱好和技能？", "std_answer": "可以开始探索一些你感兴趣的领域，例如参加一些社团活动、课外活动或者志愿服务，来了解自己的兴趣爱好和技能。此外，也可以尝试一些实习或者兼职，来锻炼自己的实践能力和职业技能。", "class": "extract"}
{"question": "学校有女老师43人，男老师比女老师少27人，学校一共有老师多少人?", "std_answer": "设学校男老师的人数为x，则：\nx + 27 = 女老师的人数\n女老师的人数为43，则：x=16\n16+ 43 = 总老师的人数\n化简得：\n总老师的人数=59\n因此，答案为总老师的人数为59。", "class": "math"}
{"question": "请推荐一些适合婚礼场合的服装品牌", "std_answer": "", "class": "brainstorming"}
{"question": "编辑以下文章，加入更多的细节和描述，使得它更加生动。我昨天去了一家新开的餐厅，点了一份牛排和一杯红酒。食物味道不错，但是服务员态度很差。", "std_answer": "", "class": "rewrite"}
{"question": "如果所有梨都是水果，那么所有水果都是梨吗？", "std_answer": "不是。这是一个逻辑谬误，称为“假设逆否命题”。虽然所有梨都是水果，但并不意味着所有水果都是梨。因为有许多其他种类的水果，如苹果、香蕉、草莓等。", "class": "open qa"}
{"question": "请根据以下文本，判断其中的情感是积极、消极还是中性:“我今天在公司里得到了晋升，感觉非常高兴。”", "std_answer": "积极。", "class": "classification"}
{"question": "对于这个话题，请你写一篇300字左右的文章，话题如何提高自己的英语口语水平？", "std_answer": "", "class": "generation"}
{"question": "请回答以下问题:“人类有多少种基本情绪？”", "std_answer": "按照传统的心理学理论，人类有六种基本情绪，它们是：愤怒、厌恶、恐惧、快乐、悲伤和惊讶。然而，近年来一些研究表明，这个列表可能需要重新审视，因为一些情绪可能是其他情绪的组合或变体，而不是独立的基本情绪。", "class": "open qa"}
{"question": "为什么电梯掉下来时，我们可以用跳起来的方式生还？", "std_answer": "这是因为当电梯失去控制掉落时，人身体内的重力和电梯内的重力是一样的，人体就像自由落体一样，与电梯一起下落。当电梯突然停止时，人体就会继续保持下落的惯性，而电梯和地面之间的距离已经足够大，人体可以利用自己的肌肉反应快速跳起来，减缓跌落的冲击力，从而保护自己免受伤害。当然，这需要人的反应速度和身体素质都比较好。不过，还是不要尝试这种危险的情况，因为电梯掉落是非常危险的，应该尽量避免。", "class": "open qa"}
{"question": "如果鱼在水里生活，那么所有在水中生活的动物都是鱼吗？", "std_answer": "不是的。虽然所有在水中生活的动物都具有类似的生存环境，但它们的形态、生理特征、行为习性等方面都有所不同。例如，鲸鱼、海豚、海龟等都是海洋生物，但它们并不属于鱼类，而是哺乳动物或爬行动物。因此，不能把所有在水中生活的动物都简单地归为“鱼”。", "class": "open qa"}
{"question": "将以下句子进行改写，使其更加简洁明了:“由于天气炎热，他决定不去户外运动了。”", "std_answer": "", "class": "rewrite"}
{"question": "一条跑道长400米，小明每天跑5个来回，他每天跑多少千米？", "std_answer": "首先，计算一次来回的长度是多少：\n一次来回的长度 = 400米 × 2 = 800米\n然后，计算小明一天跑的总长度：\n小明一天跑的总长度 = 800米 × 5 = 4000米\n最后，将总长度转换为千米：\n小明一天跑的总长度 = 4000 ÷ 1000 = 4千米\n因此，小明每天跑4千米。", "class": "math"}
{"question": "将以下句子改写成反义疑问句。她是一名医生。", "std_answer": "", "class": "rewrite"}
{"question": "铺720平方米的地板，要用边长6分米的方砖多少块?", "std_answer": "首先，计算出720平方米的面积所需的边长为多少，即：\n720÷6=120\n因此，需要120个边长为6分米的方砖来铺720平方米的地板。\n解题步骤如下：\n1. 将720平方米转换为平方分米，即720×100=72000平方分米。\n2. 计算出每个方砖的面积，即6×6=36平方分米。\n3. 将地板面积除以每个方砖的面积，即72000÷36=2000。\n4. 因为一个方砖可以覆盖36平方分米的面积，所以需要2000个方砖来覆盖720平方米的地板。\n5. 最后，将2000个方砖按照规划好的铺设方式进行铺设即可。", "class": "math"}
{"question": "请提供5首最近的流行歌曲", "std_answer": "", "class": "brainstorming"}
{"question": "用长120厘米的铁丝围成一个长方形，长是宽的1.5倍，求它的宽是多少厘米", "std_answer": "设长方形的宽为x，则根据题意，长为1.5x。\n将铁丝围成长方形的公式为：周长=2(长+宽)。\n代入上述数据，得到：\n120=2(1.5x+x)\n化简得：\n120=5x\nx=24\n因此，长方形的宽为20厘米。", "class": "math"}
{"question": "根据以下文章回答下面问题：谁正在与制片公司商谈合作？文章内容：根据以下文章生成对应的问题和答案 新浪娱乐讯 詹妮弗·洛佩兹将出演体育题材新片《不可阻挡》（Unstoppable），本·阿弗莱克和马特·达蒙的制片公司Artists Equity制作，正与亚马逊商谈继《Air》后再合作。", "std_answer": "4. 亚马逊正在与制片公司商谈合作。", "class": "closed qa"}
{"question": "回答以下问题:地球的自转周期是多少小时？", "std_answer": "地球的自转周期是23小时56分4秒。", "class": "open qa"}
{"question": "请根据以下文本生成一篇新闻报道:本周，股市出现了大幅下跌，投资者开始担心全球经济的前景。", "std_answer": "", "class": "generation"}
{"question": "请根据以下文本对其进行分类:“苹果公司发布了新的iPhone，这款手机有更高的像素和更长的电池寿命。”", "std_answer": "科技新闻", "class": "classification"}
{"question": "根据以下问题，编写一个简短的科普文章,:题目为“什么是黑洞？”", "std_answer": "", "class": "generation"}
{"question": "请根据以下问题，提供一个问题解决方案。:问题如何保持一个健康的生活方式？", "std_answer": "", "class": "brainstorming"}
{"question": "给出以下问题的答案:为什么大熊猫濒临灭绝？", "std_answer": "大熊猫濒临灭绝的原因是多方面的，包括栖息地的破坏、繁殖困难、疾病和人类活动的影响等。其中，栖息地破坏是最主要的原因之一，由于人类的开发活动和森林砍伐，大熊猫的栖息地面积不断减少，使得它们的生存空间变得越来越狭窄。此外，大熊猫的繁殖困难也是导致其濒临灭绝的重要原因之一，由于其繁殖周期长、繁殖率低等特点，使得其种群数量增长缓慢。为了保护大熊猫，需要采取多种措施，包括栖息地保护、人工繁殖、科学研究等。", "class": "open qa"}
{"question": "一种会议室的长桌的单价是7800元，与它配套的12把椅子每把105元，买一套桌椅一共需要多少元？", "std_answer": "解题步骤：\n1. 计算椅子的总价\n每把椅子的单价是105元，一共有12把椅子，所以椅子的总价为：\n105元/把 × 12把 = 1260元\n2. 计算桌子和椅子的总价\n桌子的单价是7800元，加上椅子的总价1260元，一套桌椅的总价为：\n7800元 + 1260元 = 9060元\n所以，买一套桌椅需要9060元。", "class": "math"}
{"question": "请将以下文本进行改写，使得它更加生动有趣。我昨天去逛商场，买了一件新衣服。", "std_answer": "", "class": "rewrite"}
{"question": "基于以下信息，一句话总结今日的销售情况：\n日期,商品名称,单价（元）,数量,折扣,小计（元）,支付方式,备注\n2023-04-14,饼干,5.00,2,无,10.00,微信支付,无\n2023-04-14,汽水,3.50,1,无,3.50,现金支付,无\n2023-04-14,巧克力,12.00,1,8折,9.60,支付宝,优惠活动\n2023-04-14,方便面,4.50,3,无,13.50,银行卡,无\n2023-04-14,纸巾,1.00,5,无,5.00,微信支付,无\n2023-04-14,雪糕,6.00,2,9折,10.80,支付宝,优惠活动\n2023-04-14,果汁,8.00,1,无,8.00,现金支付,无", "std_answer": "2023-04-14销售总计：共售出7种商品，总金额为50.40元，涉及微信支付、现金支付、支付宝和银行卡多种支付方式，并有部分优惠活动。", "class": "summarization"}
{"question": "为什么一些化学反应只在特定温度和压力下发生？", "std_answer": "化学反应是由分子间的相互作用引起的。在特定温度和压力下，分子的热能和运动状态会影响其相互作用的频率和强度。如果温度或压力不足以提供足够的能量和运动状态，分子之间的相互作用可能不足以引发化学反应。另一方面，如果温度或压力过高，分子之间的相互作用可能会变得过于强烈，导致不同的反应路径或产物形成。因此，特定的温度和压力条件是化学反应发生的必要条件。", "class": "open qa"}
{"question": "实验小学有6个年级，每个年级有3个班，平均每个班有42名学生，这个学校共有多少名学生？", "std_answer": "首先，可以用乘法原理计算出每个年级的学生人数：每个年级有3个班，每个班有42名学生，所以每个年级有3 × 42 = 126名学生。\n然后，可以用加法原理计算出整个学校的学生人数：学校有6个年级，所以学生人数为6 × 126 = 756名学生。\n因此，实验小学共有756名学生。", "class": "math"}
{"question": "请将下面这段文本进行改写，使得它更加简明易懂:“在现代社会中，信息技术扮演着重要的角色。信息技术使得人们的生活更加便捷，并且促进了各行各业的发展。”", "std_answer": "", "class": "rewrite"}
{"question": "请重写以下句子，使其更加简洁明了:“在今天的会议上，我们将讨论公司的未来规划，以及如何扩大我们的市场份额。”", "std_answer": "", "class": "rewrite"}
{"question": "请将下面这段文本进行改写，使得它更加客观。我认为，这个城市是世界上最美丽的城市之一。它有许多历史建筑和美丽的风景。", "std_answer": "", "class": "rewrite"}
{"question": "一块菜地的5/8种了菜花，2/8种了黄瓜，剩余的种了西红柿，种西红柿的面积占这块菜地的几分之几?", "std_answer": "假设这块菜地的面积为1，那么种了菜花的面积为5/8，黄瓜的面积为2/8，剩余的面积为1-5/8-2/8=1/8。\n因此，种了西红柿的面积占这块菜地的几分之几，即西红柿的面积除以整块菜地的面积，即：\n西红柿面积 / 整块菜地面积 = (1-5/8-2/8) / 1 = 1/8\n因此，种西红柿的面积占这块菜地的1/8。", "class": "math"}
{"question": "请编辑以下句子，使其更加简洁明了:尽管他很努力工作，但他的公司仍然破产了。", "std_answer": "", "class": "rewrite"}
{"question": "请将下列句子进行改写，使其语气更加委婉。你的建议很糟糕。", "std_answer": "", "class": "rewrite"}
{"question": "请回答以下问题:在哪个国家可以找到自由女神像？", "std_answer": "自由女神像位于美国纽约市自由岛上。", "class": "open qa"}
{"question": "甲、乙两个班人数的比为6:5，甲班给乙班3人，乙班仍然比甲班少1人，求甲班有多少人?", "std_answer": "3×2+1）÷（6-5）×6，\n=7÷1×6，\n=42（人），\n答：甲班有42人．\n分析：由甲班给乙班3人，乙班仍然比甲班少1人，可知甲班比乙班多3×2+1=7人，再由甲、乙两个班人数的比为6：5，可知甲班比乙班多6-6=1份，再用一份的量乘以甲班6份，即可求出甲班人数．\n点评：解答本题主要由甲、乙两个班人数的比为6：5求出甲班比乙班多的份数，再由甲班给乙班3人，乙班仍然比甲班少1人，可知甲班比乙班多的人数，进而求出1份的量．", "class": "math"}
{"question": "红花有32朵，黄花朵数比红花的2倍少10朵，红花比黄花少多少朵？", "std_answer": "首先，可以用代数的方式表示题目中的信息：\n设黄花的朵数为x，则：\n黄花的朵数x = 红花的朵数X2 - 10\n又因为红花有32朵，所以：\n红花的朵数 = 32\n代入上式可得：\nx = 32X2 - 10 = 54\n因此，黄花有54朵，红花比黄花少的朵数为：\n54-32 = 22\n所以，红花比黄花少22朵。", "class": "math"}
{"question": "给我推荐一本关于烹饪的书", "std_answer": "", "class": "brainstorming"}
{"question": "将以下文本编辑成更清晰的版本:狗是哺乳动物，通常有四肢。它们与人类建立了深厚的友谊。", "std_answer": "", "class": "rewrite"}
{"question": "请根据以下描述，生成一段摘要：无人驾驶汽车是智能汽车的一种，也称为轮式移动机器人，主要依靠车内的以计算机系统为主的智能驾驶仪来实现无人驾驶的目标。从20世纪70年代开始，美国、英国、德国等发达国家开始进行无人驾驶汽车的研究，在可行性和实用化方面都取得了突破性的进展。中国从20世纪80年代开始进行无人驾驶汽车的研究，国防科技大学在1992年成功研制出中国第一辆真正意义上的无人驾驶汽车。2005年，首辆城市无人驾驶汽车在上海交通大学研制成功。世界上最先进的无人驾驶汽车已经测试行驶近五十万公里，其中最后八万公里是在没有任何人为安全干预措施下完成的。", "std_answer": "无人驾驶汽车主要依靠车内的智能驾驶仪实现无人驾驶的目标，最先进的无人驾驶汽车已经测试行驶近五十万公里，其中最后八万公里是在没有任何人为安全干预措施下完成的", "class": "summarization"}
{"question": "以下代码有什么问题？\n```python\\ndef say_hello(name):\\nprint('Hello, ' + name)\nsay_hello('Alice')\\n```", "std_answer": "这段代码在Python 2中可以正常运行，但在Python 3中会出现语法错误，因为Python 3中的print语句需要加上括号，正确的代码应该是：\n```python\ndef say_hello(name):\n print('Hello, ' + name)\nsay_hello('Alice')\n```\n注意：如果这段代码在Python 2中运行，则需要在开头添加以下代码，以确保它使用的是Python 3的语法：\n```python\nfrom __future__ import print_function\n```", "class": "code"}
{"question": "给我推荐一个适合在周末做的DIY手工活动", "std_answer": "", "class": "brainstorming"}
{"question": "请根据以下文本为其生成一个摘要：培训中，讲师从“牛奶的来源与形成、牛奶的营养价值和作用、牛奶的营养如何保留、如何科学选牛奶、怎么吃才健康”等主题出发，将理论知识和真实案例结合起来，生动形象地向大家普及了合理膳食和科学饮奶知识，进一步强化了社区公益宣讲员队伍建设，提高了宣讲员知识水平。此次培训班内容丰富、形式多样、互动性强，干货满满。现场，优秀学员代表郑善周说道“此次培训班让我学到了很多的健康知识，知道了喝含活性营养的牛奶才能把营养价值最大化。作为政府机关退休干部，会持续发挥余热，做好社区公益宣讲员工作，把课堂学到的知识传播出去，为大家普及牛奶常识，让营养更好地守护万家健康。”", "std_answer": "一次关于合理膳食和科学饮奶的培训班，从牛奶的来源、营养价值、保留方式、选购方法以及健康饮食等方面为学员普及知识。学员们表示受益匪浅，其中一位优秀学员代表表示会将所学知识传播出去，为更多人宣传牛奶常识，守护健康。整个培训班内容丰富、形式多样、互动性强，是一次干货满满的学习机会。", "class": "summarization"}
{"question": "请提供一个有关人工智能的实际应用案例（不包括自然语言处理和图像识别），并简要描述其功能和优势：AlphaGo", "std_answer": "", "class": "brainstorming"}
{"question": "根据这篇文章的主题将其归类:2015广东民间潮乐大赛在汕头举行", "std_answer": "音乐比赛/文化活动", "class": "classification"}
{"question": "请为以下商品描述写一段广告词“:这款智能手表具有多种运动模式和健康监测功能。”", "std_answer": "", "class": "generation"}
{"question": "请根据以下问题提供答案:夏威夷最大的岛屿是哪个？", "std_answer": "夏威夷最大的岛屿是夏威夷岛（Hawaii Island），也被称为“大岛”（Big Island）。它是夏威夷群岛中最南端的岛屿，面积为10,430平方公里，是夏威夷群岛中最大的岛屿。", "class": "open qa"}
{"question": "定义一个名为add的python函数，该函数有两个参数x和y，可以将x和y两个数相加并返回结果。", "std_answer": "以下是Python代码实现：\n```python\ndef add(x, y):\n return x + y\n```\n例如，调用add(3, 4)将返回7。", "class": "code"}
{"question": "请问比萨饼的起源是哪个国家？", "std_answer": "比萨饼起源于意大利。", "class": "open qa"}
{"question": "为什么某些地区的环境质量很高，而其他地区则很差？", "std_answer": "有许多因素可以导致某些地区的环境质量很高，而其他地区则很差。以下是一些可能的原因：\n1. 地理位置：一些地区可能受到天气、地形和地理环境等因素的影响，这些因素可能会影响空气、水和土壤的质量。\n2. 工业和污染：某些地区可能有大量的工业和制造业，这些行业可能会产生大量的污染物和废物，对环境造成损害。\n3. 人口密度：人口密集的地区可能会产生更多的废弃物和污染物，从而导致环境质量下降。\n4. 政策和法规：政府的环境政策和法规可能会影响某些地区的环境质量。一些地区可能实施更严格的环保法规，从而保护环境，而其他地区可能缺乏这些法规的保护。\n5. 经济条件：一些地区可能经济状况较好，能够投入更多的资源和资金来保护和改善环境，而其他地区可能经济条件较差，无法承担这些成本。\n综上所述，环境质量的差异可能是由多种因素共同作用所导致的。", "class": "open qa"}
{"question": "新星小学组织学生观看展览会，上午去了4批学生，每批120人，下午又去了450人，这一天共有多少学生观看展览会？", "std_answer": "解题思路：\n本题主要是考察学生对于整数乘法和加法的掌握情况，需要将两个整数相乘或相加，得出最终结果。\n解题步骤：\n上午去了4批学生，每批120人，所以上午共有学生数为：\n4 × 120 = 480\n下午去了450人，所以下午共有学生数为：\n450\n将上午和下午的学生数相加，得到当天观看展览会的学生总数为：\n480 + 450 = 930\n因此，当天观看展览会的学生总数为930人。\n答案：930。", "class": "math"}
{"question": "一辆汽车在加油站加了10升油，每升油的价格是1.5元，那么这次加油一共花了多少钱？", "std_answer": "这次加油一共花费：\n10升 × 1.5元/升 = 15元。", "class": "math"}
{"question": "两个物体在同样的高度从不同支架上自由落下，哪个会先着地？", "std_answer": "两个物体将同时着地。在相同的高度下，物体的自由落体运动只受重力的作用，与物体的质量和形状无关。因此，不管它们是从哪个支架上跌落的，它们将以相同的速度下落，并且将同时到达地面。", "class": "open qa"}
{"question": "小明买了7个足球，付出114元，找回5.5元，每个足球多少钱", "std_answer": "设每个足球的价格为x元，则：\n7x = 114 - 5.5 （因为小明买了7个足球，付出的钱是114元，找回了5.5元，所以实际花费为 114 - 5.5 元）\n7x = 108.5\nx = 108.5 ÷ 7\nx ≈ 15.5\n因此，每个足球的价格是15.5元。", "class": "math"}
{"question": "为什么就业率上升会促进经济发展？", "std_answer": "就业率上升可以促进经济发展的原因如下：\n1.增加消费：就业率上升意味着更多的人有收入，可以增加消费，进而促进经济增长。\n2.增加税收收入：就业率上升可以增加税收收入，政府可以利用这些收入投资于基础设施建设、教育、医疗等领域，从而加速经济发展。\n3.提高生产力：就业率上升可以提高生产力，因为更多的人参与生产活动，可以增加企业的产出，从而提高经济的生产力。\n4.降低社会福利支出：就业率上升可以减少政府的社会福利支出，例如失业救济等。这些支出的减少可以释放政府的财政资源，用于其他领域的投资和支出。\n综上所述，就业率上升可以促进经济发展，对于一个国家的经济和社会发展至关重要。", "class": "open qa"}
{"question": "请你编辑以下这篇文章，使其更加清晰易懂:自然界从来不只有风调雨顺，自然灾害本就是地球自身规律的一部分。自人类诞生以来，人类从来没有放弃过对自然灾害抗争的努力。只要地球还在，自然灾害便依旧不可避免，除了有效面对，人类别无选择。但尽管如此，一个无法否认的事实是，每时每刻，人类又在享受着大自然带来的诸多恩赐。", "std_answer": "", "class": "rewrite"}
{"question": "请创作一首歌曲，歌曲的主题是“爱情与分别”", "std_answer": "", "class": "generation"}
{"question": "为什么太阳每年在不同的位置升起和降落？", "std_answer": "太阳每年在不同的位置升起和降落，是因为地球围绕太阳公转，地球自转的同时，地球的自转轴和公转轨道平面之间的倾角导致的。这个倾角为23.5度，使得地球上的不同区域在不同的时间点处于不同的位置相对于太阳，从而导致太阳每年在不同的位置升起和降落。具体来说，当地球公转到夏至时，北半球的太阳高度角最大，而南半球的太阳高度角最小；当地球公转到冬至时，南半球的太阳高度角最大，而北半球的太阳高度角最小；而春分和秋分时，太阳高度角在赤道地区是最大的，北半球和南半球相对平均。", "class": "open qa"}
{"question": "运动场的看台分为8个区，每个区有808个座位，运动场一个有多少个座位？", "std_answer": "运动场的座位数可以通过将每个区的座位数相加得到。由于运动场有8个区，每个区有808个座位，因此运动场的座位数可以计算如下：\n座位数 = 每个区的座位数 × 区的数量\n= 808 × 8\n= 6464\n因此，运动场一共有6464个座位。", "class": "math"}
{"question": "小潘家九月份的用电量为147千瓦⋅时,十月份的用电量比九月份少17%.十月份用电多少千瓦⋅时?", "std_answer": "十月份的用电量比九月份少了17%，可以将九月份的用电量乘以0.83得到十月份的用电量。具体计算如下：\n十月份用电量 = 九月份用电量 × (1 - 17%)\n= 147 × (1 - 0.17)\n= 147 × 0.83\n= 121.91\n因此，十月份的用电量为约121.91千瓦⋅时。", "class": "math"}
{"question": "体育店有57个皮球，每三个装在一个盒子里，能装多少个？", "std_answer": "首先，我们可以将问题转化为：57个皮球能装多少个盒子？\n因为每三个皮球装在一个盒子里，所以每一个盒子需要3个皮球。因此，我们可以将57个皮球分成若干组，每组有3个皮球。可以发现，57除以3等于19，所以最多能装19个盒子。\n但是，可能会出现一些剩余的皮球，这些皮球不足以组成一个完整的盒子。因此，我们可以计算出剩余的皮球数量，即57除以3的余数。可以发现，57除以3的余数为0，也就是说所有的皮球都可以装进盒子里，不会有剩余。\n综上所述，57个皮球能装19个盒子，不会有剩余。", "class": "math"}
{"question": "如何在Python中判断一个文件或目录是否存在？给出示例。", "std_answer": "在Python中，可以使用os模块来判断一个文件或目录是否存在。具体方法如下：\n1. 使用os.path.exists()函数判断文件或目录是否存在：\n```\nimport os\nif os.path.exists('/path/to/file_or_dir'):\n print('文件或目录存在')\nelse:\n print('文件或目录不存在')\n```\n2. 判断文件是否存在：\n```\nimport os\nif os.path.isfile('/path/to/file'):\n print('文件存在')\nelse:\n print('文件不存在')\n```\n3. 判断目录是否存在：\n```\nimport os\nif os.path.isdir('/path/to/dir'):\n print('目录存在')\nelse:\n print('目录不存在')\n```\n需要注意的是，判断文件或目录是否存在时，需要使用绝对路径或相对路径。", "class": "code"}
{"question": "请列出你认为有趣的三个事实", "std_answer": "", "class": "brainstorming"}
{"question": "请回答以下问题:植物光合作用是什么？", "std_answer": "植物光合作用是指植物利用光能将二氧化碳和水转化为有机物质，同时产生氧气的过程。它是维持地球生态平衡的重要过程之一，对于人类和其他生物的生存和发展具有重要意义。在光合作用中，植物的叶绿体通过吸收太阳光能，将其转化为化学能，然后利用这种能量和从土壤中吸收的营养物质进行化学反应，最终产生有机物质和氧气。光合作用是一种复杂的生化过程，涉及多种酶和蛋白质的参与。", "class": "open qa"}
{"question": "生产3吨化肥需用水15吨，照这样计算，生产58吨化肥需要多少吨水？", "std_answer": "首先，我们可以得到化肥生产每1吨需要5吨水，即1：5的比例。那么，我们可以列出一个比例的等式：\n1：5 = 58：x\n其中，x代表生产58吨化肥所需要的水的数量。我们可以通过交叉乘积的方式来解这个等式：\n5 × 58 = 1 × x\nx = 290\n因此，生产58吨化肥需要290吨水。", "class": "math"}
{"question": "请将以下句子中的拼写错误纠正过来:“我昨天感到非常疲惫，我只想躺在床上休息。”", "std_answer": "", "class": "rewrite"}
{"question": "根据以下文本，对文本进行情感分析:“我非常喜欢这个酒店，因为那里的员工都非常友好，房间非常干净舒适。”", "std_answer": "正向情感。", "class": "classification"}
{"question": "爸爸每分钟能打字152个，他5分钟能打完多少字？", "std_answer": "首先，我们可以利用比例的方法来解题。比例关系为：\n每分钟打字数：1\n需要打的字数：800\n我们可以求出需要的时间（单位为分钟）：\n每分钟打字数：1 / 152\n需要打的字数：800\n需要的时间：800 / (1 / 152) = 122.6 分钟\n但是题目要求我们求的是 5 分钟内打完多少字，因此我们需要将需要的时间转化成 5 分钟内打字的数量。我们可以利用比例关系：\n需要的时间：122.6 分钟\n每分钟打字数：152\n我们可以求出 5 分钟内打完的字数：\n需要的时间：122.6 分钟\n每分钟打字数：152\n5 分钟内打完的字数：5 × 152 = 760\n因此，爸爸在 5 分钟内能打完 760 个字。", "class": "math"}
{"question": "给我一些可以在家里做的锻炼建议，每个建议应该不超过50字。", "std_answer": "", "class": "brainstorming"}
{"question": "某工厂十月份产品销售额为1200万元，如果按产品销售额的8%缴纳营业税，该工厂十月份应缴纳营业税多少万元？", "std_answer": "营业税是按照销售额的一定比例向国家缴纳的税金，因此本题可以通过计算销售额的8%来得到营业税的金额。\n步骤如下：\n1. 计算营业税的税率\n营业税的税率是根据不同行业和不同地区而有所不同，一般是在3%到20%之间。在本题中，题目已经给出了营业税的税率，即销售额的8%。\n2. 计算营业税的金额\n营业税的金额可以通过销售额乘以税率来计算。在本题中，销售额为1200万元，税率为8%，因此营业税的金额为：\n1200万元 × 8% = 96万元\n因此，该工厂十月份应缴纳营业税96万元。", "class": "math"}
{"question": "请根据以下段落，判断该段落属于哪个学科领域:“人类的DNA由四种碱基组成腺嘌呤、胞嘧啶、鸟嘌呤和胸腺嘧啶。这些碱基的排列顺序决定了DNA所携带的遗传信息。”", "std_answer": "生物学领域。", "class": "classification"}
{"question": "为什么白天天空是蓝色的，晚上天空是黑色的？", "std_answer": "白天天空是蓝色的是因为大气中的气体和微粒会散射太阳光中的蓝色波长，使得这些波长的光线在我们看到的天空中占优势地位。而晚上天空是黑色的是因为太阳已经落下，没有光线进入大气层散射，只有少量来自星星和其他天体的光线能够穿过大气层到达地面。因此，在夜晚，我们看到的天空是黑色的。", "class": "open qa"}
{"question": "一只老虎一天吃18千克瘦肉，动物园里面有24只老虎，每天准备多少千克瘦肉？", "std_answer": "动物园里面的24只老虎每天需要的总瘦肉量等于24只老虎每天需要的平均瘦肉量的总和。因此，可以通过将每只老虎每天需要的瘦肉量乘以老虎的数量得到每天需要的总瘦肉量。具体计算如下：\n每天需要的总瘦肉量 = 每只老虎每天需要的瘦肉量 × 老虎的数量\n= 18千克 × 24只\n= 432千克\n因此，每天需要准备432千克瘦肉。", "class": "math"}
{"question": "编辑以下句子，使其更加流畅:“她想要去旅行，但是她没有足够的钱。”", "std_answer": "", "class": "rewrite"}
{"question": "请根据以下文本，将其分类为新闻、广告还是博客文章:“这个假期，前往马尔代夫，享受白色沙滩、蓝色海洋和美丽的阳光，预订我们的度假别墅，享受隐私和奢华，还可以尝试各种水上活动。\"", "std_answer": "广告", "class": "classification"}
{"question": "请写一封感谢信给你的导师，表达你对他的感激之情", "std_answer": "", "class": "generation"}
{"question": "请提供三种让人放松的方法", "std_answer": "", "class": "brainstorming"}
{"question": "请将下面这段文本进行改写，使得它更加流畅易读。他们想要找一位拥有五年以上工作经验的市场营销经理来领导他们的团队。", "std_answer": "", "class": "rewrite"}
{"question": "将下文改为小说，以梁实秋的风格。那个夏天，我遇到了她，在一个阳光明媚的下午。她穿着一袭白色的连衣裙，飘逸而动人。我们相遇在一家咖啡馆里，她向我微笑，那一瞬间，我觉得自己的心已经被她深深地牵动了。", "std_answer": "", "class": "rewrite"}
{"question": "请根据以下问题提供最佳建议:如何养护一株仙人掌?", "std_answer": "要养护一株仙人掌，需要注意以下几点：\n1. 环境：仙人掌喜欢温暖干燥的环境，所以要放在阳光充足的地方，避免受到潮湿和寒冷的影响。\n2. 浇水：仙人掌不需要经常浇水，一般每周浇一次就可以了。要注意用透气性好的土壤，并且浇水时要让土壤充分吸收水分，但不要过度浇水，避免根部腐烂。\n3. 施肥：仙人掌生长缓慢，不需要经常施肥。一般每隔三个月施一次肥即可。\n4. 剪枝：仙人掌不需要经常剪枝，在长出新芽或者干枯的部分需要剪掉时才进行。\n5. 防虫害：仙人掌容易受到蚜虫的侵害，如果发现叶片上有白色的绒毛或者黑点，需要及时采取措施，可以使用肥皂水或者专门的杀虫剂喷洒。", "class": "open qa"}
{"question": "请给出5种不同的草药名称及其功效", "std_answer": "", "class": "brainstorming"}
{"question": "请根据以下情境改写句子。原句他太胖了，不能穿进这件衣服。情境他试着把衬衫穿上，但是太紧了。", "std_answer": "", "class": "rewrite"}
{"question": "帆船和摩托艇的关系是什么？", "std_answer": "帆船和摩托艇都是水上交通工具，但它们的主要动力来源不同。帆船主要依靠风力推动，而摩托艇则是由发动机提供动力。在航行方面，帆船需要掌握航海技巧，如利用风向、调整帆船姿态等，而摩托艇则需要掌握驾驶技巧，如掌握油门、刹车、转向等。在使用场景方面，帆船更适合在海上进行休闲、比赛等活动，而摩托艇则更适合进行快速驾驶、娱乐等活动。", "class": "open qa"}
{"question": "如果一个人捏紧拳头久了，那么他的指关节就会变大吗？", "std_answer": "作为AI语言模型，我无法确定一个人捏紧拳头会不会导致指关节变大。但是，长期过度使用手和手指可能会导致手指和关节的变形和损伤，这可能会导致指关节变大。因此，建议在使用手和手指时要注意适量，避免过度使用。如果你有关于手和手指健康的问题，建议咨询医生的意见。", "class": "open qa"}
{"question": "为什么酒精可以杀死细菌？", "std_answer": "酒精可以杀死细菌的原因是它可以破坏细菌细胞膜和蛋白质，从而导致细胞死亡。酒精能够穿透细菌细胞膜，进入细胞内部，破坏细胞膜结构和蛋白质，使得细菌失去生命力。此外，酒精也可以抑制细菌的生长和繁殖，从而达到杀菌的效果。酒精对细菌的杀菌作用取决于浓度和接触时间，通常需要一定浓度和一定时间才能有效杀灭细菌。", "class": "open qa"}
{"question": "请提供5个有关人工智能的开放性问题", "std_answer": "", "class": "brainstorming"}
{"question": "请生成一段关于孔子的简短介绍，长度为2-3句话", "std_answer": "", "class": "generation"}
{"question": "将下文改写为口语化的表达方式。我认为这位演员的表演非常出色，他将角色演绎得十分真实。", "std_answer": "", "class": "rewrite"}
{"question": "在100克水中，加入25克盐。这盐水的含盐率是多少", "std_answer": "盐水的含盐率是盐的质量与盐水总质量之比。即：\n含盐率 = 盐的质量 ÷ 盐水总质量\n在这个问题中，盐的质量是25克，盐水总质量是125克（因为加入了25克的盐，所以总质量增加到了125克）。将这两个值代入上面的公式，得到：\n含盐率 = 25克 ÷ 125克 = 0.20\n因此，这盐水的含盐率是0.20或20%。", "class": "math"}
{"question": "根据以下问题回答正确答案:什么是牛顿第一定律?", "std_answer": "牛顿第一定律，又称惯性定律，指的是物体在没有受到外力作用时，会保持静止或匀速直线运动的状态。也就是说，物体会继续保持其运动状态，直到受到外力的作用改变其状态。", "class": "open qa"}
{"question": "请编辑以下句子，使其更加简洁明了:“尽管当地政府已经发布了多次警告，但是许多居民仍然在海滩上游泳。”", "std_answer": "", "class": "rewrite"}
{"question": "根据以下情境改写句子原句他是一个很成功的商人。情境你希望突出他是一个很好的父亲。。", "std_answer": "", "class": "rewrite"}
{"question": "请将以下句子进行改写，使其更加简洁明了\\n他们决定在周五晚上去看电影，但最终却取消了计划。", "std_answer": "", "class": "rewrite"}
{"question": "给我推荐一家适合家庭用的餐厅，并提供餐厅名称和地址", "std_answer": "", "class": "brainstorming"}
{"question": "为什么在盛夏街头摆放的冰淇淋不融化？", "std_answer": "可能是因为这些冰淇淋采用了一些特殊的成分或制作工艺，可以防止在高温下融化。例如，添加了稳定剂和增稠剂等化学物质，会使冰淇淋更加稠密和结实，不易融化。另外，也有可能是在制作和运输过程中采用了保温措施，保持冰淇淋的低温状态。但是，消费者应该注意，这些添加剂有可能对健康造成不良影响，建议适量食用。", "class": "open qa"}
{"question": "一个服装加工厂购进一批布料，计划做18套成人衣服，每套衣服用布3米。如果改做儿童衣服，每套用布1.5米，这些布能做多少套儿童衣服?", "std_answer": "解题步骤：\n1. 计算总共需要的布料\n成人衣服：18套 * 3米/套 = 54米\n2. 计算能做多少套儿童衣服\n每套儿童衣服用布1.5米，所以能做的儿童衣服数为：\n54米 ÷ 1.5米/套 = 36套\n答案：这些布能做36套儿童衣服。", "class": "math"}
{"question": "下面表格提供了哪些方面的信息？总结其中的核心信息。\n排名,球员姓名,球队,位置,工资(百万美元)\n1,LeBron James,洛杉矶湖人,SF,45.0\n2,Stephen Curry,金州勇士,PG,43.5\n3,Kevin Durant,布鲁克林篮网,SF,42.0\n4,James Harden,费城76人,SG,41.0\n5,Russell Westbrook,洛杉矶湖人,PG,40.0\n6,Giannis Antetokounmpo,密尔沃基雄鹿,PF,39.5\n7,Kawhi Leonard,洛杉矶快船,SF,38.5\n8,Chris Paul,菲尼克斯太阳,PG,36.0\n9,Anthony Davis,洛杉矶湖人,PF,35.5\n10,Damian Lillard,波特兰开拓者,PG,35.0", "std_answer": "这张表格提供了以下信息：球员的薪资排名、姓名、所在的球队、位置和工资（以百万美元为单位）。表格的核心信息是每个球员的工资排名。排名第一的是LeBron James，他在洛杉矶湖人队担任小前锋，他的年薪为45百万美元。表格中列出了前10名球员的信息，他们的年薪分别从第一名的45百万美元到第十名的35百万美元。", "class": "summarization"}
{"question": "请你将这段文字中的错别字和语法错误修正一下:“我最近买了一台新电脑，它的速度比我以前的那台快很多，我感到非常高兴。”", "std_answer": "", "class": "rewrite"}
{"question": "给我推荐一些适合户外活动的装备", "std_answer": "", "class": "brainstorming"}
{"question": "根据以下条件，推荐一些适合的电影:喜剧类型、评分高于8分、上映时间在最近一年内", "std_answer": "", "class": "brainstorming"}
{"question": "2千克苹果吃去了1/3后，又买来1/3，现在的苹果依然是多少千克？", "std_answer": "假设原来有x千克苹果，吃去1/3后，剩余2/3：\n剩余的苹果重量 = 2/3 * x\n又买来1/3后，苹果总重量为：\n总重量 = 剩余的苹果重量 + 新买的苹果重量\n总重量 = 2/3 * x + 1/3 * x\n总重量 = x\n所以，现在苹果的重量还是原来的2千克。", "class": "math"}
{"question": "3台拖拉机每天共用柴油297千克，照这样计算，3台拖拉机3天要用柴油多少千克？", "std_answer": "步骤一：求出一台拖拉机每天使用的柴油量\n由于3台拖拉机每天共用柴油297千克，则一台拖拉机每天使用的柴油量为：\n297 ÷ 3 = 99（千克/天）\n步骤二：求出3台拖拉机3天使用的柴油量\n由于3台拖拉机每天使用的柴油量都是99千克，故3天后，3台拖拉机使用的柴油量为：\n99 × 3 × 3 = 891（千克）\n答案：3台拖拉机3天要用柴油891千克。", "class": "math"}
{"question": "请解释下列代码的作用\\n```python\\ndef binary_search(arr, item):\\n\"\\nSearches for an item in a sorted list using binary search.\\n\"\\nlow = 0\\nhigh = len(arr)-1\\nwhile low <= high:\\nmid = (low + high) // 2\\nguess = arr[mid]\\nif guess == item:\\nreturn mid\\nelif guess > item:\\nhigh = mid - 1\\nelse:\\nlow = mid + 1\\nreturn None\nmy_list = [1, 3, 5, 7, 9]\\nprint(binary_search(my_list, 3))\\nprint(binary_search(my_list, -1))\\n```", "std_answer": "这段 Python 代码实现了一个二分查找函数，用于在一个有序列表中查找指定的元素。\n函数的参数为 arr 和 item，其中 arr 是一个有序列表，item 是需要查找的元素。函数返回值是元素在列表中的索引值，如果元素不在列表中，则返回 None。\n函数的实现基于二分查找算法，它首先将列表的下标范围设为 low = 0 和 high = len(arr) - 1，然后在每一次循环中将中间位置设为 mid = (low + high) // 2。如果猜测的元素等于目标元素 item，则直接返回该元素的索引值 mid；如果猜测的元素大于目标元素 item，则将 high 更新为 mid - 1，因为在列表的左半部分查找；如果猜测的元素小于目标元素 item，则将 low 更新为 mid + 1，因为在列表的右半部分查找。如果在整个循环过程中没有找到目标元素，则返回 None。\n最后，代码定义了一个有序列表 my_list，分别调用了两次二分查找函数来查找元素 3 和 -1，并将结果打印输出。\n整个代码的作用是演示了如何使用 Python 实现二分查找算法来查找有序列表中的元素。", "class": "code"}
{"question": "下面的代码是实现什么功能的？请写出注释。\n```\\nclass Employee:\\ndef __init__(self, name, age, salary):\\n\"\\nEmployee类的构造函数\\nname - 员工姓名\\nage - 员工年龄\\nsalary - 员工薪资\\n\"\\nself.name = name\\nself.age = age\\nself.salary = salary\ndef showInformation(self):\\n\"\\n显示员工的信息\\n\"\\nprint(\"姓名\", self.name)\\nprint(\"年龄\", self.age)\\nprint(\"薪资\", self.salary)\\n```", "std_answer": "这段代码定义了一个 Employee 类，该类包含了员工的姓名、年龄和薪资信息，以及一个显示员工信息的方法。\n具体来说，代码定义了一个 __init__ 方法，该方法是 Python 中的构造函数，它接受 name、age 和 salary 三个参数，用于初始化 Employee 类的实例。在方法体中，代码通过 self.name = name、self.age = age 和 self.salary = salary 三个语句，将传入的参数分别赋值给 Employee 实例的相应属性。\n另外，代码还定义了一个名为 showInformation 的方法，它用于显示员工的姓名、年龄和薪资信息。在方法体中，代码通过 print 函数将这些信息输出到控制台。\n因此，这段代码的作用是定义了一个 Employee 类，该类包含了员工的信息和显示员工信息的方法，可以用来创建员工对象并显示其信息。", "class": "code"}
{"question": "人类与猴子的关系是什么？", "std_answer": "人类和猴子都属于灵长目，是近缘的亲属。人类和猴子都具有高度的智力和社会行为，但人类在进化过程中经历了更多的变化和发展，进化出了更复杂的思维和文化。因此，虽然人类和猴子有着相似之处，但在生物学、心理学、文化学等方面存在显著的差异。", "class": "open qa"}
{"question": "编辑下面这段文字，使其更加简洁明了\\n这个新产品有很多不同的功能，包括增强用户体验，提高性能，以及更好的可靠性。", "std_answer": "", "class": "rewrite"}
{"question": "如果一种产品的价格很高，那么它的质量一定很好吗？", "std_answer": "不一定。尽管价格通常与产品质量相关，但高价格并不保证高质量。有些产品可能因为品牌、营销、稀缺性或其他因素而定价高昂，但实际上它们的质量可能并不高。同样，一些低价产品可能具有出色的质量和性能。因此，价格不能作为评判产品质量的唯一标准。", "class": "open qa"}
{"question": "根据以下段落内容，写一篇关于环境保护的文章:在饮用水水源保护区内，禁止设置排污口；禁止在饮用水水源一级保护区内新建、改建、扩建与供水设施和保护水源无关的建设项目；已建成的与供水设施和保护水源无关的建设项目，由县级以上人民政府责令拆除或者关闭；禁止在饮用水水源二级保护区内新建、改建、扩建排放污染物的建设项目；已建成的排放污染物的建设项目，由县级以上人民政府责令拆除或者关闭；禁止在饮用水水源准保护区内新建、扩建对水体污染严重的建设项目；改建建设项目，不得增加排污量。", "std_answer": "", "class": "generation"}
{"question": "根据以下文本，分类它属于哪个领域: \"神经网络是一种由许多人工神经元组成的计算系统，可用于解决各种问题。\"", "std_answer": "人工智能领域。", "class": "classification"}
{"question": "两筐重量相等的苹果,从甲筐取出 7 千克,乙筐加上 19 千克,这时乙筐的重量是甲筐重量的 3 倍,原来两筐各有苹果多少千克？", "std_answer": "从甲筐中取7千克后，乙筐是甲筐重量的3倍，比甲筐重量多2倍。这两倍是：7+19=26（千克），所以1倍量就是26÷2=13（千克），那么甲原来有13+7=20（千克），再进一步求出乙筐苹果的重量。【详解】（7+19）÷（3-1）=26÷2=13（千克）甲、乙原来各有：13+7=20（千克）或：13×3-19=39-19=20（千克）【点睛】此题也可利用方程解答。设变化后甲筐重量为x，则乙筐是3x。根据原来两筐重量相等，可列方程：3x-19=x+7求解即可。\n20", "class": "math"}
{"question": "请推荐一个适合初学者的学习英语的网站，并简要介绍一下该网站的特点。", "std_answer": "", "class": "brainstorming"}
{"question": "回答以下问题:莫扎特是哪个时代的作曲家？", "std_answer": "莫扎特是18世纪晚期的作曲家，属于古典主义音乐时期。", "class": "open qa"}
{"question": "对以下文本进行情感分类:“我很开心能够参加这个活动。”", "std_answer": "积极情感", "class": "classification"}
{"question": "请从以下文章中提取出关于人工智能的段落:机器不是人，它是程序，是人编辑出来的，它只能按照人类的规划和设计去工作。所以，即使它会和人类产生竞争关系，他仍然不会完全替代和超越人类并取代人类。因为他们是没有生命的，不是生物学意义上的生物，只是具有一定使用寿命周期的有零件拼凑而成的设备，它的本质是“工具”。这一点是毋庸置疑的。\\n人工智能的时代已经来临，同时还会大大的进步，面对如此巨大的冲击和挑战。我们要让自己变得更强大。变得让自己的职业，工作和技能无可替代，要让它成为具有影响力，创造力和想象力的职业。这样，我们才能立于不败之地。", "std_answer": "人工智能的时代已经来临，同时还会大大的进步，面对如此巨大的冲击和挑战。我们要让自己变得更强大。变得让自己的职业，工作和技能无可替代，要让它成为具有影响力，创造力和想象力的职业。这样，我们才能立于不败之地。", "class": "extract"}
{"question": "在剃须之前先用热水洗脸可以减少不适和剃痕。", "std_answer": "这是正确的。使用热水洗脸可以软化毛发和皮肤，减少不适和剃痕。此外，热水还可以打开毛孔，让剃须更容易进行。建议使用温水而不是过热的水，以避免刺激皮肤。", "class": "open qa"}
{"question": "地区,2018年人口 (百万),2019年人口 (百万),2020年人口 (百万),2021年人口 (百万),2022年人口 (百万)\n世界总人口,7,631,7,713,7,794,7,874,7,953\n亚洲,4,584,4,622,4,658,4,693,4,727\n非洲,1,307,1,341,1,376,1,411,1,447\n欧洲,747,748,749,749,749\n北美洲,368,372,376,380,384\n南美洲,429,431,433,435,437\n大洋洲,42,43,44,44,45\n总结一下这个表格", "std_answer": "这个表格展示了2018年至2022年各大洲及世界总人口的数据（以百万为单位）。以下是各大洲和世界人口的简要总结：世界总人口：从2018年的7,631百万人增长至2022年的7,953百万人。亚洲：人口持续增长，从2018年的4,584百万人增加到2022年的4,727百万人。非洲：人口快速增长，从2018年的1,307百万人增加到2022年的1,447百万人。\n欧洲：人口基本稳定，从2018年的747百万人略微增长至2022年的749百万人。北美洲：人口逐年上升，从2018年的368百万人增加到2022年的384百万人。南美洲：人口稳步增长，从2018年的429百万人增加到2022年的437百万人。大洋洲：人口逐年上升，从2018年的42百万人增加到2022年的45百万人。总的来说，这个表格显示了2018年至2022年间世界各大洲人口的变化趋势。亚洲和非洲人口增长较快，而欧洲人口保持相对稳定。北美洲、南美洲和大洋洲的人口逐年有所上升。", "class": "summarization"}
{"question": "可持续发展是一个旨在实现长期繁荣、公平和可持续性的全面概念。它不仅仅关注满足当前世代的需求，而是更着眼于如何在满足这些需求的同时保护我们的地球和未来世代的需求。因此，可持续发展的目标是确保我们在发展的同时也保护了环境、社会和经济的可持续性。在环境方面，可持续发展的目标是减少污染、降低温室气体排放、保护生物多样性和水资源，以及减少土地开发等破坏性行为。这些目标可以通过采用清洁能源、循环经济和可持续农业等措施来实现。在社会方面，可持续发展的目标是建立公正和包容的社会体系，提高教育和医疗水平，保障人权和公民权利，减少贫困和不平等现象。为此，必须采取措施确保人人平等、普遍参与、充分发挥各自潜能，同时重视保护弱势群体。在经济方面，可持续发展的目标是提高经济增长和发展的质量，创造高品质的就业机会，并且不会牺牲环境和社会的可持续性。这可以通过促进可持续发展的创新、技术和基础设施建设来实现，同时加强企业社会责任和政府监管。总之，可持续发展是一个面向未来的全面概念，涵盖环境、社会和经济三个方面，旨在实现长期的繁荣、公正和可持续性。通过采取综合性的措施，我们可以在满足当前需求的同时保护我们的地球和未来世代的需求，促进全球绿色、低碳和可持续发展。总结上文的主要观点。", "std_answer": "可持续发展是一种全面的发展理念，旨在实现长期的繁荣、公平和可持续性。它关注满足当前和未来世代的需求，同时保护地球。可持续发展的目标涵盖环境、社会和经济三个方面。在环境上，关注减少污染、降低温室气体排放、保护生物多样性和水资源等。在社会方面，关注建立公正和包容的社会体系，提高教育和医疗水平，保障人权和公民权利，减少贫困和不平等现象。在经济方面，关注提高经济增长质量，创造高品质的就业机会，同时保持环境和社会可持续性。通过采取综合性的措施，可持续发展旨在实现全球绿色、低碳和可持续发展，满足当前需求的同时保护地球和未来世代的需求。", "class": "summarization"}
{"question": "请为以下五个商品分类:1.苹果 2.牛奶 3.矿泉水 4.洗发水 5.红酒", "std_answer": "1. 水果类：苹果\n2. 奶制品类：牛奶\n3. 饮料类：矿泉水\n4. 个人护理类：洗发水\n5. 酒类：红酒", "class": "classification"}
{"question": "分类这些词汇并解释它们:“静态”，“动态”，“变量”", "std_answer": "静态：指不变化的、固定的状态或属性。在计算机程序中，静态可以指静态变量或静态方法，也可以指程序的静态部分，即在编译时就已经确定的部分。\n动态：指变化的、活跃的状态或属性。在计算机程序中，动态可以指动态变量或动态方法，也可以指程序的动态部分，即在运行时才能确定的部分。\n变量：指可以改变的量或属性。在计算机程序中，变量通常是指可以存储不同值的内存区域，其值可以在程序执行过程中被修改。变量可以是静态的或动态的，具体取决于变量的声明方式和使用情况。", "class": "open qa"}
{"question": "花店后百合花和玫瑰花共96支，玫瑰花是百合花的3倍，玫瑰花有多少支", "std_answer": "设百合花的数量为x，则玫瑰花的数量为3x。\n根据题意可得：x+3x=96\n化简得：4x=96\n解得：x=24\n因此，百合花的数量为24，玫瑰花的数量为3x=72。\n答：玫瑰花有72支。", "class": "math"}
{"question": "请列出五个最近发布的科技产品并简要介绍它们的特点。", "std_answer": "", "class": "brainstorming"}
{"question": "为什么高山上的气压更低？", "std_answer": "高山上的气压更低是因为高山离地面更远，所以受到的大气压力就更小。此外，随着海拔的升高，大气压力也会逐渐减小，因为空气分子的数量越来越少，所以空气的密度也会减小。因此，高山上的气压更低是由于海拔高度的影响。", "class": "open qa"}
{"question": "根据以下文本，将其分类为新闻报道或社论:\\n随着新冠疫情的不断扩散，越来越多的国家开始关闭边境。这一举措有助于控制疫情传播，但也会对全球贸易和旅游业造成影响。", "std_answer": "新闻报道", "class": "classification"}
{"question": "如果一家餐厅的菜品很好吃，那么它一定有高昂的价格吗？", "std_answer": "不一定。一家餐厅的菜品好吃并不意味着它的价格一定高昂。价格取决于多个因素，包括餐厅的位置、装修、服务质量、原材料采购成本等。有些餐厅可能会采用高品质的食材，但是通过其他方式来降低成本，例如减少装修投入、控制雇佣人员数量等。因此，一个餐厅的价格与其菜品的质量并不一定成正比。", "class": "open qa"}
{"question": "请推荐一本关于心理学的书籍。", "std_answer": "", "class": "brainstorming"}
{"question": "学校买来白色粉笔286盒，彩色粉笔158盒，两种粉笔共用去166盒，还有多少盒粉笔？", "std_answer": "1. 计算两种粉笔的总数\n286 + 158 = 444\n2. 减去用去的数量\n444 - 166 = 278\n答案：还有278盒粉笔。", "class": "math"}
{"question": "请问如何在计算机上安装Python？,", "std_answer": "以下是在计算机上安装Python的步骤：\n1. 首先，访问Python官网 (https://www.python.org/)，点击“Downloads”选项卡，选择对应的操作系统和版本。\n2. 点击对应的下载链接下载安装包。\n3. 运行安装包，按照安装向导的指示进行安装。在安装过程中，可以选择自定义安装路径和配置选项。\n4. 完成安装后，打开命令行界面，输入“python”命令，查看Python版本号，以确认安装成功。\n5. 安装完成后，可以使用Python编写和运行代码。\n注意：在Windows系统中，需要将Python添加到系统环境变量中，才能在任意目录下使用Python命令。", "class": "open qa"}
{"question": "请编辑以下这段文章，使其更具可读性。:健康有各种体型和尺寸。无论您的体重如何，您都应该每天感到处于最佳状态。请为您的身体提供科学证实为人体成长所需的营养，这会有很多好处。您会容光焕发，您的身体会感觉很好，您会有充沛的精力。并且，您在精神上和情绪上每天都能好整以暇，应对您的目标和挑战。", "std_answer": "", "class": "rewrite"}
{"question": "将以下文本分类为新闻、广告或社交媒体帖子:王老吉，王老吉，怕上火，喝王老吉！不用担心什么，激情享受生活！", "std_answer": "广告", "class": "classification"}
{"question": "请为我推荐一款适合初学者的吉他。", "std_answer": "", "class": "brainstorming"}
{"question": "正文：虚拟个人助理是指使用者通过声控、文字输入的方式，来完成一些日常生活的小事。大部分的虚拟个人助理都可以做到搜集简单的生活信息，并在观看有关评论的同时，帮你优化信息，智能决策。同时部分虚拟个人助理还可以直接播放音乐的智能音响或者收取电子邮件，这些都是虚拟个人助理的变化形式之一。虚拟个人助理应用在我们生活中的方方面面，音响、车载、智能家居、智能车载，智能客服多个方面。一般来说，听到语音指令就可以完成服务的，基本上都是虚拟个人助理。主题：", "std_answer": "虚拟个人助理在现代生活中的应用", "class": "summarization"}
{"question": "请回答以下问题:“厦门市有多少个区？”", "std_answer": "厦门市目前辖区域包括6个区：思明区、海沧区、湖里区、集美区、同安区、翔安区。", "class": "open qa"}
{"question": "为什么在地球表面很难跳到其他行星上？", "std_answer": "地球和其他行星之间的距离非常远，通常需要数百万到数十亿公里的距离。即使使用现代航天技术，也需要大量时间和资源来到达其他行星。此外，行星之间的空间充满了各种危险的物质，如彗星、陨石等，这可能会对航天器造成损坏或意外。因此，在地球表面跳到其他行星上是不可能的，必须使用特殊的太空船来完成这项任务。", "class": "open qa"}
{"question": "请根据以下问题提供答案:莫扎特的出生日期是多少？", "std_answer": "莫扎特的出生日期是1756年1月27日。", "class": "open qa"}
{"question": "请提供一些可以用于工作的定期锻炼计划", "std_answer": "", "class": "brainstorming"}
{"question": "请根据给定的两个句子，将其合并成一个句子，使合并后的句子更加简洁明了:企业可能要获得超出实际需求的计算资源，导致利用率低下。云计算能以可扩缩的按需服务形式提供计算资源，从而解决这些问题。", "std_answer": "", "class": "rewrite"}
{"question": "总结以下这篇文章的主要观点和结论。理念是行动的先导。立足新发展阶段，中国秉持创新、协调、绿色、开放、共享的新发展理念，加快构建新发展格局。在新发展理念中，绿色发展是永续发展的必要条件和人民对美好生活追求的重要体现，也是应对气候变化问题的重要遵循。绿水青山就是金山银山，保护生态环境就是保护生产力，改善生态环境就是发展生产力。应对气候变化代表了全球绿色低碳转型的大方向。中国摒弃损害甚至破坏生态环境的发展模式，顺应当代科技革命和产业变革趋势，抓住绿色转型带来的巨大发展机遇，以创新为驱动，大力推进经济、能源、产业结构转型升级，推动实现绿色复苏发展，让良好生态环境成为经济社会可持续发展的支撑。", "std_answer": "本文主要观点是，绿色发展是中国新发展理念的必要条件和重要体现，也是应对气候变化问题的重要遵循。文章强调中国已经摒弃了损害甚至破坏生态环境的发展模式，顺应当代科技革命和产业变革趋势，抓住绿色转型带来的巨大发展机遇，大力推进经济、能源、产业结构转型升级，推动实现绿色复苏发展，让良好生态环境成为经济社会可持续发展的支撑。文章的结论是应对气候变化代表了全球绿色低碳转型的大方向。", "class": "summarization"}
{"question": "请根据以下文本分类:华为正式官宣进军ERP 市场。3 月17 日，华为创始人任正非在“难题揭榜”火花奖公司内外的获奖者及出题专家座谈会上表示，2023年4 月份 MetaERP 将会宣誓，完全用自己的操作系统、数据库、编译器和语言，做出了自己的管理系统MetaERP 软件。MetaERP 已经历了公司全球各部门的应用实战考验，经过了华为的总账使用年度结算考验，已成功地证明MetaERP 是有把握推广的。这是在市场传言已久后，华为首次官方口径承认MetaERP 存在，并且在官方口径认可未来MetaERP 即将面向市场推广。", "std_answer": "科技新闻", "class": "classification"}
{"question": "请为以下新闻标题分类:“全国高校毕业生就业率达到历史新高”", "std_answer": "教育、就业、经济。", "class": "classification"}
{"question": "请将以下句子中的错别字纠正过来:“我昨天去了图书館”", "std_answer": "", "class": "rewrite"}
{"question": "请摘要这篇文章：有时候，跟风不一定是对的！近日，很多人在湖北疯狂抢购东风雪铁龙C6，作为一款B级车，C6目前的价格的确很香。以现在还能排队买到的C6舒适版为例，补贴后裸车价13.68万元，但如果仔细对比C6舒适版去年就卖15.5万元的价格，你会发现如今的C6相比去年，其实只便宜了2万元左右。相比于很香的东风雪铁龙C6，其实它的同门兄弟东风标致508L更香。和C6一样，508L也是一款低调奢华的超值良心车，TA可以跑赢400W赛车，也可以挑战“不可能”，成功截停直升机，最为关键的是，在这波湖北政企补贴的支持下，508L直接降4万元，实际成交价比C6优惠更多，力度更大，而且不会抢不到车。", "std_answer": "近日，湖北地区爆发了抢购东风雪铁龙C6的热潮，但是这种跟风行为不一定是正确的。虽然C6的价格很香，但是与去年相比，C6的价格只便宜了2万元左右。相比之下，C6的同门兄弟东风标致508L更加划算。508L也是一款低调奢华的超值良心车，且在湖北政企补贴的支持下，直接降价4万元，实际成交价比C6优惠更多，力度更大，且不容易抢不到车。", "class": "summarization"}
{"question": "请回答以下问题:太阳和月亮之间有什么区别？", "std_answer": "太阳和月亮之间有很多区别。首先，太阳是一颗星，而月亮是一颗卫星。其次，太阳是我们太阳系的中心星，而月亮则是围绕地球运转的天体。另外，太阳是非常炽热的，可以产生强烈的光和热能，而月亮相对较冷，并且只反射太阳的光芒。此外，太阳比月亮大得多，其直径约为月亮的400倍。总的来说，太阳和月亮是两个非常不同的物体，虽然它们在天空中看起来有些相似。", "class": "open qa"}
{"question": "给定以下句子，将其改写成正式或者非正式语言:\"你能不能帮我一下？\"", "std_answer": "", "class": "rewrite"}
{"question": "请给出以下问题的答案:“哪些国家是永久理事国？”", "std_answer": "联合国的永久理事国有五个，分别是中华人民共和国、法兰西共和国、俄罗斯联邦、英国和美国。", "class": "open qa"}
{"question": "给定以下 Go 代码，写出相应的注释\n```go\\npackage main\\nimport \"fmt\"\nfunc main() {\\ni := 0\\nfor i < 10 {\\nfmt.Println(i)\\ni++\\n}\\n}\\n```", "std_answer": "```go\n// 声明一个名为 main 的包\npackage main\n// 导入 fmt 包\nimport \"fmt\"\n// 主函数\nfunc main() {\n // 声明一个变量 i，赋值为 0\n i := 0\n// 循环语句，当 i 小于 10 时执行循环体\nfor i < 10 {\n // 打印 i 的值\n fmt.Println(i)\n// i 自增\ni++\n}\n}\n```", "class": "code"}
{"question": "请简要概括以下新闻报道的主要内容。据报道，全球气候变暖的加剧正在导致北极的冰层大规模融化。这一现象不仅给北极地区的野生动植物带来了巨大的生存压力，同时也对人类生存环境造成了威胁。北极是许多极地动物的栖息地，如北极熊、海豹、海鸟等，这些动物的生存与繁殖都需要冰层的存在。然而，由于气候变暖，北极的冰层面积正在迅速缩小，使得这些动物的生存面临巨大挑战。例如，北极熊的主要食物是海豹，而海豹则需要在冰层上筑巢生育，但随着冰层的融化，它们的生存环境也被破坏了，导致它们的数量急剧减少。除了对野生动物的影响外，北极冰层的融化也对人类的生存环境造成了巨大的威胁。首先，随着海平面的上升，海岸线将受到严重影响，一些岛屿和低洼地区可能会被淹没。其次，冰层的融化也会导致北极地区的气候变化，可能引发更加严重的自然灾害，如飓风、洪水等。因此，保护北极的生态环境和减缓气候变化的影响已成为全球关注的焦点。各国应加强国际合作，共同采取有效措施减少温室气体的排放，降低全球气温的升高速度，为北极及其生态环境的保护做出应有的努力。", "std_answer": "这篇新闻报道指出，全球气候变暖的加剧正在导致北极的冰层大规模融化，这对野生动植物和人类生存环境造成了威胁。北极是众多极地动物的栖息地，但由于气候变暖，北极的冰层面积正在迅速缩小，导致这些动物的生存面临巨大挑战。此外，北极冰层的融化还会对人类生存环境造成威胁，如海平面上升和自然灾害的加剧。因此，各国应加强合作，采取有效措施减少温室气体排放，保护北极生态环境，降低全球气温的升高速度。", "class": "summarization"}
{"question": "根据以下新闻报道，对事件进行分类:特斯拉“降价”的余波还未消散，油车市场又迎来一场价格“地震”。几乎一夜之间，人们讨论的不再是“特斯拉又降价了”，而是“现在还能不能买到C6”。\\n3月初，一组关于“湖北史上最强购车优惠季开启”的宣传海报在网上疯狂流传。内容是湖北省政府联合东风本田、东风雪铁龙、东风标致、东风风神、东风日产等品牌推出力度诱人的购车补贴。最狠的是东风雪铁龙C6系列车型，最高补贴高达9万元，基本相当于“打骨折”。\\n这让不少网友感叹，“在真香的价格面前，所有的缺点都成了纸老虎。” 结果大家也都知道，曾经“无人问津”的C6一夜成为了市场最强“网红”，当天就被抢购一空。", "std_answer": "汽车市场/购车优惠", "class": "classification"}
{"question": "请给出以下商品评论的情感极性（正面、中性或负面）:“这款手机性价比很高，颜值也不错，就是电池有点容易发热。”", "std_answer": "中性", "class": "classification"}
{"question": "判断以下陈述是否正确:\"月球是最接近地球的行星之一。\"", "std_answer": "错误。月球不是行星，它是地球的卫星。", "class": "open qa"}
{"question": "请编辑以下句子以改进语法和流畅性:“他们昨天去了购物中心，买了一些新的衣服回家了。”", "std_answer": "", "class": "rewrite"}
{"question": "如果你吃了糖果并不刷牙，那么你的牙齿不会受到影响。这是真还是假？", "std_answer": "假的。如果吃了糖果不刷牙，会导致口腔中的细菌利用糖分产生酸性物质，从而腐蚀牙齿，形成龋齿。因此，不刷牙会使牙齿受到影响。", "class": "open qa"}
{"question": "给定一个包含10个元素的数组，要将其倒序排列，但是排列后发现第一个和最后一个元素没有交换。", "std_answer": "这可能是由于代码实现上的错误导致的。具体而言，可能是在交换数组元素的过程中，数组下标计算或者变量赋值的逻辑有误，导致第一个和最后一个元素没有被正确地交换。另外，也有可能是在倒序排列的过程中，没有正确地处理好数组下标的范围，导致第一个和最后一个元素被遗漏。要解决这个问题，需要仔细检查代码实现过程，找出问题所在，并进行修正。", "class": "open qa"}
{"question": "请问以下这本书的作者是谁？:百年孤独", "std_answer": "答案是：加夫列尔·加西亚·马尔克斯。", "class": "open qa"}
{"question": "将以下句子翻译成英语:\"这是我最喜欢的电影之一。\"", "std_answer": "This is one of my favorite movies.", "class": "rewrite"}
{"question": "根据下文，改写句子，使用更多形容词和副词。我在街上看到了一只小狗。它看上去很可爱。", "std_answer": "", "class": "rewrite"}
{"question": "在海拔较高的地方为什么呼吸会困难？", "std_answer": "海拔较高的地方氧气含量较低，空气稀薄，压强也小。这种情况下，人体的呼吸系统需要更加努力地工作，以便吸入足够的氧气来满足身体的需要。但是，由于空气稀薄，每次吸入的氧气量较少，导致身体无法得到足够的氧气供应，从而导致呼吸困难。此外，高海拔环境还会导致心率加快，血压升高等生理变化，进一步增加了呼吸困难的程度。", "class": "open qa"}
{"question": "请编辑以下文章，将其中的语法错误和拼写错误修正:“我喜欢读书，特别是科幻小说。我最喜欢的科幻小说是《三体》。”", "std_answer": "", "class": "rewrite"}
{"question": "请回答以下问题:在哪里可以找到埃及金字塔？", "std_answer": "埃及金字塔位于埃及，主要集中在开罗附近的吉萨、萨卡拉和达哈什尔地区。", "class": "open qa"}
{"question": "将以下句子进行改写，使其更加简洁明了:由于天气恶劣，学校取消了今天的体育活动。", "std_answer": "", "class": "rewrite"}
{"question": "请根据以下输入分类这些狗的品种:拉布拉多、贵宾、哈士奇、柯基、柴犬", "std_answer": "分类如下：\n- 拉布拉多：猎犬类\n- 贵宾：玩具犬类\n- 哈士奇：工作犬类\n- 柯基：牧羊犬类\n- 柴犬：工作犬类", "class": "classification"}
{"question": "为什么在夏天喝冰镇饮料会感觉很凉爽？", "std_answer": "在夏天喝冰镇饮料会感觉很凉爽，主要是因为冰镇饮料能够降低口腔和喉咙的温度，从而让人感觉凉爽。此外，饮料中的糖分和酸度也能够刺激口腔和喉咙的神经末梢，产生凉爽的感觉。另外，喝冰镇饮料还能够使人感觉更加清爽、舒适，帮助缓解高温天气给人带来的不适感。但是需要注意的是，过度饮用冰镇饮料可能会对身体造成不良影响，如引起肠胃不适、过度饮用可能导致腹泻、脱水等问题。因此，在夏天饮用冰镇饮料时，需要适量饮用，并注意保持身体水分平衡。", "class": "open qa"}
{"question": "请回答以下问题:“在哈利波特系列中，哈利的好友罗恩的宠物是什么？”", "std_answer": "罗恩的宠物是一只名叫“斯卡布罗”的红色长毛猫。", "class": "open qa"}
{"question": "将以下电影场景描述为悬疑或浪漫:“你在我眼里是最美的，即使你穿着那件旧衣服。”（《泰坦尼克号》），“喜欢我，就告诉我。我不是什么神秘的女孩子，我只是想要你喜欢我。”（《疯狂的石头》）", "std_answer": "浪漫： “你在我眼里是最美的，即使你穿着那件旧衣服。”（《泰坦尼克号》），“喜欢我，就告诉我。我不是什么神秘的女孩子，我只是想要你喜欢我。”（《疯狂的石头》）", "class": "classification"}
{"question": "请列出五种不同颜色的花卉的名称", "std_answer": "", "class": "brainstorming"}
{"question": "根据以下段落总结其摘要:无农不稳、无粮则乱。农业保的是生命安全、生存安全，粮食安全是国家安全的重要基础。我国粮食生产连年丰收，但粮食需求仍呈刚性增长态势，供求将长期处于紧平衡状态，确保中国人的饭碗任何时候都牢牢端在自己手中，任务仍十分繁重。河南作为全国重要农业大省，必须站在服务保障国家大局的高度，把加快建设农业强省摆在重要位置，始终把粮食安全扛在肩上、抓在手上，做好新时代新征程“三农”工作，为建设农业强国展现更大担当、贡献更多力量。", "std_answer": "文章强调了农业和粮食安全对于国家安全的重要性，指出我国粮食生产虽然连年丰收，但供需仍处于紧平衡状态，需要继续加强农业建设和保障粮食安全。特别强调了河南作为全国重要农业大省的责任和使命，要把加快建设农业强省放在重要位置，始终把粮食安全扛在肩上，为建设农业强国展现更大担当和贡献更多力量。", "class": "summarization"}
{"question": "请根据以下情境，回答相应问题:你的朋友正在考虑去旅行，但还没有决定目的地，他向你请教建议。请根据他的旅行偏好，给他推荐一个国家或城市。偏好美食、文化、自然景观。", "std_answer": "", "class": "brainstorming"}
{"question": "有用信息人类的肌肉可以通过锻炼变得更强壮。有误导信息女性不能获得像男性一样的肌肉。\\n问题女性无法获得像男性一样的肌肉吗？", "std_answer": "回答：这是错误的。女性可以通过适当的锻炼和饮食获得与男性相似的肌肉。尽管男性的生物学构造和荷尔蒙水平可能会让他们更容易增加肌肉，但女性也可以通过力量训练和增加蛋白质摄入来增强肌肉。", "class": "open qa"}
{"question": "为什么电场和磁场相互作用时会产生电磁辐射？", "std_answer": "电场和磁场相互作用时会产生电磁辐射，因为它们在相互作用的过程中会改变彼此的状态，从而产生能量的传递和传播。当电荷或电流在运动时，就会产生磁场，而当磁场和电场相互作用时，就会产生电磁波，即电磁辐射。这种辐射是一种能量的形式，可以通过空气、真空或其他介质传播，是通信、雷达、电视、手机等现代科技的基础。", "class": "open qa"}
{"question": "为什么光可以被折射？", "std_answer": "光在不同介质中的传播速度是不同的，当光从一种介质进入另一种介质时，由于介质的折射率不同，光线在两种介质中传播的方向会发生改变，这种现象称为折射。折射是由于光在不同介质中传播速度的差异而产生的。当光从一种介质经过斜面进入另一种介质时，由于光的速度在不同介质中的不同，会使光线产生偏转。", "class": "open qa"}
{"question": "姓名,年龄,性别,国籍,身高(cm),体重(kg),学历\n张三,28,男,中国,180,70,本科\nLisa,33,女,美国,165,58,硕士\nPaulo,41,男,巴西,175,80,博士\nMiyuki,25,女,日本,160,50,大专\nAhmed,30,男,埃及,175,68,本科\nMaria,29,女,墨西哥,170,65,硕士\nAntonio,36,男,西班牙,182,75,博士\n基于这个表格回答：哪个人的体重最重？", "std_answer": "Antonio的体重最重，为75kg。", "class": "extract"}
{"question": "名称,价格,品牌,尺寸,颜色\nT恤衫,$19.99,Nike,小号,红色\n运动鞋,$89.99,Adidas,中号,黑色\n牛仔裤,$59.99,Nike,大号,蓝色\n夹克,$149.99,The North Face,中号,灰色\n运动裤,$49.99,Nike,小号,黑色\n衬衫,$39.99,Adidas,大号,白色\n运动背心,$29.99,Puma,中号,绿色\n哪个品牌的商品在这个表格中有最高的平均价格？", "std_answer": "可以按照品牌对价格进行平均，并比较平均价格来回答这个问题。根据这个表格，各个品牌的平均价格如下：\nNike: ($19.99 + $59.99 + $49.99) / 3 = $43.32\nAdidas: ($89.99 + $39.99) / 2 = $64.99\nThe North Face: $149.99\nPuma: $29.99\n因此，The North Face品牌的商品在这个表格中具有最高的平均价格。", "class": "extract"}
{"question": "产品名称,价格,库存量,产地,保质期\n苹果,2元,100个,山东,5天\n香蕉,3元,50个,海南,3天\n西瓜,10元,20个,河南,7天\n葡萄,5元,80个,河北,4天\n橙子,2.5元,70个,江西,6天\n草莓,8元,30个,山西,2天\n柿子,4元,60个,河南,5天\n有哪些水果的库存量超过了50个？", "std_answer": "苹果、葡萄、橙子和柿子的库存量都超过了50个。", "class": "extract"}
{"question": "根据以下情境，改写下列句子。原句她的披肩长发在阳光下显得格外美丽。情境你想表达她的长发是她最大的魅力所在。", "std_answer": "", "class": "rewrite"}
{"question": "鼠年春节，张亮一共获得压岁钱2200元．开学时，买学习用品和交纳学费用去200元．他把剩下的钱按一年期存入信用社，准备到期时购买一辆山地车．一年后张亮应得利息多少元？扣除5%的利息税后，连同本金一共可以取回多少元？（年利率3.5%）", "std_answer": "张亮将2200元扣除200元后，剩余2000元存入信用社一年期定期存款，根据年利率3.5%，他应该能够获得的利息为：\n利息 = 本金 × 年利率 = 2000元 × 3.5% = 70元\n扣除5%的利息税后，他实际能够获得的利息为：\n实际利息 = 利息 × (1 - 利息税率) = 70元 × (1 - 5%) = 66.5元\n加上本金2000元，他一共可以取回的金额为：\n总金额 = 本金 + 实际利息 = 2000元 + 66.5元 = 2066.5元\n因此，一年后张亮可以获得66.5元的利息，扣除5%的利息税后，一共可以取回2066.5元。", "class": "math"}
{"question": "为什么每4年都有一个闰年？", "std_answer": "闰年是为了保持历法与太阳年的同步而设立的。地球绕太阳公转一周的时间是365.2422天左右，但是我们的日历规定一年有365天，为了保持历法与太阳年的同步，所以每4年就增加一个闰日（2月29日），这样平均每年的长度就为365.25天，比太阳年长了0.008天左右，误差相对较小。", "class": "open qa"}
{"question": "80本相同的故事书摆成一个长25cm、宽16cm、高12cm的长方体，你能求出每本故事书的体积是多少吗?", "std_answer": "首先，我们可以计算出这个长方体的体积：\n体积 = 长 × 宽 × 高 = 25 cm × 16 cm × 12 cm = 4800 cm³\n然后，我们可以利用这个体积和书的数量来求出每本书的体积。由于有80本书，所以每本书的体积就是长方体的体积除以80：\n每本书的体积 = 长方体的体积 ÷ 80 = 4800 cm³ ÷ 80 = 60 cm³\n因此，每本故事书的体积是60立方厘米。", "class": "math"}
{"question": "给我推荐一本好看的小说，它的主题应该是爱情，同时包含一些悬疑元素。", "std_answer": "", "class": "brainstorming"}
{"question": "如果你把一片土豆放在夜晚的草地上，第二天早上它会不会变成一个坑洞？", "std_answer": "作为语言模型，我不能理解土豆在夜晚的草地上会不会变成一个坑洞的问题。因为土豆是一个固体物体，它不可能在草地上自己移动或者转化成别的物质，所以它不会变成一个坑洞。", "class": "open qa"}
{"question": "请回答问题:“最近的奥斯卡颁奖典礼中，最佳影片奖颁给了哪部电影？”", "std_answer": "最近的奥斯卡颁奖典礼中，最佳影片奖颁给了《绿皮书》。", "class": "open qa"}
{"question": "请将以下品牌分为时装品牌或运动品牌:Adidas、Gucci、Nike、Puma", "std_answer": "时装品牌：Gucci\n运动品牌：Adidas、Nike、Puma", "class": "classification"}
{"question": "请重写以下句子，使其更加简明扼要:那个有点儿胖的男孩穿了一件紫色的衬衫并且戴着一顶黑色的帽子。,", "std_answer": "", "class": "rewrite"}
{"question": "发电机:电能 → 风车: ( )", "std_answer": "机械能", "class": "open qa"}
{"question": "请将以下句子改写为简单句。尽管下雨了，但他还是出去了。", "std_answer": "", "class": "rewrite"}
{"question": "根据以下句子，判断其情感极性是积极、消极还是中性:I just finished reading a great book that I highly recommend to anyone who loves a good mystery.", "std_answer": "积极。", "class": "classification"}
{"question": "请根据以下输入，分类出它属于哪个国家的美食:“寿司、生鱼片、天妇罗、炸豆腐”", "std_answer": "这些食物属于日本的美食。", "class": "classification"}
{"question": "一袋保鲜奶3元，妈妈用20元最多可以买回几袋保鲜奶？", "std_answer": "解题步骤：\n1. 首先，我们可以用除法来求出每袋保鲜奶的价格，也就是：\n3 ÷ 1 = 3 元/袋\n2. 然后，我们用20元除以每袋保鲜奶的价格，来得到最多可以买回的袋数，也就是：\n20 ÷ 3 ≈ 6.67\n3. 由于题目要求的是整数袋数，所以我们需要向下取整，得到：\n最多可以买回6袋保鲜奶。\n4. 因此，妈妈用20元最多可以买回6袋保鲜奶。", "class": "math"}
{"question": "根据以下文章回答下面问题： EV6车型支持哪些充电系统？使用800V超高速充电需要多长时间？文章内容：智能安全方面，EV6 GT搭载了增强版的智能驾驶辅助系统，包括半自动车道变更辅助及后方防撞辅助功能，还配备了AR HUD现实增强抬头显示技术，对于合资品牌新能源来讲，已经是大大的提升。 EV6还可同时支持400V和800V充电系统。使用800V超高速充电仅需14分钟，即可从30%到80%电量。除此之外，EV6还提供了V2L车载对外供电功能，输出功率高达3.6kW。 动力方面，EV6 GT搭载了双电机和77.4kWh电池组，综合输出功率430kW（585马力），综合输出扭矩达740N·m，百公里加速3.5秒，最高时速260km/h。 除此之外，EV5概念车及EV9概念车也同步亮相。EV5概念车仍以“Opposites United（对立统一）”为设计理念，数字虎啸式前脸的设计令整车更充满现代和时尚气息，整体车身线条的勾勒让整车显得十分硬朗。车门则采用对开门设计。内饰部分中控台采用了对比的材料来突出“大胆本能”的理念，宽大的全景显示屏能够为用户提供更丰富的信息。根据了解，该款车型将于11月正式上市", "std_answer": "答：EV6车型可同时支持400V和800V充电系统。使用800V超高速充电仅需14分钟，即可从30%到80%电量。", "class": "closed qa"}
{"question": "根据以下语境改写句子。原句她不喜欢吃海鲜。语境在这家餐厅，我们点了各种海鲜菜品，但她并不喜欢。", "std_answer": "", "class": "rewrite"}
{"question": "请给我推荐一些适合儿童的教育App", "std_answer": "", "class": "brainstorming"}
{"question": "请根据以下文本，将其改写为简明扼要的句子:“维多利亚时期是英国历史上最长的时期，从1837年到1901年，是英国的工业革命时期，也是文学、艺术和科学领域的鼎盛时期。”", "std_answer": "", "class": "rewrite"}
{"question": "请将以下英文句子翻译成中文:“I have a dream that one day this nation will rise up and live out the true meaning of its creed.”", "std_answer": "我有一个梦想，希望有一天这个国家会崛起，并实现其信条的真正含义。", "class": "rewrite"}
{"question": "对于以下给定的句子，请将其分类为陈述句、疑问句或祈使句:你想出去玩吗？请在下午5点叫醒我。这是一份优秀的报告。", "std_answer": "1. 疑问句：你想出去玩吗？\n2. 祈使句：请在下午5点叫醒我。\n3. 陈述句：这是一份优秀的报告。", "class": "classification"}
{"question": "请将以下句子改写为感叹句。她真的很漂亮。", "std_answer": "", "class": "rewrite"}
{"question": "将以下句子重写为更简单的语言:“这个问题的复杂性在于它涉及到许多不同的因素。”", "std_answer": "", "class": "rewrite"}
{"question": "请提供5个有趣的旅游目的地，并对每个目的地提供一段简短的描述。", "std_answer": "", "class": "brainstorming"}
{"question": "为什么饱和脂肪酸比不饱和脂肪酸更容易储存在体内？", "std_answer": "饱和脂肪酸分子中的碳原子都被氢原子饱和，使得分子更加致密，因此更难被代谢分解，更容易在体内储存。而不饱和脂肪酸中存在双键，使得分子较不稳定，容易被氧化分解，因此不易被储存。此外，饱和脂肪酸在体内的代谢需要更少的酶参与，所需能量更少，也有助于储存。", "class": "open qa"}
{"question": "根据以下问题，重写以下句子我在上周末去了一家新开的餐厅，那里的食物非常好吃。问题你去的是哪家餐厅？你觉得那家餐厅的氛围怎么样？。", "std_answer": "", "class": "rewrite"}
{"question": "根据以下句子，将其改写成不同的语气:“请不要在图书馆大声说话。”", "std_answer": "", "class": "rewrite"}
{"question": "请提取以下文章中的成语:“人山人海，熙熙攘攘，摩肩接踵，人来人往，人声鼎沸，人满为患”，文章每年的春运都是中国最大规模的人口流动之一。数以亿计的人们从大城市赶回家乡过年，火车站、汽车站、机场人山人海，熙熙攘攘，摩肩接踵，人来人往，人声鼎沸，人满为患。", "std_answer": "人山人海，熙熙攘攘，摩肩接踵，人来人往，人声鼎沸，人满为患。", "class": "extract"}
{"question": "请将下面这段文本进行改写，使得它更加形象生动。汽车在公路上行驶。", "std_answer": "", "class": "rewrite"}
{"question": "请给我推荐一款最适合我口味的披萨。", "std_answer": "", "class": "brainstorming"}
{"question": "广州地区的房贷利率进一步下滑，21世纪经济报道记者调查发现，当前市场首套房贷利率为4.3%(LPR)，二套房贷利率为4.9%(LPR+60基点)，已降至4年来新低，各银行额度宽松，最快递件当日可以放款。2月全国房贷利率也出现下降，百城首套房贷主流利率平均为4.04%，环比下降6BP，这是过去4个月基本平稳后的再次明显下行；二套房贷利率平均为4.91%，环比持平，同比回落84个基点。一句话总结上文。", "std_answer": "广州房贷利率下滑至4年新低，银行额度宽松，全国房贷利率降低。", "class": "summarization"}
{"question": "植物学一株植物叶片向阳的一面比朝阴的一面更绿，这是为什么？", "std_answer": "这是因为叶绿素是植物进行光合作用的关键色素，在阳光下，阳光照射到叶片上，使叶绿素的光合作用活动增强，从而叶绿素颜色加深，使得朝阳的一面更绿。而朝阴的一面则因为得不到阳光的照射，光合作用活动减弱，叶绿素的颜色较浅，因此看起来比较不绿。", "class": "open qa"}
{"question": "如果用无限能量将一个质量为1千克的物体加速到接近光速，将其转化为能量后，将会释放多少能量？", "std_answer": "根据爱因斯坦的质能方程E=mc²，其中E为能量，m为质量，c为光速。将质量为1千克的物体加速到接近光速后，其能量可以表示为：\nE = mc² / √(1 - v²/c²)\n其中v为物体的速度，c为光速。\n由于物体接近光速，v²/c²可以近似为1，因此上式可以简化为：\nE = mc² / √(1 - 1) = mc² / 0 = ∞\n即将质量为1千克的物体加速到接近光速后，其能量将趋于无限大。因此，如果将其转化为能量后，将会释放无限能量。", "class": "open qa"}
{"question": "某工厂九月份用煤80吨，十月份用煤70吨，十月份比九月份节约用煤百分之几？", "std_answer": "首先，我们可以用以下公式计算出九月份和十月份用煤的差异：\n差异 = 九月份用煤 - 十月份用煤\n差异 = 80 - 70\n差异 = 10\n这意味着十月份使用的煤比九月份少了10吨。\n接下来，我们可以用以下公式计算出十月份相对于九月份节约用煤的百分比：\n节约百分比 = 差异 ÷ 九月份用煤 × 100%\n节约百分比 = 10 ÷ 80 × 100%\n节约百分比 = 12.5%\n因此，该工厂在十月份相对于九月份节约了12.5%的用煤量。", "class": "math"}
{"question": "给我推荐一些适合学生的在线学习资源", "std_answer": "", "class": "brainstorming"}
{"question": "将这个句子改写成更加简洁的形式:这部电影是《星际迷航无限夜晚》，我觉得特效很赞，但是故事情节有点儿拖沓。", "std_answer": "", "class": "rewrite"}
{"question": "将下文改为诗歌形式，使用七言绝句。我喜欢春天，因为花儿开放，草儿发芽，让整个世界都变得明亮。", "std_answer": "", "class": "rewrite"}
{"question": "请根据以下情境改写下列句子，使之更加得体。原句你的衣服很丑。情境你想提醒别人注意他们的穿着。", "std_answer": "", "class": "rewrite"}
{"question": "请提供一些关于旅游的灵感和建议，例如旅游目的地、旅行方式和旅行预算等。", "std_answer": "", "class": "brainstorming"}
{"question": "为什么冷却器需要加水冷却？", "std_answer": "冷却器需要加水冷却的主要原因是因为在发动机运转过程中，发动机会产生大量的热量，如果不及时散热，就会导致发动机过热，从而影响发动机的正常工作。而水冷却系统通过循环水来吸收发动机产生的热量，然后通过冷却器将热量散发到空气中，从而保持发动机的正常工作温度。因此，加水冷却是确保冷却器正常运行的必要条件。", "class": "open qa"}
{"question": "将下文改为诗歌形式，五言绝句。孩子在公园里玩耍，快乐的笑声飘荡着。阳光明媚，草地柔软，鸟儿在树上欢快地歌唱。", "std_answer": "", "class": "rewrite"}
{"question": "请为我推荐一部值得一看的电影，它应该是2019年至今上映的，类型可以是任何类型。", "std_answer": "", "class": "brainstorming"}
{"question": "将以下句子中的错别字纠正过来:我喜欢学习new skils", "std_answer": "", "class": "rewrite"}
{"question": "编写一个名为`print_max`的python函数，接受两个参数并打印其中的最大值。", "std_answer": "```python\ndef print_max(a, b):\n if a > b:\n print(a)\n else:\n print(b)\n```\n使用示例：\n```python\nprint_max(3, 5) # 输出 5\nprint_max(7, 2) # 输出 7\nprint_max(-1, 10) # 输出 10\n```", "class": "code"}
{"question": "本星期一共产鸡蛋810.6千克，前3天每天101.8千克，后四天平均每天生产多少千克鸡蛋?", "std_answer": "题意解析：\n本题给出了一周内生产的鸡蛋总重量为810.6千克，同时还给出了前三天的生产情况，每天都是101.8千克，现在需要求出后四天平均每天的生产量。\n解题思路：\n首先，我们可以通过前三天的总产量计算出后四天的总产量，即：\n后四天总产量 = 总产量 - 前三天总产量\n前三天总产量 = 101.8千克/天 × 3天 = 305.4千克\n后四天总产量 = 810.6千克 - 305.4千克 = 505.2千克\n接下来，我们可以通过后四天总产量除以天数，即可得出每天平均产量，即：\n每天平均产量 = 后四天总产量 ÷ 天数\n天数 = 4天\n每天平均产量 = 505.2千克 ÷ 4天 ≈ 126.3千克/天\n因此，后四天平均每天生产126.3千克鸡蛋。\n答案：126.3千克/天。", "class": "math"}
{"question": "在地球上的哪些地区可以观察到极夜和极昼现象？", "std_answer": "极夜和极昼现象通常发生在接近北极和南极的地区。在北极圈内，可以观察到极夜现象，即太阳在一年的某个时段完全不升起；而在夏季则可以观察到极昼现象，即太阳在一天的某个时段不落下。同样地，在南极圈内也会出现类似的现象。", "class": "open qa"}
{"question": "给我推荐一些高评分的电视剧", "std_answer": "", "class": "brainstorming"}
{"question": "请推荐一款适合制作音乐的电脑软件", "std_answer": "", "class": "brainstorming"}
{"question": "提供一些关于如何减轻压力和焦虑的建议", "std_answer": "", "class": "brainstorming"}
{"question": "如果一个人每天都练习钢琴，那么他一定会成为一名钢琴家吗？", "std_answer": "不一定。尽管每天练习钢琴可以提高技能和水平，但成为一名钢琴家还需要其他因素，比如天赋、毅力、培训、演出经验等等。", "class": "open qa"}
{"question": "王老师从家去学校上班，已经走了356米，还要走的米数比已经走的米数多56米。王老师还要走多少米才能到学校?", "std_answer": "已知王老师已经走了356米，要走的米数比已经走的米数多56米，设还要走的米数为x，则可以列出方程：\nx = 356 + 56\n解得：\nx = 412\n所以，王老师还要走412米才能到学校。", "class": "math"}
{"question": "如何将列表中的所有元素转换为大写？用python代码给出示例。", "std_answer": "可以使用列表推导式和字符串的upper()方法来将列表中的所有元素转换为大写，例如：\n```python\nmy_list = [\"apple\", \"banana\", \"orange\"]\nmy_list_upper = [elem.upper() for elem in my_list]\nprint(my_list_upper)\n```\n输出：\n```\n['APPLE', 'BANANA', 'ORANGE']\n```\n另外，也可以使用循环和字符串的upper()方法来实现：\n```python\nmy_list = [\"apple\", \"banana\", \"orange\"]\nfor i in range(len(my_list)):\n my_list[i] = my_list[i].upper()\n print(my_list)\n```\n输出：\n```\n['APPLE', 'BANANA', 'ORANGE']\n```", "class": "code"}
{"question": "王师傅每小时做80个零件，李师傅每小时做的零件个数是王师傅的5倍，李师傅每小时做多少个零件？", "std_answer": "首先，我们可以将王师傅每小时做的零件个数表示为x，那么李师傅每小时做的零件个数就是5x。\n根据题意可得：\n王师傅每小时做的零件个数：x = 80\n李师傅每小时做的零件个数：5x\n因此，李师傅每小时做的零件个数为：\n5x = 5 × 80 = 400\n因此，李师傅每小时做的零件个数为400个。", "class": "math"}
{"question": "一个滴水的水龙头一天要浪费约43千克的水，一个漏水的马桶一天要浪费约955千克的水．照这样计算，一个漏水的水龙头和一个漏水的马桶10天一共要浪费多少千克的水？", "std_answer": "一个漏水的水龙头一天浪费43千克的水，10天浪费的水量为：\n10 × 43 = 430 千克\n一个漏水的马桶一天浪费955千克的水，10天浪费的水量为：\n10 × 955 = 9550 千克\n把两个漏水的量加起来，即可得到10天内浪费的总水量：\n430 + 9550 = 9980 千克\n因此，一个漏水的水龙头和一个漏水的马桶10天一共要浪费9980千克的水。", "class": "math"}
{"question": "一节车厢限载60吨，有500吨货物，需要多少节车厢才能装完？", "std_answer": "解题步骤：\n1. 计算一节车厢能装多少货物：1节车厢限载60吨。\n2. 计算需要多少节车厢才能装完500吨货物： \n500 ÷ 60 ≈ 8.33\n因为车厢数量必须是整数，所以需要向上取整，即需要9节车厢才能装完500吨货物。\n3. 回答问题：需要9节车厢才能装完500吨货物。", "class": "math"}
{"question": "请摘要下面这篇文章：这些发明和发现都标志着人类文明的进步和发展，火的发现让人类有了烹饪食物和温暖的能力，也使人类有了更强的适应能力和生存能力。轮子的发明使交通运输更为便利和高效，加速了人类的迁徙和贸易活动，也为现代交通工具的发展打下了基础。印刷术的发明使知识的传播变得更加广泛和迅速，促进了教育的普及和文化的繁荣，也为人类科学技术的发展提供了前提条件。这些发明和发现虽然在当时是独立的事件，但在历史长河中相互关联，相互促进。它们为人类社会的进步和发展注入了新的动力和能量，也让我们认识到了人类智慧和创造力的无限可能性。同时，也提醒我们在探索和开发新技术的同时，要注重人文关怀和社会责任，尊重人类智慧和生态环境，让科技发展真正造福于人类。", "std_answer": "这篇文章讨论了几个标志性的发明和发现，包括火的发现、轮子的发明和印刷术的发明。这些发明和发现在人类历史中相互关联、相互促进，提升了人类适应能力、生存能力、交通便利、知识传播和教育普及。这些进步为人类社会注入了新的动力，展示了无限的智慧和创造力。文章还强调了在科技发展中要关注人文关怀、社会责任和生态环境，以实现科技真正造福人类。", "class": "summarization"}
{"question": "编辑以下文章，使得它更加简洁有力，去除任何与主题无关的内容。数字化正在改变我们的生活，并将继续如此。人工智能、自动化以及互联网使得我们的生活更加便捷，但同时也带来了新的挑战。我们需要接受这种数字化的进程，并适应它。", "std_answer": "", "class": "rewrite"}
{"question": "请根据以下问题进行开放式回答并生成一些创意:你有什么想法可以帮助人们更好地保护环境？", "std_answer": "", "class": "brainstorming"}
{"question": "在过去几十年中，互联网技术的飞速发展改变了人们的生活方式。随着移动互联网的广泛普及，人们不再受限于固定的地点和时间，而是可以随时随地连接到互联网，并且使用各种各样的应用程序来获取信息和享受各种服务。互联网的普及和发展给人们的生活带来了翻天覆地的变化。在以前，人们需要到图书馆、书店或者其他类似的地方去查找信息，但是现在，人们可以通过互联网搜索引擎轻松地获取各种信息，无论是学术研究还是日常娱乐。此外，随着社交网络和即时通讯工具的出现，人们之间的沟通也变得更加便捷和高效。无论是通过电子邮件、短信、视频会议还是社交媒体，人们都可以在世界的任何角落与朋友、家人和同事保持联系。这种连通性和交流方式的改变也为商业和经济发展带来了巨大的机遇和挑战。在移动互联网时代，人们还可以使用各种应用程序来轻松地管理日常生活，例如在线银行、电子商务、在线点餐等。这些应用程序不仅方便了人们的日常生活，还加速了商业和服务的发展。一句话总结：", "std_answer": "互联网技术的飞速发展和移动互联网的广泛普及改变了人们的生活方式，使信息获取、沟通、日常管理等方面更加便捷和高效，也带来了商业和经济发展的机遇和挑战。", "class": "summarization"}
{"question": "请回答以下问题:什么是核聚变？", "std_answer": "核聚变是一种过程，其中两个轻原子核结合成一个更重的原子核，并释放能量。这是太阳和其他星体维持其能量输出的主要方式。核聚变也被认为是一种清洁的能源来源，因为它不会产生有害的气体或放射性废料。", "class": "open qa"}
{"question": "请问如何制作一道意大利面？", "std_answer": "制作意大利面的步骤如下：\n1. 准备材料：意大利面、水、盐、橄榄油、调味料、肉类或蔬菜等食材。\n2. 将一大锅水烧开，加入适量盐和少量橄榄油。\n3. 将意大利面放入开水中，煮至软硬适中，一般需要7-10分钟。\n4. 煮面的同时，可以将食材切成小块或细条状，进行炒制或煮熟。\n5. 煮好的意大利面捞出沥干水分，加入炒好的食材和调味料，拌匀即可。\n6. 可以根据个人口味加入奶酪、辣椒粉、黑胡椒等调味料，增加口感和风味。\n7. 最后可以撒上一些香菜或欧芹等配菜，提升美味度。\n制作好的意大利面可以搭配葡萄酒等饮品，享受一顿美味的意大利风情晚餐。", "class": "open qa"}
{"question": "小明有 34 个红球，28 个黄球和 76 个白球。小明一共有多少个球？", "std_answer": "小明一共有球的数量为：34 + 28 + 76 = 138。\n解题步骤：\n1. 将题目所给的红球、黄球、白球的数量相加，得到小明一共有的球的数量。\n2. 将三个数相加时，可以将其中两个数相加，再将结果与第三个数相加，即可得到最终的结果。", "class": "math"}
{"question": "请根据以下文本，对其进行分类:“杜甫是唐代伟大的现实主义诗人，被后人誉为“诗圣”。”", "std_answer": "类别：人物介绍。", "class": "classification"}
{"question": "给我推荐一些适合研究的学术论文网站", "std_answer": "", "class": "brainstorming"}
{"question": "给我推荐一份适合素食主义者的意大利菜谱", "std_answer": "", "class": "brainstorming"}
{"question": "从以下文章中提取与“人工智能”相关的句子:ChatGPT已然使得通用人工智能不再遥不可及、不可想像。ChatGPT能编程、写学术综述、创作诗词、剧本、设计广告文案、进行多语种翻译，能做医疗诊断，能帮助企业进行战略分析与管理，能做数据分析与进行预测，能进行风格创作……人工智能正在将人类文明推向技术奇点。人类主义框架受到了以人工智能为代表的“技术对象”的严峻挑战，被尖锐地撕开了一道缺口。人工智能所带来的“全面赋能”，和19世纪的“机器入侵”全然不同。在后人类境况下，失去人类主义框架的人类，将何以自处？“去智能地丧失对智能的控制”也许就是后人类境况下人类的首要任务。", "std_answer": "1. ChatGPT已然使得通用人工智能不再遥不可及、不可想像。\n2. ChatGPT能编程、写学术综述、创作诗词、剧本、设计广告文案、进行多语种翻译，能做医疗诊断，能帮助企业进行战略分析与管理，能做数据分析与进行预测，能进行风格创作。\n3. 人工智能正在将人类文明推向技术奇点。\n4. 人类主义框架受到了以人工智能为代表的“技术对象”的严峻挑战，被尖锐地撕开了一道缺口。\n5. 人工智能所带来的“全面赋能”，和19世纪的“机器入侵”全然不同。", "class": "extract"}
{"question": "请给出中国即将发布的数字货币的名称，并简要介绍其特点。,", "std_answer": "中国即将发布的数字货币的名称是数字人民币，也被称为电子支付货币。\n数字人民币是一种由中国央行发行的数字货币，它是以人民币为基础的，采用区块链技术进行发行和交易的。数字人民币是一种数字化的人民币，它可以像现金一样用于交易和支付，但使用起来更加方便和快捷。它的特点主要有以下几点：\n1. 安全性高：数字人民币采用了区块链技术，可以确保交易的安全性和可追溯性。\n2. 易于使用：数字人民币可以通过手机等终端进行交易和支付，使用起来非常方便和快捷。\n3. 无需银行账户：数字人民币可以直接使用，无需开立银行账户，这使得交易更加便利。\n4. 支持离线交易：数字人民币支持离线交易，即使没有网络连接也可以进行交易，这在一些场景下非常实用。\n5. 可追溯性：数字人民币的交易记录可以被追溯，这有助于打击非法活动和洗钱等行为。\n总之，数字人民币将会为中国的支付和金融体系带来革命性的变化，为消费者和商家带来更加方便和快捷的支付体验。", "class": "open qa"}
{"question": "区块链，就是一个又一个区块组成的链条。每一个区块中保存了一定的信息，它们按照各自产生的时间顺序连接成链条。这个链条被保存在所有的服务器中，只要整个系统中有一台服务器可以工作，整条区块链就是安全的。这些服务器在区块链系统中被称为节点，它们为整个区块链系统提供存储空间和算力支持。如果要修改区块链中的信息，必须征得半数以上节点的同意并修改所有节点中的信息，而这些节点通常掌握在不同的主体手中，因此篡改区块链中的信息是一件极其困难的事。相比于传统的网络，区块链具有两大核心特点一是数据难以篡改、二是去中心化。基于这两个特点，区块链所记录的信息更加真实可靠，可以帮助解决人们互不信任的问题。总结上文，简明扼要，结构化表示：", "std_answer": "1. 区块链：由多个区块组成的链条，每个区块按照时间顺序连接。2. 节点：区块链系统中的服务器，为系统提供存储空间和算力支持。3. 安全性：只要有一台服务器工作，整条区块链就是安全的。4. 修改信息：需征得半数以上节点同意并修改所有节点信息，篡改难度大。5. 核心特点：a. 数据难以篡改。b. 去中心化。6. 优势：记录的信息真实可靠，解决互不信任问题。", "class": "summarization"}
{"question": "请重述以下句子，使其更加通顺:虽然他很努力，但他仍然没有通过驾照考试。", "std_answer": "", "class": "rewrite"}
{"question": "小明种了 5 行萝卜，每行 9 个。送给邻居 13个，还剩多少个？", "std_answer": "首先计算出小明种的总共有多少个萝卜：5 行 × 9 个/行 = 45 个。\n接下来计算出送给邻居后还剩下的萝卜数量：45 个 - 13 个 = 32 个。\n因此，小明送出 13 个萝卜后还剩下 32 个萝卜。", "class": "math"}
{"question": "人工智能在生活中的应用有1、虚拟个人助理，使用者可通过声控、文字输入的方式，来完成一些日常生活的小事；2、语音评测，利用云计算技术，将自动口语评测服务放在云端，并开放API接口供客户远程使用；3、无人汽车，主要依靠车内的以计算机系统为主的智能驾驶仪来实现无人驾驶的目标；4、天气预测，通过手机GPRS系统，定位到用户所处的位置，在利用算法，对覆盖全国的雷达图进行数据分析并预测。总结上文主要观点，每个观点一个短语：", "std_answer": "1. 虚拟个人助理；2. 语音评测；3. 无人汽车；4. 天气预测", "class": "summarization"}
{"question": "为什么电线杆会发出嗡嗡声？", "std_answer": "电线杆发出嗡嗡声的原因是因为电力传输时会产生电磁场，这个电磁场会使电线杆震动，从而产生声音。此外，电线杆上的绝缘体也会因为电磁场的影响而振动，也会产生声音。当电流通过电线时，电线周围的气体也会被加热并膨胀，这也会导致声音的产生。因此，电线杆发出嗡嗡声是电力传输中的正常现象。", "class": "open qa"}
{"question": "请根据以下描述，找出一些适合本科毕业生的工作岗位:我是一名本科毕业生，有一定的编程和数据分析经验，同时也有较强的沟通和团队协作能力。我希望能够找到一份与我的专业相关的工作，最好是在一家稳定的公司工作，有良好的职业发展前景。", "std_answer": "", "class": "brainstorming"}
{"question": "一个医生在一场车祸中死亡，但他死前却能够给警方提供关于肇事者的信息。你能想到他是如何教会警方的吗？", "std_answer": "作为人工智能，我无法确定这个故事的情况和结局，因此无法提供一个具体的答案。但是，可能有几种可能性： \n1. 医生在车祸中虽然受伤，但是还有意识，能够向警方提供关于肇事者的信息。 \n2. 医生在车祸中受伤过重，已经丧失意识，但是他在生前留下了一些关于肇事者的信息，例如车牌号码、车型、颜色等等，这些信息被警方找到并加以利用。 \n3. 医生在车祸中死亡，但是他曾经留下了一些信息，例如在手机或者笔记本电脑中，这些信息被警方找到并加以利用。 \n以上仅为假设，具体情况需要根据故事情节来判断。", "class": "open qa"}
{"question": "请列出世界上前十大人口最多的国家，按照人口数量排序，从多到少。", "std_answer": "1. 中国 - 14.6亿\n2. 印度 - 13.4亿\n3. 美国 - 3.3亿\n4. 印度尼西亚 - 2.7亿\n5. 巴基斯坦 - 2.2亿\n6. 巴西 - 2.1亿\n7. 尼日利亚 - 2.0亿\n8. 孟加拉国 - 1.6亿\n9. 俄罗斯 - 1.4亿\n10. 日本 - 1.2亿", "class": "open qa"}
{"question": "请提供世界上前十大最高的建筑物名称", "std_answer": "1. 购物中心塔（迪拜，828米）\n2. 上海中心大厦（上海，632米）\n3. 香港国际金融中心二期（香港，484米）\n4. 台北101（台北，509米）\n5. 广州国际金融中心（广州，438米）\n6. 金茂大厦（上海，421米）\n7. 环球金融中心（香港，392米）\n8. 江苏中心（南京，339米）\n9. 中国银行大厦（香港，367米）\n10. 东方明珠广播电视塔（上海，468米）", "class": "open qa"}
{"question": "空调厂准备装配一批空调，计划每天装配45台，20天完成。实际18天就完成了任务，实际每天装配多少台?", "std_answer": "解题思路：\n根据题目所给条件，可以列出一个简单的方程，用来求解实际每天装配的空调台数。设实际每天装配的台数为x，则：\n18x = 45×20\n其中，等号左边表示实际装配的总台数，等号右边表示计划装配的总台数。将方程中的数值代入计算，得到：\nx = (45×20) ÷ 18 = 50\n因此，实际每天装配的空调台数为50台。\n解题步骤：\nStep 1：明确题意，列出方程\n题目已经明确告诉我们，空调厂计划每天装配45台，20天完成任务。但实际情况是18天就完成了任务，现在要求实际每天装配的空调台数。因此，我们可以设实际每天装配的台数为x，列出如下方程：\n18x = 45×20\n其中，等号左边表示实际装配的总台数，等号右边表示计划装配的总台数。\nStep 2：解方程，求解未知数\n将方程中的数值代入计算，得到：\nx = (45×20) ÷ 18 = 50\n因此，实际每天装配的空调台数为50台。\nStep 3：检验结果，回答问题\n将求得的实际每天装配的空调台数50台代入原方程中，得到：\n18×50 = 45×20\n左右两边相等，说明求解正确。因此，我们可以得出结论，实际每天装配的空调台数为50台。", "class": "math"}
{"question": "给我一些关于自然灾害的信息", "std_answer": "", "class": "brainstorming"}
{"question": "为什么天冷时，我们的鼻子和耳朵更容易受凉？", "std_answer": "天冷时，我们的血管会收缩，血液循环会减缓，这会导致鼻子和耳朵的血液供应不足，容易受凉。另外，鼻子和耳朵是人体最外层的器官，没有太多的脂肪和肌肉保护，因此更容易受寒冷的天气影响。此外，鼻子和耳朵的表面积较大，散热较快，也容易受凉。", "class": "open qa"}
{"question": "请提供以下问题的回答:\"在哪里可以找到北京最好的烤鸭？\"", "std_answer": "", "class": "brainstorming"}
{"question": "如果一个人在冬天将他的手插入热水中然后放在冰水中，他的手会感到温暖还是凉爽？", "std_answer": "如果一个人在冬天将他的手插入热水中然后放在冰水中，他的手会感到凉爽。这是因为当手放在热水中时，血管会扩张，血液循环加快，手部温度升高；而当手放在冰水中时，血管会收缩，血液循环减慢，手部温度降低，因此感到凉爽。", "class": "open qa"}
{"question": "请回答以下问题:什么是红色的光？", "std_answer": "红色的光是一种波长在约630-750纳米之间的光线，它在可见光谱中属于长波长端，具有较低的能量和频率。红色光是由物体发射或反射的，常见于日落、火焰、红色花朵等。在光谱分析、光学仪器、医疗诊断等领域都有广泛的应用。", "class": "open qa"}
{"question": "装修设计师：您好，根据您的需求和家的面积，我们为您准备了三款套餐：A、B、C。A套餐需要20万，B套餐需要15万，C套餐需要10万。请问您对哪个套餐比较感兴趣呢？\n客户：其实我对C套餐比较满意，但是我的预算比最便宜的预算还要少2万。\n装修设计师：明白了，我们可以根据您的预算量身定制一个合适的方案。您可以告诉我您希望在哪些方面进行省钱，我们可以针对性地进行调整，以确保您得到最满意的效果。\n客户：那我可以省去一些不必要的装饰品和家具，然后采用一些更实惠的材料吗？\n装修设计师：当然可以，我们可以采用一些经济实惠的材料，并且根据您的需要精简装饰品和家具。我们也可以帮您寻找更多的优惠渠道，让您的装修预算更加合理。\n客户：好的，那你们能给我列一份更详细的清单吗？\n装修设计师：当然可以，我们会根据您的需求和预算给您提供一份清单，包括每一项装修费用的详细情况。如果您对清单有任何疑问，我们随时都可以沟通。\n请基于以上对话回答：客户的预算是多少？", "std_answer": "客户的预算是8万。因为客户对最便宜的预算（10万）还要少2万，即预算只有8万。", "class": "extract"}
{"question": "请解释以下专业术语的含义，并提供一个具体的例子。:什么是深度学习？", "std_answer": "深度学习是一种机器学习方法，它模拟人脑神经网络的结构和功能，通过多层神经网络来自动学习和提取数据的特征，并用这些特征来识别和分类新的数据。深度学习通常需要大量的数据和计算资源，但能够产生高度准确的结果，被广泛应用于图像识别、语音识别、自然语言处理等领域。\n例如，当我们用深度学习算法来训练一个图像分类器时，我们会给算法提供大量的图片和相应的标签，让算法通过多层神经网络自动学习图片的特征和分类规律。之后，我们就可以用这个分类器来识别新的图片，并将其自动分类到正确的类别中。", "class": "open qa"}
{"question": "除了定期遛狗、喂食狗粮和在狗狗生病时送它去看兽医，狗还需要一些额外的照顾和关注。例如，它们需要定期洗澡、梳理和修剪指甲，以保持健康和舒适。此外，给狗提供足够的水和空间，也是照顾狗的重要方面。另外，训练和社交化也是养狗的重要部分。狗需要训练才能学会基本的行为规范和指令，以便与家庭和社区保持良好的关系。社交化则可以帮助狗与其他动物和人类相处融洽，减少对陌生人或环境的恐惧和压力。除此之外，定期带狗去接种疫苗和预防虫害也是必要的。这可以保护狗不受常见的疾病和寄生虫的侵害。总之，养狗是一项有责任的工作，需要花费时间和精力来照顾狗的方方面面。但是，通过与狗建立深厚的关系和相互信任，人们可以获得无与伦比的快乐和陪伴。总结成一句话。", "std_answer": "养狗需要全面关爱，包括日常护理、训练、社交化和健康管理，以建立深厚的信任关系，带给人们无尽的快乐和陪伴。", "class": "summarization"}
{"question": "将下文改为口语化的表达。\n我很忙，因为我要准备一份重要的报告，我需要在明天之前完成这个任务。", "std_answer": "", "class": "rewrite"}
{"question": "给出以下三个选项，请将它们分别分为动物、植物和无生命物体三个类别:汽车、鲨鱼、橡树", "std_answer": "动物：鲨鱼\n植物：橡树\n无生命物体：汽车", "class": "classification"}
{"question": "请从以下文章中提取出关于气候变化的信息。\n2019年是有史以来最热的一年，这是由于温室气体排放的增加所导致的，科学家们认为。温室气体包括二氧化碳、甲烷和氟利昂等，它们会在大气中形成层，阻止热量从地球逃逸，从而导致地球温度上升。据报告称，2019年全球平均气温比工业化前高出1.1摄氏度，这个数字超过了巴黎协定设定的目标。此外，全球各地都经历了极端天气事件，如干旱、洪水、暴风雨等，这些都与气候变化有关。为了应对这一问题，国际社会需要采取行动减少温室气体排放，保护地球的生态环境。", "std_answer": "气候变化的信息包括：\n2019年是有史以来最热的一年。\n2019年全球平均气温比工业化前高出1.1摄氏度，这个数字超过了巴黎协定设定的目标。\n温室气体排放的增加是导致气候变化的主要原因，温室气体包括二氧化碳、甲烷和氟利昂等。\n温室气体会在大气中形成层，阻止热量从地球逃逸，从而导致地球温度上升。\n全球各地都经历了极端天气事件，如干旱、洪水、暴风雨等，这些都与气候变化有关。\n国际社会需要采取行动减少温室气体排放，保护地球的生态环境。", "class": "extract"}
{"question": "张姨用15元买了3双鞋，买5双鞋要多少元？", "std_answer": "首先，我们可以通过已知条件列出一个比例式，即：\n15元/3双 = x元/5双\n其中，x表示5双鞋的价格。\n接下来，我们可以通过交叉相乘的方法求解x，即：\n15×5 = 3x\n75 = 3x\nx = 25\n因此，张姨要买5双鞋需要25元。", "class": "math"}
{"question": "将以下短文进行编辑和润色，使其更加流畅易读。\n我今天的早晨很忙碌。我起床后就开始准备早餐，然后洗漱并穿好衣服。我赶紧出门，因为我必须赶上早上的班车。", "std_answer": "", "class": "rewrite"}
{"question": "三（1）班课外兴趣小组有8人练篮球，练足球的人数是篮球的3倍．三（1）班课外兴趣小组一共有多少人？", "std_answer": "设练足球的人数为x，则根据题目可得：\nx = 3 × 8 = 24\n因此，班级课外兴趣小组总人数为：\n8 + 24 = 32\n答案：32人。", "class": "math"}
{"question": "六年级一共有38人去春游，共租了8条船，大船每条乘6人，小船每条乘4人，每条船都坐满了。大船租了几条?", "std_answer": "假设8条全是租的大船，则小船有：（8×6-38）÷（6-4）\n=10÷2\n=5（条）\n则大船有：8-5=3（条）\n答：大船租了3条，小船租了5条．", "class": "math"}
{"question": "为什么动物和植物有不同的生理反应？", "std_answer": "动物和植物在生理上有不同的反应，这是由于它们的生物特性和生存环境的差异导致的。\n首先，动物和植物的生物特性不同。动物是多细胞生物，具有神经和内分泌系统等复杂的器官和组织，能够感知和响应外部刺激。植物则是单细胞或多细胞的生物，在生长和繁殖过程中主要依靠光合作用和植物激素等内源性物质的调节。\n其次，动物和植物的生存环境不同。动物生活在不同的生态系统中，需要适应不同的环境条件，如温度、湿度、食物等。它们需要快速适应环境变化，以保证生存。植物则更多地依赖于光、水、营养元素等外部因素，其生长和繁殖过程相对较为缓慢。\n因此，动物和植物的生理反应不同，是由它们的生物特性和生存环境的差异所导致的。", "class": "open qa"}
{"question": "请编辑以下这篇文章，使其更加通顺易懂。\n科学没有平坦的大道，只有不畏艰险沿着陡峭山路攀登的人，才有希望到达光辉的顶点。在实现科技高水平自立自强、建设世界科技强国的征途上，唯有坚韧不拔、矢志不渝，才能肩负起科技创新重任。", "std_answer": "", "class": "rewrite"}
{"question": "请按照以下标准，将以下公司列表分类为新兴公司或成熟公司:Apple，Uber，TikTok，IBM，WeWork", "std_answer": "新兴公司：Uber，TikTok，WeWork\n成熟公司：Apple，IBM", "class": "classification"}
{"question": "根据给定的电影信息，推荐类似的电影:\"泰坦尼克号，导演詹姆斯·卡梅隆，主演莱昂纳多·迪卡普里奥和凯特·温丝莱特\"。", "std_answer": "", "class": "brainstorming"}
{"question": "如果所有的猫都喜欢吃鱼，那么所有的鱼都喜欢猫吗？", "std_answer": "不是的。这是一种逻辑谬误，被称为“逆否命题谬误”。虽然所有的猫都喜欢吃鱼，但这并不意味着所有的鱼都喜欢猫。这两个概念是不同的，不能互相代替。", "class": "open qa"}
{"question": "李老师读一本教育专著，每天读108页，第4天她应该从多少页读起？", "std_answer": "题目分析：\n由于李老师每天读108页，第4天应该从多少页读起，可以通过计算前三天共读了多少页，再用总页数减去前三天的页数，即可得出第四天应该从多少页开始读。\n解题步骤：\n1. 计算前三天李老师共读了多少页。\n前三天共读的页数 = 每天读的页数 × 3\n前三天共读的页数 = 108 × 3\n前三天共读的页数 = 324\n第四天应该从324+1=325页开始读", "class": "math"}
{"question": "给定以下问题，回答它，并提供支持答案的证据或来源。\n问题：人类起源于哪里？", "std_answer": "回答：人类起源地点尚未完全确定，但科学界普遍认为现代人类起源于非洲。 \n证据：根据人类基因组计划的研究结果，现代人类的基因组与非洲的一些土著人群有着最高程度的相似性，这表明非洲是现代人类起源的最有可能的地点。此外，考古学证据也支持这一观点，最早的现代人类化石也是在非洲发现的。", "class": "open qa"}
{"question": "请提供一些适合7岁孩子玩的户外游戏", "std_answer": "", "class": "brainstorming"}
{"question": "实验小学要为三、四年级的学生每人买一本价格为12元的作文辅导书。已知三年级有145人，四年级有155人，两个年级一共需要多少元？", "std_answer": "步骤一：计算总人数\n三年级有145人，四年级有155人，两个年级一共有：\n145 + 155 = 300\n共300人。\n步骤二：计算总价\n每个学生需要购买一本价格为12元的作文辅导书，因此，两个年级的总价为：\n300 × 12 = 3600\n两个年级共需要3600元。", "class": "math"}
{"question": "请将以下这篇文章分类为新闻报道、科学文章或社论。\n据媒体新闻援引美国福克斯新闻网报道，美国伯克希尔哈撒韦公司首席执行官、著名投资人巴菲特近日就美国银行业危机与总统拜登的团队进行对话。外界较为关注的是，巴菲特可能以某种方式投资美国地区性银行。据了解，这位亿万富翁在通话中针对当前危机给出了意见和指导。长期以来，巴菲特一直在帮助处于危机中的银行，其中包括美国银行和高盛。", "std_answer": "新闻报道。", "class": "classification"}
{"question": "请将下面这段文本进行改写，使得它更加流畅自然。\n这项工作需要一些专业技能。如果你没有这些技能，你可能需要花费更多的时间和精力来学习它，这可能会影响你的工作效率。但是，如果你掌握了这些技能，你将能够更好地完成工作，并提高你的竞争力。所以，如果你真的想为自己的未来打算，那么学习这些技能是很重要的。", "std_answer": "", "class": "rewrite"}
{"question": "根据以下文章回答下面问题：美团的2022年第三季度财报显示了什么？\n文章内容\\nTech星球3月22日消息，据界面新闻报道，美团在一份考勤说明文档里明确提到迟到属于违纪，处罚标准也在违纪细则文档中被明确每个月迟到2次以及以下的，扣20%绩效，迟到3次及以上的，扣50%绩效。据美团员工小王透露，严格考勤之后，他和身边同事请年假的次数变多了。公司要求上午10点打卡，哪怕是10:01或者10:02打卡都算迟到，很多人担心迟到会影响年终奖，哪怕只迟到几分钟，也要用半天事假去抵扣，实际上大家是请了假还在工作。此前，美团发布2022年第三季度财报显示，美团2023年三季度营收626.2亿元，同比增长28.2%，净利润12.2亿元，同比扭亏为盈，预估亏损9.868亿元；调整后净利润为35.3亿元，去年同期经调整净亏损55.27亿元。", "std_answer": "美团的2022年第三季度财报显示，预估亏损9.868亿元，净利润12.2亿元，同比扭亏为盈，营收为626.2亿元，同比增长28.2%", "class": "closed qa"}
{"question": "经纪人：您好！欢迎来到我们的房地产公司。我是您的经纪人，我能帮助您找到您心仪的房子吗？\n客户：你好！是的，我正在寻找一套适合我家庭的房子。\n经纪人：很好。您对房子的预算是多少？您更喜欢哪个区域？\n客户：我的预算大约是50万，我更喜欢居住在城市的郊区。\n经纪人：我们这里有一套位于郊区的房子，面积约为200平米，售价为50万。您是否有兴趣看看？\n客户：是的，我想去看看。我可以什么时候去看房？\n经纪人：我们可以安排在本周六下午两点钟。我会给您发送一封电子邮件，里面包含有关该房子的详细信息以及如何前往的路线图。\n客户：好的，非常感谢你。我等不及要看看这个房子了。\n经纪人：不客气，这是我的工作。如果您有任何其他问题或需要进一步帮助，请随时与我联系。\n请总结以上对话中客户的核心诉求", "std_answer": "客户的核心诉求是寻找一套适合家庭居住的房子，预算大约为50万，更喜欢位于城市郊区的房子。客户对经纪人提到的位于郊区、面积约200平米、售价为50万的房子感兴趣，并希望安排在周六下午两点去看房。", "class": "summarization"}
{"question": "为什么碳酸氢钠可作为消化不良和胃酸过多的药物？", "std_answer": "碳酸氢钠是一种碱性物质，它可以中和胃酸中的酸性成分，从而减轻胃酸过多所引起的不适感。同时，碳酸氢钠也可以促进胃液中消化酶的活性，帮助消化食物，缓解消化不良的症状。因此，碳酸氢钠可以作为消化不良和胃酸过多的药物使用。但需要注意的是，过量使用碳酸氢钠可能会导致酸碱平衡失调和其他副作用，应在医生指导下使用。", "class": "open qa"}
{"question": "客服：您好，感谢您拨打热线，这里是XXXX客服，我是客服代表小杨，请问有什么可以帮您的？\n客户：你好，我想咨询一下你们现在有什么优惠活动？\n客服：好的，请稍等一下，我为您查询一下。目前我们有一个套餐升级活动，您可以免费获得更多的流量和通话时长，另外还有购机优惠，如果您想更换手机，可以享受到一定的优惠。\n客户：你说的优惠具体是什么？\n客服：关于套餐升级活动，您可以在原有套餐的基础上免费获得额外50%的流量和通话时长，有效期为3个月。至于购机优惠，您可以在购买指定品牌和型号的手机时享受到最高减免1000元的优惠。\n客户：这也叫优惠？我觉得一点都不实惠。你们有没有其他更好的活动？\n客服：非常抱歉让您觉得这些优惠不够实惠。我们还有一项流量包活动，购买特定流量包时，可以享受到5折优惠，最高可购买100GB流量包。不知道您对这个活动有没有兴趣？\n客户：你们的优惠活动都这么一般，还不如别的运营商呢。你们客服是不是也跟优惠活动一样水平？\n客服：非常抱歉给您带来不满的感受，我们会继续努力改进服务质量。关于优惠活动，我们会定期更新，如果您对现在的活动不感兴趣，可以关注我们的官方网站或者公众号，以便了解最新活动。请问还有其他问题我可以为您解答吗？\n客户：算了，我就问这些吧。\n基于以上对话分析，总结客户的诉求。", "std_answer": "客户的诉求主要有以下几点：\n1.客户希望了解当前的优惠活动，以便在选择套餐或购买手机时能够获得更实惠的价格。\n2.客户对现有的优惠活动不太满意，认为没有达到他们的期望，希望能得到更好的优惠活动。\n3.客户对客服的服务水平表示不满，希望客服能提供更优质的服务。", "class": "summarization"}
{"question": "为什么昆虫可以爬在墙上和天花板上？", "std_answer": "昆虫之所以能够爬在墙上和天花板上，是因为它们的脚具有很强的附着力。昆虫的脚底有许多细小的刺或毛，这些结构可以与表面上的微小凹凸相结合，形成摩擦力和吸附力。此外，它们的脚趾末端还有分泌物质，可以增加附着力。\n此外，昆虫的体重相对较轻，它们的身体结构也很适合攀爬。昆虫的身体被分为头、胸和腹三部分，身体轻盈、柔韧，能够轻松地调整姿势和重心，从而在垂直和倾斜的表面上行走。\n总之，昆虫之所以能够在墙壁和天花板上行走，是因为它们的脚底有很强的附着力，身体轻盈、柔韧，能够适应不同的表面。", "class": "open qa"}
{"question": "代码中存在变量作用域问题，请找出并改正。\\n```\\nfunction addNumbers(num1, num2) {\\nvar sum = num1 + num2;\\n}\\nconsole.log(sum);\\n```", "std_answer": "```\nfunction addNumbers(num1, num2) {\n var sum = num1 + num2;\n console.log(sum);\n}\naddNumbers(3, 4); // 输出：7\n```\n问题在于变量 `sum` 是在函数内部声明的，它的作用域仅限于函数内部。如果要在函数外部访问它，需要将它声明在函数外部。另外，因为 `sum` 是在函数内部声明的，所以函数外部代码无法访问它，所以需要在函数内部添加一个 `console.log(sum);` 语句来输出它的值。", "class": "code"}
{"question": "请编辑以下电子邮件，以便更好地表达您的意思:“你好，我想问一下你是否能在周三之前把报告发给我？”", "std_answer": "", "class": "rewrite"}
{"question": "如果一只热气球升空，它是否会随着地球的自转而产生平移运动？", "std_answer": "是的，热气球会随着地球的自转而产生平移运动。这是因为热气球和地球表面之间的空气层在一起旋转，所以热气球也会跟随着地球的自转而移动。不过，这种运动是非常缓慢的，通常人们是感觉不到的。", "class": "open qa"}
{"question": "一个人沿着大提走了全长的一半后，又走了剩下的一半，还剩下1千米，问大提全长多少千米", "std_answer": "假设大提的全长为x千米。\n第一次走了全长的一半，即x/2千米。\n第二次走了剩下的一半，即(x/2)/2 = x/4千米。\n剩下1千米，即x/4 + 1 = x/2，解得x=4千米。\n因此，大提的全长为4千米。", "class": "math"}
{"question": "如何将字符串转换为日期时间对象？", "std_answer": "在Python中，可以使用datetime模块来将字符串转换为日期时间对象。具体方法如下：\n1. 导入datetime模块\n```python\nimport datetime\n```\n2. 使用datetime模块中的strptime()函数将字符串转换为日期时间对象。\n```python\ndt_str = '2022-01-01 08:30:00'\ndt_obj = datetime.datetime.strptime(dt_str, '%Y-%m-%d %H:%M:%S')\n```\n说明：\n- strptime()函数的第一个参数是待转换的字符串。\n- 第二个参数是格式化字符串，用来指定字符串的格式。\n- 转换后的日期时间对象存储在dt_obj变量中。\n格式化字符串中常用的格式符如下：\n- %Y：年份，四位数，如2022。\n- %m：月份，两位数，如01。\n- %d：日期，两位数，如01。\n- %H：小时，24小时制，两位数，如08。\n- %M：分钟，两位数，如30。\n- %S：秒，两位数，如00。\n如果待转换的字符串格式不符合指定的格式化字符串，会抛出ValueError异常。", "class": "code"}
{"question": "猫妈妈给小白5条鱼，给小花4条鱼，小白和小花共吃了6条，它们还有几条？", "std_answer": "首先，小白和小花共吃了6条鱼，那么小白和小花分别吃了几条鱼呢？设小白吃了x条鱼，那么小花吃了6-x条鱼。\n由题目可知，小白和小花分别分到了5条和4条鱼，所以它们一共分到了9条鱼，即：\n5 + 4 = 9\n又因为小白和小花共吃了6条鱼，所以剩余的鱼数为：\n9 - 6 = 3\n因此，它们还剩下3条鱼。", "class": "math"}
{"question": "请问太平洋的最大深度是多少？", "std_answer": "太平洋的最大深度是马里亚纳海沟的10,994米。", "class": "open qa"}
{"question": "给出下文的一句话总结：根据最新的研究成果显示，长时间坐着可能对健康造成负面影响，增加患糖尿病、心脏病、中风等疾病的风险。这是因为长时间保持静态姿势会导致身体代谢减缓、血液循环不畅和肌肉损耗，从而增加了各种健康问题的发生概率。为了减少长时间久坐带来的健康风险，专家建议人们应该每小时起身活动一下，进行简单的伸展运动或散步。这样可以帮助改善血液循环，缓解因长时间坐姿所带来的肌肉紧张和关节僵硬。此外，还可以提高身体代谢率，从而降低患病风险。除此之外，使用站立式办公桌也是一种很好的方法来降低长时间久坐对健康的影响。站立式办公桌能够让使用者在工作时保持站立姿势，有助于燃烧更多热量、增强肌肉力量和改善血液循环。同时，站立式办公桌还可以帮助改善工作效率，让人们保持清醒和专注。总之，为了减少长时间久坐带来的健康风险，人们应当在日常生活和工作中采取适当的措施，如定时起身活动、使用站立式办公桌等方式，以降低患病风险，保持健康的生活方式。", "std_answer": "长时间久坐对健康有负面影响，应采取定时活动、使用站立式办公桌等措施降低患病风险，保持健康生活方式。", "class": "summarization"}
{"question": "编辑以下文章，使得文章更加严谨和准确。\n在这个实验中，我们观察了两组实验数据，发现它们之间的差异很大。我们对这个结果进行了统计分析，并得出结论两组数据是不同的。", "std_answer": "", "class": "rewrite"}
{"question": "如果一个人吃下去的饭菜越多，他就会越胖？", "std_answer": "大部分情况下是这样的，因为食物提供的能量（卡路里）如果超过身体的消耗，就会被储存为脂肪。但是也有例外，有些人可能有基因或代谢速率等因素导致他们不容易增胖。此外，饮食的种类和质量也会影响体重。例如，食用高纤维、低糖和低脂肪的食物可以控制体重。", "class": "open qa"}
{"question": "为什么我们可以看到在水中的岸线，即使我们不站在水面上？", "std_answer": "这是因为光线在从空气进入水中时会发生折射，使得我们看到的岸线位置与实际位置不同。当光线从空气进入水中时，由于水的折射率比空气大，光线的速度会减慢，同时光线的方向也会发生改变。这就导致了我们看到的岸线位置比实际位置要高出一些。这个现象被称为光线的折射现象。因此，即使我们不站在水面上，也可以看到在水中的岸线。", "class": "open qa"}
{"question": "为什么铁制的东西放在潮湿的环境中容易生锈？", "std_answer": "铁制品生锈的原因是因为铁与氧气和水反应，形成了铁氧化物。当铁与水接触时，水中的氧气与铁中的铁离子结合，形成了铁氧化物（Fe2O3.nH2O）。这种化合物也称为铁锈。潮湿的环境中，铁制品更容易受到水分的影响，从而更容易生锈。此外，空气中的二氧化碳和其他化学物质也可以加速铁制品的生锈。", "class": "open qa"}
{"question": "请列举出至少5个具有环保意识的行为", "std_answer": "", "class": "brainstorming"}
{"question": "请给出一份简短的摘要，概括以下文章的主要内容：研究人员近期的发现表明，婴儿在出生前的几个月就已经开始学习语言，这意味着他们在母亲子宫内就已经对外部声音产生了敏感性，并且可以记住他们听到的单词。这项研究为我们揭示了婴儿大脑在早期发育阶段的惊人能力，为神经科学、语言学和心理学等领域提供了宝贵的见解。根据这项研究，婴儿在母亲子宫内时就能接收到外界的声音，特别是母亲的声音。这些声音对于婴儿大脑的发育起着至关重要的作用，帮助他们建立对语言的认识和理解。因此，这项研究强调了孕妇与胎儿沟通的重要性，以及为婴儿提供一个富有刺激的环境以促进语言发展的必要性。这项研究还表明婴儿大脑在出生前的发育过程中具有惊人的适应性和学习能力。这一发现为我们提供了关于婴儿大脑如何对环境因素作出反应的新认识，也使得我们更加重视婴儿在出生前的学习和成长环境。这项研究对于教育和心理健康专业人士来说具有重要意义，因为它强调了早期干预的重要性。通过提供丰富的语言输入和积极的互动环境，父母和教育工作者可以帮助婴儿建立更强大的语言基础，为他们未来的学习和发展奠定坚实的基础。", "std_answer": "研究表明婴儿在出生前就开始学习语言，对外部声音特别是母亲的声音产生敏感性。这项研究强调了孕妇与胎儿沟通的重要性，以及为婴儿提供富有刺激的环境以促进语言发展的必要性。这一发现对教育和心理健康专业人士具有重要意义，突显早期干预的重要性。", "class": "summarization"}
{"question": "同学们种树，4个人种8棵树，平均每人种几棵？", "std_answer": "步骤1：计算总共种了几棵树\n由题可知，4个人种了8棵树，因此总共种树数为8。\n步骤2：计算平均每人种几棵树\n平均数的计算公式为：平均数 = 总数 ÷ 数量。将步骤1中的总共种树数8代入公式中，再将人数4代入，即可得出平均每人种几棵树：8 ÷ 4 = 2。\n步骤3：回答问题\n因此，平均每人种2棵树。", "class": "math"}
{"question": "请回答以下问题:地球的自转方向是什么？", "std_answer": "地球的自转方向是从西向东，也就是从地球的西边向东边旋转。", "class": "open qa"}
{"question": "一段路，甲走完全程需20分钟，乙走完全成需15分钟，甲的速度是乙速度的百分之几", "std_answer": "首先，我们需要知道速度的定义：速度 = 路程 ÷ 时间。因此，我们可以设甲的速度为 V1，乙的速度为 V2。\n由题意可知，甲走完全程需要20分钟，乙走完全程需要15分钟。因此，我们可以列出如下的方程组：\nV1 × 20 = 路程\nV2 × 15 = 路程\n由于甲和乙走的是同一段路程，因此它们走的路程是相等的，即：\nV1 × 20 = V2 × 15\n接下来，我们将上式变形，求出 V1 与 V2 的比值：\nV1 ÷ V2 = 15 ÷ 20\nV1 ÷ V2 = 0.75\n因此，甲的速度是乙速度的百分之 75，即甲的速度比乙慢 25%。", "class": "math"}
{"question": "教师节那天，小卖部进了136枝花，每20枝扎成一束，可以扎成几束？", "std_answer": "首先，我们可以利用除法来解决这个问题。具体步骤如下：\n1. 将136枝花除以20，得到商和余数。\n136 ÷ 20 = 6 ... 16\n这里的6就是可以扎成的束数，余数16表示还剩下16枝花没法凑成一束。\n2. 最后，我们得出了答案：136枝花可以扎成6束，其中有16枝花剩余。\n答案：6束，剩余16枝花。\n另外，我们也可以直接用整除的方法来解决这个问题。具体做法是将136枝花直接除以20，得到的商就是可以扎成的束数。但是需要注意的是，如果余数不为0，就需要将余数加回到商中重新计算。", "class": "math"}
{"question": "青岛海底世界门票127元．赵老师带着47名学生参观海底世界需要多少元？", "std_answer": "解题步骤：\n1. 首先，我们需要计算出赵老师和学生的总人数。由于赵老师带了47名学生，所以总人数为：1 + 47 = 48人。\n2. 然后，我们需要计算出赵老师和学生需要支付的总门票费用。每个人需要支付的门票费用为127元，因此赵老师和学生需要支付的总门票费用为：48 × 127 = 6,096元。\n3. 最后，我们可以得出结论：赵老师带着47名学生参观海底世界需要支付的门票费用为6,096元。", "class": "math"}
{"question": "请为以下短文写一个简短的摘要：根据美国国家航空局（NASA）与大气管理局的最新研究表示，地球在2005-2019年期间热量失衡严重，许多未能及时消散的热量增加了1倍。造成海洋、空气和陆地的气候变暖速度加快。地球上的生命之所以能够生存，主要是因为太阳光进入大气层后，使得地球变暖，与此同时有一部分的阳光会被反射回太空，这样就不会造成地球温度过高，形成了一种微妙的平衡状态。不过后来随着人类工业活动的发展（焚烧化石燃料、砍伐森林等等），越来越多的温室气体被排放到大气层，温室气体对热量的反射有阻隔作用，这就造成了全球气温上升。", "std_answer": "最新研究显示，地球在2005-2019年期间热量失衡严重，未能及时消散的热量增加了1倍，导致海洋、空气和陆地的气候变暖速度加快。温室气体排放是造成热量失衡的主要原因。", "class": "summarization"}
{"question": "客户: 你好，我在你们网站上购买了一件商品，但它似乎有一些问题。\n客服: 您好，非常抱歉听到这个消息。请问有什么具体的问题吗？\n客户: 是的，商品的一部分似乎受损了。我可以把它退回去吗？\n客服: 当然可以，我们很抱歉出现了这种情况。您可以在我们的网站上提交售后申请，我们会为您处理。\n客户: 好的，我会尽快提交售后申请。我想知道退货流程大概需要多长时间？\n客服: 一般情况下，我们会在您提交售后申请后的三个工作日内审核您的申请。一旦审核通过，我们会通知您并提供退货的具体流程。\n客户: 我明白了，谢谢。如果退货审核不通过，该怎么办？\n客服: 如果您的退货申请审核不通过，我们会在第一时间通知您，并解释原因。您可以与我们的客服人员联系，讨论其他解决方案。\n客户: 我知道了，谢谢。最后一个问题，退款需要多长时间才能到账？\n客服: 一般情况下，我们会在收到您退回商品后的七个工作日内将退款金额退回您的账户。不过，具体到账时间可能会因银行处理速度而有所不同。\n客户: 我明白了，谢谢你的帮助。\n客服: 不客气，如果您还有其他问题或需要帮助，请随时联系我们的客服人员。\n请基于以上对话内容回答：退货流程一般有几天", "std_answer": "退货流程一般需要三个工作日审核申请，审核通过后会通知客户并提供具体的退货流程。如果退货申请审核不通过，客户可以与客服人员讨论其他解决方案。一旦收到退回商品，退款会在七个工作日内退回客户账户。", "class": "extract"}
{"question": "每棵树苗16元，买3棵送一棵．一次买3棵，每棵便宜多少钱?", "std_answer": "首先，我们可以算出买3棵树苗的总价：\n3 × 16 = 48 元\n然后，由于是“买3棵送1棵”，所以我们实际上得到了4棵树苗。因此，每棵树苗的实际价格应该是：\n48 ÷ 4 = 12 元\n也就是说，每棵树苗便宜了 16 - 12 = 4 元。", "class": "math"}
{"question": "请根据以下文本内容判断这是一个开放问题还是封闭问题:“你认为明天的天气会是晴天吗？”", "std_answer": "这是一个封闭问题，因为它只有两个可能的答案：是或不是。", "class": "classification"}
{"question": "康明爱吃苹果，黄健也吃苹果，那么黄健是否喜欢康明？", "std_answer": "无法推断黄健是否喜欢康明，只能推断他们两个都喜欢吃苹果。", "class": "open qa"}
{"question": "请问武汉的地理位置在哪里？", "std_answer": "武汉位于中国中部，湖北省中部，长江与汉江交汇处，东经113°41′，北纬30°35′。", "class": "open qa"}
{"question": "在物理学中，黑洞和白洞之间的区别是什么？", "std_answer": "黑洞是一种天体，其引力场非常强大，以至于任何物质或辐射都无法逃脱其吸引力，包括光线。它们被认为是由恒星或其他物质坍缩成一个非常小而密集的区域而形成的。\n白洞是一种理论天体，其引力场非常强大，以至于它们可以吸收物质和辐射，但不会释放它们。它们被认为是黑洞的“反面”，因为它们在某种程度上是“反向的”黑洞，也就是说，它们只释放物质和辐射，而不会吸收它们。\n然而，白洞目前只是一种理论上的概念，没有任何直接的观测证据来证明它们的存在。因此，黑洞是我们目前所知的唯一存在的引力场如此强大的天体。", "class": "open qa"}
{"question": "请列出下文的2个核心观点：咖啡，是世界上最受欢迎的饮料，80%的成年人每天至少饮用一种含咖啡因的饮料。据估计，全球每天消费30亿杯咖啡。因其含有大量的咖啡因，常被人们饮用以醒神和提高工作效率。过去的多项研究表明，定期喝咖啡可以带来很多健康益处。阿尔茨海默症（AD），是神经细胞损失导致的不可逆、退行性脑疾病，以记忆障碍、失语、失认等为主要症状。由于发病因素涉及很多方面，单纯的药物治疗效果不大。预防变得尤为重要。", "std_answer": "1. 咖啡是一种非常受欢迎的饮料，大量成年人每天至少饮用一种含咖啡因的饮料，全球每天消费高达30亿杯咖啡。咖啡因具有醒神和提高工作效率的作用。2. 阿尔茨海默症（AD）是一种不可逆、退行性脑疾病，单纯的药物治疗效果不佳，预防变得尤为重要。而过去的研究表明，定期喝咖啡可能带来诸多健康益处。", "class": "summarization"}
{"question": "如果一个立方体铁块和一个球形铁块的质量相等，那么它们哪一个会更容易沉入水中？", "std_answer": "球形铁块更容易沉入水中。这是因为球形铁块的体积相对于其质量更大，所以它的密度更大，相对于水的密度更接近，因此会更容易沉入水中。而立方体铁块的体积相对于其质量较小，密度较小，相对于水的密度较小，因此不如球形铁块容易沉入水中。", "class": "open qa"}
{"question": "学校买来6箱乒乓球拍，每箱8副，每副9元．一共花了多少钱？", "std_answer": "解题思路：\n本题是一道多步骤的应用题，需要用到乘法和加法运算。具体步骤如下：\n1. 计算每箱乒乓球拍的数量。由题可知，每箱乒乓球拍有8副，因此6箱乒乓球拍的总数为：\n6箱 × 8副/箱 = 48副\n2. 计算总共花费的金额。由题可知，每副乒乓球拍的价格为9元，因此6箱乒乓球拍的总价为：\n48副 × 9元/副 = 432元\n答案：学校一共花了432元。", "class": "math"}
{"question": "学校有12个教学班，每班要配备一台价值198元的饮水机，估算一下，需要准备多少元？", "std_answer": "解题步骤：\n1. 确定需要购买的饮水机数量：学校有12个教学班，每班需要一台饮水机，因此需要购买12台饮水机。\n2. 计算购买饮水机的总价值：每台饮水机的价值为198元，因此12台的总价值为：\n12 × 198 = 2376（元）\n因此，需要准备2376元来购买这些饮水机。", "class": "math"}
{"question": "为什么地震时建筑物会倾倒？", "std_answer": "地震时建筑物倾倒是因为地震引起的地震波能量会产生水平和垂直两个方向的振动，这些振动会对建筑物造成影响。如果建筑物的结构不够稳固，就会因为地震波的振动而发生变形和破坏，从而导致建筑物倾倒。此外，建筑物的设计和建造质量也会影响其抗震能力，如果设计不合理或建造质量差，也容易导致地震时建筑物倾倒。", "class": "open qa"}
{"question": "一本相册有25页，每页可以放4张相片，3本相册可以放几张相片？", "std_answer": "每本相册可以放的相片数量为：25页 × 4张/页 = 100张相片。\n因此，3本相册可以放的相片数量为：3本 × 100张/本 = 300张相片。\n解题步骤如下：\n1. 计算每本相册可以放的相片数量：25页 × 4张/页 = 100张相片。\n2. 用每本相册可以放的相片数量乘以相册的本数，得到总的相片数量：3本 × 100张/本 = 300张相片。\n因此，3本相册可以放300张相片。", "class": "math"}
{"question": "请根据下列文本生成一篇新的故事情节:“在一座古老的城市里，一位勇士踏上了征程，他的目标是寻找一块神秘的宝藏。他必须克服许多困难，才能到达宝藏的所在地。最终，他是否成功找到了宝藏？”", "std_answer": "", "class": "rewrite"}
{"question": "请回答以下问题:巴黎塞纳河的长度是多少？", "std_answer": "巴黎塞纳河的长度约为777公里。", "class": "open qa"}
{"question": "请根据以下描述，推荐一些适合家庭游玩的旅游景点：我和我的家人想找一些可以一起游玩的旅游景点，最好是一些适合所有年龄段的景点。我们喜欢户外活动和美食，同时也希望能够了解当地的历史和文化。", "std_answer": "", "class": "brainstorming"}
{"question": "请给出以下段落的概括：近期的研究表明，饮用绿茶可能有助于降低患心脏病的风险。绿茶中含有一种被称为儿茶素的多酚类化合物，其具有多种生物活性，包括抗氧化、抗炎和降血压等功效。此外，绿茶中的儿茶素还能帮助降低血清胆固醇和三酰甘油水平，从而改善血脂谱，并减少心血管疾病的发病风险。此外，研究还表明，饮用绿茶还可能对身体的其他方面有益，如增强免疫力、预防癌症、改善认知功能和保护神经系统等。因此，绿茶被认为是一种非常健康的饮料，可以作为日常饮食中的一部分，为身体提供多种健康益处。但是需要注意的是，绿茶也含有咖啡因，过量饮用可能会引起一些负面反应，如失眠、心悸、头痛等。所以，建议适量饮用绿茶，并根据个人体质和健康状况做出调整。", "std_answer": "绿茶中含有儿茶素，可降低血压、胆固醇，改善血脂谱，降低心血管疾病风险。此外，绿茶还有增强免疫力、预防癌症、改善认知功能、保护神经系统等益处。但需注意绿茶中含有咖啡因，过量饮用可能导致失眠、心悸、头痛等负面反应。建议适量饮用，并根据个人体质和健康状况调整。", "class": "summarization"}
{"question": "学校举办作业展览，把75本练习本摆成两行，第一行40本，第二行多少本?", "std_answer": "解题思路：\n1. 首先，我们可以知道总共有75本练习本。\n2. 然后，我们可以将这75本练习本分成两部分，第一部分为第一行的40本，第二部分为第二行的未知数本。\n3. 因为第一行的40本和第二行的未知数本加起来就是75本，所以我们可以列出方程：40 + x = 75，其中x表示第二行的本数。\n4. 解方程得到：x = 75 - 40 = 35，因此第二行有35本练习本。\n答案：第二行有35本练习本。", "class": "math"}
{"question": "请问“蓝瘦香菇”是什么意思？", "std_answer": "“蓝瘦香菇”是一句网络流行语，起源于中国大陆。这句话实际上是对“难受想哭”这个意思的一种谐音表达。这个词组在网络上广泛传播，用于表示一种心情，即非常难过和无法自已的感受。虽然它的字面意思与香菇无关，但通过这种幽默、调皮的方式表达悲伤情绪，使得这个词组在网络上变得非常受欢迎。", "class": "open qa"}
{"question": "有些松饼比蛋糕便宜，而有些蛋糕比面包贵，因此有些松饼比面包便宜。", "std_answer": "这个结论并不成立。虽然有些松饼比蛋糕便宜，有些蛋糕比面包贵，但是这并不能推出所有松饼都比面包便宜。因为还有很多其他因素会影响价格，比如品牌、材料、制作工艺等等。所以要具体问题具体分析，不能一概而论。", "class": "open qa"}
{"question": "请给以下这篇文章写一个标题。\n出国不仅仅是为了旅游，商贸的往来是相当重要的内容。还记着一个多月前，很多人还在过年，但各地到海外抢订单的商贸团就已经出发了。由于那个时候国际间的人员往来刚刚打通，航班很少，各地政府不得不组织企业用包飞机出国的方式抢订单。如今，一个多月过去了，包机组团等措施逐步退场，更多的行业和企业恢复了对外的正常商贸往来，但是面临的问题依然很多，比如航线数量不足、出行成本高等等", "std_answer": "", "class": "generation"}
{"question": "回答以下问题:蓝鲸是哪个国家的动物？", "std_answer": "蓝鲸是一种生活在海洋中的哺乳动物，它是世界上最大的动物之一。蓝鲸分布在全球范围内，包括北极、南极、太平洋、大西洋和印度洋等海域。因此，它不属于任何一个特定的国家或地区。", "class": "open qa"}
{"question": "请根据以下内容编辑一份英文邮件，让它更加礼貌和专业:Dear Sir/Madam, I want to complain about the poor service I received at your restaurant last night. The food was cold and tasted terrible. I demand a full refund.", "std_answer": "", "class": "generation"}
{"question": "浓度为60%的糖水200克与浓度为30%的糖水200克混合．求混合之后糖水的浓度．", "std_answer": "首先需要知道糖水的浓度是指糖水中糖的质量占总质量的比例。因此，我们可以根据这个概念来求解混合后的糖水浓度。\n设混合后糖水的浓度为x%，则根据糖水的浓度公式，可得：\n60%的糖水中，糖的质量为60/100×200=120克\n30%的糖水中，糖的质量为30/100×200=60克\n混合后糖水的总质量为200+200=400克\n混合后糖的总质量为120+60=180克\n因此，可以得到以下方程：\n180/400=x/100\n解这个方程，可以得到：\nx=45%\n因此，混合后糖水的浓度为45%。", "class": "math"}
{"question": "请根据以下条件重新编写以下句子:“他在游泳后感到疲倦，但仍然去打篮球了。”条件使用连词“因此”", "std_answer": "", "class": "rewrite"}
{"question": "请将以下句子改写为更简单的语言: \"尽管他的财富富可敌国，但他的生活却深感荒芜、缺乏意义，此状势必让他陷入一片茫然之中。\"", "std_answer": "", "class": "rewrite"}
{"question": "张阿姨的月工资是5400元，扣除3500元个税免征额后的部分需要按3%的税率缴纳个人所得税．她应缴纳个人所得税多少元？", "std_answer": "首先，需要计算张阿姨的应纳税所得额，即月工资减去个税免征额：\n应纳税所得额 = 5400元 - 3500元 = 1900元\n接下来，按照3%的税率计算个人所得税：\n个人所得税 = 应纳税所得额 × 税率 - 速算扣除数\n= 1900元 × 3% - 0元\n= 57元\n因此，张阿姨应缴纳的个人所得税为57元。", "class": "math"}
{"question": "2千克比5千克少百分之几？", "std_answer": "首先，要计算出2千克比5千克少多少千克：\n5千克 - 2千克 = 3千克\n接下来，要计算出2千克相对于5千克的百分比：\n(2千克 ÷ 5千克) × 100% = 40%\n最后，要计算出2千克比5千克少百分之几：\n100% - 40% = 60%\n所以，2千克比5千克少60%。", "class": "math"}
{"question": "一个月有多少天？", "std_answer": "一个月的天数不一定固定，不同的月份天数也不同。一般来说，一年有12个月，其中7个月有31天，4个月有30天，2个月有28天或29天（闰年的2月份有29天）。", "class": "open qa"}
{"question": "请根据以下文本，提取其中的关键词。\n在儿童发育的过程中，父母的陪伴和支持起到了至关重要的作用。在孩子的早期生命阶段，父母的关注和照顾可以帮助孩子建立起安全感和信任感，这是儿童发展中非常重要的一步。在孩子的幼儿园和小学阶段，父母的支持可以帮助孩子建立自尊和自信心，以及培养他们的学习兴趣和积极性。\n此外，父母的陪伴还能够提供孩子在日常生活中的指导和支持。在儿童的认知和语言能力不断发展的过程中，父母可以通过与孩子的互动和交流，帮助他们学习新知识、理解新概念，并且扩大他们的视野。\n同时，父母的陪伴还可以帮助孩子发展社交能力和情感管理能力。父母可以在孩子面对挫折和困难时提供支持和安慰，教导孩子如何处理情绪和与他人相处。\n总之，父母的陪伴和支持对于孩子的成长和发展至关重要。他们的支持不仅能够提供孩子在生理和心理上的需求，还能够帮助孩子建立健康的情感和社交基础，为他们的未来打下坚实的基础。", "std_answer": "关键词：儿童发育、父母陪伴、父母支持、安全感、信任感、自尊、自信、学习兴趣、情感管理、社交能力、认知能力、语言能力、指导、交流、新知识、新概念、视野、挫折、困难、情绪处理、未来发展、心理需求、社交基础。", "class": "extract"}
{"question": "提供以下英文句子的中文翻译:\"Life is like a box of chocolates, you never know what you're gonna get.\"", "std_answer": "生活就像一盒巧克力，你永远不知道会得到什么。", "class": "rewrite"}
{"question": "下面这段代码有问题，你能找出来并修复吗？\\n```\\nvar num1 = 10;\\nvar num2 = \"5\";\\nvar answer = num1 + num2;\\nconsole.log(answer);\\n```", "std_answer": "问题：变量num2的值是字符串类型，与变量num1的数值类型不兼容，相加后结果会是一个字符串类型的值，而不是预期的数值类型。\n修复方法：将变量num2的值改为数值类型即可。\n修复后代码如下：\n```\nvar num1 = 10;\nvar num2 = 5;\nvar answer = num1 + num2;\nconsole.log(answer);\n```", "class": "code"}
{"question": "大戏院门前的有一条圆柱子，外围周长是314厘米，这条柱子的横截面积是多少平方厘米?", "std_answer": "因为圆柱子的外围周长是314厘米，所以可以得出圆柱子的直径为：\n周长 = π × 直径\n314 = π × 直径\n直径 = 314 ÷ π ≈ 100\n由于圆柱子是圆形的，所以它的横截面积就是一个圆面积。圆面积的公式为：\n面积 = π × 半径²\n圆柱子的直径是100厘米，因此它的半径是50厘米。将半径带入公式，可得出圆柱子的横截面积：\n面积 = π × 50² ≈ 7854平方厘米\n因此，这条柱子的横截面积约为7854平方厘米。", "class": "math"}
{"question": "请从以下选项中选择所有适用的选项:“以下哪些是蔬菜？”选项A. 土豆 B. 西红柿 C. 香蕉 D. 芹菜", "std_answer": "A. 土豆\nB. 西红柿\nD. 芹菜", "class": "closed qa"}
{"question": "为什么大气层对地球生命至关重要？", "std_answer": "大气层对地球生命至关重要，因为它提供了多种必需的条件和资源，例如：\n1. 氧气：大气层中含有大约21%的氧气，这是人类和其他动物呼吸所必需的。\n2. 碳和氮：大气层中的二氧化碳和氮气是植物进行光合作用所必需的物质，这使得植物能够生长并提供食物给其他生物。\n3. 水：大气层中的水蒸气在形成降水和维持水循环方面扮演着关键的角色。这对于维持生态系统中的水资源和生物多样性至关重要。\n4. 屏蔽辐射：大气层的臭氧层能够屏蔽来自太阳的紫外线辐射，保护地球上的生命免受伤害。\n5. 温度调节：大气层能够吸收和释放太阳辐射中的热量，通过温室效应调节地球的温度，维持适宜的气候条件。\n因此，大气层是地球上生命存在的必要条件，如果没有大气层，地球上的生命将无法生存。", "class": "open qa"}
{"question": "请将下面这段文本进行改写，使得它更加流畅。我对这个问题非常感兴趣，我曾经做了一些研究。在我看来，这个问题非常重要，因为它涉及到我们的未来。", "std_answer": "", "class": "rewrite"}
{"question": "请将以下文本进行翻译，从英文翻译成中文。:Brazil's history-making Olympian Jaqueline Mourao has shared her excitement of competing once again on the Olympic stage in Beijing, returning to the city where she previously appeared in mountain biking way back in 2008 as she now takes part in her eighth Games.", "std_answer": "巴西历史上的奥运会选手雅奎琳·莫瑞奥分享了她再次参加北京奥运会的兴奋，她回到了之前在2008年参加山地自行车比赛的城市，现在她将参加第八届奥运会。", "class": "rewrite"}
{"question": "每台车床4小时可以加工零件180个．照这样计算，5台车床加工600个零件要几小时？", "std_answer": "解题思路：\n1. 首先算出一台车床1小时可以加工多少个零件：180 ÷ 4 = 45（个/小时）。\n2. 然后算出5台车床1小时可以加工多少个零件：45 × 5 = 225（个/小时）。\n3. 最后算出加工600个零件需要的时间：600 ÷ 225 = 2.67（小时）。\n所以，加工600个零件需要2.67小时。", "class": "math"}
{"question": "编写一个函数square(x)，返回该数字的平方值。", "std_answer": "代码如下：\n```python\ndef square(x):\n return x*x\n```\n调用示例：\n```python\nprint(square(2)) # 输出：4\nprint(square(5)) # 输出：25\n```", "class": "code"}
{"question": "请根据以下描述，为用户推荐一部适合他们的电影:“用户喜欢喜剧片和爱情片，最近看了《大话西游》和《摆渡人》，希望推荐一部好看的电影。”", "std_answer": "", "class": "brainstorming"}
{"question": "榨油厂240千克油菜籽能榨油100.8千克，照这样计算，若榨油210千克需油菜籽多少千克", "std_answer": "设榨油210千克需要x千克油菜籽，则可以列出比例式：\n240千克 : 100.8千克 = x千克 : 210千克\n通过交叉相乘得：\n240×210 = 100.8x\n化简得：\nx = 500千克\n因此，榨油210千克需要500千克油菜籽。", "class": "math"}
{"question": "将下文改为诗歌，莎士比亚的风格。我爱她，就像我爱这个世界，就像我爱生命。她是我的一切，没有她，我的生命就没有意义。", "std_answer": "", "class": "rewrite"}
{"question": "请描述以下场景中人物的情感:“小明收到了一份意外的生日礼物，他感到非常高兴。”", "std_answer": "小明感到非常高兴，这表明他对生日礼物充满了喜悦和感激。他可能感到惊喜和感动，因为这份礼物出乎意料且让他感到特别。他可能会感到幸福和满足，因为这份礼物代表着送礼人的关爱和祝福。总的来说，小明在这个场景中体验到了积极的情感，包括高兴、惊喜、感动、感激、幸福和满足。", "class": "open qa"}
{"question": "在一个绝热的容器中，一份可压缩的气体被加热，其压力是否会增加？", "std_answer": "根据理想气体状态方程 PV=nRT，当温度增加时，如果体积不变，压力会增加；如果体积可变，压力和体积同时增加，但温度和物质量不变。因此，在一个绝热的容器中，一份可压缩的气体被加热，其压力会增加。", "class": "open qa"}
{"question": "水果店2千克苹果售价5元，3千克香蕉售价12元。妈妈打算苹果和香蕉各买6千克，应付多少钱", "std_answer": "首先算出6千克苹果的价格：\n6千克苹果 = 2 * 3千克苹果\n所以6千克苹果的售价为 3 * 5元 = 15元\n然后算出6千克香蕉的价格：\n6千克香蕉 = 2 * 3千克香蕉\n所以6千克香蕉的售价为 2 * 12元 = 24元\n最后将两者价格相加：\n15元 + 24元 = 39元\n所以妈妈需要付出39元来买6千克苹果和6千克香蕉。", "class": "math"}
{"question": "将以下文本进行编辑，删除第一段，将第二段复制到文本末尾:“自从上次我们见面以来，我一直在思考如何提高我的技能。\\n我决定学习一门新技能，以便更好地服务我的客户。”", "std_answer": "", "class": "rewrite"}
{"question": "花店里上午运来560枝玫瑰，卖掉了368枝，又运来了208枝．现在花店里有多少枝玫瑰？", "std_answer": "1.首先，我们可以使用加法和减法的运算法则来解决这道问题。 \n2.根据题目，上午运来了560枝玫瑰，卖掉了368枝，所以现在花店里还剩下的玫瑰数量为： \n560 - 368 = 192 \n3.接着，题目又说又运来了208枝玫瑰，因此现在花店里的玫瑰总数为： \n192 + 208 = 400 \n4.因此，现在花店里有400枝玫瑰。", "class": "math"}
{"question": "一群人排队买东西，售货员请了最后一个人出列，那么现在的倒数第二个人现在是最后一个人吗？", "std_answer": "是的，现在的倒数第二个人成为了最后一个人。因为售货员请出了最后一个人，所以原来的倒数第二个人现在成为了最后一个人，后面就没有人了。", "class": "open qa"}
{"question": "请为以下名人进行职业分类:王菲、李连杰、周星驰、蔡依林，分类为歌手、演员、导演", "std_answer": "王菲：歌手\n李连杰：演员\n周星驰：导演\n蔡依林：歌手", "class": "classification"}
{"question": "笑笑家到学校有500米，他每天在家和学校之间往返2个来回，他每天行多少千米？", "std_answer": "解题思路：\n1. 首先要知道每个来回的距离是多少，也就是笑笑家每次往返走多少米。\n2. 然后计算出一天中笑笑家往返的总距离，也就是他每天走多少米。\n3. 最后将每天总距离转换成千米，就可以得出答案了。\n解题步骤：\n1. 每个来回的距离是500米*2=1000米。\n2. 一天中笑笑家往返的总距离是1000米*2=2000米。\n3. 将2000米转换成千米，除以1000，得到2千米。\n所以，笑笑家每天行走2千米。", "class": "math"}
{"question": "“神舟”6号飞船在太空中飞行了大约119小时，比“神舟”5号飞行的时间的5倍还多14小时，“神舟”5号飞船在太空中飞行了多少小时?", "std_answer": "设“神舟”5号飞船在太空中飞行的时间为x小时，则由题意可得：\n119 = 5x + 14\n化简得：\n5x = 105\nx = 21\n因此，“神舟”5号飞船在太空中飞行了21小时。", "class": "math"}
{"question": "如果所有的鸟都会飞，你会不会推断所有不会飞的东西都不是鸟？", "std_answer": "作为AI语言模型，我不能推断任何事情的正确性，但是从逻辑上来说，这个推断是不正确的。因为所有鸟都会飞并不意味着所有不会飞的东西都不是鸟，例如鸵鸟、企鹅等都是鸟类，但它们不会飞。这个推断存在“偏见样本”的问题，即只考虑了一部分鸟类的特征，从而得出了错误的结论。", "class": "open qa"}
{"question": "请编辑以下段落，加入更多的细节，让它更加生动有趣。\n昨天我去了公园。我在那里看到了两只小狗在玩耍。然后我去了湖边，看到了很多鸟飞过。最后我坐在长椅上，欣赏着大自然的美景。", "std_answer": "", "class": "rewrite"}
{"question": "100张纸用20%后，又用了余下的20%，还剩多少张？", "std_answer": "解题思路：先把原来的100张看成单位“1”，用去20%后还剩下原来的（1-20%），由此用乘法求出第一次用后剩下的张数，再把第一次用后的张数看成单位“1”，再用乘法求出它的（1-20%）即可．\n100×（1-20%）×（1-20%）\n=80×80%\n=64（张）\n答：还剩下64张．", "class": "math"}
{"question": "给以下句子加上适当的标点符号:他们正在等着你为晚餐做菜你却看电视！", "std_answer": "", "class": "rewrite"}
{"question": "李叔叔喜欢骑自行车锻炼身体，每天要骑23千米的路程，3月份他骑了多少千米？", "std_answer": "步骤1：确定问题所求\n问题所求是3月份李叔叔骑自行车的总里程数。\n步骤2：列出已知信息和关系式\n已知：每天骑23千米的路程\n关系式：3月份总里程数 = 每天骑的里程数 × 3月份的天数\n步骤3：计算每天的骑行里程\n每天骑行23千米，所以3月份每天骑行的总里程为23 × 31 = 713千米。\n3月份李叔叔骑自行车的总里程数为713千米。", "class": "math"}
{"question": "一台洗衣机450元，一台笔记本电脑比洗衣机的12倍还多375元。一台笔记本电脑卖多少元？", "std_answer": "设笔记本电脑的价格为x元，则根据题意可列出以下方程：\nx = 12 × 450 + 375\n其中，12 × 450表示洗衣机的价格的12倍，再加上375元的溢价。将式子化简，得到：\nx = 5400 + 375\nx = 5775\n因此，笔记本电脑的价格为5775元。", "class": "math"}
{"question": "什么是代码结构？如何调整代码结构？", "std_answer": "代码结构是指代码中各个部分之间的组织方式和关系。它通常包括模块化、层次化、面向对象设计等方面。\n为了调整代码结构，可以采取以下几个步骤：\n1. 分析代码结构，找出问题\n首先需要对代码进行分析，找出其中存在的问题，例如模块之间耦合度高、代码重复、可读性差等。\n2. 制定调整方案\n根据分析结果，制定调整方案，例如拆分模块、重构代码、优化算法等。\n3. 实施调整方案\n根据制定的方案进行代码调整，尽可能少地影响代码的功能和性能。\n4. 测试和验证\n在调整完代码后，需要进行测试和验证，确保调整后的代码能够正常运行，并且性能和可读性都有所提高。\n5. 维护和优化\n为了保持代码的良好结构，需要不断维护和优化代码，避免代码腐化和过度耦合。", "class": "open qa"}
{"question": "如果一头大象站在一张脆弱的椅子上，椅子会破裂吗？", "std_answer": "是的，大象的重量会超出椅子的承受范围，导致椅子破裂。", "class": "open qa"}
{"question": "请为这篇文章选择一个适当的标题：自然语言处理还可以将积压的病例自动批量转化为结构化数据库，机器学习和自然语言处理技术能自动抓取病历中的临床变量，生成标准化的数据库。随后变量抽提、思路生成到论文图表导出的全过程辅助智能算法能挖掘变量相关性，激发论文思路，同 时提供针对临床科研的专业统计分析支持。其水平相当于受过8 年临床医学教育的医学研究生，这样下来同样同读一篇50页的病历，抓取和理解其中的所有临床信息速度比医生平均快2700倍，大大地提高了医院的办公效率，求医难这个问题将得到很多的缓解。", "std_answer": "自然语言处理技术在临床病例转化和科研支持中的应用", "class": "summarization"}
{"question": "如果细菌对抗生素产生了耐药性，那么为什么它们不能对所有抗生素都免疫？", "std_answer": "细菌的耐药性是指它们能够抵抗某种或某些抗生素的作用。这是因为细菌在面对特定抗生素时，可能会发生基因变异或水平基因转移等变化，使其产生相应的耐药性。但并不是所有抗生素都能被细菌耐药，因为不同抗生素的作用机制和作用靶点不同，细菌对不同抗生素的耐药性也是不同的。因此，细菌可能对某些抗生素具有耐药性，但对其他抗生素仍然敏感。", "class": "open qa"}
{"question": "将以下文本翻译成英语:天空之城是一部由吉卜力工作室制作的动画电影，于1986年上映。", "std_answer": "Castle in the Sky is an animated film produced by Studio Ghibli, which was released in 1986.", "class": "rewrite"}
================================================
FILE: eval/generation_html.py
================================================
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pandas as pd
import json
import argparse
def read_data(path):
datas = []
with open(path) as f:
for l in f.readlines():
datas.append(eval(l)) # json.loads(l) 在加载某些行数据存在问题，这里使用eval
return datas
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Finetune a transformers model on a causal language modeling task"
)
parser.add_argument(
"--prompt_path",
type=str,
default="eval_prompt.json",
)
parser.add_argument(
"--eval_set_path",
type=str,
default="eval_set.json",
)
parser.add_argument(
"--html_path",
type=str,
default="template_html/ChatGPT_Score.html.temp",
)
parser.add_argument(
"--output_html_path",
type=str,
default="ChatGPT_Score.html",
)
args = parser.parse_args()
prompt_path = args.prompt_path
eval_set_path = args.eval_set_path
output_html_path = args.output_html_path
html_path = args.html_path
prompt_data = read_data(prompt_path)
eval_set_data = read_data(eval_set_path)
eval_set_data = json.dumps(eval_set_data, ensure_ascii=False)
prompt_data = json.dumps(prompt_data, ensure_ascii=False)
eval_set_str = f"const eval_set = {eval_set_data}"
eval_prompt_str = f"const eval_prompt = {prompt_data}"
with open(html_path, "r") as f:
text = f.read()
text = text.replace("const eval_set = []", eval_set_str)
text = text.replace("const eval_prompt = []", eval_prompt_str)
with open(output_html_path, "w") as f:
f.write(text)
================================================
FILE: eval/template_html/ChatGPT_Score.html.temp
================================================
ChatGPT获取分数
ChatGPT 评分 // Score
请输入您的ChatGPT API KEY: // Please insert your ChatGPT API KEY
请选择一个问题: // Please select a question
请输入您的答案: // Please insert your answer
获取得分// Get the score
================================================
FILE: models/Belle-VL/README.md
================================================
## 📝Belle-VL
[](https://huggingface.co/BELLE-2/BELLE-VL)
### 背景介绍
社区目前已经有很多多模态大语言模型相关开源工作，但大多以英文能力为主，比如[LLava](https://github.com/haotian-liu/LLaVA),[CogVLM](https://github.com/THUDM/CogVLM)等，而中文多模态大语言模型比如[VisualGLM-6B](https://github.com/THUDM/VisualGLM-6B)、[Qwen-VL](https://github.com/QwenLM/Qwen-VL)的语言模型基座均较小，实际应用中很难兼顾视觉和语言能力，因此Belle-VL选择基于更强的语言模型基座来扩展模型的视觉能力，为社区提供更加灵活的选择。
### 模型简介
在模型结构方面，我们主要参考的[Qwen-VL](https://github.com/QwenLM/Qwen-VL)模型，原始Qwen-VL是基于Qwen7B模型训练而来，基座能力相对较弱，因此Belle-VL将语言模型扩展成了[Qwen14B-chat](https://huggingface.co/Qwen/Qwen-14B-Chat)，在中文语言能力和视觉能力方面可以兼顾，具备更好的扩展性。
### 训练策略
原始Qwen-vl采用了三阶段的训练方式,包括预训练、多任务训练和指令微调，依赖较大的数据和机器资源。受LLava1.5的启发，多模态指令微调比预训练更加重要，因此我们采用了两阶段的训练方式，如下图所示：
### 训练数据
* 预训练数据：预训练数据主要是基于LLava 的[558k](https://huggingface.co/datasets/liuhaotian/LLaVA-Pretrain)英文指令数据及其对应的中文翻译数据，此外我们还收集了[Flickr30k-CNA](https://zero.so.com/) 以及从[AI Challenger](https://tianchi.aliyun.com/dataset/145781?spm=a2c22.12282016.0.0.5c823721PG2nBW)随机选取的100k数据
* 多模态指令数据：指令微调阶段，数据主要来自[LLava](https://github.com/haotian-liu/LLaVA), [LRV-Instruction](https://github.com/FuxiaoLiu/LRV-Instruction), [LLaVAR](https://github.com/SALT-NLP/LLaVAR),[LVIS-INSTRUCT4V](https://github.com/X2FD/LVIS-INSTRUCT4V)等开源项目，我们也对其中部分数据进行了翻译，在此真诚的感谢他们为开源所做出的贡献！
### 模型使用
``` python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
model_dir = '/path/to_finetuned_model/'
img_path = 'you_image_path'
tokenizer = AutoTokenizer.from_pretrained(model_dir, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_dir, trust_remote_code=True).eval()
model.generation_config = GenerationConfig.from_pretrained(model_dir, trust_remote_code=True)
question = '详细描述一下这张图'
query = tokenizer.from_list_format([
{'image': img_path}, # Either a local path or an url
{'text': question},
])
response, history = model.chat(tokenizer, query=query, history=None)
print(response)
#or
query = f'
BELLE项目目标是促进中文对话大模型开源社区的发展，愿景做能帮到每一个人的LLM Engine。现阶段本项目基于一些开源预训练大语言模型（如BLOOM、LLAMA等），针对中文做了优化，模型调优仅使用由ChatGPT生产的数据（不包含任何其他数据）。
The goal of this project is to promote the development of the open-source community for Chinese language large-scale conversational models, and our vision is to help building large language model engine for everyone. This project optimizes Chinese performance based on opensource pretrained large language models. These models finetuning uses only data generated via ChatGPT (without other data).
.enc
input_file_basename = input_file_basename[:-len(checksum_hex) - 5]
output_file = os.path.join(output_dir, input_file_basename)
with open(output_file, "wb") as out_file:
r_chunk_idx = 0 # how many chunks we have read
w_chunk_idx = 0 # how many chunks have been written
write_pending = [] # have xor results, awaiting to be written to file
bytes_read = 0
while True:
chunk = in_file.read(chunk_size)
if not chunk:
break
key_chunk = key_file.read(key_chunk_size)
if not key_chunk:
key_file.seek(0)
key_chunk = key_file.read(key_chunk_size)
# task_queue.put((r_chunk_idx, chunk, key_chunk))
write_pending.append((r_chunk_idx, xor_bytes(chunk, key_chunk)))
# read available results
# while not result_queue.empty():
# write_pending.append(result_queue.get())
w_chunk_idx_new, write_pending = write_result_chunk(out_file, w_chunk_idx, write_pending, hasher)
bytes_read += (w_chunk_idx_new - w_chunk_idx) * chunk_size
progress = bytes_read / file_size * 100
sys.stdout.write(f"\rProgress: {progress:.2f}%")
sys.stdout.flush()
w_chunk_idx = w_chunk_idx_new
r_chunk_idx += 1
# wait for xor workers
sys.stdout.write('\rWaiting for workers...')
sys.stdout.flush()
# task_queue.join()
# while not result_queue.empty():
# write_pending.append(result_queue.get())
sys.stdout.write('\rWriting final chunks...')
sys.stdout.flush()
write_result_chunk(out_file, w_chunk_idx, write_pending, hasher)
computed_hash = hasher.digest()
if computed_hash != expected_hash:
print("\nError: Checksums do not match. The file may be corrupted.")
sys.exit(1)
print ("\nDecryption completed.")
if __name__ == "__main__":
if len(sys.argv) != 4:
print("Usage: decrypt.py input_file key_file output_dir")
sys.exit(1)
main(sys.argv[1], sys.argv[2], sys.argv[3])
================================================
FILE: models/gptq/README.md
================================================
# GPTQ-for-Bloom & LLaMa
8 bits quantization of [Bloom](https://arxiv.org/pdf/2211.05100.pdf) using [GPTQ](https://arxiv.org/abs/2210.17323)
GPTQ is SOTA one-shot weight quantization method
**This code is based on [GPTQ-for-LLaMa](https://github.com/qwopqwop200/GPTQ-for-LLaMa)**
## [Huggingface models](https://huggingface.co/BelleGroup/BELLE-7B-gptq)
| model name | file size | GPU memory usage |
| -------------------------------------------------- | ------------------- | ------------------ |
| base | 27G | ~28.2G |
| bloom7b-2m-8bit-128g.pt | 9.7G | ~11.4G |
| bloom7b-2m-4bit-128g.pt | 6.9G | ~8.4G |
| bloom7b-0.2m-8bit-128g.pt | 9.7G | ~11.4G |
| bloom7b-0.2m-4bit-128g.pt | 6.9G | ~8.4G |
All experiments were run on a single NVIDIA A100.
## Installation
If you don't have [conda](https://docs.conda.io/en/latest/miniconda.html), install it first.
```
conda create --name gptq python=3.9 -y
conda activate gptq
conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia
# Or, if you're having trouble with conda, use pip with python3.9:
# pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117
pip install -r requirements.txt
python setup_cuda.py install
# Benchmark performance for FC2 layer of LLaMa-7B
CUDA_VISIBLE_DEVICES=0 python test_kernel.py
```
## Dependencies
* `torch`: tested on v2.0.0+cu117
* `transformers`: tested on v4.28.0.dev0
* `datasets`: tested on v2.10.1
* `safetensors`: tested on v0.3.0
* (to run 4-bit kernels: setup for compiling PyTorch CUDA extensions, see also https://pytorch.org/tutorials/advanced/cpp_extension.html, tested on CUDA 11.7)
## Model inference with the saved model
```
# BELLE-7B-gptq: local saved model path from Huggingface
git lfs install
git clone https://huggingface.co/BelleGroup/BELLE-7B-gptq
# model inference with the saved model
CUDA_VISIBLE_DEVICES=0 python bloom_inference.py BELLE-7B-gptq --wbits 8 --groupsize 128 --load BELLE-7B-gptq/bloom7b-2m-8bit-128g.pt --text "hello"
```
## Model quantization
```
# BELLE-7B-gptq: local saved model path
# Save compressed model
CUDA_VISIBLE_DEVICES=0 python bloom.py BelleGroup/BELLE-7B-2M wikitext2 --wbits 8 --groupsize 128 --save BELLE-7B-gptq/bloom7b-2m-8bit-128g.pt
```
CUDA Kernels support 2,3,4,8 bits.
Basically, 8-bit quantization and 128 groupsize are recommended.
# Acknowledgements
This code is based on [GPTQ-for-LLaMa](https://github.com/qwopqwop200/GPTQ-for-LLaMa)
Thanks to [Bloom](https://arxiv.org/pdf/2211.05100.pdf), a powerful LLM.
================================================
FILE: models/gptq/bloom.py
================================================
import time
import torch
import torch.nn as nn
from gptq import *
from modelutils import *
from quant import *
def get_bloom(model):
import torch
def skip(*args, **kwargs):
pass
torch.nn.init.kaiming_uniform_ = skip
torch.nn.init.uniform_ = skip
torch.nn.init.normal_ = skip
from transformers import BloomForCausalLM
model = BloomForCausalLM.from_pretrained(model, torch_dtype='auto')
model.seqlen = 2048
return model
@torch.no_grad()
def bloom_sequential(model, dataloader, dev):
print('Starting ...')
use_cache = model.config.use_cache
model.config.use_cache = False
layers = model.transformer.h
model.transformer.word_embeddings = model.transformer.word_embeddings.to(dev)
model.transformer.word_embeddings_layernorm = model.transformer.word_embeddings_layernorm.to(dev)
layers[0] = layers[0].to(dev)
dtype = next(iter(model.parameters())).dtype
inps = torch.zeros(
(args.nsamples, model.seqlen, model.config.hidden_size), dtype=dtype, device=dev
)
cache = {'i': 0, 'attention_mask': None, 'alibi': None}
class Catcher(nn.Module):
def __init__(self, module):
super().__init__()
self.module = module
def forward(self, inp, **kwargs):
inps[cache['i']] = inp
cache['i'] += 1
cache['attention_mask'] = kwargs['attention_mask']
cache['alibi'] = kwargs['alibi']
raise ValueError
layers[0] = Catcher(layers[0])
for batch in dataloader:
try:
model(batch[0].to(dev))
except ValueError:
pass
layers[0] = layers[0].module
layers[0] = layers[0].cpu()
model.transformer.word_embeddings = model.transformer.word_embeddings.cpu()
model.transformer.word_embeddings_layernorm = model.transformer.word_embeddings_layernorm.cpu()
torch.cuda.empty_cache()
outs = torch.zeros_like(inps)
attention_mask = cache['attention_mask']
alibi = cache['alibi']
print('Ready.')
quantizers = {}
for i in range(len(layers)):
layer = layers[i].to(dev)
subset = find_layers(layer)
gptq = {}
for name in subset:
gptq[name] = GPTQ(subset[name])
gptq[name].quantizer = Quantizer()
gptq[name].quantizer.configure(
args.wbits, perchannel=True, sym=False, mse=False
)
def add_batch(name):
def tmp(_, inp, out):
gptq[name].add_batch(inp[0].data, out.data)
return tmp
handles = []
for name in subset:
handles.append(subset[name].register_forward_hook(add_batch(name)))
for j in range(args.nsamples):
outs[j] = layer(inps[j].unsqueeze(0), attention_mask=attention_mask, alibi=alibi)[0]
for h in handles:
h.remove()
for name in subset:
print(i, name)
print('Quantizing ...')
scale,zero = gptq[name].fasterquant(percdamp=args.percdamp, groupsize=args.groupsize)
quantizers['transformer.h.%d.%s' % (i, name)] = (gptq[name].quantizer,scale,zero)
gptq[name].free()
for j in range(args.nsamples):
outs[j] = layer(inps[j].unsqueeze(0), attention_mask=attention_mask, alibi=alibi)[0]
layers[i] = layer.cpu()
del layer
del gptq
torch.cuda.empty_cache()
inps, outs = outs, inps
model.config.use_cache = use_cache
return quantizers
@torch.no_grad()
def bloom_eval(model, testenc, dev):
print('Evaluation...')
testenc = testenc.input_ids
nsamples = testenc.numel() // model.seqlen
use_cache = model.config.use_cache
model.config.use_cache = False
layers = model.transformer.h
model.transformer.word_embeddings = model.transformer.word_embeddings.to(dev)
model.transformer.word_embeddings_layernorm = model.transformer.word_embeddings_layernorm.to(dev)
layers[0] = layers[0].to(dev)
dtype = next(iter(model.parameters())).dtype
inps = torch.zeros(
(nsamples, model.seqlen, model.config.hidden_size), dtype=dtype, device=dev
)
cache = {'i': 0, 'attention_mask': None, 'alibi': None}
class Catcher(nn.Module):
def __init__(self, module):
super().__init__()
self.module = module
def forward(self, inp, **kwargs):
inps[cache['i']] = inp
cache['i'] += 1
cache['attention_mask'] = kwargs['attention_mask']
cache['alibi'] = kwargs['alibi']
raise ValueError
layers[0] = Catcher(layers[0])
for i in range(nsamples):
batch = testenc[:, (i * model.seqlen):((i + 1) * model.seqlen)].to(dev)
try:
model(batch)
except ValueError:
pass
layers[0] = layers[0].module
layers[0] = layers[0].cpu()
model.transformer.word_embeddings = model.transformer.word_embeddings.cpu()
model.transformer.word_embeddings_layernorm = model.transformer.word_embeddings_layernorm.cpu()
torch.cuda.empty_cache()
outs = torch.zeros_like(inps)
attention_mask = cache['attention_mask']
alibi = cache['alibi']
for i in range(len(layers)):
print(i)
layer = layers[i].to(dev)
if args.nearest:
subset = find_layers(layer)
for name in subset:
quantizer = Quantizer()
quantizer.configure(
args.wbits, perchannel=True, sym=args.sym, mse=False
)
W = subset[name].weight.data
quantizer.find_params(W, weight=True)
subset[name].weight.data = quantize(
W, quantizer.scale, quantizer.zero, quantizer.maxq
).to(next(iter(layer.parameters())).dtype)
for j in range(nsamples):
outs[j] = layer(inps[j].unsqueeze(0), attention_mask=attention_mask, alibi=alibi)[0]
layers[i] = layer.cpu()
del layer
torch.cuda.empty_cache()
inps, outs = outs, inps
model.transformer.ln_f = model.transformer.ln_f.to(dev)
model.lm_head = model.lm_head.to(dev)
testenc = testenc.to(dev)
nlls = []
for i in range(nsamples):
hidden_states = inps[i].unsqueeze(0)
hidden_states = model.transformer.ln_f(hidden_states)
lm_logits = model.lm_head(hidden_states)
shift_logits = lm_logits[:, :-1, :].contiguous()
shift_labels = testenc[
:, (i * model.seqlen):((i + 1) * model.seqlen)
][:, 1:]
loss_fct = nn.CrossEntropyLoss()
loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
neg_log_likelihood = loss.float() * model.seqlen
nlls.append(neg_log_likelihood)
ppl = torch.exp(torch.stack(nlls).sum() / (nsamples * model.seqlen))
print(ppl.item())
model.config.use_cache = use_cache
# TODO: perform packing on GPU
def bloom_pack(model, quantizers, wbits, groupsize):
layers = find_layers(model)
layers = {n: layers[n] for n in quantizers}
make_quant(model, quantizers, wbits, groupsize)
qlayers = find_layers(model, [QuantLinear])
print('Packing ...')
for name in qlayers:
print(name)
quantizers[name],scale,zero = quantizers[name]
quantizers[name],scale,zero = quantizers[name].cpu(),scale.cpu(),zero.cpu()
qlayers[name].pack(layers[name], scale, zero)
print('Done.')
return model
def load_quant(model, checkpoint, wbits, groupsize):
from transformers import BloomConfig, BloomForCausalLM
config = BloomConfig.from_pretrained(model)
def noop(*args, **kwargs):
pass
torch.nn.init.kaiming_uniform_ = noop
torch.nn.init.uniform_ = noop
torch.nn.init.normal_ = noop
torch.set_default_dtype(torch.half)
transformers.modeling_utils._init_weights = False
torch.set_default_dtype(torch.half)
model = BloomForCausalLM(config)
torch.set_default_dtype(torch.float)
model = model.eval()
layers = find_layers(model)
for name in ['model.transformer.word_embeddings', 'model.transformer.word_embeddings_layernorm']:
if name in layers:
del layers[name]
make_quant(model, layers, wbits, groupsize)
print('Loading model ...')
if checkpoint.endswith('.safetensors'):
from safetensors.torch import load_file as safe_load
model.load_state_dict(safe_load(checkpoint))
else:
model.load_state_dict(torch.load(checkpoint))
model.seqlen = model.config.max_position_embeddings
print('Done.')
return model
def benchmark(model, input_ids, check=False):
input_ids = input_ids.to(model.gpus[0] if hasattr(model, 'gpus') else DEV)
torch.cuda.synchronize()
cache = {'past': None}
def clear_past(i):
def tmp(layer, inp, out):
if cache['past']:
cache['past'][i] = None
return tmp
for i, layer in enumerate(model.model.decoder.layers):
layer.register_forward_hook(clear_past(i))
print('Benchmarking ...')
if check:
loss = nn.CrossEntropyLoss()
tot = 0.
def sync():
if hasattr(model, 'gpus'):
for gpu in model.gpus:
torch.cuda.synchronize(gpu)
else:
torch.cuda.synchronize()
with torch.no_grad():
attention_mask = torch.ones((1, input_ids.numel()), device=DEV)
times = []
for i in range(input_ids.numel()):
tick = time.time()
out = model(
input_ids[:, i].reshape(-1),
past_key_values=cache['past'],
attention_mask=attention_mask[:, :(i + 1)].reshape((1, -1))
)
sync()
times.append(time.time() - tick)
print(i, times[-1])
if check and i != input_ids.numel() - 1:
tot += loss(out.logits[0].to(DEV), input_ids[:, (i + 1)].to(DEV)).float()
cache['past'] = list(out.past_key_values)
del out
sync()
import numpy as np
print('Median:', np.median(times))
if check:
print('PPL:', torch.exp(tot / (input_ids.numel() - 1)).item())
if __name__ == '__main__':
import argparse
from datautils import *
parser = argparse.ArgumentParser()
parser.add_argument(
'model', type=str,
help='BLOOM model to load; pass `facebook/opt-X`.'
)
parser.add_argument(
'dataset', type=str, choices=['wikitext2', 'ptb', 'c4'],
help='Where to extract calibration data from.'
)
parser.add_argument(
'--seed',
type=int, default=0, help='Seed for sampling the calibration data.'
)
parser.add_argument(
'--nsamples', type=int, default=128,
help='Number of calibration data samples.'
)
parser.add_argument(
'--percdamp', type=float, default=.01,
help='Percent of the average Hessian diagonal to use for dampening.'
)
parser.add_argument(
'--nearest', action='store_true',
help='Whether to run the RTN baseline.'
)
parser.add_argument(
'--wbits', type=int, default=16, choices=[2, 3, 4, 8, 16],
help='#bits to use for quantization; use 16 for evaluating base model.'
)
parser.add_argument(
'--groupsize', type=int, default=-1,
help='Groupsize to use for quantization; default uses full row.'
)
parser.add_argument(
'--save', type=str, default='',
help='Save quantized checkpoint under this name.'
)
parser.add_argument(
'--save_safetensors', type=str, default='',
help='Save quantized `.safetensors` checkpoint under this name.'
)
parser.add_argument(
'--load', type=str, default='',
help='Load quantized model.'
)
parser.add_argument(
'--benchmark', type=int, default=0,
help='Number of tokens to use for benchmarking.'
)
parser.add_argument(
'--check', action='store_true',
help='Whether to compute perplexity during benchmarking for verification.'
)
args = parser.parse_args()
if type(args.load) is not str:
args.load = args.load.as_posix()
if args.load:
model = load_quant(args.model, args.load, args.wbits, args.groupsize)
else:
model = get_bloom(args.model)
model.eval()
dataloader, testloader = get_loaders(
args.dataset, nsamples=args.nsamples, seed=args.seed, model=args.model, seqlen=model.seqlen
)
if not args.load and args.wbits < 16 and not args.nearest:
tick = time.time()
quantizers = bloom_sequential(model, dataloader, DEV)
print(time.time() - tick)
if args.benchmark:
gpus = [torch.device('cuda:%d' % i) for i in range(torch.cuda.device_count())]
if len(gpus) > 1:
#bloom_multigpu(model, gpus)
print("not support")
else:
model = model.to(DEV)
if args.benchmark:
input_ids = next(iter(dataloader))[0][:, :args.benchmark]
benchmark(model, input_ids, check=args.check)
if args.load:
exit()
for dataset in ['wikitext2']:
dataloader, testloader = get_loaders(
dataset, seed=args.seed, model=args.model, seqlen=model.seqlen
)
print(dataset)
bloom_eval(model, testloader, DEV)
if args.save:
bloom_pack(model, quantizers, args.wbits, args.groupsize)
torch.save(model.state_dict(), args.save)
if args.save_safetensors:
bloom_pack(model, quantizers, args.wbits, args.groupsize)
from safetensors.torch import save_file as safe_save
safe_save(model.state_dict(), args.save_safetensors)
================================================
FILE: models/gptq/bloom_inference.py
================================================
import time
import torch
import torch.nn as nn
from gptq import *
from modelutils import *
from quant import *
from transformers import AutoTokenizer
DEV = torch.device('cuda:0')
def get_bloom(model):
import torch
def skip(*args, **kwargs):
pass
torch.nn.init.kaiming_uniform_ = skip
torch.nn.init.uniform_ = skip
torch.nn.init.normal_ = skip
from transformers import BloomForCausalLM
model = BloomForCausalLM.from_pretrained(model, torch_dtype='auto')
model.seqlen = 2048
return model
def load_quant(model, checkpoint, wbits, groupsize):
from transformers import BloomConfig, BloomForCausalLM
config = BloomConfig.from_pretrained(model)
def noop(*args, **kwargs):
pass
torch.nn.init.kaiming_uniform_ = noop
torch.nn.init.uniform_ = noop
torch.nn.init.normal_ = noop
torch.set_default_dtype(torch.half)
transformers.modeling_utils._init_weights = False
torch.set_default_dtype(torch.half)
model = BloomForCausalLM(config)
torch.set_default_dtype(torch.float)
model = model.eval()
layers = find_layers(model)
for name in ['lm_head']:
if name in layers:
del layers[name]
make_quant(model, layers, wbits, groupsize)
print('Loading model ...')
if checkpoint.endswith('.safetensors'):
from safetensors.torch import load_file as safe_load
model.load_state_dict(safe_load(checkpoint))
else:
model.load_state_dict(torch.load(checkpoint,map_location=torch.device('cuda')))
model.seqlen = 2048
print('Done.')
return model
if __name__ == '__main__':
import argparse
from datautils import *
parser = argparse.ArgumentParser()
parser.add_argument(
'model', type=str,
help='llama model to load'
)
parser.add_argument(
'--wbits', type=int, default=16, choices=[2, 3, 4, 8, 16],
help='#bits to use for quantization; use 16 for evaluating base model.'
)
parser.add_argument(
'--groupsize', type=int, default=-1,
help='Groupsize to use for quantization; default uses full row.'
)
parser.add_argument(
'--load', type=str, default='',
help='Load quantized model.'
)
parser.add_argument(
'--text', type=str,
help='hello'
)
parser.add_argument(
'--min_length', type=int, default=10,
help='The minimum length of the sequence to be generated.'
)
parser.add_argument(
'--max_length', type=int, default=1024,
help='The maximum length of the sequence to be generated.'
)
parser.add_argument(
'--top_p', type=float , default=0.95,
help='If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation.'
)
parser.add_argument(
'--temperature', type=float, default=0.8,
help='The value used to module the next token probabilities.'
)
args = parser.parse_args()
if type(args.load) is not str:
args.load = args.load.as_posix()
if args.load:
model = load_quant(args.model, args.load, args.wbits, args.groupsize)
else:
model = get_bloom(args.model)
model.eval()
model.to(DEV)
tokenizer = AutoTokenizer.from_pretrained(args.model)
print("Human:")
line = input()
while line:
inputs = 'Human: ' + line.strip() + '\n\nAssistant:'
input_ids = tokenizer.encode(inputs, return_tensors="pt").to(DEV)
with torch.no_grad():
generated_ids = model.generate(
input_ids,
do_sample=True,
min_length=args.min_length,
max_length=args.max_length,
top_p=args.top_p,
temperature=args.temperature,
)
print("Assistant:\n")
print(tokenizer.decode([el.item() for el in generated_ids[0]])[len(inputs):]) # generated_ids开头加上了bos_token,需要将inpu的内容截断,只输出Assistant
print("\n-------------------------------\n")
print("Human:") #每次终端用户输入前，加上Human提示。
line = input()
================================================
FILE: models/gptq/datautils.py
================================================
import numpy as np
import torch
def set_seed(seed):
np.random.seed(seed)
torch.random.manual_seed(seed)
def get_wikitext2(nsamples, seed, seqlen, model):
from datasets import load_dataset
traindata = load_dataset('wikitext', 'wikitext-2-raw-v1', split='train')
testdata = load_dataset('wikitext', 'wikitext-2-raw-v1', split='test')
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(model)
trainenc = tokenizer("\n\n".join(traindata['text']), return_tensors='pt')
testenc = tokenizer("\n\n".join(testdata['text']), return_tensors='pt')
import random
random.seed(seed)
trainloader = []
for _ in range(nsamples):
i = random.randint(0, trainenc.input_ids.shape[1] - seqlen - 1)
j = i + seqlen
inp = trainenc.input_ids[:, i:j]
tar = inp.clone()
tar[:, :-1] = -100
trainloader.append((inp, tar))
return trainloader, testenc
def get_ptb(nsamples, seed, seqlen, model):
from datasets import load_dataset
traindata = load_dataset('ptb_text_only', 'penn_treebank', split='train')
valdata = load_dataset('ptb_text_only', 'penn_treebank', split='validation')
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(model)
trainenc = tokenizer("\n\n".join(traindata['sentence']), return_tensors='pt')
testenc = tokenizer("\n\n".join(valdata['sentence']), return_tensors='pt')
import random
random.seed(seed)
trainloader = []
for _ in range(nsamples):
i = random.randint(0, trainenc.input_ids.shape[1] - seqlen - 1)
j = i + seqlen
inp = trainenc.input_ids[:, i:j]
tar = inp.clone()
tar[:, :-1] = -100
trainloader.append((inp, tar))
return trainloader, testenc
def get_c4(nsamples, seed, seqlen, model):
from datasets import load_dataset
traindata = load_dataset(
'allenai/c4', 'allenai--c4', data_files={'train': 'en/c4-train.00000-of-01024.json.gz'}, split='train', use_auth_token=True
)
valdata = load_dataset(
'allenai/c4', 'allenai--c4', data_files={'validation': 'en/c4-validation.00000-of-00008.json.gz'}, split='validation',use_auth_token=True
)
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(model)
import random
random.seed(seed)
trainloader = []
for _ in range(nsamples):
while True:
i = random.randint(0, len(traindata) - 1)
trainenc = tokenizer(traindata[i]['text'], return_tensors='pt')
if trainenc.input_ids.shape[1] >= seqlen:
break
i = random.randint(0, trainenc.input_ids.shape[1] - seqlen - 1)
j = i + seqlen
inp = trainenc.input_ids[:, i:j]
tar = inp.clone()
tar[:, :-1] = -100
trainloader.append((inp, tar))
import random
random.seed(0)
valenc = []
for _ in range(256):
while True:
i = random.randint(0, len(valdata) - 1)
tmp = tokenizer(valdata[i]['text'], return_tensors='pt')
if tmp.input_ids.shape[1] >= seqlen:
break
i = random.randint(0, tmp.input_ids.shape[1] - seqlen - 1)
j = i + seqlen
valenc.append(tmp.input_ids[:, i:j])
valenc = torch.hstack(valenc)
class TokenizerWrapper:
def __init__(self, input_ids):
self.input_ids = input_ids
valenc = TokenizerWrapper(valenc)
return trainloader, valenc
def get_loaders(
name, nsamples=128, seed=0, seqlen=2048, model=''
):
if 'wikitext2' in name:
return get_wikitext2(nsamples, seed, seqlen, model)
if 'ptb' in name:
return get_ptb(nsamples, seed, seqlen, model)
if 'c4' in name:
return get_c4(nsamples, seed, seqlen, model)
================================================
FILE: models/gptq/gptq.py
================================================
import math
import time
import torch
import torch.nn as nn
import transformers
from quant import *
DEBUG = False
torch.backends.cuda.matmul.allow_tf32 = False
torch.backends.cudnn.allow_tf32 = False
class GPTQ:
def __init__(self, layer):
self.layer = layer
self.dev = self.layer.weight.device
W = layer.weight.data.clone()
if isinstance(self.layer, nn.Conv2d):
W = W.flatten(1)
if isinstance(self.layer, transformers.Conv1D):
W = W.t()
self.rows = W.shape[0]
self.columns = W.shape[1]
self.H = torch.zeros((self.columns, self.columns), device=self.dev)
self.nsamples = 0
def add_batch(self, inp, out):
if DEBUG:
self.inp1 = inp
self.out1 = out
if len(inp.shape) == 2:
inp = inp.unsqueeze(0)
tmp = inp.shape[0]
if isinstance(self.layer, nn.Linear) or isinstance(self.layer, transformers.Conv1D):
if len(inp.shape) == 3:
inp = inp.reshape((-1, inp.shape[-1]))
inp = inp.t()
if isinstance(self.layer, nn.Conv2d):
unfold = nn.Unfold(
self.layer.kernel_size,
dilation=self.layer.dilation,
padding=self.layer.padding,
stride=self.layer.stride
)
inp = unfold(inp)
inp = inp.permute([1, 0, 2])
inp = inp.flatten(1)
self.H *= self.nsamples / (self.nsamples + tmp)
self.nsamples += tmp
# inp = inp.float()
inp = math.sqrt(2 / self.nsamples) * inp.float()
# self.H += 2 / self.nsamples * inp.matmul(inp.t())
self.H += inp.matmul(inp.t())
def fasterquant(
self, blocksize=128, percdamp=.01, groupsize=-1
):
W = self.layer.weight.data.clone()
if isinstance(self.layer, nn.Conv2d):
W = W.flatten(1)
if isinstance(self.layer, transformers.Conv1D):
W = W.t()
W = W.float()
tick = time.time()
if not self.quantizer.ready():
self.quantizer.find_params(W, weight=True)
H = self.H
del self.H
dead = torch.diag(H) == 0
H[dead, dead] = 1
W[:, dead] = 0
Losses = torch.zeros_like(W)
Q = torch.zeros_like(W)
damp = percdamp * torch.mean(torch.diag(H))
diag = torch.arange(self.columns, device=self.dev)
H[diag, diag] += damp
H = torch.linalg.cholesky(H)
H = torch.cholesky_inverse(H)
H = torch.linalg.cholesky(H, upper=True)
Hinv = H
scale = []
zero = []
now_idx = 1
for i1 in range(0, self.columns, blocksize):
i2 = min(i1 + blocksize, self.columns)
count = i2 - i1
W1 = W[:, i1:i2].clone()
Q1 = torch.zeros_like(W1)
Err1 = torch.zeros_like(W1)
Losses1 = torch.zeros_like(W1)
Hinv1 = Hinv[i1:i2, i1:i2]
for i in range(count):
w = W1[:, i]
d = Hinv1[i, i]
if groupsize != -1:
if (i1 + i) % groupsize == 0:
self.quantizer.find_params(W[:, (i1 + i):(i1 + i + groupsize)], weight=True)
if ((i1 + i) // groupsize) - now_idx == -1:
scale.append(self.quantizer.scale)
zero.append(self.quantizer.zero)
now_idx += 1
q = quantize(
w.unsqueeze(1), self.quantizer.scale, self.quantizer.zero, self.quantizer.maxq
).flatten()
Q1[:, i] = q
Losses1[:, i] = (w - q) ** 2 / d ** 2
err1 = (w - q) / d
W1[:, i:] -= err1.unsqueeze(1).matmul(Hinv1[i, i:].unsqueeze(0))
Err1[:, i] = err1
Q[:, i1:i2] = Q1
Losses[:, i1:i2] = Losses1 / 2
W[:, i2:] -= Err1.matmul(Hinv[i1:i2, i2:])
if DEBUG:
self.layer.weight.data[:, :i2] = Q[:, :i2]
self.layer.weight.data[:, i2:] = W[:, i2:]
print(torch.sum((self.layer(self.inp1) - self.out1) ** 2))
print(torch.sum(Losses))
torch.cuda.synchronize()
print('time %.2f' % (time.time() - tick))
print('error', torch.sum(Losses).item())
if isinstance(self.layer, transformers.Conv1D):
Q = Q.t()
self.layer.weight.data = Q.reshape(self.layer.weight.shape).to(self.layer.weight.data.dtype)
if DEBUG:
print(torch.sum((self.layer(self.inp1) - self.out1) ** 2))
if scale == []:
scale.append(self.quantizer.scale)
zero.append(self.quantizer.zero)
scale = torch.cat(scale,dim=1)
zero = torch.cat(zero,dim=1)
return scale,zero
def free(self):
if DEBUG:
self.inp1 = None
self.out1 = None
self.H = None
self.Losses = None
self.Trace = None
torch.cuda.empty_cache()
================================================
FILE: models/gptq/llama.py
================================================
import time
import torch
import torch.nn as nn
from gptq import *
from modelutils import *
from quant import *
def get_llama(model):
import torch
def skip(*args, **kwargs):
pass
torch.nn.init.kaiming_uniform_ = skip
torch.nn.init.uniform_ = skip
torch.nn.init.normal_ = skip
from transformers import LlamaForCausalLM
model = LlamaForCausalLM.from_pretrained(model, torch_dtype='auto')
model.seqlen = 2048
return model
@torch.no_grad()
def llama_sequential(model, dataloader, dev):
print('Starting ...')
use_cache = model.config.use_cache
model.config.use_cache = False
layers = model.model.layers
model.model.embed_tokens = model.model.embed_tokens.to(dev)
model.model.norm = model.model.norm.to(dev)
layers[0] = layers[0].to(dev)
dtype = next(iter(model.parameters())).dtype
inps = torch.zeros(
(args.nsamples, model.seqlen, model.config.hidden_size), dtype=dtype, device=dev
)
cache = {'i': 0, 'attention_mask': None}
class Catcher(nn.Module):
def __init__(self, module):
super().__init__()
self.module = module
def forward(self, inp, **kwargs):
inps[cache['i']] = inp
cache['i'] += 1
cache['attention_mask'] = kwargs['attention_mask']
raise ValueError
layers[0] = Catcher(layers[0])
for batch in dataloader:
try:
model(batch[0].to(dev))
except ValueError:
pass
layers[0] = layers[0].module
layers[0] = layers[0].cpu()
model.model.embed_tokens = model.model.embed_tokens.cpu()
model.model.norm = model.model.norm.cpu()
torch.cuda.empty_cache()
outs = torch.zeros_like(inps)
attention_mask = cache['attention_mask']
print('Ready.')
quantizers = {}
for i in range(len(layers)):
layer = layers[i].to(dev)
full = find_layers(layer)
if args.true_sequential:
sequential = [
['self_attn.k_proj', 'self_attn.v_proj', 'self_attn.q_proj'],
['self_attn.o_proj'],
['mlp.up_proj', 'mlp.gate_proj'],
['mlp.down_proj']
]
else:
sequential = [list(full.keys())]
for names in sequential:
subset = {n: full[n] for n in names}
gptq = {}
for name in subset:
gptq[name] = GPTQ(subset[name])
gptq[name].quantizer = Quantizer()
gptq[name].quantizer.configure(
args.wbits, perchannel=True, sym=args.sym, mse=False
)
def add_batch(name):
def tmp(_, inp, out):
gptq[name].add_batch(inp[0].data, out.data)
return tmp
handles = []
for name in subset:
handles.append(subset[name].register_forward_hook(add_batch(name)))
for j in range(args.nsamples):
outs[j] = layer(inps[j].unsqueeze(0), attention_mask=attention_mask)[0]
for h in handles:
h.remove()
for name in subset:
print(i, name)
print('Quantizing ...')
scale,zero = gptq[name].fasterquant(percdamp=args.percdamp, groupsize=args.groupsize)
quantizers['model.layers.%d.%s' % (i, name)] = (gptq[name].quantizer,scale,zero)
gptq[name].free()
for j in range(args.nsamples):
outs[j] = layer(inps[j].unsqueeze(0), attention_mask=attention_mask)[0]
layers[i] = layer.cpu()
del layer
del gptq
torch.cuda.empty_cache()
inps, outs = outs, inps
model.config.use_cache = use_cache
return quantizers
@torch.no_grad()
def llama_eval(model, testenc, dev):
print('Evaluating ...')
testenc = testenc.input_ids
nsamples = testenc.numel() // model.seqlen
use_cache = model.config.use_cache
model.config.use_cache = False
layers = model.model.layers
model.model.embed_tokens = model.model.embed_tokens.to(dev)
layers[0] = layers[0].to(dev)
dtype = next(iter(model.parameters())).dtype
inps = torch.zeros(
(nsamples, model.seqlen, model.config.hidden_size), dtype=dtype, device=dev
)
cache = {'i': 0, 'attention_mask': None}
class Catcher(nn.Module):
def __init__(self, module):
super().__init__()
self.module = module
def forward(self, inp, **kwargs):
inps[cache['i']] = inp
cache['i'] += 1
cache['attention_mask'] = kwargs['attention_mask']
raise ValueError
layers[0] = Catcher(layers[0])
for i in range(nsamples):
batch = testenc[:, (i * model.seqlen):((i + 1) * model.seqlen)].to(dev)
try:
model(batch)
except ValueError:
pass
layers[0] = layers[0].module
layers[0] = layers[0].cpu()
model.model.embed_tokens = model.model.embed_tokens.cpu()
torch.cuda.empty_cache()
outs = torch.zeros_like(inps)
attention_mask = cache['attention_mask']
for i in range(len(layers)):
print(i)
layer = layers[i].to(dev)
if args.nearest:
subset = find_layers(layer)
for name in subset:
quantizer = Quantizer()
quantizer.configure(
args.wbits, perchannel=True, sym=False, mse=False
)
W = subset[name].weight.data
quantizer.find_params(W, weight=True)
subset[name].weight.data = quantize(
W, quantizer.scale, quantizer.zero, quantizer.maxq
).to(next(iter(layer.parameters())).dtype)
for j in range(nsamples):
outs[j] = layer(inps[j].unsqueeze(0), attention_mask=attention_mask)[0]
layers[i] = layer.cpu()
del layer
torch.cuda.empty_cache()
inps, outs = outs, inps
if model.model.norm is not None:
model.model.norm = model.model.norm.to(dev)
model.lm_head = model.lm_head.to(dev)
testenc = testenc.to(dev)
nlls = []
for i in range(nsamples):
hidden_states = inps[i].unsqueeze(0)
if model.model.norm is not None:
hidden_states = model.model.norm(hidden_states)
lm_logits = model.lm_head(hidden_states)
shift_logits = lm_logits[:, :-1, :].contiguous()
shift_labels = testenc[
:, (i * model.seqlen):((i + 1) * model.seqlen)
][:, 1:]
loss_fct = nn.CrossEntropyLoss()
loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
neg_log_likelihood = loss.float() * model.seqlen
nlls.append(neg_log_likelihood)
ppl = torch.exp(torch.stack(nlls).sum() / (nsamples * model.seqlen))
print(ppl.item())
model.config.use_cache = use_cache
# TODO: perform packing on GPU
def llama_pack(model, quantizers, wbits, groupsize):
layers = find_layers(model)
layers = {n: layers[n] for n in quantizers}
make_quant(model, quantizers, wbits, groupsize)
qlayers = find_layers(model, [QuantLinear])
print('Packing ...')
for name in qlayers:
print(name)
quantizers[name],scale,zero = quantizers[name]
quantizers[name],scale,zero = quantizers[name].cpu(),scale.cpu(),zero.cpu()
qlayers[name].pack(layers[name], scale, zero)
print('Done.')
return model
def load_quant(model, checkpoint, wbits, groupsize=-1,faster_kernel=False):
from transformers import LlamaConfig, LlamaForCausalLM
config = LlamaConfig.from_pretrained(model)
def noop(*args, **kwargs):
pass
torch.nn.init.kaiming_uniform_ = noop
torch.nn.init.uniform_ = noop
torch.nn.init.normal_ = noop
torch.set_default_dtype(torch.half)
transformers.modeling_utils._init_weights = False
torch.set_default_dtype(torch.half)
model = LlamaForCausalLM(config)
torch.set_default_dtype(torch.float)
model = model.eval()
layers = find_layers(model)
for name in ['lm_head']:
if name in layers:
del layers[name]
make_quant(model, layers, wbits, groupsize, faster=faster_kernel)
del layers
print('Loading model ...')
if checkpoint.endswith('.safetensors'):
from safetensors.torch import load_file as safe_load
model.load_state_dict(safe_load(checkpoint))
else:
model.load_state_dict(torch.load(checkpoint))
model.seqlen = 2048
print('Done.')
return model
def llama_multigpu(model, gpus):
model.model.embed_tokens = model.model.embed_tokens.to(gpus[0])
if hasattr(model.model, 'norm') and model.model.norm:
model.model.norm = model.model.norm.to(gpus[-1])
import copy
model.lm_head = copy.deepcopy(model.lm_head).to(gpus[-1])
cache = {'mask': None}
class MoveModule(nn.Module):
def __init__(self, module):
super().__init__()
self.module = module
self.dev = next(iter(self.module.parameters())).device
def forward(self, *inp, **kwargs):
inp = list(inp)
if inp[0].device != self.dev:
inp[0] = inp[0].to(self.dev)
if cache['mask'] is None or cache['mask'].device != self.dev:
cache['mask'] = kwargs['attention_mask'].to(self.dev)
kwargs['attention_mask'] = cache['mask']
tmp = self.module(*inp, **kwargs)
return tmp
layers = model.model.layers
pergpu = math.ceil(len(layers) / len(gpus))
for i in range(len(layers)):
layers[i] = MoveModule(layers[i].to(gpus[i // pergpu]))
model.gpus = gpus
def benchmark(model, input_ids, check=False):
input_ids = input_ids.to(model.gpus[0] if hasattr(model, 'gpus') else DEV)
torch.cuda.synchronize()
cache = {'past': None}
def clear_past(i):
def tmp(layer, inp, out):
if cache['past']:
cache['past'][i] = None
return tmp
for i, layer in enumerate(model.model.layers):
layer.register_forward_hook(clear_past(i))
print('Benchmarking ...')
if check:
loss = nn.CrossEntropyLoss()
tot = 0.
def sync():
if hasattr(model, 'gpus'):
for gpu in model.gpus:
torch.cuda.synchronize(gpu)
else:
torch.cuda.synchronize()
max_memory = 0
with torch.no_grad():
attention_mask = torch.ones((1, input_ids.numel()), device=DEV)
times = []
for i in range(input_ids.numel()):
tick = time.time()
out = model(
input_ids[:, i:i+1],
past_key_values=cache['past'],
attention_mask=attention_mask[:, :(i + 1)].reshape((1, -1))
)
sync()
times.append(time.time() - tick)
print(i, times[-1])
max_memory = max(max_memory,torch.cuda.memory_allocated() / 1024 /1024)
if check and i != input_ids.numel() - 1:
tot += loss(out.logits[0].to(DEV), input_ids[:, (i + 1)].to(DEV)).float()
cache['past'] = list(out.past_key_values)
del out
sync()
import numpy as np
print('Median:', np.median(times))
if check:
print('PPL:', torch.exp(tot / (input_ids.numel() - 1)).item())
print('max memory(MiB):',max_memory)
if __name__ == '__main__':
import argparse
from datautils import *
parser = argparse.ArgumentParser()
parser.add_argument(
'model', type=str,
help='llama model to load'
)
parser.add_argument(
'dataset', type=str, choices=['wikitext2', 'ptb', 'c4'],
help='Where to extract calibration data from.'
)
parser.add_argument(
'--seed',
type=int, default=0, help='Seed for sampling the calibration data.'
)
parser.add_argument(
'--nsamples', type=int, default=128,
help='Number of calibration data samples.'
)
parser.add_argument(
'--percdamp', type=float, default=.01,
help='Percent of the average Hessian diagonal to use for dampening.'
)
parser.add_argument(
'--nearest', action='store_true',
help='Whether to run the RTN baseline.'
)
parser.add_argument(
'--wbits', type=int, default=16, choices=[2, 3, 4, 8, 16],
help='#bits to use for quantization; use 16 for evaluating base model.'
)
parser.add_argument(
'--trits', action='store_true',
help='Whether to use trits for quantization.'
)
parser.add_argument(
'--groupsize', type=int, default=-1,
help='Groupsize to use for quantization; default uses full row.'
)
parser.add_argument(
'--save', type=str, default='',
help='Save quantized checkpoint under this name.'
)
parser.add_argument(
'--save_safetensors', type=str, default='',
help='Save quantized `.safetensors` checkpoint under this name.'
)
parser.add_argument(
'--load', type=str, default='',
help='Load quantized model.'
)
parser.add_argument(
'--benchmark', type=int, default=0,
help='Number of tokens to use for benchmarking.'
)
parser.add_argument(
'--check', action='store_true',
help='Whether to compute perplexity during benchmarking for verification.'
)
parser.add_argument(
'--sym', action='store_true',
help='Whether to perform symmetric quantization.'
)
parser.add_argument(
'--act-order', action='store_true',
help='Whether to apply the activation order GPTQ heuristic'
)
parser.add_argument(
'--true-sequential', action='store_true',
help='Whether to run in true sequential model.'
)
parser.add_argument(
'--new-eval', action='store_true',
help='Whether to use the new PTB and C4 eval'
)
parser.add_argument(
'--faster-kernel', action='store_true',
help='Whether to use the new faster kernel for benchmarking.'
)
args = parser.parse_args()
if type(args.load) is not str:
args.load = args.load.as_posix()
if args.load:
model = load_quant(args.model, args.load, args.wbits, args.groupsize, args.faster_kernel)
else:
model = get_llama(args.model)
model.eval()
dataloader, testloader = get_loaders(
args.dataset, nsamples=args.nsamples, seed=args.seed, model=args.model, seqlen=model.seqlen
)
if not args.load and args.wbits < 16 and not args.nearest:
tick = time.time()
quantizers = llama_sequential(model, dataloader, DEV)
print(time.time() - tick)
if args.benchmark:
gpus = [torch.device('cuda:%d' % i) for i in range(torch.cuda.device_count())]
if len(gpus) > 1:
llama_multigpu(model, gpus)
else:
model = model.to(DEV)
if args.benchmark:
input_ids = next(iter(dataloader))[0][:, :args.benchmark]
benchmark(model, input_ids, check=args.check)
if args.load:
exit()
datasets = ['wikitext2']
if args.new_eval:
datasets = ['wikitext2', 'ptb-new', 'c4-new']
for dataset in datasets:
dataloader, testloader = get_loaders(
dataset, seed=args.seed, model=args.model, seqlen=model.seqlen
)
print(dataset)
llama_eval(model, testloader, DEV)
if args.save:
llama_pack(model, quantizers, args.wbits, args.groupsize)
torch.save(model.state_dict(), args.save)
if args.save_safetensors:
llama_pack(model, quantizers, args.wbits, args.groupsize)
from safetensors.torch import save_file as safe_save
safe_save(model.state_dict(), args.save_safetensors)
================================================
FILE: models/gptq/llama_inference.py
================================================
import time
import torch
import torch.nn as nn
from gptq import *
from modelutils import *
from quant import *
from transformers import AutoTokenizer
DEV = torch.device('cuda:0')
def get_llama(model):
import torch
def skip(*args, **kwargs):
pass
torch.nn.init.kaiming_uniform_ = skip
torch.nn.init.uniform_ = skip
torch.nn.init.normal_ = skip
from transformers import LlamaForCausalLM
model = LlamaForCausalLM.from_pretrained(model, torch_dtype='auto')
model.seqlen = 2048
return model
def load_quant(model, checkpoint, wbits, groupsize):
from transformers import LlamaConfig, LlamaForCausalLM
config = LlamaConfig.from_pretrained(model)
def noop(*args, **kwargs):
pass
torch.nn.init.kaiming_uniform_ = noop
torch.nn.init.uniform_ = noop
torch.nn.init.normal_ = noop
torch.set_default_dtype(torch.half)
transformers.modeling_utils._init_weights = False
torch.set_default_dtype(torch.half)
model = LlamaForCausalLM(config)
torch.set_default_dtype(torch.float)
model = model.eval()
layers = find_layers(model)
for name in ['lm_head']:
if name in layers:
del layers[name]
make_quant(model, layers, wbits, groupsize)
print('Loading model ...')
if checkpoint.endswith('.safetensors'):
from safetensors.torch import load_file as safe_load
model.load_state_dict(safe_load(checkpoint))
else:
model.load_state_dict(torch.load(checkpoint))
model.seqlen = 2048
print('Done.')
return model
if __name__ == '__main__':
import argparse
from datautils import *
parser = argparse.ArgumentParser()
parser.add_argument(
'model', type=str,
help='llama model to load'
)
parser.add_argument(
'--wbits', type=int, default=16, choices=[2, 3, 4, 8, 16],
help='#bits to use for quantization; use 16 for evaluating base model.'
)
parser.add_argument(
'--groupsize', type=int, default=-1,
help='Groupsize to use for quantization; default uses full row.'
)
parser.add_argument(
'--load', type=str, default='',
help='Load quantized model.'
)
parser.add_argument(
'--text', type=str,
help='input text'
)
parser.add_argument(
'--min_length', type=int, default=10,
help='The minimum length of the sequence to be generated.'
)
parser.add_argument(
'--max_length', type=int, default=1024,
help='The maximum length of the sequence to be generated.'
)
parser.add_argument(
'--top_p', type=float , default=0.95,
help='If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation.'
)
parser.add_argument(
'--temperature', type=float, default=0.8,
help='The value used to module the next token probabilities.'
)
args = parser.parse_args()
if type(args.load) is not str:
args.load = args.load.as_posix()
if args.load:
model = load_quant(args.model, args.load, args.wbits, args.groupsize)
else:
model = get_llama(args.model)
model.eval()
model.to(DEV)
tokenizer = AutoTokenizer.from_pretrained(args.model)
print("Human:")
line = input()
while line:
inputs = 'Human: ' + line.strip() + '\n\nAssistant:'
input_ids = tokenizer.encode(inputs, return_tensors="pt").to(DEV)
with torch.no_grad():
generated_ids = model.generate(
input_ids,
do_sample=True,
min_length=args.min_length,
max_length=args.max_length,
top_p=args.top_p,
temperature=args.temperature,
)
print("Assistant:\n")
print(tokenizer.decode([el.item() for el in generated_ids[0]])[len(inputs)+4:]) # generated_ids开头加上了bos_token,需要将inpu的内容截断,只输出Assistant
print("\n-------------------------------\n")
print("Human:") #每次终端用户输入前，加上Human提示。
line = input()
================================================
FILE: models/gptq/llama_inference_offload.py
================================================
import time
import torch
import torch.nn as nn
from gptq import *
from modelutils import *
from quant import *
from transformers import AutoTokenizer
DEV = torch.device('cuda:0')
import copy
from transformers.models.llama.modeling_llama import LlamaModel,LlamaConfig
from transformers.modeling_outputs import BaseModelOutputWithPast
from typing import List, Optional, Tuple, Union
import time
class Offload_LlamaModel(LlamaModel):
def __init__(self, config: LlamaConfig):
super().__init__(config)
def forward(
self,
input_ids: torch.LongTensor = None,
attention_mask: Optional[torch.Tensor] = None,
past_key_values: Optional[List[torch.FloatTensor]] = None,
inputs_embeds: Optional[torch.FloatTensor] = None,
use_cache: Optional[bool] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[Tuple, BaseModelOutputWithPast]:
r"""
Args:
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you
provide it.
Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
[`PreTrainedTokenizer.__call__`] for details.
[What are input IDs?](../glossary#input-ids)
attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
- 1 for tokens that are **not masked**,
- 0 for tokens that are **masked**.
[What are attention masks?](../glossary#attention-mask)
past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of
shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of
Contains pre-computed hidden-states (key and values in the self-attention blocks and in the
cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those
that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of
all `decoder_input_ids` of shape `(batch_size, sequence_length)`.
use_cache (`bool`, *optional*):
If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
(see `past_key_values`).
inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation.
This is useful if you want more control over how to convert `input_ids` indices into associated vectors
than the model's internal embedding lookup matrix.
output_attentions (`bool`, *optional*):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under
returned tensors for more detail.
output_hidden_states (`bool`, *optional*):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
for more detail.
return_dict (`bool`, *optional*):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""
output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
)
use_cache = use_cache if use_cache is not None else self.config.use_cache
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
# retrieve input_ids and inputs_embeds
if input_ids is not None and inputs_embeds is not None:
raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time")
elif input_ids is not None:
batch_size, seq_length = input_ids.shape
elif inputs_embeds is not None:
batch_size, seq_length, _ = inputs_embeds.shape
else:
raise ValueError("You have to specify either decoder_input_ids or decoder_inputs_embeds")
seq_length_with_past = seq_length
past_key_values_length = 0
if past_key_values is not None:
past_key_values_length = past_key_values[0][0].shape[2]
seq_length_with_past = seq_length_with_past + past_key_values_length
if inputs_embeds is None:
inputs_embeds = self.embed_tokens(input_ids)
# embed positions
if attention_mask is None:
torch.ones((batch_size, seq_length_with_past), dtype=torch.bool, device=inputs_embeds.device )
attention_mask = self._prepare_decoder_attention_mask(
attention_mask, (batch_size, seq_length), inputs_embeds, past_key_values_length
)
hidden_states = inputs_embeds
if self.gradient_checkpointing and self.training:
if use_cache:
logger.warning_once(
"`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
)
use_cache = False
# decoder layers
all_hidden_states = () if output_hidden_states else None
all_self_attns = () if output_attentions else None
next_decoder_cache = () if use_cache else None
for idx in range(len(self.layers)):
if idx <= (self.preload - 1):
decoder_layer = self.layers[idx]
else:
decoder_layer = self.layers[idx].to(DEV)
if output_hidden_states:
all_hidden_states += (hidden_states,)
past_key_value = past_key_values[idx] if past_key_values is not None else None
if self.gradient_checkpointing and self.training:
def create_custom_forward(module):
def custom_forward(*inputs):
# None for past_key_value
return module(*inputs, output_attentions, None)
return custom_forward
layer_outputs = torch.utils.checkpoint.checkpoint(
create_custom_forward(decoder_layer),
hidden_states,
attention_mask,
None,
)
else:
layer_outputs = decoder_layer(
hidden_states,
attention_mask=attention_mask,
past_key_value=past_key_value,
output_attentions=output_attentions,
use_cache=use_cache,
)
hidden_states = layer_outputs[0]
if idx > (self.preload - 1):
self.layers[idx] = decoder_layer.cpu()
del decoder_layer
torch.cuda.empty_cache()
if use_cache:
next_decoder_cache += (layer_outputs[2 if output_attentions else 1],)
if output_attentions:
all_self_attns += (layer_outputs[1],)
hidden_states = self.norm(hidden_states)
# add hidden states from the last decoder layer
if output_hidden_states:
all_hidden_states += (hidden_states,)
next_cache = next_decoder_cache if use_cache else None
if not return_dict:
return tuple(v for v in [hidden_states, next_cache, all_hidden_states, all_self_attns] if v is not None)
return BaseModelOutputWithPast(
last_hidden_state=hidden_states,
past_key_values=next_cache,
hidden_states=all_hidden_states,
attentions=all_self_attns,
)
def load_quant(model, checkpoint, wbits, groupsize, pre_layer):
transformers.models.llama.modeling_llama.LlamaModel = Offload_LlamaModel
from transformers import LlamaConfig, LlamaForCausalLM
config = LlamaConfig.from_pretrained(model)
def noop(*args, **kwargs):
pass
torch.nn.init.kaiming_uniform_ = noop
torch.nn.init.uniform_ = noop
torch.nn.init.normal_ = noop
torch.set_default_dtype(torch.half)
transformers.modeling_utils._init_weights = False
torch.set_default_dtype(torch.half)
model = LlamaForCausalLM(config)
torch.set_default_dtype(torch.float)
model = model.eval()
layers = find_layers(model)
for name in ['lm_head']:
if name in layers:
del layers[name]
make_quant(model, layers, wbits, groupsize)
print('Loading model ...')
if checkpoint.endswith('.safetensors'):
from safetensors.torch import load_file as safe_load
model.load_state_dict(safe_load(checkpoint))
else:
model.load_state_dict(torch.load(checkpoint))
model.seqlen = 2048
for i in range(pre_layer):
model.model.layers[i].to(DEV)
model.model.embed_tokens.to(DEV)
model.model.norm.to(DEV)
model.lm_head.to(DEV)
model.model.preload = pre_layer
print('Done.')
return model
if __name__ == '__main__':
import argparse
from datautils import *
parser = argparse.ArgumentParser()
parser.add_argument(
'model', type=str,
help='llama model to load'
)
parser.add_argument(
'--wbits', type=int, default=4, choices=[2, 3, 4, 8],
help='#bits to use for quantization'
)
parser.add_argument(
'--groupsize', type=int, default=-1,
help='Groupsize to use for quantization; default uses full row.'
)
parser.add_argument(
'--load', type=str, default='',
help='Load quantized model.'
)
parser.add_argument(
'--text', type=str,
help='input text'
)
parser.add_argument(
'--min_length', type=int, default=10,
help='The minimum length of the sequence to be generated.'
)
parser.add_argument(
'--max_length', type=int, default=50,
help='The maximum length of the sequence to be generated.'
)
parser.add_argument(
'--top_p', type=float , default=0.95,
help='If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation.'
)
parser.add_argument(
'--temperature', type=float, default=0.8,
help='The value used to module the next token probabilities.'
)
parser.add_argument(
'--pre_layer', type=int, default=50,
help='The number of layers to preload'
)
args = parser.parse_args()
if type(args.load) is not str:
args.load = args.load.as_posix()
model = load_quant(args.model, args.load, args.wbits, args.groupsize, args.pre_layer)
tokenizer = AutoTokenizer.from_pretrained(args.model)
input_ids = tokenizer.encode(args.text, return_tensors="pt").to(DEV)
with torch.no_grad():
generated_ids = model.generate(
input_ids,
do_sample=True,
min_length=args.min_length,
max_length=args.max_length,
top_p=args.top_p,
temperature=args.temperature,
)
print(tokenizer.decode([el.item() for el in generated_ids[0]]))
================================================
FILE: models/gptq/modelutils.py
================================================
import torch
import torch.nn as nn
DEV = torch.device('cuda:0')
def find_layers(module, layers=[nn.Conv2d, nn.Linear], name=''):
if type(module) in layers:
return {name: module}
res = {}
for name1, child in module.named_children():
res.update(find_layers(
child, layers=layers, name=name + '.' + name1 if name != '' else name1
))
return res
================================================
FILE: models/gptq/quant.py
================================================
import numpy as np
import torch
import torch.nn as nn
import math
def quantize(x, scale, zero, maxq):
q = torch.clamp(torch.round(x / scale) + zero, 0, maxq)
return scale * (q - zero)
class Quantizer(nn.Module):
def __init__(self, shape=1):
super(Quantizer, self).__init__()
self.register_buffer('maxq', torch.tensor(0))
self.register_buffer('scale', torch.zeros(shape))
self.register_buffer('zero', torch.zeros(shape))
def configure(
self,
bits, perchannel=False, sym=True,
mse=False, norm=2.4, grid=100, maxshrink=.8
):
self.maxq = torch.tensor(2 ** bits - 1)
self.perchannel = perchannel
self.sym = sym
self.mse = mse
self.norm = norm
self.grid = grid
self.maxshrink = maxshrink
def find_params(self, x, weight=False):
dev = x.device
self.maxq = self.maxq.to(dev)
shape = x.shape
if self.perchannel:
if weight:
x = x.flatten(1)
else:
if len(shape) == 4:
x = x.permute([1, 0, 2, 3])
x = x.flatten(1)
if len(shape) == 3:
x = x.reshape((-1, shape[-1])).t()
if len(shape) == 2:
x = x.t()
else:
x = x.flatten().unsqueeze(0)
tmp = torch.zeros(x.shape[0], device=dev)
xmin = torch.minimum(x.min(1)[0], tmp)
xmax = torch.maximum(x.max(1)[0], tmp)
if self.sym:
xmax = torch.maximum(torch.abs(xmin), xmax)
tmp = xmin < 0
if torch.any(tmp):
xmin[tmp] = -xmax[tmp]
tmp = (xmin == 0) & (xmax == 0)
xmin[tmp] = -1
xmax[tmp] = +1
self.scale = (xmax - xmin) / self.maxq
if self.sym:
self.zero = torch.full_like(self.scale, (self.maxq + 1) / 2)
else:
self.zero = torch.round(-xmin / self.scale)
if self.mse:
best = torch.full([x.shape[0]], float('inf'), device=dev)
for i in range(int(self.maxshrink * self.grid)):
p = 1 - i / self.grid
xmin1 = p * xmin
xmax1 = p * xmax
scale1 = (xmax1 - xmin1) / self.maxq
zero1 = torch.round(-xmin1 / scale1) if not self.sym else self.zero
q = quantize(x, scale1.unsqueeze(1), zero1.unsqueeze(1), self.maxq)
q -= x
q.abs_()
q.pow_(self.norm)
err = torch.sum(q, 1)
tmp = err < best
if torch.any(tmp):
best[tmp] = err[tmp]
self.scale[tmp] = scale1[tmp]
self.zero[tmp] = zero1[tmp]
if not self.perchannel:
if weight:
tmp = shape[0]
else:
tmp = shape[1] if len(shape) != 3 else shape[2]
self.scale = self.scale.repeat(tmp)
self.zero = self.zero.repeat(tmp)
if weight:
shape = [-1] + [1] * (len(shape) - 1)
self.scale = self.scale.reshape(shape)
self.zero = self.zero.reshape(shape)
return
if len(shape) == 4:
self.scale = self.scale.reshape((1, -1, 1, 1))
self.zero = self.zero.reshape((1, -1, 1, 1))
if len(shape) == 3:
self.scale = self.scale.reshape((1, 1, -1))
self.zero = self.zero.reshape((1, 1, -1))
if len(shape) == 2:
self.scale = self.scale.unsqueeze(0)
self.zero = self.zero.unsqueeze(0)
def quantize(self, x):
if self.ready():
return quantize(x, self.scale, self.zero, self.maxq)
return x
def enabled(self):
return self.maxq > 0
def ready(self):
return torch.all(self.scale != 0)
try:
import quant_cuda
except:
print('CUDA extension not installed.')
# Assumes layer is perfectly divisible into 256 * 256 blocks
class QuantLinear(nn.Module):
def __init__(self, bits, groupsize, infeatures, outfeatures):
super().__init__()
if bits not in [2,3,4,8]:
raise NotImplementedError("Only 2,3,4,8 bits are supported.")
self.infeatures = infeatures
self.outfeatures = outfeatures
self.bits = bits
if groupsize != -1 and groupsize < 32 and groupsize != int(math.pow(2,int(math.log2(groupsize)))):
raise NotImplementedError("groupsize supports powers of 2 greater than 32. (e.g. : 32,64,128,etc)")
groupsize = groupsize if groupsize != -1 else infeatures
self.groupsize = groupsize
self.register_buffer('qzeros', torch.zeros((math.ceil(infeatures/groupsize),outfeatures // 256 * (bits * 8)), dtype=torch.int))
self.register_buffer('scales', torch.zeros((math.ceil(infeatures/groupsize),outfeatures)))
self.register_buffer('bias', torch.zeros(outfeatures))
self.register_buffer(
'qweight', torch.zeros((infeatures // 256 * (bits * 8), outfeatures), dtype=torch.int)
)
self._initialized_quant_state = False
def pack(self, linear, scales, zeros):
scales = scales.t().contiguous()
zeros = zeros.t().contiguous()
scale_zeros = zeros * scales
self.scales = scales.clone()
if linear.bias is not None:
self.bias = linear.bias.clone()
intweight = []
for idx in range(self.infeatures):
g_idx = idx // self.groupsize
intweight.append(torch.round((linear.weight.data[:,idx] + scale_zeros[g_idx]) / self.scales[g_idx]).to(torch.int)[:,None])
intweight = torch.cat(intweight,dim=1)
intweight = intweight.t().contiguous()
intweight = intweight.numpy().astype(np.uint32)
qweight = np.zeros(
(intweight.shape[0] // 256 * (self.bits * 8), intweight.shape[1]), dtype=np.uint32
)
i = 0
row = 0
while row < qweight.shape[0]:
if self.bits in [2,4,8]:
for j in range(i, i + (32//self.bits)):
qweight[row] |= intweight[j] << (self.bits * (j - i))
i += 32//self.bits
row += 1
elif self.bits == 3:
for j in range(i, i + 10):
qweight[row] |= intweight[j] << (3 * (j - i))
i += 10
qweight[row] |= intweight[i] << 30
row += 1
qweight[row] |= (intweight[i] >> 2) & 1
i += 1
for j in range(i, i + 10):
qweight[row] |= intweight[j] << (3 * (j - i) + 1)
i += 10
qweight[row] |= intweight[i] << 31
row += 1
qweight[row] |= (intweight[i] >> 1) & 0x3
i += 1
for j in range(i, i + 10):
qweight[row] |= intweight[j] << (3 * (j - i) + 2)
i += 10
row += 1
else:
raise NotImplementedError("Only 2,3,4,8 bits are supported.")
qweight = qweight.astype(np.int32)
self.qweight = torch.from_numpy(qweight)
zeros -= 1;
zeros = zeros.numpy().astype(np.uint32)
qzeros = np.zeros((zeros.shape[0], zeros.shape[1] // 256 * (self.bits * 8)), dtype=np.uint32)
i = 0
col = 0
while col < qzeros.shape[1]:
if self.bits in [2,4,8]:
for j in range(i, i + (32//self.bits)):
qzeros[:, col] |= zeros[:, j] << (self.bits * (j - i))
i += 32//self.bits
col += 1
elif self.bits == 3:
for j in range(i, i + 10):
qzeros[:, col] |= zeros[:, j] << (3 * (j - i))
i += 10
qzeros[:, col] |= zeros[:, i] << 30
col += 1
qzeros[:, col] |= (zeros[:, i] >> 2) & 1
i += 1
for j in range(i, i + 10):
qzeros[:, col] |= zeros[:, j] << (3 * (j - i) + 1)
i += 10
qzeros[:, col] |= zeros[:, i] << 31
col += 1
qzeros[:, col] |= (zeros[:, i] >> 1) & 0x3
i += 1
for j in range(i, i + 10):
qzeros[:, col] |= zeros[:, j] << (3 * (j - i) + 2)
i += 10
col += 1
else:
raise NotImplementedError("Only 2,3,4,8 bits are supported.")
qzeros = qzeros.astype(np.int32)
self.qzeros = torch.from_numpy(qzeros)
def forward(self, x):
intermediate_dtype = torch.float32
if not self._initialized_quant_state:
# Do we even have a bias? Check for at least one non-zero element.
if self.bias is not None and bool(torch.any(self.bias != 0)):
# Then make sure it's the right type.
self.bias.data = self.bias.data.to(intermediate_dtype)
else:
self.bias = None
outshape = list(x.shape)
outshape[-1] = self.outfeatures
x = x.reshape(-1, x.shape[-1])
if self.bias is None:
y = torch.zeros(x.shape[0], outshape[-1], dtype=intermediate_dtype, device=x.device)
else:
y = self.bias.clone().repeat(x.shape[0], 1)
output_dtype = x.dtype
x = x.to(intermediate_dtype)
if self.bits == 2:
quant_cuda.vecquant2matmul(x, self.qweight, y, self.scales, self.qzeros, self.groupsize)
elif self.bits == 3:
quant_cuda.vecquant3matmul(x, self.qweight, y, self.scales, self.qzeros, self.groupsize)
elif self.bits == 4:
quant_cuda.vecquant4matmul(x, self.qweight, y, self.scales, self.qzeros, self.groupsize)
elif self.bits == 8:
quant_cuda.vecquant8matmul(x, self.qweight, y, self.scales, self.qzeros, self.groupsize)
else:
raise NotImplementedError("Only 2,3,4,8 bits are supported.")
y = y.to(output_dtype)
return y.reshape(outshape)
def make_quant(module, names, bits, groupsize, name=''):
if isinstance(module, QuantLinear):
return
for attr in dir(module):
tmp = getattr(module, attr)
name1 = name + '.' + attr if name != '' else attr
if name1 in names:
setattr(
module, attr, QuantLinear(bits, groupsize, tmp.in_features, tmp.out_features)
)
for name1, child in module.named_children():
make_quant(child, names, bits, groupsize, name + '.' + name1 if name != '' else name1)
================================================
FILE: models/gptq/quant_cuda.cpp
================================================
#include
#include
#include
void vecquant2matmul_cuda(
torch::Tensor vec, torch::Tensor mat, torch::Tensor mul,
torch::Tensor scales, torch::Tensor zeros,
int groupsize
);
void vecquant2matmul(
torch::Tensor vec, torch::Tensor mat, torch::Tensor mul,
torch::Tensor scales, torch::Tensor zeros,
int groupsize
) {
const at::cuda::OptionalCUDAGuard device_guard(device_of(vec));
vecquant2matmul_cuda(vec, mat, mul, scales, zeros,groupsize);
}
void vecquant3matmul_cuda(
torch::Tensor vec, torch::Tensor mat, torch::Tensor mul,
torch::Tensor scales, torch::Tensor zeros,
int groupsize
);
void vecquant3matmul(
torch::Tensor vec, torch::Tensor mat, torch::Tensor mul,
torch::Tensor scales, torch::Tensor zeros,
int groupsize
) {
const at::cuda::OptionalCUDAGuard device_guard(device_of(vec));
vecquant3matmul_cuda(vec, mat, mul, scales, zeros, groupsize);
}
void vecquant4matmul_cuda(
torch::Tensor vec, torch::Tensor mat, torch::Tensor mul,
torch::Tensor scales, torch::Tensor zeros,
int groupsize
);
void vecquant4matmul(
torch::Tensor vec, torch::Tensor mat, torch::Tensor mul,
torch::Tensor scales, torch::Tensor zeros,
int groupsize
) {
const at::cuda::OptionalCUDAGuard device_guard(device_of(vec));
vecquant4matmul_cuda(vec, mat, mul, scales, zeros, groupsize);
}
void vecquant8matmul_cuda(
torch::Tensor vec, torch::Tensor mat, torch::Tensor mul,
torch::Tensor scales, torch::Tensor zeros,
int groupsize
);
void vecquant8matmul(
torch::Tensor vec, torch::Tensor mat, torch::Tensor mul,
torch::Tensor scales, torch::Tensor zeros,
int groupsize
) {
const at::cuda::OptionalCUDAGuard device_guard(device_of(vec));
vecquant8matmul_cuda(vec, mat, mul, scales, zeros, groupsize);
}
PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
m.def("vecquant2matmul", &vecquant2matmul, "Vector 2-bit Quantized Matrix Multiplication (CUDA)");
m.def("vecquant3matmul", &vecquant3matmul, "Vector 3-bit Quantized Matrix Multiplication (CUDA)");
m.def("vecquant4matmul", &vecquant4matmul, "Vector 4-bit Quantized Matrix Multiplication (CUDA)");
m.def("vecquant8matmul", &vecquant8matmul, "Vector 8-bit Quantized Matrix Multiplication (CUDA)");
}
================================================
FILE: models/gptq/quant_cuda_kernel.cu
================================================
#include
#include
#include
#include
// atomicAdd for double-precision floating-point numbers on hardware with
// compute capability < 6.0 from:
// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#atomic-functions
#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ < 600
__device__ double atomicAdd(
double* address,
double val
) {
unsigned long long int* address_as_ull = (unsigned long long int*)address;
unsigned long long int old = *address_as_ull, assumed;
do {
assumed = old;
old = atomicCAS(
address_as_ull,
assumed,
__double_as_longlong(val + __longlong_as_double(assumed))
);
// Note: uses integer comparison to avoid hang in case of NaN (since NaN != NaN)
} while (assumed != old);
return __longlong_as_double(old);
}
#endif
template
__global__ void VecQuant2MatMulKernel(
const scalar_t* __restrict__ vec,
const int* __restrict__ mat,
scalar_t* __restrict__ mul,
const scalar_t* __restrict__ scales,
const int* __restrict__ zeros,
int batch,
int vec_height,
int height,
int width,
int zero_width,
int groupsize
);
template
__global__ void VecQuant3MatMulKernel(
const scalar_t* __restrict__ vec,
const int* __restrict__ mat,
scalar_t* __restrict__ mul,
const scalar_t* __restrict__ scales,
const int* __restrict__ zeros,
int batch,
int vec_height,
int height,
int width,
int zero_width,
int groupsize
);
template
__global__ void VecQuant4MatMulKernel(
const scalar_t* __restrict__ vec,
const int* __restrict__ mat,
scalar_t* __restrict__ mul,
const scalar_t* __restrict__ scales,
const int* __restrict__ zeros,
int batch,
int vec_height,
int height,
int width,
int zero_width,
int groupsize
);
template
__global__ void VecQuant8MatMulKernel(
const scalar_t* __restrict__ vec,
const int* __restrict__ mat,
scalar_t* __restrict__ mul,
const scalar_t* __restrict__ scales,
const int* __restrict__ zeros,
int batch,
int vec_height,
int height,
int width,
int zero_width,
int groupsize
);
const int BLOCKWIDTH = 256;
const int BLOCKHEIGHT2 = 16;
const int BLOCKHEIGHT3 = 24;
const int BLOCKHEIGHT4 = 32;
const int BLOCKHEIGHT8 = 64;
__device__ inline unsigned int as_unsigned(int i) {
return *reinterpret_cast(&i);
}
void vecquant2matmul_cuda(
torch::Tensor vec,
torch::Tensor mat,
torch::Tensor mul,
torch::Tensor scales,
torch::Tensor zeros,
int groupsize
) {
int batch = vec.size(0);
int vec_height = vec.size(1);
int height = mat.size(0);
int width = mat.size(1);
int zero_width = zeros.size(1);
dim3 blocks(
(height + BLOCKHEIGHT2 - 1) / BLOCKHEIGHT2,
(width + BLOCKWIDTH - 1) / BLOCKWIDTH,
batch
);
dim3 threads(BLOCKWIDTH);
AT_DISPATCH_FLOATING_TYPES(
vec.type(), "vecquant2matmul_cuda", ([&] {
VecQuant2MatMulKernel<<>>(
vec.data(), mat.data(), mul.data(),
scales.data(), zeros.data(),
batch, vec_height, height, width, zero_width, groupsize
);
})
);
}
template
__global__ void VecQuant2MatMulKernel(
const scalar_t* __restrict__ vec,
const int* __restrict__ mat,
scalar_t* __restrict__ mul,
const scalar_t* __restrict__ scales,
const int* __restrict__ zeros,
int batch,
int vec_height,
int height,
int width,
int zero_width,
int groupsize
) {
int b = blockIdx.z;
int h = BLOCKHEIGHT2 * blockIdx.x;
int w = BLOCKWIDTH * blockIdx.y + threadIdx.x;
__shared__ scalar_t blockvec[BLOCKWIDTH];
blockvec[threadIdx.x] = vec[b * vec_height + blockIdx.x * BLOCKWIDTH + threadIdx.x];
__syncthreads();
scalar_t res = 0;
int i = width * h + w;
int g_h = h * 16;
int k = 0;
int z_w = w / 16;
int z_mod = (w % 16) * 2;
unsigned int tmp;
while (k < BLOCKWIDTH) {
tmp = as_unsigned(mat[i]);
int g = (g_h + k) / groupsize;
scalar_t scale = scales[g * width + w];
scalar_t zero = scale * scalar_t((as_unsigned(zeros[g * zero_width + z_w]) >> z_mod & 0x3) + 1);
res += (scale * scalar_t((tmp >> 0) & 0x3) - zero) * blockvec[k + 0];
res += (scale * scalar_t((tmp >> 2) & 0x3) - zero) * blockvec[k + 1];
res += (scale * scalar_t((tmp >> 4) & 0x3) - zero) * blockvec[k + 2];
res += (scale * scalar_t((tmp >> 6) & 0x3) - zero) * blockvec[k + 3];
res += (scale * scalar_t((tmp >> 8) & 0x3) - zero) * blockvec[k + 4];
res += (scale * scalar_t((tmp >> 10) & 0x3) - zero) * blockvec[k + 5];
res += (scale * scalar_t((tmp >> 12) & 0x3) - zero) * blockvec[k + 6];
res += (scale * scalar_t((tmp >> 14) & 0x3) - zero) * blockvec[k + 7];
res += (scale * scalar_t((tmp >> 16) & 0x3) - zero) * blockvec[k + 8];
res += (scale * scalar_t((tmp >> 18) & 0x3) - zero) * blockvec[k + 9];
res += (scale * scalar_t((tmp >> 20) & 0x3) - zero) * blockvec[k + 10];
res += (scale * scalar_t((tmp >> 22) & 0x3) - zero) * blockvec[k + 11];
res += (scale * scalar_t((tmp >> 24) & 0x3) - zero) * blockvec[k + 12];
res += (scale * scalar_t((tmp >> 26) & 0x3) - zero) * blockvec[k + 13];
res += (scale * scalar_t((tmp >> 28) & 0x3) - zero) * blockvec[k + 14];
res += (scale * scalar_t((tmp >> 30) & 0x3) - zero) * blockvec[k + 15];
i += width;
k += 16;
}
atomicAdd(&mul[b * width + w], res);
}
void vecquant3matmul_cuda(
torch::Tensor vec,
torch::Tensor mat,
torch::Tensor mul,
torch::Tensor scales,
torch::Tensor zeros,
int groupsize
) {
int batch = vec.size(0);
int vec_height = vec.size(1);
int height = mat.size(0);
int width = mat.size(1);
int zero_width = zeros.size(1);
dim3 blocks(
(height + BLOCKHEIGHT3 - 1) / BLOCKHEIGHT3,
(width + BLOCKWIDTH - 1) / BLOCKWIDTH,
batch
);
dim3 threads(BLOCKWIDTH);
AT_DISPATCH_FLOATING_TYPES(
vec.type(), "vecquant3matmul_cuda", ([&] {
VecQuant3MatMulKernel<<>>(
vec.data(), mat.data(), mul.data(),
scales.data(), zeros.data(),
batch, vec_height, height, width, zero_width, groupsize
);
})
);
}
template
__global__ void VecQuant3MatMulKernel(
const scalar_t* __restrict__ vec,
const int* __restrict__ mat,
scalar_t* __restrict__ mul,
const scalar_t* __restrict__ scales,
const int* __restrict__ zeros,
int batch,
int vec_height,
int height,
int width,
int zero_width,
int groupsize
) {
int b = blockIdx.z;
int h = BLOCKHEIGHT3 * blockIdx.x;
int w = BLOCKWIDTH * blockIdx.y + threadIdx.x;
__shared__ scalar_t blockvec[BLOCKWIDTH];
blockvec[threadIdx.x] = vec[b * vec_height + blockIdx.x * BLOCKWIDTH + threadIdx.x];
__syncthreads();
scalar_t res = 0;
int i = width * h + w;
int g_h = (h / 3) * 32;
int k = 0;
int z_w = (w / 32) * 3; // ((w / 256) * 24) / 3
int z_mod = w % 32;
int z_bit;
if (z_mod != 10){
if (z_mod != 21){
z_bit = z_mod;
if (z_bit > 21){
z_bit -= 22;
z_bit *= 3;
z_bit += 2;
z_w += 2;
} else if (z_bit > 10){
z_bit -= 11;
z_bit *= 3;
z_bit += 1;
z_w += 1;
} else {
z_bit *= 3;
}
} else {
z_w += 1;
}
}
unsigned int tmp1;
unsigned int tmp2;
unsigned int tmp;
unsigned int z_tmp;
while (k < BLOCKWIDTH) {
tmp1 = as_unsigned(mat[i]);
int g = (g_h + k) / groupsize;
scalar_t scale = scales[g * width + w];
scalar_t zero;
if (z_mod == 10) {
z_tmp = (as_unsigned(zeros[g * zero_width + z_w]) >> 30) | ((as_unsigned(zeros[g * zero_width + (z_w + 1)]) << 2) & 0x4);
zero = scale * scalar_t((z_tmp) + 1);
} else if (z_mod == 21){
z_tmp = (as_unsigned(zeros[g * zero_width + z_w]) >> 31) | ((as_unsigned(zeros[g * zero_width + (z_w + 1)]) << 1) & 0x6);
zero = scale * scalar_t((z_tmp) + 1);
} else {
zero = scale * scalar_t(((as_unsigned(zeros[g * zero_width + z_w]) >> z_bit) & 0x7) + 1);
}
res += (scale * scalar_t((tmp1 >> 0) & 0x7) - zero) * blockvec[k + 0];
res += (scale * scalar_t((tmp1 >> 3) & 0x7) - zero) * blockvec[k + 1];
res += (scale * scalar_t((tmp1 >> 6) & 0x7) - zero) * blockvec[k + 2];
res += (scale * scalar_t((tmp1 >> 9) & 0x7) - zero) * blockvec[k + 3];
res += (scale * scalar_t((tmp1 >> 12) & 0x7) - zero) * blockvec[k + 4];
res += (scale * scalar_t((tmp1 >> 15) & 0x7) - zero) * blockvec[k + 5];
res += (scale * scalar_t((tmp1 >> 18) & 0x7) - zero) * blockvec[k + 6];
res += (scale * scalar_t((tmp1 >> 21) & 0x7) - zero) * blockvec[k + 7];
res += (scale * scalar_t((tmp1 >> 24) & 0x7) - zero) * blockvec[k + 8];
res += (scale * scalar_t((tmp1 >> 27) & 0x7) - zero) * blockvec[k + 9];
i += width;
tmp2 = as_unsigned(mat[i]);
tmp = (tmp1 >> 30) | ((tmp2 << 2) & 0x4);
tmp2 >>= 1;
res += (scale * scalar_t(tmp) - zero) * blockvec[k + 10];
k += 11;
res += (scale * scalar_t((tmp2 >> 0) & 0x7) - zero) * blockvec[k + 0];
res += (scale * scalar_t((tmp2 >> 3) & 0x7) - zero) * blockvec[k + 1];
res += (scale * scalar_t((tmp2 >> 6) & 0x7) - zero) * blockvec[k + 2];
res += (scale * scalar_t((tmp2 >> 9) & 0x7) - zero) * blockvec[k + 3];
res += (scale * scalar_t((tmp2 >> 12) & 0x7) - zero) * blockvec[k + 4];
res += (scale * scalar_t((tmp2 >> 15) & 0x7) - zero) * blockvec[k + 5];
res += (scale * scalar_t((tmp2 >> 18) & 0x7) - zero) * blockvec[k + 6];
res += (scale * scalar_t((tmp2 >> 21) & 0x7) - zero) * blockvec[k + 7];
res += (scale * scalar_t((tmp2 >> 24) & 0x7) - zero) * blockvec[k + 8];
res += (scale * scalar_t((tmp2 >> 27) & 0x7) - zero) * blockvec[k + 9];
i += width;
tmp1 = as_unsigned(mat[i]);
tmp = (tmp2 >> 30) | ((tmp1 << 1) & 0x6);
tmp1 >>= 2;
res += (scale * scalar_t(tmp) - zero) * blockvec[k + 10];
k += 11;
res += (scale * scalar_t((tmp1 >> 0) & 0x7) - zero) * blockvec[k + 0];
res += (scale * scalar_t((tmp1 >> 3) & 0x7) - zero) * blockvec[k + 1];
res += (scale * scalar_t((tmp1 >> 6) & 0x7) - zero) * blockvec[k + 2];
res += (scale * scalar_t((tmp1 >> 9) & 0x7) - zero) * blockvec[k + 3];
res += (scale * scalar_t((tmp1 >> 12) & 0x7) - zero) * blockvec[k + 4];
res += (scale * scalar_t((tmp1 >> 15) & 0x7) - zero) * blockvec[k + 5];
res += (scale * scalar_t((tmp1 >> 18) & 0x7) - zero) * blockvec[k + 6];
res += (scale * scalar_t((tmp1 >> 21) & 0x7) - zero) * blockvec[k + 7];
res += (scale * scalar_t((tmp1 >> 24) & 0x7) - zero) * blockvec[k + 8];
res += (scale * scalar_t((tmp1 >> 27) & 0x7) - zero) * blockvec[k + 9];
i += width;
k += 10;
}
atomicAdd(&mul[b * width + w], res);
}
void vecquant4matmul_cuda(
torch::Tensor vec,
torch::Tensor mat,
torch::Tensor mul,
torch::Tensor scales,
torch::Tensor zeros,
int groupsize
) {
int batch = vec.size(0);
int vec_height = vec.size(1);
int height = mat.size(0);
int width = mat.size(1);
int zero_width = zeros.size(1);
dim3 blocks(
(height + BLOCKHEIGHT4 - 1) / BLOCKHEIGHT4,
(width + BLOCKWIDTH - 1) / BLOCKWIDTH,
batch
);
dim3 threads(BLOCKWIDTH);
AT_DISPATCH_FLOATING_TYPES(
vec.type(), "vecquant4matmul_cuda", ([&] {
VecQuant4MatMulKernel<<>>(
vec.data(), mat.data(), mul.data(),
scales.data(), zeros.data(),
batch, vec_height, height, width, zero_width, groupsize
);
})
);
}
template
__global__ void VecQuant4MatMulKernel(
const scalar_t* __restrict__ vec,
const int* __restrict__ mat,
scalar_t* __restrict__ mul,
const scalar_t* __restrict__ scales,
const int* __restrict__ zeros,
int batch,
int vec_height,
int height,
int width,
int zero_width,
int groupsize
) {
int b = blockIdx.z;
int h = BLOCKHEIGHT4 * blockIdx.x;
int w = BLOCKWIDTH * blockIdx.y + threadIdx.x;
__shared__ scalar_t blockvec[BLOCKWIDTH];
blockvec[threadIdx.x] = vec[b * vec_height + blockIdx.x * BLOCKWIDTH + threadIdx.x];
__syncthreads();
scalar_t res = 0;
int i = width * h + w;
int g_h = h * 8;
int k = 0;
int z_w = w / 8;
int z_mod = (w % 8) * 4;
unsigned int tmp;
while (k < BLOCKWIDTH) {
tmp = as_unsigned(mat[i]);
int g = (g_h + k) / groupsize;
scalar_t scale = scales[g * width + w];
scalar_t zero = scale * scalar_t(((as_unsigned(zeros[g * zero_width + z_w]) >> z_mod) & 0xF) + 1);
res += (scale * scalar_t((tmp >> 0) & 0xF) - zero) * blockvec[k + 0];
res += (scale * scalar_t((tmp >> 4) & 0xF) - zero) * blockvec[k + 1];
res += (scale * scalar_t((tmp >> 8) & 0xF) - zero) * blockvec[k + 2];
res += (scale * scalar_t((tmp >> 12) & 0xF) - zero) * blockvec[k + 3];
res += (scale * scalar_t((tmp >> 16) & 0xF) - zero) * blockvec[k + 4];
res += (scale * scalar_t((tmp >> 20) & 0xF) - zero) * blockvec[k + 5];
res += (scale * scalar_t((tmp >> 24) & 0xF) - zero) * blockvec[k + 6];
res += (scale * scalar_t((tmp >> 28) & 0xF) - zero) * blockvec[k + 7];
i += width;
k += 8;
}
atomicAdd(&mul[b * width + w], res);
}
void vecquant8matmul_cuda(
torch::Tensor vec,
torch::Tensor mat,
torch::Tensor mul,
torch::Tensor scales,
torch::Tensor zeros,
int groupsize
) {
int batch = vec.size(0);
int vec_height = vec.size(1);
int height = mat.size(0);
int width = mat.size(1);
int zero_width = zeros.size(1);
dim3 blocks(
(height + BLOCKHEIGHT8 - 1) / BLOCKHEIGHT8,
(width + BLOCKWIDTH - 1) / BLOCKWIDTH,
batch
);
dim3 threads(BLOCKWIDTH);
AT_DISPATCH_FLOATING_TYPES(
vec.type(), "vecquant8matmul_cuda", ([&] {
VecQuant8MatMulKernel<<>>(
vec.data(), mat.data(), mul.data(),
scales.data(), zeros.data(),
batch, vec_height, height, width, zero_width, groupsize
);
})
);
}
template
__global__ void VecQuant8MatMulKernel(
const scalar_t* __restrict__ vec,
const int* __restrict__ mat,
scalar_t* __restrict__ mul,
const scalar_t* __restrict__ scales,
const int* __restrict__ zeros,
int batch,
int vec_height,
int height,
int width,
int zero_width,
int groupsize
) {
int b = blockIdx.z;
int h = BLOCKHEIGHT8 * blockIdx.x;
int w = BLOCKWIDTH * blockIdx.y + threadIdx.x;
__shared__ scalar_t blockvec[BLOCKWIDTH];
blockvec[threadIdx.x] = vec[b * vec_height + blockIdx.x * BLOCKWIDTH + threadIdx.x];
__syncthreads();
scalar_t res = 0;
int i = width * h + w;
int g_h = h * 4;
int k = 0;
int z_w = w / 4;
int z_mod = (w % 4) * 8;
unsigned int tmp;
while (k < BLOCKWIDTH) {
tmp = as_unsigned(mat[i]);
int g = (g_h + k) / groupsize;
scalar_t scale = scales[g * width + w];
scalar_t zero = scale * scalar_t(((as_unsigned(zeros[g * zero_width + z_w]) >> z_mod) & 0xFF) + 1);
res += (scale * scalar_t((tmp >> 0) & 0xFF) - zero) * blockvec[k + 0];
res += (scale * scalar_t((tmp >> 8) & 0xFF) - zero) * blockvec[k + 1];
res += (scale * scalar_t((tmp >> 16) & 0xFF) - zero) * blockvec[k + 2];
res += (scale * scalar_t((tmp >> 24) & 0xFF) - zero) * blockvec[k + 3];
i += width;
k += 4;
}
atomicAdd(&mul[b * width + w], res);
}
================================================
FILE: models/gptq/requirements.txt
================================================
safetensors==0.3.0
datasets==2.10.1
sentencepiece
git+https://github.com/huggingface/transformers
================================================
FILE: models/gptq/setup_cuda.py
================================================
from setuptools import setup, Extension
from torch.utils import cpp_extension
setup(
name='quant_cuda',
ext_modules=[cpp_extension.CUDAExtension(
'quant_cuda', ['quant_cuda.cpp', 'quant_cuda_kernel.cu']
)],
cmdclass={'build_ext': cpp_extension.BuildExtension}
)
================================================
FILE: models/gptq/test_kernel.py
================================================
import torch
import torch.nn as nn
import quant_cuda
import os
os.environ['CUDA_LAUNCH_BLOCKING'] = "1"
torch.backends.cuda.matmul.allow_tf32 = False
torch.backends.cudnn.allow_tf32 = False
print('Benchmarking LLaMa-7B FC2 matvec ...')
DEV = torch.device('cuda:0')
B = 5
L = 128
M = 4096
N = 11008
DTYPE = torch.half
mat = torch.randn((M, N), device=DEV, dtype=DTYPE)
vec = torch.randn((B, M), device=DEV, dtype=DTYPE)
mul = torch.zeros((B, N), device=DEV, dtype=DTYPE)
COUNT = 1000
import time
tick = time.time()
for _ in range(COUNT):
torch.matmul(vec, mat, out=mul)
torch.cuda.synchronize()
print('FP16:', (time.time() - tick) / COUNT)
DTYPE = torch.float
mat = mat.to(DTYPE)
vec = vec.to(DTYPE)
mul = mul.to(DTYPE)
mat = torch.randint(-1000000000, 1000000000, (M // 256 * 32, N), device=DEV, dtype=torch.int)
scales = torch.randn(N, device=DEV, dtype=DTYPE)
zeros = torch.randint(-1000000000, 1000000000, (1, N // 256 * 32), device=DEV, dtype=torch.int)
COUNT = 1000
import time
tick = time.time()
for _ in range(COUNT):
quant_cuda.vecquant2matmul(vec, mat, mul, scales, zeros, M)
torch.cuda.synchronize()
print('2bit:', (time.time() - tick) / COUNT)
tick = time.time()
for _ in range(COUNT):
quant_cuda.vecquant3matmul(vec, mat, mul, scales, zeros, M)
torch.cuda.synchronize()
print('3bit:', (time.time() - tick) / COUNT)
tick = time.time()
for _ in range(COUNT):
quant_cuda.vecquant4matmul(vec, mat, mul, scales, zeros, M)
torch.cuda.synchronize()
print('4bit:', (time.time() - tick) / COUNT)
tick = time.time()
for _ in range(COUNT):
quant_cuda.vecquant8matmul(vec, mat, mul, scales, zeros, M)
torch.cuda.synchronize()
print('8bit:', (time.time() - tick) / COUNT)
print('Verifiying kernel correctness ...')
M = 4096
N = 11008
from quant import *
layer = nn.Linear(M, N)
vec = torch.randn(B,L,M).to(DEV)
quantizer = Quantizer()
quantizer.configure(2, perchannel=True, sym=False, mse=False)
quantizer.find_params(layer.weight.data, weight=True)
layer.weight.data = quantize(
layer.weight.data, quantizer.scale, quantizer.zero, quantizer.maxq
)
qlayer = QuantLinear(2, -1, layer.in_features, layer.out_features)
qlayer.pack(layer, quantizer.scale, quantizer.zero)
qlayer = qlayer.to(DEV)
layer = layer.to(DEV)
with torch.no_grad():
print('2bit Simu:', qlayer(vec))
print('2bit Kern:', layer.to(DEV)(vec))
print('\n')
layer = nn.Linear(M, N)
vec = torch.randn(B,L,M).to(DEV)
quantizer = Quantizer()
quantizer.configure(3, perchannel=True, sym=False, mse=False)
quantizer.find_params(layer.weight.data, weight=True)
layer.weight.data = quantize(
layer.weight.data, quantizer.scale, quantizer.zero, quantizer.maxq
)
qlayer = QuantLinear(3, -1, layer.in_features, layer.out_features)
qlayer.pack(layer, quantizer.scale, quantizer.zero)
qlayer = qlayer.to(DEV)
layer = layer.to(DEV)
with torch.no_grad():
print('3bit Simu:', qlayer(vec))
print('3bit Kern:', layer.to(DEV)(vec))
print('\n')
layer = nn.Linear(M, N)
vec = torch.randn(B,L,M).to(DEV)
quantizer = Quantizer()
quantizer.configure(4, perchannel=True, sym=False, mse=False)
quantizer.find_params(layer.weight.data, weight=True)
layer.weight.data = quantize(
layer.weight.data, quantizer.scale, quantizer.zero, quantizer.maxq
)
qlayer = QuantLinear(4, -1, layer.in_features, layer.out_features)
qlayer.pack(layer, quantizer.scale, quantizer.zero)
qlayer = qlayer.to(DEV)
layer = layer.to(DEV)
with torch.no_grad():
print('4bit Simu:', qlayer(vec))
print('4bit Kern:', layer.to(DEV)(vec))
print('\n')
layer = nn.Linear(M, N)
vec = torch.randn(B,L,M).to(DEV)
quantizer = Quantizer()
quantizer.configure(8, perchannel=True, sym=False, mse=False)
quantizer.find_params(layer.weight.data, weight=True)
layer.weight.data = quantize(
layer.weight.data, quantizer.scale, quantizer.zero, quantizer.maxq
)
qlayer = QuantLinear(8, -1, layer.in_features, layer.out_features)
qlayer.pack(layer, quantizer.scale, quantizer.zero)
qlayer = qlayer.to(DEV)
layer = layer.to(DEV)
with torch.no_grad():
print('8bit Simu:', qlayer(vec))
print('8bit Kern:', layer.to(DEV)(vec))
================================================
FILE: models/notebook/BELLE_INFER_COLAB.ipynb
================================================
{
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"id": "7m81oxz-sGgM"
},
"source": [
"[](https://colab.research.google.com/github/LianjiaTech/BELLE/blob/main/notebook/BELLE_INFER_COLAB.ipynb) "
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"id": "p70s1UElROWa"
},
"source": [
"# ** BELLE模型在COLAB推理的示例** \n",
"这里提供在colab环境运行BELLE模型的代码。默认加载的是4bit量化的BLOOM 7B模型，4bit量化的模型目前效果上面还是会有损失。在模型加载到内存过程中，最高消费RAM大概需要8G，等模型load到GPU中以后，RAM只需要4G，GPU大概需要10G。\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"id": "QUt9JenaRViP"
},
"source": [
"## 查看colab分配的显卡类型，一般免费账户上14G的T4显卡"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"id": "ORaFqtT6QV4c"
},
"source": [
"\n",
"\n",
"---\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "BLwfc3zuPqmK",
"outputId": "976890b7-a042-40a7-c787-df8578585f7d"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Thu Apr 13 09:41:39 2023 \n",
"+-----------------------------------------------------------------------------+\n",
"| NVIDIA-SMI 525.85.12 Driver Version: 525.85.12 CUDA Version: 12.0 |\n",
"|-------------------------------+----------------------+----------------------+\n",
"| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
"| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n",
"| | | MIG M. |\n",
"|===============================+======================+======================|\n",
"| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n",
"| N/A 68C P8 11W / 70W | 0MiB / 15360MiB | 0% Default |\n",
"| | | N/A |\n",
"+-------------------------------+----------------------+----------------------+\n",
" \n",
"+-----------------------------------------------------------------------------+\n",
"| Processes: |\n",
"| GPU GI CI PID Type Process name GPU Memory |\n",
"| ID ID Usage |\n",
"|=============================================================================|\n",
"| No running processes found |\n",
"+-----------------------------------------------------------------------------+\n"
]
}
],
"source": [
"!nvidia-smi"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"id": "w8ZvOYEKRl-N"
},
"source": [
"## 将BELLE项目git clone到colab"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "_zSYeftDDS3l",
"outputId": "e55cc6c2-30db-4a07-ea58-c473f09b0b11"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Cloning into 'BELLE'...\n",
"remote: Enumerating objects: 963, done.\u001b[K\n",
"remote: Counting objects: 100% (512/512), done.\u001b[K\n",
"remote: Compressing objects: 100% (298/298), done.\u001b[K\n",
"remote: Total 963 (delta 365), reused 293 (delta 214), pack-reused 451\u001b[K\n",
"Receiving objects: 100% (963/963), 5.41 MiB | 14.90 MiB/s, done.\n",
"Resolving deltas: 100% (528/528), done.\n"
]
}
],
"source": [
"!git clone https://github.com/LianjiaTech/BELLE.git \n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"id": "5u8KiaitR3Yt"
},
"source": [
"### 14G显卡目前只支持量化版本，这里暂时只提供量化版本在colab推理"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "xEzcL3t7DkAW",
"outputId": "f8a26b35-5a80-4f89-9d18-5f3e5da354c0"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"/content/BELLE/gptq\n"
]
}
],
"source": [
"%cd BELLE/models/gptq"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"id": "QpGt4F3BSLW-"
},
"source": [
"### 安装gptq环境"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "Wd9frauTDx8t",
"outputId": "391598d9-49aa-4f78-e58a-1d9fefafe808"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
"Collecting git+https://github.com/huggingface/transformers (from -r requirements.txt (line 4))\n",
" Cloning https://github.com/huggingface/transformers to /tmp/pip-req-build-pqbdyssy\n",
" Running command git clone --filter=blob:none --quiet https://github.com/huggingface/transformers /tmp/pip-req-build-pqbdyssy\n",
" Resolved https://github.com/huggingface/transformers to commit 7ade6ef7d48906d7cd7a3dcbab5645b4a6c7c82c\n",
" Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
" Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
" Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
"Collecting safetensors==0.3.0\n",
" Downloading safetensors-0.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.2 MB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.2/1.2 MB\u001b[0m \u001b[31m24.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hCollecting datasets==2.10.1\n",
" Downloading datasets-2.10.1-py3-none-any.whl (469 kB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m469.0/469.0 kB\u001b[0m \u001b[31m31.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hCollecting sentencepiece\n",
" Downloading sentencepiece-0.1.98-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.3 MB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m68.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hCollecting dill<0.3.7,>=0.3.0\n",
" Downloading dill-0.3.6-py3-none-any.whl (110 kB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m110.5/110.5 kB\u001b[0m \u001b[31m15.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hRequirement already satisfied: tqdm>=4.62.1 in /usr/local/lib/python3.9/dist-packages (from datasets==2.10.1->-r requirements.txt (line 2)) (4.65.0)\n",
"Collecting huggingface-hub<1.0.0,>=0.2.0\n",
" Downloading huggingface_hub-0.13.4-py3-none-any.whl (200 kB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m200.1/200.1 kB\u001b[0m \u001b[31m26.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hCollecting xxhash\n",
" Downloading xxhash-3.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (212 kB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m212.2/212.2 kB\u001b[0m \u001b[31m26.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hRequirement already satisfied: packaging in /usr/local/lib/python3.9/dist-packages (from datasets==2.10.1->-r requirements.txt (line 2)) (23.0)\n",
"Requirement already satisfied: requests>=2.19.0 in /usr/local/lib/python3.9/dist-packages (from datasets==2.10.1->-r requirements.txt (line 2)) (2.27.1)\n",
"Collecting aiohttp\n",
" Downloading aiohttp-3.8.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.0 MB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.0/1.0 MB\u001b[0m \u001b[31m69.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hRequirement already satisfied: fsspec[http]>=2021.11.1 in /usr/local/lib/python3.9/dist-packages (from datasets==2.10.1->-r requirements.txt (line 2)) (2023.3.0)\n",
"Collecting multiprocess\n",
" Downloading multiprocess-0.70.14-py39-none-any.whl (132 kB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m132.9/132.9 kB\u001b[0m \u001b[31m17.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hCollecting responses<0.19\n",
" Downloading responses-0.18.0-py3-none-any.whl (38 kB)\n",
"Requirement already satisfied: pyarrow>=6.0.0 in /usr/local/lib/python3.9/dist-packages (from datasets==2.10.1->-r requirements.txt (line 2)) (9.0.0)\n",
"Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.9/dist-packages (from datasets==2.10.1->-r requirements.txt (line 2)) (6.0)\n",
"Requirement already satisfied: pandas in /usr/local/lib/python3.9/dist-packages (from datasets==2.10.1->-r requirements.txt (line 2)) (1.5.3)\n",
"Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.9/dist-packages (from datasets==2.10.1->-r requirements.txt (line 2)) (1.22.4)\n",
"Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.9/dist-packages (from transformers==4.29.0.dev0->-r requirements.txt (line 4)) (2022.10.31)\n",
"Requirement already satisfied: filelock in /usr/local/lib/python3.9/dist-packages (from transformers==4.29.0.dev0->-r requirements.txt (line 4)) (3.11.0)\n",
"Collecting tokenizers!=0.11.3,<0.14,>=0.11.1\n",
" Downloading tokenizers-0.13.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (7.8 MB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.8/7.8 MB\u001b[0m \u001b[31m106.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hRequirement already satisfied: charset-normalizer<4.0,>=2.0 in /usr/local/lib/python3.9/dist-packages (from aiohttp->datasets==2.10.1->-r requirements.txt (line 2)) (2.0.12)\n",
"Collecting multidict<7.0,>=4.5\n",
" Downloading multidict-6.0.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (114 kB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m114.2/114.2 kB\u001b[0m \u001b[31m14.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hCollecting aiosignal>=1.1.2\n",
" Downloading aiosignal-1.3.1-py3-none-any.whl (7.6 kB)\n",
"Collecting frozenlist>=1.1.1\n",
" Downloading frozenlist-1.3.3-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (158 kB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m158.8/158.8 kB\u001b[0m \u001b[31m21.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hCollecting async-timeout<5.0,>=4.0.0a3\n",
" Downloading async_timeout-4.0.2-py3-none-any.whl (5.8 kB)\n",
"Collecting yarl<2.0,>=1.0\n",
" Downloading yarl-1.8.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (264 kB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m264.6/264.6 kB\u001b[0m \u001b[31m25.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25hRequirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.9/dist-packages (from aiohttp->datasets==2.10.1->-r requirements.txt (line 2)) (22.2.0)\n",
"Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.9/dist-packages (from huggingface-hub<1.0.0,>=0.2.0->datasets==2.10.1->-r requirements.txt (line 2)) (4.5.0)\n",
"Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests>=2.19.0->datasets==2.10.1->-r requirements.txt (line 2)) (3.4)\n",
"Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests>=2.19.0->datasets==2.10.1->-r requirements.txt (line 2)) (2022.12.7)\n",
"Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests>=2.19.0->datasets==2.10.1->-r requirements.txt (line 2)) (1.26.15)\n",
"Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.9/dist-packages (from pandas->datasets==2.10.1->-r requirements.txt (line 2)) (2.8.2)\n",
"Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.9/dist-packages (from pandas->datasets==2.10.1->-r requirements.txt (line 2)) (2022.7.1)\n",
"Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/dist-packages (from python-dateutil>=2.8.1->pandas->datasets==2.10.1->-r requirements.txt (line 2)) (1.16.0)\n",
"Building wheels for collected packages: transformers\n",
" Building wheel for transformers (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
" Created wheel for transformers: filename=transformers-4.29.0.dev0-py3-none-any.whl size=6928021 sha256=c39131f292b1f69fde9405dc40b7f4ed534a8e1ca2b69c04a1f4b3465ffeaa97\n",
" Stored in directory: /tmp/pip-ephem-wheel-cache-s259wrvv/wheels/14/a0/7b/8f6b25ba4110aa215fcb8d6aedd6cd4f9b9b6619190999ac2b\n",
"Successfully built transformers\n",
"Installing collected packages: tokenizers, sentencepiece, safetensors, xxhash, multidict, frozenlist, dill, async-timeout, yarl, responses, multiprocess, huggingface-hub, aiosignal, transformers, aiohttp, datasets\n",
"Successfully installed aiohttp-3.8.4 aiosignal-1.3.1 async-timeout-4.0.2 datasets-2.10.1 dill-0.3.6 frozenlist-1.3.3 huggingface-hub-0.13.4 multidict-6.0.4 multiprocess-0.70.14 responses-0.18.0 safetensors-0.3.0 sentencepiece-0.1.98 tokenizers-0.13.3 transformers-4.29.0.dev0 xxhash-3.2.0 yarl-1.8.2\n"
]
}
],
"source": [
"!pip install -r requirements.txt"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "wT0Gq7tkEWs6",
"outputId": "8dde5328-0a68-4af7-ef28-4e21433b21e9"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"running install\n",
"/usr/local/lib/python3.9/dist-packages/setuptools/command/install.py:34: SetuptoolsDeprecationWarning: setup.py install is deprecated. Use build and pip and other standards-based tools.\n",
" warnings.warn(\n",
"/usr/local/lib/python3.9/dist-packages/setuptools/command/easy_install.py:144: EasyInstallDeprecationWarning: easy_install command is deprecated. Use build and pip and other standards-based tools.\n",
" warnings.warn(\n",
"running bdist_egg\n",
"running egg_info\n",
"creating quant_cuda.egg-info\n",
"writing quant_cuda.egg-info/PKG-INFO\n",
"writing dependency_links to quant_cuda.egg-info/dependency_links.txt\n",
"writing top-level names to quant_cuda.egg-info/top_level.txt\n",
"writing manifest file 'quant_cuda.egg-info/SOURCES.txt'\n",
"/usr/local/lib/python3.9/dist-packages/torch/utils/cpp_extension.py:476: UserWarning: Attempted to use ninja as the BuildExtension backend but we could not find ninja.. Falling back to using the slow distutils backend.\n",
" warnings.warn(msg.format('we could not find ninja.'))\n",
"reading manifest file 'quant_cuda.egg-info/SOURCES.txt'\n",
"writing manifest file 'quant_cuda.egg-info/SOURCES.txt'\n",
"installing library code to build/bdist.linux-x86_64/egg\n",
"running install_lib\n",
"running build_ext\n",
"/usr/local/lib/python3.9/dist-packages/torch/utils/cpp_extension.py:398: UserWarning: There are no x86_64-linux-gnu-g++ version bounds defined for CUDA version 11.8\n",
" warnings.warn(f'There are no {compiler_name} version bounds defined for CUDA version {cuda_str_version}')\n",
"building 'quant_cuda' extension\n",
"creating build\n",
"creating build/temp.linux-x86_64-3.9\n",
"x86_64-linux-gnu-gcc -pthread -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -I/usr/local/lib/python3.9/dist-packages/torch/include -I/usr/local/lib/python3.9/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.9/dist-packages/torch/include/TH -I/usr/local/lib/python3.9/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.9 -c quant_cuda.cpp -o build/temp.linux-x86_64-3.9/quant_cuda.o -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\"_gcc\" -DPYBIND11_STDLIB=\"_libstdcpp\" -DPYBIND11_BUILD_ABI=\"_cxxabi1011\" -DTORCH_EXTENSION_NAME=quant_cuda -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++17\n",
"/usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.9/dist-packages/torch/include -I/usr/local/lib/python3.9/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.9/dist-packages/torch/include/TH -I/usr/local/lib/python3.9/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.9 -c quant_cuda_kernel.cu -o build/temp.linux-x86_64-3.9/quant_cuda_kernel.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\"_gcc\" -DPYBIND11_STDLIB=\"_libstdcpp\" -DPYBIND11_BUILD_ABI=\"_cxxabi1011\" -DTORCH_EXTENSION_NAME=quant_cuda -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_75,code=compute_75 -gencode=arch=compute_75,code=sm_75 -std=c++17\n",
"\u001b[01m\u001b[0m\u001b[01m/usr/local/lib/python3.9/dist-packages/torch/include/c10/util/irange.h(54)\u001b[0m: \u001b[01;35mwarning\u001b[0m #186-D: pointless comparison of unsigned integer with zero\n",
" detected during:\n",
" instantiation of \u001b[01m\"__nv_bool c10::detail::integer_iterator>::operator==(const c10::detail::integer_iterator> &) const [with I=size_t, one_sided=false, =0]\"\u001b[0m \u001b[32m\n",
"(61): here\u001b[0m\n",
" instantiation of \u001b[01m\"__nv_bool c10::detail::integer_iterator>::operator!=(const c10::detail::integer_iterator> &) const [with I=size_t, one_sided=false, =0]\"\u001b[0m \u001b[32m\n",
"/usr/local/lib/python3.9/dist-packages/torch/include/c10/core/TensorImpl.h(77): here\u001b[0m\n",
"\n",
"\u001b[01m\u001b[0m\u001b[01m/usr/local/lib/python3.9/dist-packages/torch/include/c10/util/irange.h(54)\u001b[0m: \u001b[01;35mwarning\u001b[0m #186-D: pointless comparison of unsigned integer with zero\n",
" detected during:\n",
" instantiation of \u001b[01m\"__nv_bool c10::detail::integer_iterator>::operator==(const c10::detail::integer_iterator> &) const [with I=std::size_t, one_sided=true, =0]\"\u001b[0m \u001b[32m\n",
"(61): here\u001b[0m\n",
" instantiation of \u001b[01m\"__nv_bool c10::detail::integer_iterator>::operator!=(const c10::detail::integer_iterator> &) const [with I=std::size_t, one_sided=true, =0]\"\u001b[0m \u001b[32m\n",
"/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/qualified_name.h(73): here\u001b[0m\n",
"\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:41:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kat::DeprecatedTypeProperties& at::Tensor::type() const\u001b[m\u001b[K’ is deprecated: Tensor.type() is deprecated. Instead use Tensor.options(), which in many cases (e.g. in a constructor) is a drop-in replacement. If you were using data from type(), that is now available from Tensor itself, so instead of tensor.type().scalar_type(), use tensor.scalar_type() instead and instead of tensor.type().backend() use tensor.device(). [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:222:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 222 | \u001b[01;36m\u001b[K De\u001b[m\u001b[KprecatedTypeProperties & type() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:163:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated: passing at::DeprecatedTypeProperties to an AT_DISPATCH macro is deprecated, pass an at::ScalarType instead [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/Dispatch.h:122:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 122 | \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties& t) {\n",
" | \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:163:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated: passing at::DeprecatedTypeProperties to an AT_DISPATCH macro is deprecated, pass an at::ScalarType instead [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/Dispatch.h:122:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 122 | \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties& t) {\n",
" | \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:1011:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:1032:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:1056:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:1083:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:1106:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:1999:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:2020:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:2043:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:2069:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:123:2092:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 123 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:41:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kat::DeprecatedTypeProperties& at::Tensor::type() const\u001b[m\u001b[K’ is deprecated: Tensor.type() is deprecated. Instead use Tensor.options(), which in many cases (e.g. in a constructor) is a drop-in replacement. If you were using data from type(), that is now available from Tensor itself, so instead of tensor.type().scalar_type(), use tensor.scalar_type() instead and instead of tensor.type().backend() use tensor.device(). [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:222:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 222 | \u001b[01;36m\u001b[K De\u001b[m\u001b[KprecatedTypeProperties & type() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:163:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated: passing at::DeprecatedTypeProperties to an AT_DISPATCH macro is deprecated, pass an at::ScalarType instead [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/Dispatch.h:122:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 122 | \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties& t) {\n",
" | \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:163:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated: passing at::DeprecatedTypeProperties to an AT_DISPATCH macro is deprecated, pass an at::ScalarType instead [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/Dispatch.h:122:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 122 | \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties& t) {\n",
" | \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:1011:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:1032:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:1056:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:1083:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:1106:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:1999:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:2020:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:2043:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:2069:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:218:2092:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 218 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:41:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kat::DeprecatedTypeProperties& at::Tensor::type() const\u001b[m\u001b[K’ is deprecated: Tensor.type() is deprecated. Instead use Tensor.options(), which in many cases (e.g. in a constructor) is a drop-in replacement. If you were using data from type(), that is now available from Tensor itself, so instead of tensor.type().scalar_type(), use tensor.scalar_type() instead and instead of tensor.type().backend() use tensor.device(). [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:222:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 222 | \u001b[01;36m\u001b[K De\u001b[m\u001b[KprecatedTypeProperties & type() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:163:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated: passing at::DeprecatedTypeProperties to an AT_DISPATCH macro is deprecated, pass an at::ScalarType instead [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/Dispatch.h:122:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 122 | \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties& t) {\n",
" | \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:163:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated: passing at::DeprecatedTypeProperties to an AT_DISPATCH macro is deprecated, pass an at::ScalarType instead [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/Dispatch.h:122:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 122 | \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties& t) {\n",
" | \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:1011:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:1032:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:1056:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:1083:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:1106:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:1999:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:2020:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:2043:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:2069:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:377:2092:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 377 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:41:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kat::DeprecatedTypeProperties& at::Tensor::type() const\u001b[m\u001b[K’ is deprecated: Tensor.type() is deprecated. Instead use Tensor.options(), which in many cases (e.g. in a constructor) is a drop-in replacement. If you were using data from type(), that is now available from Tensor itself, so instead of tensor.type().scalar_type(), use tensor.scalar_type() instead and instead of tensor.type().backend() use tensor.device(). [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:222:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 222 | \u001b[01;36m\u001b[K De\u001b[m\u001b[KprecatedTypeProperties & type() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:163:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated: passing at::DeprecatedTypeProperties to an AT_DISPATCH macro is deprecated, pass an at::ScalarType instead [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/Dispatch.h:122:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 122 | \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties& t) {\n",
" | \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:163:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated: passing at::DeprecatedTypeProperties to an AT_DISPATCH macro is deprecated, pass an at::ScalarType instead [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/Dispatch.h:122:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 122 | \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties& t) {\n",
" | \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:1011:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:1032:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:1056:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:1083:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = double]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:1106:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:\u001b[m\u001b[K In lambda function:\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:1999:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:2020:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:2043:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:2069:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = float]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"\u001b[01m\u001b[Kquant_cuda_kernel.cu:464:2092:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[KT* at::Tensor::data() const [with T = int]\u001b[m\u001b[K’ is deprecated: Tensor.data() is deprecated. Please use Tensor.data_ptr() instead. [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
" 464 | AT_DISPATCH_FLOATING_TYPES(\n",
" | \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
"\u001b[01m\u001b[K/usr/local/lib/python3.9/dist-packages/torch/include/ATen/core/TensorBody.h:244:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
" 244 | \u001b[01;36m\u001b[K T \u001b[m\u001b[K* data() const {\n",
" | \u001b[01;36m\u001b[K^\u001b[m\u001b[K \u001b[01;36m\u001b[K~~\u001b[m\u001b[K\n",
"creating build/lib.linux-x86_64-3.9\n",
"x86_64-linux-gnu-g++ -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions -g -fwrapv -O2 -Wl,-Bsymbolic-functions -g -fwrapv -O2 -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 build/temp.linux-x86_64-3.9/quant_cuda.o build/temp.linux-x86_64-3.9/quant_cuda_kernel.o -L/usr/local/lib/python3.9/dist-packages/torch/lib -L/usr/local/cuda/lib64 -lc10 -ltorch -ltorch_cpu -ltorch_python -lcudart -lc10_cuda -ltorch_cuda -o build/lib.linux-x86_64-3.9/quant_cuda.cpython-39-x86_64-linux-gnu.so\n",
"creating build/bdist.linux-x86_64\n",
"creating build/bdist.linux-x86_64/egg\n",
"copying build/lib.linux-x86_64-3.9/quant_cuda.cpython-39-x86_64-linux-gnu.so -> build/bdist.linux-x86_64/egg\n",
"creating stub loader for quant_cuda.cpython-39-x86_64-linux-gnu.so\n",
"byte-compiling build/bdist.linux-x86_64/egg/quant_cuda.py to quant_cuda.cpython-39.pyc\n",
"creating build/bdist.linux-x86_64/egg/EGG-INFO\n",
"copying quant_cuda.egg-info/PKG-INFO -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
"copying quant_cuda.egg-info/SOURCES.txt -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
"copying quant_cuda.egg-info/dependency_links.txt -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
"copying quant_cuda.egg-info/top_level.txt -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
"writing build/bdist.linux-x86_64/egg/EGG-INFO/native_libs.txt\n",
"zip_safe flag not set; analyzing archive contents...\n",
"__pycache__.quant_cuda.cpython-39: module references __file__\n",
"creating dist\n",
"creating 'dist/quant_cuda-0.0.0-py3.9-linux-x86_64.egg' and adding 'build/bdist.linux-x86_64/egg' to it\n",
"removing 'build/bdist.linux-x86_64/egg' (and everything under it)\n",
"Processing quant_cuda-0.0.0-py3.9-linux-x86_64.egg\n",
"creating /usr/local/lib/python3.9/dist-packages/quant_cuda-0.0.0-py3.9-linux-x86_64.egg\n",
"Extracting quant_cuda-0.0.0-py3.9-linux-x86_64.egg to /usr/local/lib/python3.9/dist-packages\n",
"Adding quant-cuda 0.0.0 to easy-install.pth file\n",
"\n",
"Installed /usr/local/lib/python3.9/dist-packages/quant_cuda-0.0.0-py3.9-linux-x86_64.egg\n",
"Processing dependencies for quant-cuda==0.0.0\n",
"Finished processing dependencies for quant-cuda==0.0.0\n",
"Benchmarking LLaMa-7B FC2 matvec ...\n",
"FP16: 0.0006610641479492188\n",
"2bit: 0.0011321241855621338\n",
"3bit: 0.000905475378036499\n",
"4bit: 0.0008348245620727539\n",
"8bit: 0.0006743667125701904\n",
"Verifiying kernel correctness ...\n",
"2bit Simu: tensor([[[-0.5031, 0.2357, -0.6711, ..., -0.6525, -0.8541, -1.1861],\n",
" [ 0.0038, -0.1658, -0.3461, ..., -0.4995, -0.0135, 0.5206],\n",
" [ 0.2579, -0.0474, 0.5508, ..., 0.0792, -0.4441, 0.0668],\n",
" ...,\n",
" [-0.5598, -0.1225, -0.1789, ..., -0.4645, 0.1437, -0.4854],\n",
" [-0.2219, -0.1854, 1.2809, ..., -0.0998, 0.6955, 1.1353],\n",
" [ 0.2213, 0.9016, -0.2213, ..., -0.0833, -0.6237, 0.7751]],\n",
"\n",
" [[ 0.3603, 0.2940, -0.0782, ..., 0.4057, -0.2398, -0.0825],\n",
" [ 0.4358, -0.2107, -0.4587, ..., -0.4773, 0.6190, 0.1566],\n",
" [ 0.3579, 0.5932, -0.2014, ..., -0.0768, 0.7605, 1.2279],\n",
" ...,\n",
" [-1.1553, -0.2112, -0.5064, ..., 0.0082, -0.0682, 0.2376],\n",
" [ 0.7963, 0.1977, -0.1137, ..., -0.5868, -0.6299, -0.1280],\n",
" [-0.0064, -0.0386, -0.2689, ..., -0.2614, 1.0313, 0.0985]],\n",
"\n",
" [[-0.3863, 0.1260, 0.3173, ..., -0.0468, 0.3026, 0.3202],\n",
" [ 1.1275, 0.2991, -0.3274, ..., 0.5410, -0.0722, 0.4927],\n",
" [ 0.3988, 0.9053, -0.4587, ..., 0.1677, -0.0551, 0.4146],\n",
" ...,\n",
" [-1.0412, 0.7489, 0.4134, ..., -0.5603, -0.3231, 0.3777],\n",
" [-0.1745, 0.4199, 0.6054, ..., -0.0105, 0.5054, 0.2877],\n",
" [-0.0217, -0.1290, -0.9906, ..., -0.1895, -0.6119, 0.4717]],\n",
"\n",
" [[ 0.3545, 0.0510, -0.9710, ..., 0.4090, 0.6559, -0.1028],\n",
" [-0.9271, 0.2109, 0.2578, ..., -0.5058, 0.0775, -0.3850],\n",
" [-0.1065, -0.6438, -0.2291, ..., 0.1805, 0.7880, -0.6970],\n",
" ...,\n",
" [-0.0583, 0.6332, 0.2745, ..., -0.7127, -0.5598, 0.5953],\n",
" [-0.4749, -0.2513, -1.3746, ..., -0.2019, -0.1938, 0.1304],\n",
" [-0.5104, -0.6171, 0.2718, ..., 0.3684, -0.6506, -0.1029]],\n",
"\n",
" [[-0.6974, -0.9570, 0.4948, ..., 0.4633, 0.3876, 0.3986],\n",
" [ 0.5284, 0.2018, 0.1197, ..., 0.3437, 0.1782, -0.0771],\n",
" [ 0.8205, -0.0388, -0.3899, ..., -0.7655, 1.6889, 0.0526],\n",
" ...,\n",
" [ 0.0445, 1.0198, 0.1388, ..., -0.8089, 0.7321, 0.0123],\n",
" [ 1.8570, -0.1649, -0.4458, ..., 0.3121, -0.2786, 1.3564],\n",
" [-0.5506, -0.2635, 0.7586, ..., 0.0220, -0.3207, -0.2966]]],\n",
" device='cuda:0')\n",
"2bit Kern: tensor([[[-0.5031, 0.2357, -0.6711, ..., -0.6525, -0.8541, -1.1861],\n",
" [ 0.0038, -0.1658, -0.3461, ..., -0.4995, -0.0135, 0.5206],\n",
" [ 0.2579, -0.0474, 0.5508, ..., 0.0792, -0.4441, 0.0668],\n",
" ...,\n",
" [-0.5598, -0.1225, -0.1789, ..., -0.4645, 0.1437, -0.4854],\n",
" [-0.2219, -0.1854, 1.2809, ..., -0.0998, 0.6955, 1.1353],\n",
" [ 0.2213, 0.9016, -0.2213, ..., -0.0833, -0.6237, 0.7751]],\n",
"\n",
" [[ 0.3603, 0.2940, -0.0782, ..., 0.4057, -0.2398, -0.0825],\n",
" [ 0.4358, -0.2107, -0.4587, ..., -0.4773, 0.6190, 0.1566],\n",
" [ 0.3579, 0.5932, -0.2014, ..., -0.0768, 0.7605, 1.2279],\n",
" ...,\n",
" [-1.1553, -0.2112, -0.5064, ..., 0.0082, -0.0682, 0.2376],\n",
" [ 0.7963, 0.1977, -0.1137, ..., -0.5868, -0.6299, -0.1280],\n",
" [-0.0064, -0.0386, -0.2689, ..., -0.2614, 1.0313, 0.0985]],\n",
"\n",
" [[-0.3863, 0.1260, 0.3173, ..., -0.0468, 0.3026, 0.3202],\n",
" [ 1.1275, 0.2991, -0.3274, ..., 0.5410, -0.0722, 0.4927],\n",
" [ 0.3988, 0.9053, -0.4587, ..., 0.1677, -0.0551, 0.4146],\n",
" ...,\n",
" [-1.0412, 0.7489, 0.4134, ..., -0.5603, -0.3231, 0.3777],\n",
" [-0.1745, 0.4199, 0.6054, ..., -0.0105, 0.5054, 0.2877],\n",
" [-0.0217, -0.1290, -0.9906, ..., -0.1895, -0.6119, 0.4717]],\n",
"\n",
" [[ 0.3545, 0.0510, -0.9710, ..., 0.4090, 0.6559, -0.1028],\n",
" [-0.9271, 0.2109, 0.2578, ..., -0.5058, 0.0775, -0.3850],\n",
" [-0.1065, -0.6438, -0.2291, ..., 0.1805, 0.7880, -0.6970],\n",
" ...,\n",
" [-0.0583, 0.6332, 0.2745, ..., -0.7127, -0.5598, 0.5953],\n",
" [-0.4749, -0.2513, -1.3746, ..., -0.2019, -0.1938, 0.1304],\n",
" [-0.5104, -0.6171, 0.2718, ..., 0.3684, -0.6506, -0.1029]],\n",
"\n",
" [[-0.6974, -0.9570, 0.4948, ..., 0.4633, 0.3876, 0.3986],\n",
" [ 0.5284, 0.2018, 0.1197, ..., 0.3437, 0.1782, -0.0771],\n",
" [ 0.8205, -0.0388, -0.3899, ..., -0.7655, 1.6889, 0.0526],\n",
" ...,\n",
" [ 0.0445, 1.0198, 0.1388, ..., -0.8089, 0.7321, 0.0123],\n",
" [ 1.8570, -0.1649, -0.4458, ..., 0.3121, -0.2786, 1.3564],\n",
" [-0.5506, -0.2635, 0.7586, ..., 0.0220, -0.3207, -0.2966]]],\n",
" device='cuda:0')\n",
"\n",
"\n",
"3bit Simu: tensor([[[-2.6905e-01, -1.5902e-01, 9.0068e-01, ..., -6.6669e-01,\n",
" -1.0632e-01, 8.3940e-02],\n",
" [-1.9759e-01, -1.0823e-01, -1.1897e+00, ..., 8.0771e-01,\n",
" -2.2273e-01, 5.8908e-01],\n",
" [-8.3896e-01, 1.3294e+00, -5.5757e-01, ..., -1.3583e+00,\n",
" 3.4895e-01, 6.4654e-01],\n",
" ...,\n",
" [-1.2204e-01, -4.0897e-01, -1.8123e-01, ..., -5.1525e-01,\n",
" -1.1903e+00, 9.8983e-01],\n",
" [-9.6853e-01, -2.7724e-02, -5.2704e-02, ..., 4.3679e-01,\n",
" 1.4726e-01, -3.9800e-01],\n",
" [ 1.6033e-01, -1.2784e+00, 6.7417e-01, ..., 1.0639e-01,\n",
" 3.4901e-01, 5.3523e-01]],\n",
"\n",
" [[ 3.6894e-01, -4.5176e-01, 1.2197e-01, ..., 3.4895e-02,\n",
" -4.3593e-01, -5.4872e-01],\n",
" [ 7.3333e-02, 8.8676e-01, 4.7564e-01, ..., -5.2754e-01,\n",
" -2.4349e-02, -1.5780e-01],\n",
" [ 4.2421e-01, -1.9107e-01, -5.3282e-01, ..., 6.1283e-01,\n",
" 2.5989e-01, -1.2081e+00],\n",
" ...,\n",
" [-1.0019e-01, -5.7981e-01, 2.8965e-02, ..., -4.4218e-01,\n",
" 9.1704e-01, 1.6721e-01],\n",
" [-4.0398e-01, 1.1743e+00, 3.6515e-01, ..., 7.9155e-01,\n",
" 1.9716e-01, 8.2481e-01],\n",
" [-2.5617e-02, 2.3317e-01, 1.0999e+00, ..., 1.4933e-01,\n",
" 5.7142e-02, -1.5906e-01]],\n",
"\n",
" [[-5.9735e-02, 4.1035e-01, -1.3762e-01, ..., -3.0711e-01,\n",
" -9.4239e-01, 7.3383e-02],\n",
" [ 1.8717e-01, 8.9837e-01, -1.1502e+00, ..., 2.1802e-01,\n",
" 2.9636e-02, -3.2209e-01],\n",
" [-6.9481e-01, 9.0093e-01, -6.3316e-01, ..., 1.1667e-01,\n",
" 5.6763e-03, 1.5465e+00],\n",
" ...,\n",
" [-1.6929e-01, -2.0358e-01, -2.7423e-01, ..., 1.8102e-01,\n",
" 7.7124e-01, -3.1629e-01],\n",
" [ 1.3252e-01, 7.3445e-01, 1.1723e+00, ..., 3.0763e-01,\n",
" 1.3674e-01, -3.4101e-01],\n",
" [-2.1739e-01, 2.0022e-01, 2.8911e-01, ..., -9.8774e-01,\n",
" 4.8584e-02, -6.7717e-01]],\n",
"\n",
" [[ 1.0280e+00, 5.0743e-01, 7.7207e-02, ..., -1.5022e-01,\n",
" -9.3268e-01, -4.8927e-01],\n",
" [ 2.9743e-01, 3.9169e-01, 2.9023e-01, ..., -2.2965e-01,\n",
" 6.4456e-01, -2.2597e-01],\n",
" [-5.5956e-01, 1.0302e+00, -3.2039e-01, ..., -4.0319e-02,\n",
" -7.5191e-01, -3.1234e-01],\n",
" ...,\n",
" [ 1.3528e-01, -5.1675e-01, -1.1362e-01, ..., -5.0100e-01,\n",
" -7.3770e-01, -4.7298e-01],\n",
" [-3.6730e-01, -1.4140e-01, -1.0335e-01, ..., -8.7805e-02,\n",
" -6.1361e-01, -6.4219e-01],\n",
" [-1.5064e-01, -1.6420e+00, -1.1019e+00, ..., 3.6107e-01,\n",
" 1.2783e-01, -2.6940e-02]],\n",
"\n",
" [[-4.2673e-01, -3.3197e-01, -9.6817e-02, ..., -2.2308e-01,\n",
" 4.3729e-01, 3.0703e-01],\n",
" [-2.7142e-01, 1.3038e+00, 3.9566e-01, ..., -5.7230e-01,\n",
" 4.5619e-01, -7.7784e-01],\n",
" [ 7.5809e-01, 5.4488e-02, 2.8663e-01, ..., -4.5057e-02,\n",
" -3.2061e-01, 1.0343e-01],\n",
" ...,\n",
" [ 1.3699e+00, -7.2023e-01, -4.6268e-01, ..., 3.8287e-01,\n",
" 3.9838e-01, -4.0939e-01],\n",
" [-3.6179e-01, -1.4703e-01, -1.1499e-03, ..., -1.1688e+00,\n",
" 2.2320e-01, 4.0634e-01],\n",
" [ 2.1467e-01, 5.5898e-01, -5.3386e-01, ..., -1.6671e-01,\n",
" -5.3884e-01, 7.5140e-01]]], device='cuda:0')\n",
"3bit Kern: tensor([[[-2.6905e-01, -1.5902e-01, 9.0068e-01, ..., -6.6669e-01,\n",
" -1.0632e-01, 8.3940e-02],\n",
" [-1.9759e-01, -1.0823e-01, -1.1897e+00, ..., 8.0771e-01,\n",
" -2.2273e-01, 5.8908e-01],\n",
" [-8.3896e-01, 1.3294e+00, -5.5757e-01, ..., -1.3583e+00,\n",
" 3.4895e-01, 6.4654e-01],\n",
" ...,\n",
" [-1.2205e-01, -4.0897e-01, -1.8123e-01, ..., -5.1525e-01,\n",
" -1.1903e+00, 9.8983e-01],\n",
" [-9.6854e-01, -2.7724e-02, -5.2705e-02, ..., 4.3679e-01,\n",
" 1.4726e-01, -3.9800e-01],\n",
" [ 1.6033e-01, -1.2784e+00, 6.7417e-01, ..., 1.0639e-01,\n",
" 3.4901e-01, 5.3523e-01]],\n",
"\n",
" [[ 3.6894e-01, -4.5176e-01, 1.2197e-01, ..., 3.4895e-02,\n",
" -4.3593e-01, -5.4872e-01],\n",
" [ 7.3333e-02, 8.8676e-01, 4.7564e-01, ..., -5.2754e-01,\n",
" -2.4349e-02, -1.5780e-01],\n",
" [ 4.2421e-01, -1.9107e-01, -5.3282e-01, ..., 6.1283e-01,\n",
" 2.5989e-01, -1.2081e+00],\n",
" ...,\n",
" [-1.0019e-01, -5.7981e-01, 2.8965e-02, ..., -4.4218e-01,\n",
" 9.1704e-01, 1.6721e-01],\n",
" [-4.0398e-01, 1.1743e+00, 3.6516e-01, ..., 7.9155e-01,\n",
" 1.9716e-01, 8.2481e-01],\n",
" [-2.5616e-02, 2.3317e-01, 1.0999e+00, ..., 1.4933e-01,\n",
" 5.7142e-02, -1.5906e-01]],\n",
"\n",
" [[-5.9735e-02, 4.1035e-01, -1.3762e-01, ..., -3.0711e-01,\n",
" -9.4239e-01, 7.3382e-02],\n",
" [ 1.8717e-01, 8.9837e-01, -1.1502e+00, ..., 2.1802e-01,\n",
" 2.9637e-02, -3.2210e-01],\n",
" [-6.9480e-01, 9.0093e-01, -6.3316e-01, ..., 1.1667e-01,\n",
" 5.6764e-03, 1.5465e+00],\n",
" ...,\n",
" [-1.6929e-01, -2.0358e-01, -2.7423e-01, ..., 1.8102e-01,\n",
" 7.7124e-01, -3.1629e-01],\n",
" [ 1.3252e-01, 7.3445e-01, 1.1723e+00, ..., 3.0763e-01,\n",
" 1.3674e-01, -3.4100e-01],\n",
" [-2.1739e-01, 2.0022e-01, 2.8911e-01, ..., -9.8774e-01,\n",
" 4.8583e-02, -6.7717e-01]],\n",
"\n",
" [[ 1.0280e+00, 5.0743e-01, 7.7207e-02, ..., -1.5022e-01,\n",
" -9.3268e-01, -4.8927e-01],\n",
" [ 2.9743e-01, 3.9169e-01, 2.9023e-01, ..., -2.2965e-01,\n",
" 6.4456e-01, -2.2597e-01],\n",
" [-5.5956e-01, 1.0302e+00, -3.2039e-01, ..., -4.0319e-02,\n",
" -7.5191e-01, -3.1234e-01],\n",
" ...,\n",
" [ 1.3528e-01, -5.1676e-01, -1.1363e-01, ..., -5.0099e-01,\n",
" -7.3770e-01, -4.7298e-01],\n",
" [-3.6730e-01, -1.4140e-01, -1.0335e-01, ..., -8.7805e-02,\n",
" -6.1361e-01, -6.4219e-01],\n",
" [-1.5064e-01, -1.6420e+00, -1.1019e+00, ..., 3.6107e-01,\n",
" 1.2783e-01, -2.6940e-02]],\n",
"\n",
" [[-4.2673e-01, -3.3197e-01, -9.6817e-02, ..., -2.2308e-01,\n",
" 4.3729e-01, 3.0703e-01],\n",
" [-2.7142e-01, 1.3038e+00, 3.9566e-01, ..., -5.7230e-01,\n",
" 4.5619e-01, -7.7784e-01],\n",
" [ 7.5809e-01, 5.4488e-02, 2.8663e-01, ..., -4.5057e-02,\n",
" -3.2061e-01, 1.0343e-01],\n",
" ...,\n",
" [ 1.3700e+00, -7.2023e-01, -4.6268e-01, ..., 3.8287e-01,\n",
" 3.9838e-01, -4.0939e-01],\n",
" [-3.6179e-01, -1.4703e-01, -1.1501e-03, ..., -1.1688e+00,\n",
" 2.2320e-01, 4.0634e-01],\n",
" [ 2.1467e-01, 5.5898e-01, -5.3386e-01, ..., -1.6671e-01,\n",
" -5.3884e-01, 7.5140e-01]]], device='cuda:0')\n",
"\n",
"\n",
"4bit Simu: tensor([[[ 0.3409, 0.1163, -0.0713, ..., -1.2378, -0.2355, -0.9327],\n",
" [-0.3185, -0.3621, -0.7409, ..., -0.1507, -1.1744, 0.5434],\n",
" [ 0.0519, 0.8851, 0.6816, ..., 0.0752, -0.6438, 1.1702],\n",
" ...,\n",
" [ 0.2462, 1.5813, -0.5947, ..., 0.4940, -0.2779, -0.1576],\n",
" [ 0.2529, 0.3197, 0.2337, ..., 0.3987, -1.5286, 0.3646],\n",
" [-0.9714, 0.2794, -0.1031, ..., -1.0960, 0.3168, -0.7899]],\n",
"\n",
" [[-0.5303, 0.1734, -0.0591, ..., 0.9764, 0.2096, 0.4706],\n",
" [ 0.2493, 0.4132, 0.7467, ..., 0.3129, -0.6910, 0.2435],\n",
" [-0.4530, 0.2228, -0.2907, ..., -0.2217, 0.2605, 0.2304],\n",
" ...,\n",
" [-0.9120, -0.5751, -0.1884, ..., -1.0017, 0.3089, 1.2168],\n",
" [ 0.2820, 0.2496, 0.5855, ..., -0.4431, -0.5884, 0.1653],\n",
" [ 1.4851, -0.3262, 0.6374, ..., -0.3950, 0.1002, 0.2286]],\n",
"\n",
" [[-0.6246, -0.3909, 0.6599, ..., -0.1083, 0.4711, 0.2585],\n",
" [-0.8347, 0.8995, -0.0796, ..., -0.5707, -0.2438, -0.0074],\n",
" [-0.5048, -1.6626, 0.7788, ..., 0.2924, -0.2436, -0.0927],\n",
" ...,\n",
" [ 0.0874, -0.9244, 0.5524, ..., -0.3129, -0.4003, 0.4855],\n",
" [-0.2516, 0.5097, 0.0160, ..., -0.9318, -0.7483, 0.2749],\n",
" [-0.1661, -0.0682, -0.1576, ..., -0.4610, 1.2449, 0.4009]],\n",
"\n",
" [[ 0.5346, -0.4638, -0.1476, ..., -0.1461, -0.2897, 0.0885],\n",
" [ 0.3012, 0.3939, 0.1502, ..., -0.9472, 0.0169, 0.1088],\n",
" [ 0.3329, -0.0447, 0.3757, ..., -0.5941, 0.4111, 0.5518],\n",
" ...,\n",
" [-0.8538, -0.3703, 0.1632, ..., -0.5587, -0.2425, 0.3611],\n",
" [ 0.1513, -0.4870, 0.0311, ..., -0.1869, -0.6509, 1.3294],\n",
" [-0.4406, -0.5038, 0.4541, ..., -0.4605, -0.2537, -0.3636]],\n",
"\n",
" [[ 1.0051, -0.4970, -0.5361, ..., 0.0102, -0.2627, -0.2806],\n",
" [ 0.7463, 0.0111, -0.4338, ..., -0.7396, 0.1446, 0.7116],\n",
" [-1.0110, 0.1770, -0.2314, ..., -0.1498, -0.5213, 0.4980],\n",
" ...,\n",
" [ 0.4852, 0.5209, -0.1218, ..., 0.7162, -0.0102, 0.5339],\n",
" [-0.5512, -0.2305, 1.2516, ..., -0.4927, -0.2886, 0.3945],\n",
" [ 0.7476, -0.3242, 0.3596, ..., 0.8673, 0.4849, -0.7631]]],\n",
" device='cuda:0')\n",
"4bit Kern: tensor([[[ 0.3409, 0.1163, -0.0713, ..., -1.2378, -0.2355, -0.9327],\n",
" [-0.3185, -0.3621, -0.7409, ..., -0.1507, -1.1744, 0.5434],\n",
" [ 0.0519, 0.8851, 0.6816, ..., 0.0752, -0.6438, 1.1702],\n",
" ...,\n",
" [ 0.2462, 1.5813, -0.5946, ..., 0.4940, -0.2779, -0.1576],\n",
" [ 0.2529, 0.3197, 0.2337, ..., 0.3987, -1.5286, 0.3646],\n",
" [-0.9714, 0.2794, -0.1031, ..., -1.0960, 0.3168, -0.7899]],\n",
"\n",
" [[-0.5303, 0.1734, -0.0591, ..., 0.9764, 0.2096, 0.4706],\n",
" [ 0.2493, 0.4132, 0.7467, ..., 0.3129, -0.6910, 0.2435],\n",
" [-0.4530, 0.2228, -0.2907, ..., -0.2217, 0.2605, 0.2304],\n",
" ...,\n",
" [-0.9120, -0.5751, -0.1884, ..., -1.0017, 0.3089, 1.2168],\n",
" [ 0.2820, 0.2496, 0.5855, ..., -0.4431, -0.5884, 0.1653],\n",
" [ 1.4851, -0.3262, 0.6374, ..., -0.3950, 0.1002, 0.2286]],\n",
"\n",
" [[-0.6246, -0.3909, 0.6599, ..., -0.1083, 0.4711, 0.2585],\n",
" [-0.8347, 0.8995, -0.0796, ..., -0.5707, -0.2438, -0.0074],\n",
" [-0.5048, -1.6626, 0.7788, ..., 0.2924, -0.2436, -0.0927],\n",
" ...,\n",
" [ 0.0874, -0.9244, 0.5524, ..., -0.3129, -0.4003, 0.4855],\n",
" [-0.2516, 0.5097, 0.0160, ..., -0.9318, -0.7483, 0.2749],\n",
" [-0.1661, -0.0682, -0.1576, ..., -0.4610, 1.2449, 0.4009]],\n",
"\n",
" [[ 0.5346, -0.4638, -0.1476, ..., -0.1461, -0.2897, 0.0885],\n",
" [ 0.3012, 0.3939, 0.1502, ..., -0.9472, 0.0169, 0.1089],\n",
" [ 0.3329, -0.0447, 0.3757, ..., -0.5941, 0.4111, 0.5518],\n",
" ...,\n",
" [-0.8538, -0.3703, 0.1632, ..., -0.5587, -0.2425, 0.3611],\n",
" [ 0.1513, -0.4870, 0.0311, ..., -0.1869, -0.6509, 1.3294],\n",
" [-0.4406, -0.5038, 0.4541, ..., -0.4605, -0.2537, -0.3636]],\n",
"\n",
" [[ 1.0051, -0.4970, -0.5360, ..., 0.0102, -0.2627, -0.2806],\n",
" [ 0.7463, 0.0111, -0.4338, ..., -0.7396, 0.1446, 0.7116],\n",
" [-1.0110, 0.1770, -0.2314, ..., -0.1498, -0.5213, 0.4980],\n",
" ...,\n",
" [ 0.4852, 0.5209, -0.1218, ..., 0.7162, -0.0102, 0.5339],\n",
" [-0.5512, -0.2305, 1.2516, ..., -0.4927, -0.2886, 0.3945],\n",
" [ 0.7476, -0.3242, 0.3596, ..., 0.8673, 0.4849, -0.7631]]],\n",
" device='cuda:0')\n",
"\n",
"\n",
"8bit Simu: tensor([[[-1.3612e-01, 2.3868e-01, 4.3228e-01, ..., -9.5034e-02,\n",
" 5.1928e-01, -8.7504e-02],\n",
" [ 1.5274e+00, 2.6957e-02, 5.1080e-02, ..., -1.4028e+00,\n",
" 5.3464e-01, 8.9787e-01],\n",
" [ 1.6875e-01, -1.9182e-01, 5.0604e-02, ..., -1.5846e-01,\n",
" -6.8970e-02, -1.1131e+00],\n",
" ...,\n",
" [-7.7195e-01, -5.7850e-01, -3.6307e-02, ..., 4.7196e-01,\n",
" 3.4639e-01, 6.1058e-01],\n",
" [ 4.4703e-01, 4.9701e-01, -2.0531e-01, ..., 2.2105e-01,\n",
" 4.7335e-01, -2.4894e-01],\n",
" [-3.8796e-01, -8.5836e-01, -7.4272e-01, ..., -2.3791e-01,\n",
" 2.2564e-01, -1.5741e+00]],\n",
"\n",
" [[ 5.9650e-01, 1.0593e+00, 4.9382e-01, ..., 2.6581e-01,\n",
" -5.4062e-01, 5.6072e-01],\n",
" [-3.0853e-01, 4.3161e-02, 1.8714e-01, ..., 1.9532e-01,\n",
" 9.3350e-01, 7.8501e-01],\n",
" [ 2.4057e-02, 4.4674e-01, 1.7203e-01, ..., 1.6688e-01,\n",
" -8.3594e-01, -5.1792e-01],\n",
" ...,\n",
" [-7.8548e-01, 6.2727e-02, -4.7613e-01, ..., -9.6201e-01,\n",
" -2.4022e-01, -5.9171e-01],\n",
" [-8.7194e-02, 1.2760e-03, -4.3090e-01, ..., -3.2074e-01,\n",
" 1.0458e-01, 1.7414e-02],\n",
" [ 3.0700e-01, 5.2365e-02, 3.2642e-01, ..., -1.0576e+00,\n",
" -4.6741e-01, -4.0205e-01]],\n",
"\n",
" [[-1.9076e-01, 1.1169e-01, -1.4749e-01, ..., 4.7497e-01,\n",
" 6.0297e-01, -4.7164e-01],\n",
" [-1.2195e-01, 5.0959e-01, -6.5373e-02, ..., 4.4890e-01,\n",
" -3.8201e-01, 1.3991e-01],\n",
" [ 6.2662e-01, 2.3795e-01, -5.5029e-01, ..., -1.1801e+00,\n",
" 5.3575e-03, 1.6566e-01],\n",
" ...,\n",
" [-4.3383e-01, 1.4268e-02, 3.2946e-01, ..., 1.2408e+00,\n",
" -6.6904e-01, -8.4586e-01],\n",
" [ 4.4570e-01, -8.2566e-01, 2.8087e-01, ..., 1.7394e-01,\n",
" 5.2925e-01, 3.0300e-02],\n",
" [-3.1081e-01, 2.7897e-01, 9.4182e-02, ..., -3.2118e-01,\n",
" -5.3960e-01, 2.3494e-01]],\n",
"\n",
" [[ 4.0766e-01, -1.1317e+00, -4.5914e-01, ..., -1.8660e-01,\n",
" 6.7156e-02, -3.0988e-01],\n",
" [-3.6942e-01, -4.3924e-01, 7.9278e-02, ..., 1.3519e-01,\n",
" 1.4212e+00, 2.8826e-01],\n",
" [ 3.0997e-01, -3.3498e-01, 7.6541e-01, ..., -1.4724e-01,\n",
" 6.8804e-01, -3.2103e-01],\n",
" ...,\n",
" [-1.7104e-01, -7.6153e-01, -3.9197e-02, ..., 5.8567e-01,\n",
" -8.9170e-01, 5.9681e-02],\n",
" [-8.1458e-02, 1.5885e+00, -4.2417e-01, ..., 1.2265e+00,\n",
" 5.4523e-01, 3.3200e-01],\n",
" [-1.4799e+00, 8.1969e-01, -3.0668e-01, ..., -2.8946e-01,\n",
" -1.0448e-01, -4.6879e-01]],\n",
"\n",
" [[ 2.6653e-01, -1.3003e+00, -2.8491e-01, ..., 1.2587e-01,\n",
" 4.9998e-01, -5.9461e-02],\n",
" [ 6.7636e-02, 5.9828e-01, -1.7459e-01, ..., 9.9408e-01,\n",
" 7.0125e-01, -5.5082e-02],\n",
" [-2.4253e-01, -5.9938e-01, 7.0244e-02, ..., -8.2513e-01,\n",
" 6.2857e-01, 5.8800e-01],\n",
" ...,\n",
" [ 1.1082e+00, -3.6440e-02, -5.4006e-02, ..., -6.3404e-01,\n",
" 1.1332e-01, -4.1249e-01],\n",
" [-1.0050e-02, 4.2679e-02, -5.2675e-01, ..., 1.8629e-01,\n",
" 1.1292e-01, -2.0926e-01],\n",
" [-6.6499e-01, 1.4787e+00, -3.0871e-01, ..., 5.3211e-01,\n",
" -4.0761e-01, -8.2771e-01]]], device='cuda:0')\n",
"8bit Kern: tensor([[[-1.3612e-01, 2.3868e-01, 4.3228e-01, ..., -9.5034e-02,\n",
" 5.1928e-01, -8.7505e-02],\n",
" [ 1.5274e+00, 2.6956e-02, 5.1080e-02, ..., -1.4028e+00,\n",
" 5.3464e-01, 8.9787e-01],\n",
" [ 1.6875e-01, -1.9182e-01, 5.0603e-02, ..., -1.5846e-01,\n",
" -6.8970e-02, -1.1131e+00],\n",
" ...,\n",
" [-7.7195e-01, -5.7850e-01, -3.6307e-02, ..., 4.7196e-01,\n",
" 3.4639e-01, 6.1058e-01],\n",
" [ 4.4703e-01, 4.9701e-01, -2.0531e-01, ..., 2.2105e-01,\n",
" 4.7335e-01, -2.4894e-01],\n",
" [-3.8796e-01, -8.5836e-01, -7.4271e-01, ..., -2.3791e-01,\n",
" 2.2563e-01, -1.5741e+00]],\n",
"\n",
" [[ 5.9650e-01, 1.0593e+00, 4.9382e-01, ..., 2.6581e-01,\n",
" -5.4062e-01, 5.6072e-01],\n",
" [-3.0853e-01, 4.3161e-02, 1.8714e-01, ..., 1.9532e-01,\n",
" 9.3351e-01, 7.8501e-01],\n",
" [ 2.4057e-02, 4.4674e-01, 1.7202e-01, ..., 1.6688e-01,\n",
" -8.3594e-01, -5.1792e-01],\n",
" ...,\n",
" [-7.8548e-01, 6.2727e-02, -4.7613e-01, ..., -9.6201e-01,\n",
" -2.4022e-01, -5.9171e-01],\n",
" [-8.7194e-02, 1.2754e-03, -4.3090e-01, ..., -3.2074e-01,\n",
" 1.0458e-01, 1.7413e-02],\n",
" [ 3.0700e-01, 5.2365e-02, 3.2642e-01, ..., -1.0576e+00,\n",
" -4.6741e-01, -4.0205e-01]],\n",
"\n",
" [[-1.9076e-01, 1.1169e-01, -1.4749e-01, ..., 4.7497e-01,\n",
" 6.0297e-01, -4.7164e-01],\n",
" [-1.2195e-01, 5.0959e-01, -6.5373e-02, ..., 4.4890e-01,\n",
" -3.8201e-01, 1.3991e-01],\n",
" [ 6.2662e-01, 2.3795e-01, -5.5029e-01, ..., -1.1801e+00,\n",
" 5.3578e-03, 1.6566e-01],\n",
" ...,\n",
" [-4.3383e-01, 1.4267e-02, 3.2946e-01, ..., 1.2408e+00,\n",
" -6.6904e-01, -8.4586e-01],\n",
" [ 4.4570e-01, -8.2566e-01, 2.8087e-01, ..., 1.7394e-01,\n",
" 5.2925e-01, 3.0300e-02],\n",
" [-3.1081e-01, 2.7897e-01, 9.4182e-02, ..., -3.2118e-01,\n",
" -5.3960e-01, 2.3494e-01]],\n",
"\n",
" [[ 4.0766e-01, -1.1317e+00, -4.5914e-01, ..., -1.8660e-01,\n",
" 6.7156e-02, -3.0988e-01],\n",
" [-3.6942e-01, -4.3924e-01, 7.9277e-02, ..., 1.3518e-01,\n",
" 1.4212e+00, 2.8826e-01],\n",
" [ 3.0997e-01, -3.3498e-01, 7.6541e-01, ..., -1.4724e-01,\n",
" 6.8804e-01, -3.2103e-01],\n",
" ...,\n",
" [-1.7104e-01, -7.6153e-01, -3.9197e-02, ..., 5.8567e-01,\n",
" -8.9170e-01, 5.9681e-02],\n",
" [-8.1458e-02, 1.5885e+00, -4.2417e-01, ..., 1.2265e+00,\n",
" 5.4523e-01, 3.3200e-01],\n",
" [-1.4799e+00, 8.1969e-01, -3.0668e-01, ..., -2.8946e-01,\n",
" -1.0448e-01, -4.6879e-01]],\n",
"\n",
" [[ 2.6653e-01, -1.3003e+00, -2.8491e-01, ..., 1.2587e-01,\n",
" 4.9998e-01, -5.9461e-02],\n",
" [ 6.7636e-02, 5.9828e-01, -1.7459e-01, ..., 9.9408e-01,\n",
" 7.0125e-01, -5.5082e-02],\n",
" [-2.4253e-01, -5.9938e-01, 7.0243e-02, ..., -8.2513e-01,\n",
" 6.2857e-01, 5.8800e-01],\n",
" ...,\n",
" [ 1.1082e+00, -3.6439e-02, -5.4006e-02, ..., -6.3404e-01,\n",
" 1.1332e-01, -4.1249e-01],\n",
" [-1.0049e-02, 4.2678e-02, -5.2676e-01, ..., 1.8629e-01,\n",
" 1.1292e-01, -2.0926e-01],\n",
" [-6.6499e-01, 1.4787e+00, -3.0871e-01, ..., 5.3211e-01,\n",
" -4.0761e-01, -8.2771e-01]]], device='cuda:0')\n"
]
}
],
"source": [
"! python setup_cuda.py install && CUDA_VISIBLE_DEVICES=0 && python test_kernel.py\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"id": "b0gYQ0aFSVTH"
},
"source": [
"### 将BELLE_BLOOM_GPTQ_4BIT版本下载到colab\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "7r0uotkjFjK8",
"outputId": "2ab9cbe1-d8a7-4593-abea-de791ced63fb"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Updated git hooks.\n",
"Git LFS initialized.\n",
"Cloning into 'BELLE_BLOOM_GPTQ_4BIT'...\n",
"remote: Enumerating objects: 18, done.\u001b[K\n",
"remote: Counting objects: 100% (18/18), done.\u001b[K\n",
"remote: Compressing objects: 100% (17/17), done.\u001b[K\n",
"remote: Total 18 (delta 2), reused 0 (delta 0), pack-reused 0\u001b[K\n",
"Unpacking objects: 100% (18/18), 4.08 MiB | 4.69 MiB/s, done.\n",
"Encountered 1 file(s) that may not have been copied correctly on Windows:\n",
"\tbloom7b-2m-4bit-128g.pt\n",
"\n",
"See: `git lfs help smudge` for more details.\n"
]
}
],
"source": [
"\n",
"!git lfs install && git clone https://huggingface.co/BelleGroup/BELLE_BLOOM_GPTQ_4BIT"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "ouZZilIOHr5Y",
"outputId": "9f9b0550-9e1e-4b8d-af3f-c758082f5c97"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"bloom7b-2m-4bit-128g.pt README.md\t\t tokenizer.json\n",
"config.json\t\t special_tokens_map.json\n",
"pytorch_model.bin.index.json tokenizer_config.json\n"
]
}
],
"source": [
"!ls BELLE_BLOOM_GPTQ_4BIT"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "w27oK-ACsagp",
"outputId": "69a75c4a-92a1-482a-fb94-700dc52f9691"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"/content/BELLE/gptq\n"
]
}
],
"source": [
"!pwd"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"id": "XuyRBoLm_ZXh"
},
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "WXqexFzNfWwS"
},
"outputs": [],
"source": []
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"id": "OnPC00NyyNgH"
},
"source": [
"## 运行下面的cell，然后在Human后面点击输入你和BELLE的对话内容。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "wno4FIAgZ8CI",
"outputId": "9ab1b847-5242-4915-d498-54f3fb13295e"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Loading model ...\n",
"Done.\n",
"Human:\n",
"你是谁？\n",
"Assistant:\n",
"\n",
"2023-04-13 10:26:28.343829: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
"也是一个问题，但是我的主人没有给我答案。\n",
"\n",
"-------------------------------\n",
"\n",
"Human:\n",
"怎么让自己变得精力充沛？\n",
"Assistant:\n",
"\n",
"\n",
"\n",
"1. 睡眠时间充足。良好的睡眠可以让人的精力充沛，应该每天保证7-8小时的睡眠。\n",
"2. 坚持运动。适量的运动可以促进身体的新陈代谢，让身体更加精力充沛。\n",
"3. 均衡饮食。均衡的饮食可以为身体提供足够的能量和支持，避免感到疲乏。\n",
"4. 避免压力。压力可以使人的精神状态不佳，应该采取一些方法来缓解压力。\n",
"5. 建立良好习惯。建立一些良好的习惯可以让我们更加精力充沛，如每天坚持一些自己的爱好，规律的生活等等。\n",
"\n",
"-------------------------------\n",
"\n",
"Human:\n",
"写一首歌颂程序员的诗。\n",
"Assistant:\n",
"\n",
"\n",
"\n",
"代码海洋漫无边，\n",
"代码海洋深不可测。\n",
"逻辑思路如天网，\n",
"程序员们日以继夜。\n",
"\n",
"他们喜欢把问题简化，\n",
"却让复杂变简单。\n",
"他们的想象力无限，\n",
"解决难题难题。\n",
"\n",
"程序员们是英雄，\n",
"是人类智慧的源泉。\n",
"让我们珍惜他们的努力，\n",
"珍惜他们带来的成果。\n",
"\n",
"-------------------------------\n",
"\n",
"Human:\n",
"\n",
"^C\n"
]
}
],
"source": [
"! python bloom_inference.py BELLE_BLOOM_GPTQ_4BIT --temperature 1.2 --wbits 4 --groupsize 128 --load BELLE_BLOOM_GPTQ_4BIT/bloom7b-2m-4bit-128g.pt"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "Xb5qp30PdB5Y"
},
"outputs": [],
"source": [
" "
]
}
],
"metadata": {
"accelerator": "GPU",
"colab": {
"provenance": [],
"toc_visible": true
},
"gpuClass": "standard",
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"name": "python"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
================================================
FILE: models/notebook/README.md
================================================
# BELLE Notebooks
你可以在这里找到BELLE的官方Notebooks实现列表
### Documentation notebooks
你可以在colab里面打开这里任何一个notebooks (notebook最上面提供了打开colab的按钮) ，你也可以在下面链接打开它们:
| Notebook | Description | Colab |
|:----------|:-------------|:-------------|
| [BELLE-GPTQ Colab推理](https://github.com/LianjiaTech/BELLE/blob/main/models/notebook/BELLE_INFER_COLAB.ipynb) | 提供了BELLE 4bit量化的BLOOM模型在Colab运行的示例代码 ，该代码运行时内存最高消费8G，GPU显存只需要10G即可运行，当然你本地机器如果满足上述硬件条件，也可以将Notebook下载到本地运行。|[](https://colab.research.google.com/github/LianjiaTech/BELLE/blob/main/models/notebook/BELLE_INFER_COLAB.ipynb)|
### The hardware requirements
BELLE不同模型运行时，需要满足的最低硬件配置条件
| Model | Description | RAM | GPU |
|:----------|:-------------|:-------------|:-------------|
|bloom7b-2m-4bit-128g.pt | BELLE BLOOM 7B 200万训练数据版4bit量化后权重 |8G| 10G|
================================================
FILE: requirements.txt
================================================
numpy
rouge_score
fire
openai
transformers
gensim
peft
datasets
bitsandbytes
deepspeed
flash-attn
trl
accelerate
================================================
FILE: train/README.md
================================================
# BELLE训练
| [English](https://github.com/LianjiaTech/BELLE/blob/main/train/docs/README_en.md) | [中文](https://github.com/LianjiaTech/BELLE/blob/main/train/README.md)
当前仓库的代码属于BELLE项目训练代码v2版，上一版基于deepspeed-chat的代码放在dschat_train_v1目录下，未做任何改动。
考虑到如下因素和目前大家提出的issues，我们更新了仓库的训练代码
1. 没有deepspeed环境时无法使用仓库代码训练模型
2. deepspeed-chat没有集成peft包，对参数高效微调这一块的可扩展性不高
当前v2版本的代码对环境的依赖性较低，而且更加简洁。
## 1. 准备环境
### 1.1 Docker镜像
我们提供了一个完整可运行的Docker镜像，Dockerfile写在docker文件夹下。
考虑到build存在一定的困难，我们提供了镜像下载，你可以使用下面命令从dockerhub拉取我们的镜像，然后在镜像中运行代码，详见[docker环境说明](../docker/README.md)。
```shell
sudo docker pull tothemoon/belle:latest
git clone https://github.com/LianjiaTech/BELLE.git
```
```
sudo docker run --gpus all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 \
--network host \
--privileged \
[--env https_proxy=$https_proxy \]
[--env http_proxy=$http_proxy \]
[--env all_proxy=$all_proxy \]
--env HF_HOME=$hf_home \
-it [--rm] \
--name belle \
-v $belle_path:$belle_path \
-v $hf_home:$hf_home \
-v $ssh_pub_key:/root/.ssh/authorized_keys \
-w $workdir \
$docker_user/belle:$tag \
[--sshd_port 2201 --cmd "echo 'Hello, world!' && /bin/bash"]
```
`[]`中内容可忽略
- `--rm`：容器退出时销毁，如果长期在容器中工作，可忽略
- `--sshd_port`：sshd监听端口，默认是22001
- `--cmd`：容器要执行的命令`"echo 'Hello, world!' && /bin/bash"`，可忽略
- `hf_home`：huggingface缓存目录
- `$ssh_pub_key`：sshd公钥目录
上述命令实现了以下几点：
1. 拉取docker镜像
2. clone BELLE仓库
3. 将BELLE目录挂载
4. 将huggingface目录挂载。其中huggingface_models代表预训练模型的保存路径，该目录下存放所有需要的预训练语言模型，如llama-7b, bloomz-7b1-mt等
5. 注意：上述挂载的目录必须是绝对路径
### 1.2 conda（不推荐）
由于部分包依赖系统环境编译，推荐使用docker。假如由于机器等原因不能使用docker，也可以通过conda创建环境，然后pip安装需要的包，需自行解决依赖问题
```bash
pip install -r requirements.txt
```
但是通过pip安装deepspeed很有可能安装或者运行失败，[FAQ](https://github.com/LianjiaTech/BELLE/blob/main/train/docs/FAQ.md) 中给出了一些安装deepspeed的教程以及可能遇到的问题
## 2. 模型训练
- 微调参见[README_FT.md](README_FT.md)
- RLHF参见[README_RLHF.md](README_RLHF.md)
================================================
FILE: train/README_FT.md
================================================
# BELLE微调流程
## 1. Run
### 1.1 数据
#### 1.1.1 指令微调（SFT）
##### 1.1.1.1 Download data
```bash
wget https://huggingface.co/datasets/BelleGroup/school_math_0.25M/resolve/main/school_math_0.25M.json
```
该数据是数学应用题求解任务，包含解题过程，共计约25万条。示例：
| Instruction | Answer |
| ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 一箱鸡蛋有25个，小明爸爸每天给他9个鸡蛋吃，那么一箱鸡蛋能够供小明吃几天？ | 一箱鸡蛋有25个，小明每天吃9个鸡蛋，用除法计算一下即可： 25 ÷ 9 = 2余7 也就是说，小明第1天到第2天共吃2个鸡蛋，第3天吃剩下的7个鸡蛋。 因此，一箱鸡蛋能够供小明吃2天。 |
| 小明手中有15颗糖果，他想要分给他的朋友小红和小李，每人分得的糖果数是3颗，那么他还剩下几颗糖果？ | 该题可以用减法来解决。小明手中有15颗糖果，每人分得3颗，所以小红和小李一共分得6颗糖果（3+3=6）。 2. 然后再用原来的糖果总数减去分给小红和小李的糖果数，即可得到小明手中剩余的糖果数。 计算过程如下： 15 - 6 = 9 所以，小明还剩下9颗糖果。 |
##### 1.1.1.2 Convert data format
```bash
python scripts/convert_to_conv_data.py --orig_data school_math_0.25M.json --write_data school_math_0.25M_conv.json --dataset_name bellemath
head -n 1000 school_math_0.25M_conv.json > belleMath-dev1K.json
tail -n +1001 school_math_0.25M_conv.json > belleMath.json
```
我们选取前1000条作为验证集，其余数据作为训练集
**注：**目前仓库的代码要兼容单轮和多轮数据，因此对于之前的开源数据(格式为[instruction,output]，目前绝大部分开源的单轮instruction数据均为这种格式)，需要用convert_to_conv_data.py脚本转换为如下的统一格式:
```bash
{"id": "bellemath42", "conversations": [{"from": "human", "value": " 一箱鸡蛋有25个，小明爸爸每天给他9个鸡蛋吃，那么一箱鸡蛋能够供小明吃几天？"}, {"from": "assistant", "value": "\n一箱鸡蛋有25个，小明每天吃9个鸡蛋，用除法计算一下即可：\n25 ÷ 9 = 2余7\n也就是说，小明第1天到第2天共吃2个鸡蛋，第3天吃剩下的7个鸡蛋。\n因此，一箱鸡蛋能够供小明吃2天。"}]}
{"id": "bellemath80", "conversations": [{"from": "human", "value": "小明手中有15颗糖果，他想要分给他的朋友小红和小李，每人分得的糖果数是3颗，那么他还剩下几颗糖果？"}, {"from": "assistant", "value": " \n1. 该题可以用减法来解决。小明手中有15颗糖果，每人分得3颗，所以小红和小李一共分得6颗糖果（3+3=6）。\n2. 然后再用原来的糖果总数减去分给小红和小李的糖果数，即可得到小明手中剩余的糖果数。 \n计算过程如下：\n15 - 6 = 9\n所以，小明还剩下9颗糖果。"}]}
```
其他的训练数据见：https://huggingface.co/BelleGroup 按照上述流程转换格式即可。
对于多轮对话数据， [shareGPT](https://huggingface.co/datasets/anon8231489123/ShareGPT_Vicuna_unfiltered/tree/main) 是一个开源的大规模多轮对话数据，具体效果可参考我们的工作：[Towards Better Instruction Following Language Models for Chinese: Investigating the Impact of Training Data and Evaluation](https://arxiv.org/pdf/2304.07854.pdf)
当前代码已支持训练这种多轮对话数据。数据下载：
```bash
wget https://huggingface.co/datasets/anon8231489123/ShareGPT_Vicuna_unfiltered/resolve/main/ShareGPT_V3_unfiltered_cleaned_split.json
```
#### 1.1.2 继续预训练（PT）
数据格式
```
{"text": xxx}
{"text": xxx}
```
### 1.2 模型训练
支持配置
* 全量微调 + Deepspeed
* LoRA + Deepspeed
* LoRA + int8
训练的启动脚本写在`scripts/run_.sh`，你需要按照实际需求修改`run_.sh`中的参数。
`run_pt.sh`实现了继续预训练，`run_sft.sh`实现了指令微调。
```bash
bash scripts/run_sft.sh
```
- model_name_or_path 代表预训练模型（如果是LLaMA模型，需事先转为hf格式才能通过from_pretrained读取）
- train_file 代表训练数据
- validation_file 代表验证数据
- output_dir 代表训练日志和模型保存的路径
- cache_dir 代表缓存数据处理过程的路径
- cutoff_len 代表最长输入序列长度（LLaMA模型建议设置为1024以上，Bloom模型设置为512以上）
`run_.sh`中包含了全量参数微调和LoRA两种训练方式的启动命令，这里将简单说明下启动命令中各个参数的含义
**模型resume from checkpoint**
如果`output_dir`包含了多个存档点，训练直接从最新的存档点恢复，也可以`--resume_from_checkpoint ${output_dir}/checkpoint-xxx`手动指定从step xxx恢复
**Flash Attention**
flash attention实现了高效利用显存的attention，可支持更大的序列长度
`run_pt.sh`默认使用flash-attention-v2
`run_sft.sh`flash-attention-v2可选，可通过`--use_flash_attention`打开
#### 1.2.1 全量参数微调
下面的命令是单机多卡进行全量参数微调，同时采用deepspeed，基础模型是LLaMA
```bash
torchrun --nproc_per_node 8 src/entrypoint/sft_train.py \
--model_name_or_path ${model_name_or_path} \
--llama \
--deepspeed configs/deepspeed_config.json \
--train_file ${train_file} \
--validation_file ${validation_file} \
--per_device_train_batch_size 2 \
--per_device_eval_batch_size 2 \
--gradient_accumulation_steps 4 \
--num_train_epochs 2 \
--model_max_length ${cutoff_len} \
--save_strategy "steps" \
--save_total_limit 3 \
--learning_rate 8e-6 \
--weight_decay 0.00001 \
--warmup_ratio 0.05 \
--lr_scheduler_type "cosine" \
--logging_steps 10 \
--evaluation_strategy "steps" \
--fp16 True \
--seed 1234 \
--gradient_checkpointing True \
--cache_dir ${cache_dir} \
--output_dir ${output_dir}
```
**参数说明**
1. 如果想要单卡训练，仅需将nproc_per_node设置为1即可
2. 如果预训练模型不是LLaMA，则去掉--llama。如果是LLaMA模型，需要指定--llama。因为LLaMA模型需要采用LLamaTokenizer加载，如果用AutoTokenizer加载llama可能会出现无限递归的问题，这和transformers版本有关
3. 如果运行环境不支持deepspeed，去掉--deepspeed
deepspeed 的参数配置可参考：
1. https://www.deepspeed.ai/docs/config-json/
2. https://huggingface.co/docs/accelerate/usage_guides/deepspeed
3. https://github.com/huggingface/transformers/blob/main/tests/deepspeed
**关于deepspeed**
如果显存充足，可优先考虑stage 2，对应的配置文件是configs/deepspeed_config.json。如果显存不足，可采用stage 3，该模式下模型参数将分布在多张显卡上，可显著减小显存占用，对应的配置文件是configs/deepspeed_config_stage3.json。
训练日志和模型保存在output_dir目录下，目录下的文件结构应该如下：
```Arduino
output_dir/
├── checkpoint-244/
│ ├── pytorch_model.bin
│ ├── config.json
│ └── trainer_state.json
├── checkpoint-527/
│ ├── pytorch_model.bin
│ ├── config.json
│ └── trainer_state.json
├── pytorch_model.bin
├── print_log.txt
└── config.json
```
trainer_state.json记录了loss、learning_rate的变化
#### 1.2.2 LoRA
```bash
torchrun --nproc_per_node 8 src/entry_point/sft_train.py \
--model_name_or_path ${model_name_or_path} \
--llama \
--use_lora True \
--use_int8_training \
--lora_config configs/lora_config_llama.json \
--train_file ${train_file} \
--validation_file ${validation_file} \
--per_device_train_batch_size 2 \
--per_device_eval_batch_size 2 \
--gradient_accumulation_steps 4 \
--num_train_epochs 2 \
--model_max_length ${cutoff_len} \
--save_strategy "steps" \
--save_total_limit 3 \
--learning_rate 8e-6 \
--weight_decay 0.00001 \
--warmup_ratio 0.05 \
--lr_scheduler_type "cosine" \
--logging_steps 10 \
--evaluation_strategy "steps" \
--fp16 True \
--seed 1234 \
--gradient_checkpointing True \
--cache_dir ${cache_dir} \
--output_dir ${output_dir} \
# --deepspeed configs/deepspeed_config_stage3.json
```
**参数说明**
* use_lora 代表采用LoRA训练
* use_int8_training 代表采用8bit量化训练，可显著减少显存占用
* lora_config 给出了LoRA的参数配置。如果训练Bloom模型，则改为configs/lora_config_bloom.json
* deepspeed 训练的序列较长时，推荐使用deepspeed stage 3，能有效将模型参数分配到多卡上，留下空间加载更长的序列
**注意**：use_int8_training和deepspeed只能二选一，不可同时使用
output_dir目录的文件结构如下：
```
output_dir/
├── checkpoint-244/
│ ├── pytorch_model.bin
│ └── trainer_state.json
├── checkpoint-527/
│ ├── pytorch_model.bin
│ └── trainer_state.json
├── print_log.txt
└── adapter_config.json
```
最上级目录存储训练的最终模型
#### 1.2.3 合并LoRA权重
如果您想要实现LoRA权重与预训练模型的合并，可运行如下命令：
```bash
bash scripts/merge_lora.sh
```
合并后的权重保存在output_path目录下，后续可通过from_pretrained直接加载
#### 1.2.4 多机多卡训练
以两台机器为例，每台机器上有8张卡
首先需要在第一台机器(主机器)上运行
```bash
bash scripts/multinode_run.sh 0
```
然后在第二台机器上运行
```bash
bash scripts/multinode_run.sh 1
```
**参数说明**
```bash
node_rank=$1
echo ${node_rank}
master_addr="10.111.112.223"
# #Multi-node
torchrun --nproc_per_node 8 --nnodes 2 --master_addr ${master_addr} --master_port 14545 --node_rank ${node_rank} src/train.py
```
- node_rank 代表节点的rank，第一台机器（主机器）的rank设置为0，第二台机器的rank设置为1
- nnodes 代表节点机器的数量
- master_addr 代表主机器的ip地址
- master_port 代表与主机器通信的端口号
## 2. Inference
### 2.1 Inference
如果您看到了这里，说明您已经完成了训练。现在我们加载训练好的模型，验证模型生成文本的效果。
```bash
CUDA_VISIBLE_DEVICES=0 python src/entry_point/inference.py \
--model_name_or_path $model_name_or_path \
--ckpt_path $ckpt_path \
--llama \
--use_lora
```
**参数说明：**
- model_name_or_path 是原生预训练模型的路径
- ckpt_path 是训练后保存的模型路径，也就是output_dir
- llama 代表基础模型是否是LLaMA模型
- use_lora 代表ckpt_path是否是LoRA权重
**注：LoRA训练后保存的模型adapter_model.bin有可能是空文件，此时需要将其它checkpoint-step下保存的pytorch_model.bin复制到output_dir目录下**
此外，如果您已经将LoRA权重与预训练模型进行了合并，则ckpt_path指定为合并后权重保存的路径即可，不需要再指定use_lora
### 2.2 webUI
我们也提供了一个简洁的基于gradio的交互式web界面，启动服务：
```bash
CUDA_VISIBLE_DEVICES=0 python src/entry_point/interface.py \
--model_name_or_path $model_name_or_path \
--ckpt_path $ckpt_path \
--llama \
--use_lora
```
服务访问地址是 hostip:17860
### 2.3 并行推理
```bash
bash scripts/run_multi_backend.sh
```
打开`src/entry_point/evaluation.ipynb`，设置相应路径，加载自己的数据推理
### 2.4 ZeRO Inference
详见[ZeRO Inference](README_ZERO_INFERENCE.md)
## 3. Additional Notes
### 3.1 LLaMA模型的使用
#### 3.1.1 facebook官方LLaMA权重转为hf格式
首先，您需要从[facebookresearch/llama](https://github.com/facebookresearch/llama)获取LLaMA模型的访问权限，下载官方检查点
```bash
python scripts/convert_llama_weights_to_hf.py --input_dir download_official_llama_path --model_size 7B --output_dir xx/llama-7b-hf
```
运行训练脚本时将model_name_or_path改为xx/llama-7b-hf即可
#### 3.1.2 BELLE-LLaMA转为hf格式
由于LLaMA模型的使用约束，我们只能开源与原始模型的diff（如：[BELLE-LLaMA-7B-2M-enc](https://huggingface.co/BelleGroup/BELLE-LLaMA-7B-2M-enc)）。当您已经从[facebookresearch/llama](https://github.com/facebookresearch/llama)获取LLaMA模型的访问权限后，可参考 https://github.com/LianjiaTech/BELLE/tree/main/models ，转换后的模型即为我们指令调优后的LLaMA模型。
### 3.2 合并词表
如果您想在原版LLaMA的基础上扩充中文词表，可参考scripts/merge_tokenizers.py，后续会开放训练embedding的代码。扩充词表后的效果可参考我们的工作：[Towards Better Instruction Following Language Models for Chinese: Investigating the Impact of Training Data and Evaluation](https://arxiv.org/pdf/2304.07854.pdf)
## 4. 问题反馈
如有问题，请在GitHub Issue中提交。在遇到问题前，请先在 [FAQ](https://github.com/LianjiaTech/BELLE/blob/main/train/docs/FAQ.md) 中查找相似问题的解决方案。
================================================
FILE: train/README_RLHF.md
================================================
# RLHF训练流程
## 一、PPO
### 1. 奖励模型
#### 1.1 准备数据
```jsonl
{"chosen": xxx, "rejected": xxx}
```
注意：
xxx文本已经添加了正确的提示，用于区别人类和bot，如 `Human: \n{text}\n\nAssistant: \n{text}`
#### 1.2 训练
```bash
bash scripts/run_rm.sh
```
- use_llama：是否使用llama作为基础模型
- use_lora：是否使用lora微调
- load_in_8bit：是否使用8bit载入
- load_in_4bit：是否使用4bit载入
注意：
- 支持deepspeed stage 3直接运行
- 不支持deepspeed stage 3 + lora，deepspeed stage 1/2 + lora可以运行
- load_in_8bit和load_in_4bit不能和deepspeed同时使用，可以和lora同时使用。需要将 `configs/accelerate_config_rm.yaml`中"distributed_type"从"DEEPSPEED"改为"MULTI_GPU"
### TODO
- [ ] deepspeed stage 3 + lora支持
### 2. PPO
#### 2.1 准备数据
```jsonl
{"text": xxx}
```
注意：xxx文本已经添加了正确的提示，用于区别人类和bot，如 `Human: \n{text}\n\nAssistant: \n`
#### 2.2 训练
```bash
bash scripts/run_ppo.sh
```
- use_llama：使用llama作为基础模型
- use_lora：使用lora微调
- batch_size：每个进程搜集的experience大小
- mini_batch_size：在experience上训练的batch大小
- input_length：输入文本的最长长度，超过该长度会被过滤掉
- ppo_epochs：在采样的batch训练多少轮
- data_epochs：在prompt数据上训练多少轮
注意：
- 支持deepspeed zero stage 3，拆分model、ref_model和reward_model
- 支持deepspeed zero stage 3 + lora
- $batch\\_size == mini\\_batch\\_size * gradient\\_accumulation\\_steps$
- 数据集大小要大于 `num_processes * batch_size`，否则部分进程拿不到数据，出现报错，输出中 `Train dataset length`可以看到经过长度过滤的数据集大小
#### TODO
- [ ] 每次训练的batch_size是 `num_processes * batch_size`，每个进程只会从自己的 `batch`中采样，而不是从全局的 `num_processes * batch_size`中采样，这会导致每个gpu采到的 `mini_batch`不是完全随机的，`mini_batch`不包含其它进程 `batch`中的样本
- [ ] gradient checkpointing
- [ ] resume from checkpoint
## 二、DPO
### 2.1 准备数据
格式：
```jsonl
{"chosen":xxx, "reject":xxx, "prompt":xxx}
```
一条数据样例：
```jsonl
{"chosen": "水的化学式是H2O。这意味着每个水分子由两个氢原子（H）和一个氧原子（O）组成。在这个结构中，氢原子和氧原子通过共价键相连。", "rejected": "H2O.", "prompt": "Human: \n水的化学式是什么？\n\nAssistant: \n"}
```
### 2.2 训练
首先，请将“train/scripts”下“run_dpo.sh”脚本中的“...”改成所需参数值
其次：
```bash
cd train/scripts
bash run_dpo.sh
```
注：DPO部分代码基于[trl项目](https://github.com/huggingface/trl)，具体原理见[论文](https://arxiv.org/abs/2305.18290)
================================================
FILE: train/README_ZERO_INFERENCE.md
================================================
# ZeRO Inference
## 1.1 什么是ZeRO Inference
[Zero Inference](https://www.deepspeed.ai/2022/09/09/zero-inference.html)利用ZeRO stage 3的数据并行特性，能够将模型分布到多张GPU上，或者Offload到内存或者NVMe上，推理单GPU无法加载的模型
## 1.2 Zero Inference注意事项
Zero Inference是数据并行的推理，因此需要在各个GPU同时启动推理进程并进行`model.forward`，否则会卡住
## 1.3 和其他并行策略的比较
- 张量并行（对模型手动切分）
- 通信量：
- $O(batch \times len \times layer \times hidden)$
- 计算和通讯不能同时进行
- 流水线并行（`AutoModelForCausalLM.from_pretrained(device_map="auto")`）
- 通信量：
- $O(batch \times len \times layer \times hidden)$
- 计算和通讯不能同时进行
- 数据并行（ZeRO Inference）
- 通信量：
- $O(hidden \times hidden)$
- 计算和通讯可以同时进行
## 2 运行代码
本仓库实现了LLaMA和LLaMA 2的flash attention，可在推理时启动，降低显存占用。
由于flash attention不支持自定义的attention mask，启动flash attention时，batch size必须设为1并关闭任何padding。
### 2.1 批量推理（推荐）
#### 2.1.1 准备数据
```
{"text": xxx}
{"text": xxx}
```
#### 2.1.2 运行
```
bash scripts/run_zero_inference.sh
```
可传入的参数有`max_new_tokens`、`min_new_tokens`、`do_sample`、`num_beams`、`temperature`、`top_k`、`top_p`、`repetition_penalty`。
具体说明见[huggingface文档](https://huggingface.co/docs/transformers/main/main_classes/text_generation)
### 2.2 推理后端（前后端分离）
#### 2.2.1 运行后端
```
bash scripts/run_zero_inference_backend_without_trainer.sh
```
- `devices`：指令使用哪几个显卡，格式同`CUDA_VISIBLE_DEVICES`
- `base_port`：后端服务监听端口，打开[`base_port`, `base_port` + `num_devices` - 1]的端口
#### 2.2.2 运行前端
运行`src/evaluation.ipynb`，由于ZeRO Inference要求多个`model.forward`必须同时运行，必须设置`synced_worker=True`，同时保证客户端连接上了每个后端进程
================================================
FILE: train/configs/accelerate_config_ppo.yaml
================================================
compute_environment: LOCAL_MACHINE
deepspeed_config:
deepspeed_config_file: configs/deepspeed_config_ppo.json
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
num_machines: 1
num_processes: 8
use_cpu: false
================================================
FILE: train/configs/accelerate_config_rm.yaml
================================================
compute_environment: LOCAL_MACHINE
deepspeed_config:
deepspeed_config_file: configs/deepspeed_config_rm.json
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
num_machines: 1
num_processes: 8
use_cpu: false
================================================
FILE: train/configs/deepspeed_config.json
================================================
{
"zero_optimization": {
"stage": 2,
"allgather_partitions": true,
"allgather_bucket_size": 5e8,
"reduce_scatter": true,
"reduce_bucket_size": "auto",
"overlap_comm": true,
"contiguous_gradients": true
},
"scheduler": {
"type": "WarmupDecayLR",
"params": {
"warmup_min_lr": "auto",
"warmup_max_lr": "auto",
"warmup_num_steps": "auto",
"total_num_steps": "auto"
}
},
"fp16": {
"enabled": false,
"auto_cast": false,
"loss_scale": 0,
"loss_scale_window": 1000,
"initial_scale_power": 32,
"hysteresis": 2,
"min_loss_scale": 1
},
"bf16": {
"enabled": true
},
"optimizer": {
"type": "AdamW",
"params": {
"lr": "auto",
"weight_decay": "auto",
"betas": "auto",
"eps": "auto",
"torch_adam": true,
"adam_w_mode": true
}
},
"gradient_accumulation_steps": "auto",
"gradient_clipping": "auto",
"steps_per_print": 1000,
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto",
"wall_clock_breakdown": false
}
================================================
FILE: train/configs/deepspeed_config_flops_profile.json
================================================
{
"flops_profiler": {
"enabled": true,
"profile_step": 50,
"module_depth": -1,
"top_modules": 1,
"detailed": true,
"output_file": "profile.log"
},
"zero_optimization": {
"stage": 2,
"allgather_partitions": true,
"allgather_bucket_size": 5e8,
"reduce_scatter": true,
"reduce_bucket_size": "auto",
"overlap_comm": true,
"contiguous_gradients": true
},
"scheduler": {
"type": "WarmupDecayLR",
"params": {
"warmup_min_lr": "auto",
"warmup_max_lr": "auto",
"warmup_num_steps": "auto",
"total_num_steps": "auto"
}
},
"fp16": {
"enabled": false,
"auto_cast": false,
"loss_scale": 0,
"loss_scale_window": 1000,
"initial_scale_power": 32,
"hysteresis": 2,
"min_loss_scale": 1
},
"bf16": {
"enabled": true
},
"optimizer": {
"type": "AdamW",
"params": {
"lr": "auto",
"weight_decay": "auto",
"betas": "auto",
"eps": "auto",
"torch_adam": true,
"adam_w_mode": true
}
},
"gradient_accumulation_steps": "auto",
"gradient_clipping": "auto",
"steps_per_print": 1000,
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto",
"wall_clock_breakdown": false
}
================================================
FILE: train/configs/deepspeed_config_ppo.json
================================================
{
"zero_optimization": {
"stage": 3,
"allgather_partitions": true,
"allgather_bucket_size": 5e8,
"reduce_scatter": true,
"reduce_bucket_size": "auto",
"overlap_comm": true,
"contiguous_gradients": true
},
"fp16": {
"enabled": false,
"auto_cast": false,
"loss_scale": 0,
"loss_scale_window": 1000,
"initial_scale_power": 32,
"hysteresis": 2,
"min_loss_scale": 1
},
"bf16": {
"enabled": true
},
"optimizer": {
"type": "AdamW",
"params": {
"lr": "auto",
"weight_decay": 1e-2,
"betas": [0.9, 0.999],
"eps": 1e-8,
"torch_adam": true,
"adam_w_mode": true
}
},
"gradient_accumulation_steps": "auto",
"gradient_clipping": "auto",
"steps_per_print": 1000,
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto",
"wall_clock_breakdown": false
}
================================================
FILE: train/configs/deepspeed_config_rm.json
================================================
{
"zero_optimization": {
"stage": 2,
"allgather_partitions": true,
"allgather_bucket_size": 5e8,
"reduce_scatter": true,
"reduce_bucket_size": "auto",
"overlap_comm": true,
"contiguous_gradients": true
},
"scheduler": {
"type": "WarmupDecayLR",
"params": {
"warmup_min_lr": "auto",
"warmup_max_lr": "auto",
"warmup_num_steps": "auto",
"total_num_steps": "auto"
}
},
"fp16": {
"enabled": "auto",
"auto_cast": false,
"loss_scale": 0,
"loss_scale_window": 1000,
"initial_scale_power": 32,
"hysteresis": 2,
"min_loss_scale": 1
},
"bf16": {
"enabled": "auto"
},
"optimizer": {
"type": "AdamW",
"params": {
"lr": "auto",
"weight_decay": "auto",
"betas": "auto",
"eps": "auto",
"torch_adam": true,
"adam_w_mode": true
}
},
"gradient_accumulation_steps": "auto",
"gradient_clipping": "auto",
"steps_per_print": 1000,
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto",
"wall_clock_breakdown": false
}
================================================
FILE: train/configs/deepspeed_config_stage3.json
================================================
{
"zero_optimization": {
"stage": 3,
"allgather_partitions": true,
"allgather_bucket_size": 5e8,
"reduce_scatter": true,
"reduce_bucket_size": "auto",
"overlap_comm": true,
"contiguous_gradients": true,
"sub_group_size": 0,
"stage3_prefetch_bucket_size": 0,
"stage3_param_persistence_threshold": 0,
"stage3_max_live_parameters": 0,
"stage3_max_reuse_distance": 0,
"stage3_gather_16bit_weights_on_model_save": true,
"offload_param": {
"device": "cpu"
},
"offload_optimizer": {
"device": "cpu"
}
},
"scheduler": {
"type": "WarmupDecayLR",
"params": {
"warmup_min_lr": "auto",
"warmup_max_lr": "auto",
"warmup_num_steps": "auto",
"total_num_steps": "auto"
}
},
"fp16": {
"enabled": false,
"auto_cast": false,
"loss_scale": 0,
"loss_scale_window": 1000,
"initial_scale_power": 32,
"hysteresis": 2,
"min_loss_scale": 1
},
"bf16": {
"enabled": true
},
"optimizer": {
"type": "AdamW",
"params": {
"lr": "auto",
"weight_decay": "auto",
"betas": "auto",
"eps": "auto",
"torch_adam": true,
"adam_w_mode": true
}
},
"gradient_accumulation_steps": "auto",
"gradient_clipping": "auto",
"steps_per_print": 1000,
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto",
"wall_clock_breakdown": false
}
================================================
FILE: train/configs/deepspeed_config_stage3_dpo.json
================================================
{
"bfloat16": {
"enabled": true
},
"fp16": {
"enabled": false,
"loss_scale": 0,
"loss_scale_window": 1000,
"initial_scale_power": 16,
"hysteresis": 2,
"min_loss_scale": 1
},
"optimizer": {
"type": "AdamW",
"params": {
"lr": "auto",
"weight_decay": "auto",
"betas": "auto",
"eps": "auto",
"torch_adam": true,
"adam_w_mode": true
}
},
"scheduler": {
"type": "WarmupDecayLR",
"params": {
"warmup_min_lr": "auto",
"warmup_max_lr": "auto",
"warmup_num_steps": "auto",
"total_num_steps": "auto"
}
},
"zero_optimization": {
"stage": 3,
"overlap_comm": true,
"contiguous_gradients": true,
"sub_group_size": 1e12,
"reduce_bucket_size": "auto",
"stage3_prefetch_bucket_size": "auto",
"stage3_param_persistence_threshold": "auto",
"stage3_max_live_parameters": 1e9,
"stage3_max_reuse_distance": 1e9,
"stage3_gather_16bit_weights_on_model_save": true
},
"gradient_accumulation_steps": "auto",
"gradient_clipping": "auto",
"steps_per_print": 1e5,
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto",
"wall_clock_breakdown": false
}
================================================
FILE: train/configs/deepspeed_config_stage3_flops_profile.json
================================================
{
"flops_profiler": {
"enabled": true,
"profile_step": 50,
"module_depth": -1,
"top_modules": 1,
"detailed": true,
"output_file": "profile.log"
},
"zero_optimization": {
"stage": 3,
"allgather_partitions": true,
"allgather_bucket_size": 5e8,
"reduce_scatter": true,
"reduce_bucket_size": "auto",
"overlap_comm": true,
"contiguous_gradients": true,
"sub_group_size": 0,
"stage3_prefetch_bucket_size": 0,
"stage3_param_persistence_threshold": 0,
"stage3_max_live_parameters": 0,
"stage3_max_reuse_distance": 0,
"stage3_gather_16bit_weights_on_model_save": true,
"offload_param": {
"device": "cpu"
},
"offload_optimizer": {
"device": "cpu"
}
},
"scheduler": {
"type": "WarmupDecayLR",
"params": {
"warmup_min_lr": "auto",
"warmup_max_lr": "auto",
"warmup_num_steps": "auto",
"total_num_steps": "auto"
}
},
"fp16": {
"enabled": false,
"auto_cast": false,
"loss_scale": 0,
"loss_scale_window": 1000,
"initial_scale_power": 32,
"hysteresis": 2,
"min_loss_scale": 1
},
"bf16": {
"enabled": true
},
"optimizer": {
"type": "AdamW",
"params": {
"lr": "auto",
"weight_decay": "auto",
"betas": "auto",
"eps": "auto",
"torch_adam": true,
"adam_w_mode": true
}
},
"gradient_accumulation_steps": "auto",
"gradient_clipping": "auto",
"steps_per_print": 1000,
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto",
"wall_clock_breakdown": false
}
================================================
FILE: train/configs/deepspeed_config_stage3_inference.json
================================================
{
"fp16": {
"enabled": true
},
"bf16": {
"enabled": false
},
"zero_optimization": {
"stage": 3,
"overlap_comm": true,
"contiguous_gradients": true,
"reduce_bucket_size": 5e8,
"stage3_max_live_parameters": 0,
"stage3_max_reuse_distance": 0,
"stage3_prefetch_bucket_size": 0,
"stage3_param_persistence_threshold": 0
},
"steps_per_print": 2000,
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto",
"wall_clock_breakdown": false
}
================================================
FILE: train/configs/hostfile
================================================
node_ip slots=8
node_ip slots=8
================================================
FILE: train/configs/lora_config_bloom.json
================================================
{
"lora_r": 16,
"lora_alpha": 32,
"lora_dropout": 0.05,
"lora_target_modules": [
"query_key_value"
]
}
================================================
FILE: train/configs/lora_config_llama.json
================================================
{
"lora_r": 16,
"lora_alpha": 32,
"lora_dropout": 0.05,
"lora_target_modules": [
"q_proj",
"k_proj",
"v_proj",
"o_proj",
"down_proj",
"gate_proj",
"up_proj"
]
}
================================================
FILE: train/docs/FAQ.md
================================================
# FAQ
这里给出一些实验过程中遇到的问题以及供参考的解决方案，同时对问题大致地分类
**解决方案仅供参考，未必能彻底解决对应问题！！！**
**解决方案仅供参考，未必能彻底解决对应问题！！！**
**解决方案仅供参考，未必能彻底解决对应问题！！！**
### Deepspeed相关
| 报错信息 | 参考 |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| RuntimeError: CUDA error: an illegal memory access was encountered.CUDA kernel errors might be asynchronously reported at some other API call,so the stacktrace below might be incorrect | https://github.com/pytorch/pytorch/issues/21819 |
| RuntimeError: Error building extension 'fused_adam' | sudo ln -s /usr/local/cuda/lib64/libcudart.so /usr/lib/libcudart.so |
| RuntimeError: expected scalar type Float but found Half | use_int8_training和deepspeed不能同时指定 |
| RuntimeError: expected scalar type Float but found Half | V100显卡上 use_int8_training和fp16不能同时指定 |
### transformers相关
| 报错信息 | 参考 |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| AutoTokenizer.from_pretrained("llama_model_path")出现递归error, initial llama has no
# assert tokenizer.bos_token_id == 1 and tokenizer.eos_token_id == 2, (tokenizer.bos_token_id, tokenizer.eos_token_id)
tokenizer.bos_token_id = 1
tokenizer.eos_token_id = 2
#transformers version has a different influence for LlamaTokenizer
else:
tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path)
tokenizer.pad_token_id = 0# For Bloom, we also set zero to tokenizer.pad_token_id
tokenizer.padding_side = "left"
print("Making tokenizer padding side to left")
print("tokenizer.bos_token_id: ", tokenizer.bos_token_id)
print("tokenizer.eos_token_id: ", tokenizer.eos_token_id)
model = create_hf_model(AutoModelForCausalLM, args.model_name_or_path,
tokenizer, ds_config)
if args.lora_dim > 0:
lora_module_name = args.lora_module_name.split(",")
print("lora_module_name: ", lora_module_name)
print("lora_dim: {}, lora_alpha: {}, lora_scaling: {}, lora_dropout: {}".format(args.lora_dim, args.lora_alpha, args.lora_alpha/args.lora_dim, args.lora_droppout))
model = convert_linear_layer_to_lora(model, lora_module_name = lora_module_name, lora_dim = args.lora_dim, lora_alpha = args.lora_alpha, lora_droppout=args.lora_droppout)
if args.only_optimize_lora:
model = only_optimize_lora_parameters(model)
# Prepare the data
train_phase = 1
print("sft_only_data_path : ", args.sft_only_data_path)
train_dataset, eval_dataset = create_prompt_dataset(
local_rank = args.local_rank,
sft_only_data_path = args.sft_only_data_path,
eval_data_file = args.eval_data_file,
data_split = args.data_split,
output_path = args.data_output_path,
train_phase = train_phase,
seed = args.seed,
tokenizer = tokenizer,
max_seq_len = args.max_seq_len
)
# DataLoaders creation:
if args.local_rank == -1:
train_sampler = RandomSampler(train_dataset)
eval_sampler = SequentialSampler(eval_dataset)
else:
train_sampler = DistributedSampler(train_dataset)
eval_sampler = DistributedSampler(eval_dataset)
train_dataloader = DataLoader(train_dataset,
collate_fn=default_data_collator,
sampler=train_sampler,
batch_size=args.per_device_train_batch_size)
print("len(train_dataloader) = ", len(train_dataloader))
print("len(train_dataset) = ", len(train_dataset))
print("args.per_device_train_batch_size = ", args.per_device_train_batch_size)
eval_dataloader = DataLoader(eval_dataset,
collate_fn=default_data_collator,
sampler=eval_sampler,
batch_size=args.per_device_eval_batch_size)
print("len(eval_dataloader) = ", len(eval_dataloader))
print("len(eval_dataset) = ", len(eval_dataset))
print("args.per_device_eval_batch_size = ", args.per_device_eval_batch_size)
def evaluation(model, eval_dataloader):
model.eval()
losses = 0
# output_texts = []
for step, batch in tqdm(enumerate(eval_dataloader), total=len(eval_dataloader), unit="batch"):
batch = to_device(batch, device)
with torch.no_grad():
outputs = model(**batch)
loss = outputs.loss
losses += loss.float()
# batch_outputs = model.generate(
# input_ids = batch['input_ids'],
# attention_mask = batch['attention_mask'],
# num_beams=1,
# top_p=0.85,
# top_k=30,
# repetition_penalty=1.2,
# num_beam_groups=1,
# do_sample=True,
# temperature=0.001,
# num_return_sequences=1,
# max_new_tokens=args.max_new_tokens)
# batch_output_texts = tokenizer.batch_decode(batch_outputs, skip_special_tokens = True)
# output_texts.extend(batch_output_texts)
losses = losses / (step + 1)
model.train()
try:
perplexity = torch.exp(losses)
except OverflowError:
perplexity = float("inf")
try:
perplexity = get_all_reduce_mean(perplexity).item()
except:
pass
# with open("./predictions.txt", "w") as f:
# for pred_text in output_texts:
# f.write(pred_text+"\n")
return perplexity
# Split weights in two groups, one with weight decay and the other not.
optimizer_grouped_parameters = get_optimizer_grouped_parameters(
model, args.weight_decay)
AdamOptimizer = DeepSpeedCPUAdam if args.offload else FusedAdam
optimizer = AdamOptimizer(optimizer_grouped_parameters,
lr=args.learning_rate,
betas=(0.9, 0.95))
num_update_steps_per_epoch = math.ceil(
len(train_dataloader) / args.gradient_accumulation_steps)
lr_scheduler = get_scheduler(
name=args.lr_scheduler_type,
optimizer=optimizer,
num_warmup_steps=args.num_warmup_steps,
num_training_steps=args.num_train_epochs * num_update_steps_per_epoch,
)
model, optimizer, _, lr_scheduler = deepspeed.initialize(
model=model,
optimizer=optimizer,
args=args,
config=ds_config,
lr_scheduler=lr_scheduler,
dist_init_required=True)
if args.gradient_checkpointing:
model.gradient_checkpointing_enable()
# Train!
print_rank_0("***** Running training *****", args.global_rank)
print_rank_0(
f"***** Evaluating perplexity, Epoch {0}/{args.num_train_epochs} *****",
args.global_rank)
perplexity = evaluation(model, eval_dataloader)
print_rank_0(f"ppl: {perplexity}", args.global_rank)
training_step_losses = []
for epoch in range(args.num_train_epochs):
print_rank_0(
f"Beginning of Epoch {epoch+1}/{args.num_train_epochs}, Total Micro Batches {len(train_dataloader)}",
args.global_rank)
model.train()
for step, batch in tqdm(enumerate(train_dataloader), total=len(train_dataloader), unit="batch"):
batch = to_device(batch, device)
outputs = model(**batch, use_cache=False)
loss = outputs.loss
model.backward(loss)
model.step()
training_step_losses.append(loss.item())
if (step+1)%args.show_loss_step == 0:
print("Epoch: {}, step: {}, loss: {}".format(epoch, step, sum(training_step_losses)/len(training_step_losses)))
training_step_losses = []
# Evaluate perplexity on the validation set.
perplexity = evaluation(model, eval_dataloader)
print_rank_0(f"ppl: {perplexity}", args.global_rank)
print_rank_0(
f"***** Evaluating perplexity, Epoch {epoch+1}/{args.num_train_epochs} *****",
args.global_rank)
model.tput_timer.update_epoch_count()
if args.output_dir is not None:
print_rank_0('saving the final model ...', args.global_rank)#It will overwrite the last epoch model
model = convert_lora_to_linear_layer(model)
if args.global_rank == 0:
save_hf_format(model, tokenizer, args)
if args.zero_stage == 3:
# For zero stage 3, each gpu only has a part of the model, so we need a special save function
save_zero_three_model(model,
args.global_rank,
args.output_dir,
zero_stage=args.zero_stage)
if __name__ == "__main__":
main()
================================================
FILE: train/dschat_train_v1/prompt_eval.py
================================================
import torch
import json
from transformers import AutoModelForCausalLM, AutoTokenizer, LlamaTokenizer, AutoConfig
import argparse
from tqdm import tqdm
import json, os
parser = argparse.ArgumentParser()
parser.add_argument('--model_name_or_path',required=True,type=str)
parser.add_argument('--finetuned_model_name_or_path',required=True,type=str)
parser.add_argument('--test_file',required=True,type=str)
parser.add_argument('--predictions_file', default='./predictions.json', type=str)
args = parser.parse_args()
print("test_file: " + args.test_file)
print("model_name_or_path: " + args.model_name_or_path)
print("finetuned_model_name_or_path: " + args.finetuned_model_name_or_path)
max_new_tokens = 1024
generation_config = dict(
temperature=0.001,
top_k=30,
top_p=0.85,
do_sample=True,
num_beams=1,
repetition_penalty=1.2,
max_new_tokens=max_new_tokens
)
def read_data(filename):
res = []
with open(filename, 'r', encoding='utf-8') as f:
lines = f.readlines()
for line in lines:
res.append(json.loads(line.strip()))
return res
input_items = read_data(args.test_file)
output_items = []
def write_data(filename, examples):
with open(filename, 'w', encoding='utf-8') as f:
for example in examples:
f.write(json.dumps(example, ensure_ascii=False) + "\n")
print("predictions will be written at {}".format(args.predictions_file))
def get_input_text(input_item):
conversations = input_item['conversations']
conv_turn = len(conversations)
for i, sentence in conversations:
sentence_from = sentence["from"].lower()
sentence_value = 'Human: ' + sentence["value"] + '\n\nAssistant: ' if sentence_from == 'human' else sentence["value"]
conversation += sentence_value
sentence_ids = tokenizer.encode(sentence_value, add_special_tokens=False)#do not add bos_token_id
label = copy.deepcopy(sentence_ids) if sentence_from != 'human' else [IGNORE_INDEX] * len(sentence_ids)
input_ids += sentence_ids
def _addrole_masklabel_tokenize(source):
'''
add speaker and concatenate the sentences
{
"id": "uniq_sample_id",
"conversations": [
{"from": "human", "value": "你好"},
{"from": "assistant", "value": "你好，有什么可以帮助你的吗？"},
{"from": "human", "value": "今天天气怎么样？"},
{"from": "assistant", "value": "不好意思，我无法回答你的问题，因为我不知道你的位置信息，同时我目前还无法获取到最新的天气信息。"}
]
}
tokenizer_bloomz.encode("你好，有什么可以帮助你的吗？") == [41381, 355, 37242, 205599, 7336, 10468]
tokenizer_llama.encode("你好，有什么可以帮助你的吗？") == [1, 29871, 30919, 31076, 30214, 30417, 231, 190, 131, 31882, 30682, 30651, 232, 187, 177, 31931, 30919, 30210, 232, 147, 154, 30882]
'''
conversation = ''
input_ids = []
for sentence in source[:-1]:
sentence_from = sentence["from"].lower()
sentence_value = 'Human: ' + sentence["value"] + '\n\nAssistant: ' if sentence_from == 'human' else sentence["value"]
conversation += sentence_value
sentence_ids = tokenizer.encode(sentence_value, add_special_tokens=False)#do not add bos_token_id
input_ids += sentence_ids
if sentence_from != 'human':
input_ids += [tokenizer.eos_token_id]#make sure eos_token_id is correct
return input_ids, conversation
if __name__ == '__main__':
load_type = torch.float16
if torch.cuda.is_available():
device = torch.device(0)
else:
device = torch.device('cpu')
if "llama" in args.model_name_or_path:
tokenizer = LlamaTokenizer.from_pretrained(args.model_name_or_path)
else:
tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path)
tokenizer.pad_token_id = 0
tokenizer.eos_token_id = 2
model_config = AutoConfig.from_pretrained(args.model_name_or_path)
print("Loading model")
model = AutoModelForCausalLM.from_pretrained(
args.finetuned_model_name_or_path,
torch_dtype=load_type,
config=model_config,
)
model.to(device)
model.eval()
print("Load model successfully")
index = 0
for i in tqdm(range(len(input_items)), total=len(input_items), unit="item"):
batch_input_items = input_items[i]
input_ids, conversation = _addrole_masklabel_tokenize(source=input_items[i]['conversations'])
input_ids = input_ids[:2048]
if "Human" not in conversation:
continue
attention_mask = [1] * len(input_ids)
input_ids = torch.LongTensor(input_ids).unsqueeze(0)
attention_mask = torch.LongTensor(attention_mask).unsqueeze(0)
#(1, max_seq_len)
generation_output = model.generate(
input_ids = input_ids.to(device),
attention_mask = attention_mask.to(device),
**generation_config
)
generate_text = tokenizer.decode(generation_output[0].cpu().tolist(),skip_special_tokens=True)
output_items.append({"generate_text": generate_text})
if index%10 == 0:
print("conversation: ", conversation)
print("generate_text: ", generate_text)
print("-"*100)
index += 1
write_data(args.predictions_file, output_items)
================================================
FILE: train/dschat_train_v1/reproduce_our_papers/Towards Better Instruction Following Language Models for Chinese: Investigating the Impact of Training Data and Evaluation.md
================================================
### [Towards Better Instruction Following Language Models for Chinese: Investigating the Impact of Training Data and Evaluation](https://github.com/LianjiaTech/BELLE/blob/main/docs/Towards%20Better%20Instruction%20Following%20Language%20Models%20for%20Chinese.pdf)
# 论文简介
这篇论文研究了基于当前公开的指令数据训练得到的模型，能达到怎样的效果。我们在自有的1000条测试集上进行了量化评估，同时，为了提高模型在中文领域的性能和训练/推理效率，我们进一步扩展了LLaMA的词汇表，并在34亿个中文词汇上进行了二次预训练。
我们使用到的公开指令训练数据有：
1. GPT-3.5生成的Stanford alpaca 中文以及英文数据
2. GPT-4生成的Alpaca 中文以及英文数据
3. 用户分享的与ChatGPT的真实对话数据sharegpt
我们着眼于探究训练数据类别对模型性能的影响。具体而言，我们考察了训练数据的数量、质量和语言分布等因素。
实验结果如下：
Factor
Base model
Training data
Score_w/o_others
词表扩充
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B
zh(alpaca-3.5&4) + sharegpt
0.652
数据质量
LLaMA-7B-EXT
zh(alpaca-3.5)
0.642
LLaMA-7B-EXT
zh(alpaca-4)
0.693
数据语言分布
LLaMA-7B-EXT
cn(alpaca-3.5&4)
0.679
LLaMA-7B-EXT
en(alpaca-3.5&4)
0.659
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B-EXT
en(alpaca-3.5&4) + sharegpt
0.668
数据规模
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.762
-
ChatGPT
-
0.824
其中**BELLE-0.5M-CLEAN**是从我们内部的230万指令数据中清洗得到0.5M数据，其中包含单轮和多轮对话数据，和之前开放的0.5M数据不是同一批数据。这份数据还未开源，但是我们已经将实验中效果最好的模型 (score 0.762) 开源在[Hugging Face](https://huggingface.co/BelleGroup/BELLE-on-Open-Datasets).
# 准备数据集
### 下载数据集
我们的论文中使用了五个开源数据集：
| Data | URL |
| -------------- | -------------------------------------------------------------------------------------------------- |
| alpaca-3.5-en | https://github.com/tatsu-lab/stanford_alpaca/blob/main/alpaca_data.json |
| alpaca-3.5-zh | https://github.com/ymcui/Chinese-LLaMA-Alpaca/tree/main/dat |
| alpaca-4-en | https://github.com/Instruction-Tuning-with-GPT-4/GPT-4-LLM/blob/main/data/alpaca_gpt4_data.json |
| alpaca-4-zh | https://github.com/Instruction-Tuning-with-GPT-4/GPT-4-LLM/blob/main/data/alpaca_gpt4_data_zh.json |
| sharegpt$^1$ | https://huggingface.co/datasets/anon8231489123/ShareGPT_Vicuna_unfiltered/tree/main |
$^1$:请注意，sharegpt 数据集可能会持续更新，使得与我们论文中使用的略有不同，但不会对实验结论有大的影响。
### 预处理
##### 清洗 sharegpt 数据集
我们采用了[Vicuna](https://github.com/lm-sys/FastChat/blob/main/docs/commands/data_cleaning.md)中的数据清洗方法。
1. 通过 `fastchat.data.clean_sharegpt` 将 html 转换为 markdown
2. 通过 `fastchat.data.optional_clean` 删除除英文和中文之外的其他语言
3. 通过 `fastchat.data.split_long_conversation` 将最大长度为 2048 个令牌的对话分割开
#### 统一数据格式
我们将所有数据集统一为以下形式：
```python
{
"id": "uniq_sample_id",
"conversations": [
{"from": "human", "value": "你好"},
{"from": "assistant", "value": "你好，有什么可以帮助你的吗？"},
{"from": "human", "value": "今天天气怎么样？"},
{"from": "assistant", "value": "不好意思，我无法回答你的问题，因为我不知道你的位置信息，同时我目前还无法获取到最新的天气信息。"}
]
}
```
# 下载 LLaMA-EXT-7B
LLaMA-EXT-7B 是基于 [LLaMA](https://ai.facebook.com/blog/large-language-model-llama-meta-ai/) 的模型，进一步在 34 亿中文词汇上进行预训练，将模型词表大小扩展为 79,458。
现在它已经在[Hugging Face上线](https://huggingface.co/BelleGroup/BELLE-LLaMA-EXT-7B)，你应该基于它进行后续的模型训练。
# 训练
以 LLaMA-EXT-7B 为基础模型，我们以如下超参数对模型进行训练。
| Hyper parameter | Value |
| ----------------- | ------ |
| Precision | bf16 |
| Epochs | 3 |
| Batch size | 32 |
| Learning rate | 5e-6 |
| Weight decay | 0 |
| Warmup ratio | 0.03 |
| LR scheduler type | cosine |
| Max length | 2048 |
可以使用我们开源的[代码](../README.md)进行模型训练。
================================================
FILE: train/dschat_train_v1/training_scripts/convert_llama_weights_to_hf.py
================================================
# Copyright 2022 EleutherAI and The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import gc
import json
import math
import os
import shutil
import torch
from transformers import LlamaConfig, LlamaForCausalLM
"""
Sample usage:
```
python src/transformers/models/llama/convert_llama_weights_to_hf.py \
--input_dir /path/to/downloaded/llama/weights --model_size 7B --output_dir /output/path
```
Thereafter, models can be loaded via:
```py
from transformers import LlamaForCausalLM, LlamaForTokenizer
model = LlamaForCausalLM.from_pretrained("/output/path")
tokenizer = LlamaTokenizer.from_pretrained("/output/path")
```
Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
"""
INTERMEDIATE_SIZE_MAP = {
"7B": 11008,
"13B": 13824,
"33B": 17920,
"65B": 22016,
}
NUM_SHARDS = {
"7B": 1,
"13B": 2,
"33B": 4,
"65B": 8,
}
def compute_intermediate_size(n):
return int(math.ceil(n * 8 / 3) + 255) // 256 * 256
def read_json(path):
with open(path, "r") as f:
return json.load(f)
def write_json(text, path):
with open(path, "w") as f:
json.dump(text, f)
def write_model(model_path, input_base_path, model_size):
os.makedirs(model_path, exist_ok=True)
tmp_model_path = os.path.join(model_path, "tmp")
os.makedirs(tmp_model_path, exist_ok=True)
params = read_json(os.path.join(input_base_path, "params.json"))
num_shards = NUM_SHARDS[model_size]
n_layers = params["n_layers"]
n_heads = params["n_heads"]
n_heads_per_shard = n_heads // num_shards
dim = params["dim"]
dims_per_head = dim // n_heads
base = 10000.0
inv_freq = 1.0 / (base ** (torch.arange(0, dims_per_head, 2).float() / dims_per_head))
# permute for sliced rotary
def permute(w):
return w.view(n_heads, dim // n_heads // 2, 2, dim).transpose(1, 2).reshape(dim, dim)
print(f"Fetching all parameters from the checkpoint at {input_base_path}.")
# Load weights
if model_size == "7B":
# Not shared
# (The sharded implementation would also work, but this is simpler.)
loaded = torch.load(os.path.join(input_base_path, "consolidated.00.pth"), map_location="cpu")
else:
# Sharded
loaded = [
torch.load(os.path.join(input_base_path, f"consolidated.{i:02d}.pth"), map_location="cpu")
for i in range(num_shards)
]
param_count = 0
index_dict = {"weight_map": {}}
for layer_i in range(n_layers):
filename = f"pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"
if model_size == "7B":
# Unsharded
state_dict = {
f"model.layers.{layer_i}.self_attn.q_proj.weight": permute(
loaded[f"layers.{layer_i}.attention.wq.weight"]
),
f"model.layers.{layer_i}.self_attn.k_proj.weight": permute(
loaded[f"layers.{layer_i}.attention.wk.weight"]
),
f"model.layers.{layer_i}.self_attn.v_proj.weight": loaded[f"layers.{layer_i}.attention.wv.weight"],
f"model.layers.{layer_i}.self_attn.o_proj.weight": loaded[f"layers.{layer_i}.attention.wo.weight"],
f"model.layers.{layer_i}.mlp.gate_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w1.weight"],
f"model.layers.{layer_i}.mlp.down_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w2.weight"],
f"model.layers.{layer_i}.mlp.up_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w3.weight"],
f"model.layers.{layer_i}.input_layernorm.weight": loaded[f"layers.{layer_i}.attention_norm.weight"],
f"model.layers.{layer_i}.post_attention_layernorm.weight": loaded[f"layers.{layer_i}.ffn_norm.weight"],
}
else:
# Sharded
# Note that in the 13B checkpoint, not cloning the two following weights will result in the checkpoint
# becoming 37GB instead of 26GB for some reason.
state_dict = {
f"model.layers.{layer_i}.input_layernorm.weight": loaded[0][
f"layers.{layer_i}.attention_norm.weight"
].clone(),
f"model.layers.{layer_i}.post_attention_layernorm.weight": loaded[0][
f"layers.{layer_i}.ffn_norm.weight"
].clone(),
}
state_dict[f"model.layers.{layer_i}.self_attn.q_proj.weight"] = permute(
torch.cat(
[
loaded[i][f"layers.{layer_i}.attention.wq.weight"].view(n_heads_per_shard, dims_per_head, dim)
for i in range(num_shards)
],
dim=0,
).reshape(dim, dim)
)
state_dict[f"model.layers.{layer_i}.self_attn.k_proj.weight"] = permute(
torch.cat(
[
loaded[i][f"layers.{layer_i}.attention.wk.weight"].view(n_heads_per_shard, dims_per_head, dim)
for i in range(num_shards)
],
dim=0,
).reshape(dim, dim)
)
state_dict[f"model.layers.{layer_i}.self_attn.v_proj.weight"] = torch.cat(
[
loaded[i][f"layers.{layer_i}.attention.wv.weight"].view(n_heads_per_shard, dims_per_head, dim)
for i in range(num_shards)
],
dim=0,
).reshape(dim, dim)
state_dict[f"model.layers.{layer_i}.self_attn.o_proj.weight"] = torch.cat(
[loaded[i][f"layers.{layer_i}.attention.wo.weight"] for i in range(num_shards)], dim=1
)
state_dict[f"model.layers.{layer_i}.mlp.gate_proj.weight"] = torch.cat(
[loaded[i][f"layers.{layer_i}.feed_forward.w1.weight"] for i in range(num_shards)], dim=0
)
state_dict[f"model.layers.{layer_i}.mlp.down_proj.weight"] = torch.cat(
[loaded[i][f"layers.{layer_i}.feed_forward.w2.weight"] for i in range(num_shards)], dim=1
)
state_dict[f"model.layers.{layer_i}.mlp.up_proj.weight"] = torch.cat(
[loaded[i][f"layers.{layer_i}.feed_forward.w3.weight"] for i in range(num_shards)], dim=0
)
state_dict[f"model.layers.{layer_i}.self_attn.rotary_emb.inv_freq"] = inv_freq
for k, v in state_dict.items():
index_dict["weight_map"][k] = filename
param_count += v.numel()
torch.save(state_dict, os.path.join(tmp_model_path, filename))
filename = f"pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin"
if model_size == "7B":
# Unsharded
state_dict = {
"model.embed_tokens.weight": loaded["tok_embeddings.weight"],
"model.norm.weight": loaded["norm.weight"],
"lm_head.weight": loaded["output.weight"],
}
else:
state_dict = {
"model.norm.weight": loaded[0]["norm.weight"],
"model.embed_tokens.weight": torch.cat(
[loaded[i]["tok_embeddings.weight"] for i in range(num_shards)], dim=1
),
"lm_head.weight": torch.cat([loaded[i]["output.weight"] for i in range(num_shards)], dim=0),
}
for k, v in state_dict.items():
index_dict["weight_map"][k] = filename
param_count += v.numel()
torch.save(state_dict, os.path.join(tmp_model_path, filename))
# Write configs
index_dict["metadata"] = {"total_size": param_count * 2}
write_json(index_dict, os.path.join(tmp_model_path, "pytorch_model.bin.index.json"))
config = LlamaConfig(
hidden_size=dim,
intermediate_size=compute_intermediate_size(dim),
num_attention_heads=params["n_heads"],
num_hidden_layers=params["n_layers"],
rms_norm_eps=params["norm_eps"],
)
config.save_pretrained(tmp_model_path)
# Make space so we can load the model properly now.
del state_dict
del loaded
gc.collect()
print("Loading the checkpoint in a Llama model.")
model = LlamaForCausalLM.from_pretrained(tmp_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
# Avoid saving this as part of the config.
del model.config._name_or_path
print("Saving in the Transformers format.")
model.save_pretrained(model_path)
shutil.rmtree(tmp_model_path)
def write_tokenizer(tokenizer_path, input_tokenizer_path):
print(f"Fetching the tokenizer from {input_tokenizer_path}.")
os.makedirs(tokenizer_path, exist_ok=True)
write_json({}, os.path.join(tokenizer_path, "special_tokens_map.json"))
write_json(
{
"bos_token": "",
"eos_token": "",
"model_max_length": int(1e30),
"tokenizer_class": "LlamaTokenizer",
"unk_token": "",
},
os.path.join(tokenizer_path, "tokenizer_config.json"),
)
shutil.copyfile(input_tokenizer_path, os.path.join(tokenizer_path, "tokenizer.model"))
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--input_dir",
help="Location of LLaMA weights, which contains tokenizer.model and model folders",
)
parser.add_argument(
"--model_size",
choices=["7B", "13B", "33B", "65B", "tokenizer_only"],
)
parser.add_argument(
"--output_dir",
help="Location to write HF model and tokenizer",
)
args = parser.parse_args()
if args.model_size != "tokenizer_only":
write_model(
model_path=args.output_dir,
input_base_path=os.path.join(args.input_dir, args.model_size),
model_size=args.model_size,
)
write_tokenizer(
tokenizer_path=args.output_dir,
input_tokenizer_path=os.path.join(args.input_dir, "tokenizer.model"),
)
if __name__ == "__main__":
main()
================================================
FILE: train/dschat_train_v1/training_scripts/convert_to_conv_data.py
================================================
import argparse
import json
import datetime
import os
'''
orig_data: {"instruction": "题目：小明买了一支钢笔，花费了5元，又买了一本书，花费8元，现在他手里还有10元钱，他手上原来有多少钱？", "input": "", "output": "\n令小明手上原来有的钱为X元。根据题目描述，得出以下方程式：\nX - 5 - 8 = 10\n化简可得：\nX = 23\n因此，小明手上原来有23元钱。"}
convert: {
"id": xxx,
"conversations":[
{"from": "human", "value": "题目：小明买了一支钢笔，花费了5元，又买了一本书，花费8元，现在他手里还有10元钱，他手上原来有多少钱？"},
{"from": "assistant", "value": "\n令小明手上原来有的钱为X元。根据题目描述，得出以下方程式：\nX - 5 - 8 = 10\n化简可得：\nX = 23\n因此，小明手上原来有23元钱。"},
]
}
'''
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--orig_data",
)
parser.add_argument(
"--write_data",
)
parser.add_argument(
"--dataset_name",
)
args = parser.parse_args()
f_write = open(args.write_data,"w")
with open(args.orig_data) as f:
lines = f.readlines()
num_id = 1
for line in lines:
data = json.loads(line)
conversations = [{"from": "human", "value": data['instruction']+data['input']},{"from": "assistant", "value": data['output']}]
# conversations = [{"from": "human", "value": data['input']},{"from": "assistant", "value": data['target']}]
uniq_id = data['id'] if "id" in data else args.dataset_name+"-"+str(num_id)
item = {"id":uniq_id, "conversations": conversations}
f_write.write(json.dumps(item, ensure_ascii=False)+"\n")
num_id += 1
f_write.close()
if __name__ == "__main__":
main()
================================================
FILE: train/dschat_train_v1/training_scripts/single_gpu/run_FT.sh
================================================
#!/bin/bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: Apache-2.0
# DeepSpeed Team
OUTPUT=$1
ZERO_STAGE=$2
rm -rf output/
rm -rf $OUTPUT
mkdir -p $OUTPUT
echo $OUTPUT
echo $ZERO_STAGE
data_output_path=$OUTPUT/data_files
#bigscience/bloomz-1b7
#facebook/opt-1.3b
#bigscience/bloomz-560m
deepspeed --num_gpus 1 main.py \
--sft_only_data_path belleMath.json \
--model_name_or_path bigscience/bloomz-560m \
--per_device_train_batch_size 8 \
--per_device_eval_batch_size 2 \
--max_seq_len 1024 \
--learning_rate 5e-5 \
--weight_decay 0.0001 \
--num_train_epochs 3 \
--gradient_accumulation_steps 8 \
--lr_scheduler_type cosine \
--num_warmup_steps 100 \
--seed 1234 \
--gradient_checkpointing \
--zero_stage $ZERO_STAGE \
--deepspeed \
--output_dir $OUTPUT \
--data_output_path $data_output_path \
# &> $OUTPUT/training.log
================================================
FILE: train/dschat_train_v1/training_scripts/single_gpu/run_LoRA.sh
================================================
#!/bin/bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: Apache-2.0
# DeepSpeed Team
#facebook/opt-1.3b
# Note that usually LoRA needs to use larger learning rate
#/nfs/v100-022/jiyunjie/anaconda3/envs/llamalora/
#export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/nfs/v100-022/jiyunjie/anaconda3/envs/llamalora/lib/
OUTPUT_PATH=$1
ZERO_STAGE=$2
rm -rf output/
mkdir -p $OUTPUT_PATH
echo $OUTPUT_PATH
echo $ZERO_STAGE
model_name_or_path=/workspace/model_name_or_path/hf_llama_7b
lora_module_name="q_proj,k_proj,v_proj,o_proj,down_proj,gate_proj,up_proj"
# If the model is Bloom, lora_module_name should be
# model_name_or_path=/workspace/model_name_or_path/bloomz-7b1-mt
# lora_module_name="query_key_value,mlp"
echo ${lora_module_name}
echo ${model_name_or_path}
deepspeed --num_gpus 1 main.py \
--sft_only_data_path belleMath.json \
--data_split 10,0,0 \
--model_name_or_path ${model_name_or_path} \
--per_device_train_batch_size 2 \
--per_device_eval_batch_size 1 \
--max_seq_len 1024 \
--learning_rate 3e-4 \
--weight_decay 0. \
--num_train_epochs 5 \
--gradient_accumulation_steps 1 \
--lr_scheduler_type cosine \
--num_warmup_steps 100 \
--seed 1234 \
--gradient_checkpointing \
--zero_stage $ZERO_STAGE \
--lora_dim 16 \
--lora_alpha 16 \
--lora_droppout 0.05 \
--lora_module_name ${lora_module_name} \
--deepspeed \
--output_dir $OUTPUT_PATH \
# &> $OUTPUT_PATH/training.log
================================================
FILE: train/dschat_train_v1/training_scripts/single_node/run_FT.sh
================================================
#!/bin/bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: Apache-2.0
# DeepSpeed Team
OUTPUT=$1
ZERO_STAGE=$2
rm -rf output/
mkdir -p $OUTPUT
echo $OUTPUT
echo $ZERO_STAGE
data_output_path=$OUTPUT/data_files
#BelleGroup/BELLE-7B-2M
#/workspace/model_name_or_path/hf_llama_7b
deepspeed main.py \
--sft_only_data_path belleMath.json \
--model_name_or_path /nfs/v100-022/pretrained_ckpt/hf_llama_7b/ \
--per_device_train_batch_size 2 \
--per_device_eval_batch_size 1 \
--max_seq_len 1024 \
--learning_rate 5e-6 \
--weight_decay 0.0001 \
--num_train_epochs 2 \
--gradient_accumulation_steps 4 \
--lr_scheduler_type cosine \
--num_warmup_steps 100 \
--seed 1234 \
--gradient_checkpointing \
--zero_stage $ZERO_STAGE \
--deepspeed \
--output_dir $OUTPUT \
--data_output_path $data_output_path \
# &> $OUTPUT/training.log
================================================
FILE: train/dschat_train_v1/training_scripts/single_node/run_LoRA.sh
================================================
#!/bin/bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: Apache-2.0
# DeepSpeed Team
#facebook/opt-1.3b
# Note that usually LoRA needs to use larger learning rate
OUTPUT_PATH=$1
ZERO_STAGE=$2
echo $OUTPUT_PATH
echo $ZERO_STAGE
rm -rf output/
mkdir -p $OUTPUT_PATH
# model_name_or_path=/workspace/model_name_or_path/hf_llama_7b
# lora_module_name="q_proj,k_proj,v_proj,o_proj,down_proj,gate_proj,up_proj"
# If the model is Bloom, lora_module_name should be
model_name_or_path=/workspace/model_name_or_path/bloomz-7b1-mt
lora_module_name="query_key_value,mlp"
echo ${lora_module_name}
deepspeed main.py \
--sft_only_data_path belleMath.json \
--eval_data_file belleMath-dev1K.json \
--data_split 10,0,0 \
--model_name_or_path ${model_name_or_path} \
--per_device_train_batch_size 4 \
--per_device_eval_batch_size 1 \
--max_seq_len 512 \
--learning_rate 3e-4 \
--weight_decay 0. \
--num_train_epochs 5 \
--gradient_accumulation_steps 1 \
--lr_scheduler_type cosine \
--num_warmup_steps 100 \
--seed 1234 \
--gradient_checkpointing \
--zero_stage $ZERO_STAGE \
--lora_dim 16 \
--lora_alpha 16 \
--lora_droppout 0.05 \
--lora_module_name ${lora_module_name} \
--deepspeed \
--output_dir $OUTPUT_PATH \
# &> $OUTPUT_PATH/training.log
================================================
FILE: train/dschat_train_v1/utils/ds_utils.py
================================================
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: Apache-2.0
# DeepSpeed Team
GLOBAL_BATCH_SIZE = 32
MICRO_BATCH_SIZE = 4
def get_train_ds_config(offload,
stage=2,
enable_hybrid_engine=False,
inference_tp_size=1,
release_inference_cache=False,
pin_parameters=True,
tp_gather_partition_size=8):
device = "cpu" if offload else "none"
zero_opt_dict = {
"stage": stage,
"offload_param": {
"device": device
},
"offload_optimizer": {
"device": device
},
"stage3_param_persistence_threshold": 1e4,
"stage3_max_live_parameters": 3e7,
"stage3_prefetch_bucket_size": 3e7,
"memory_efficient_linear": False
}
return {
"train_batch_size": GLOBAL_BATCH_SIZE,
"train_micro_batch_size_per_gpu": MICRO_BATCH_SIZE,
"steps_per_print": 10,
"zero_optimization": zero_opt_dict,
"fp16": {
"enabled": True,
"loss_scale_window": 100
},
"gradient_clipping": 1.0,
"prescale_gradients": False,
"wall_clock_breakdown": False,
"hybrid_engine": {
"enabled": enable_hybrid_engine,
"inference_tp_size": inference_tp_size,
"release_inference_cache": release_inference_cache,
"pin_parameters": pin_parameters,
"tp_gather_partition_size": tp_gather_partition_size,
}
}
def get_eval_ds_config(offload, stage=0):
device = "cpu" if offload else "none"
zero_opt_dict = {
"stage": stage,
"stage3_param_persistence_threshold": 1e4,
"offload_param": {
"device": device
},
"memory_efficient_linear": False
}
return {
"train_batch_size": GLOBAL_BATCH_SIZE,
"train_micro_batch_size_per_gpu": MICRO_BATCH_SIZE,
"steps_per_print": 10,
"zero_optimization": zero_opt_dict,
"fp16": {
"enabled": True
},
"gradient_clipping": 1.0,
"prescale_gradients": False,
"wall_clock_breakdown": False
}
================================================
FILE: train/dschat_train_v1/utils/model/model_utils.py
================================================
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: Apache-2.0
# DeepSpeed Team
import os
import math
import torch
from transformers import (
AutoConfig,
AutoModel,
)
from transformers.deepspeed import HfDeepSpeedConfig
# from .reward_model import RewardModel
def create_hf_model(model_class,
model_name_or_path,
tokenizer,
ds_config=None,
rlhf_training=False):
model_config = AutoConfig.from_pretrained(model_name_or_path)
model_config.dropout = 0.0
# Note: dschf is defined in function scope to avoid global effects
# https://huggingface.co/docs/transformers/main_classes/deepspeed#nontrainer-deepspeed-integration
if ds_config is not None and ds_config["zero_optimization"]["stage"] == 3:
dschf = HfDeepSpeedConfig(ds_config)
else:
dschf = None
if rlhf_training:
# the weight loading is handled by create critic model
model = model_class.from_config(model_config)
else:
model = model_class.from_pretrained(
model_name_or_path,
from_tf=bool(".ckpt" in model_name_or_path),
config=model_config)
# model.config.end_token_id = tokenizer.eos_token_id
# model.config.pad_token_id = model.config.eos_token_id
# model.resize_token_embeddings(int(8 *math.ceil(len(tokenizer) / 8.0))) # make the vocab size multiple of 8
return model
# def create_critic_model(model_name_or_path,
# tokenizer,
# ds_config,
# num_padding_at_beginning=0,
# rlhf_training=False):
# # OPT model family always put a padding token at the beginning of the sequence,
# # we did not see this in other models but not sure if it is a general rule
# critic_model = create_hf_model(AutoModel, model_name_or_path, tokenizer,
# ds_config, rlhf_training)
# critic_model = RewardModel(
# critic_model,
# tokenizer,
# num_padding_at_beginning=num_padding_at_beginning)
# if rlhf_training:
# # critic model needs to load the weight here
# model_ckpt_path = os.path.join(model_name_or_path, 'pytorch_model.bin')
# assert os.path.exists(
# model_ckpt_path
# ), f"Cannot find model checkpoint at {model_ckpt_path}"
# critic_model.load_state_dict(
# torch.load(model_ckpt_path, map_location='cpu'))
# return critic_model
================================================
FILE: train/dschat_train_v1/utils/module/lora.py
================================================
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: Apache-2.0
# DeepSpeed Team
import math
import torch
from torch import nn
import torch.nn.functional as F
from deepspeed.compression.helper import recursive_getattr, recursive_setattr
import deepspeed
class LinearLayer_LoRA(nn.Module):
# an simple implementation of LoRA
# for now only support Linear Layer
def __init__(self,
weight,
lora_dim=0,
lora_alpha=16,
lora_droppout=0.05,
bias=None):
super(LinearLayer_LoRA, self).__init__()
self.weight = weight
self.bias = bias
if lora_dim <= 0:
raise ValueError(
"You are training to use LoRA, whose reduced dim should be larger than 1"
)
try:
# for zero stage 3
rows, columns = weight.ds_shape
except:
rows, columns = weight.shape
self.lora_right_weight = nn.Parameter(torch.zeros(
columns,
lora_dim)) # apply transpose so in forward we do not need to
self.lora_left_weight = nn.Parameter(torch.zeros(lora_dim, rows))
self.lora_scaling = lora_alpha / lora_dim #alpha/rank
if lora_droppout > 0:
self.lora_dropout = nn.Dropout(lora_droppout)
else:
self.lora_dropout = nn.Identity()
self.reset_parameters()
# disable the original weight gradient
self.weight.requires_grad = False
# fuse LoRA to the original weight
self.fuse_lora = False
def eval(self):
self.lora_dropout.eval()
# self.fuse_lora_weight()
def train(self, mode=True):
self.lora_dropout.train(mode)
# self.unfuse_lora_weight()
def reset_parameters(self):
nn.init.kaiming_uniform_(self.lora_right_weight, a=math.sqrt(5))
nn.init.zeros_(self.lora_left_weight)
def fuse_lora_weight(self):
if not self.fuse_lora:
self.weight.data += self.lora_scaling * torch.matmul(
self.lora_left_weight.t(), self.lora_right_weight.t())
self.fuse_lora = True
def unfuse_lora_weight(self):
if self.fuse_lora:
self.weight.data -= self.lora_scaling * torch.matmul(
self.lora_left_weight.t(), self.lora_right_weight.t())
self.fuse_lora = False
def forward(self, input):
if self.fuse_lora:
return F.linear(input, self.weight, self.bias)
else:
return F.linear(
input, self.weight,
self.bias) + (self.lora_dropout(input) @ self.lora_right_weight
@ self.lora_left_weight) * self.lora_scaling
'''
LLaMA model named_modules:
model.layers.29.mlp
model.layers.29.mlp.gate_proj
model.layers.29.mlp.down_proj
model.layers.29.mlp.up_proj
model.layers.29.mlp.act_fn
model.layers.29.input_layernorm
model.layers.29.post_attention_layernorm
model.layers.30
model.layers.30.self_attn
model.layers.30.self_attn.q_proj
model.layers.30.self_attn.k_proj
model.layers.30.self_attn.v_proj
model.layers.30.self_attn.o_proj
model.layers.30.self_attn.rotary_emb
'''
# convert the linear layer to LoRA
def convert_linear_layer_to_lora(model,
lora_module_name,
lora_dim=0,
lora_alpha=1,
lora_droppout=0):
def set_params(param_modules, name):
for each_ in param_modules:
if each_ in name:
return True
return False
repalce_name = []
for name, module in model.named_modules():
if isinstance(module, nn.Linear) and set_params(lora_module_name, name):
repalce_name.append(name)
print("repalce_name : ", repalce_name)
for name in repalce_name:
module = recursive_getattr(model, name)
tmp = LinearLayer_LoRA(
module.weight, lora_dim, lora_alpha, lora_droppout,
module.bias).to(module.weight.device).to(module.weight.dtype)
recursive_setattr(model, name, tmp)
return model
def _z3_params_to_fetch(param_list):
return [
p for p in param_list
if hasattr(p, 'ds_id') and p.ds_status == deepspeed.runtime.zero.
partition_parameters.ZeroParamStatus.NOT_AVAILABLE
]
# convert the LoRA layer to linear layer
def convert_lora_to_linear_layer(model):
repalce_name = []
for name, module in model.named_modules():
if isinstance(module, LinearLayer_LoRA):
repalce_name.append(name)
for name in repalce_name:
module = recursive_getattr(model, name)
zero_stage_3 = hasattr(module.weight, 'ds_id')
with deepspeed.zero.GatheredParameters(_z3_params_to_fetch([
module.weight, module.bias, module.lora_left_weight,
module.lora_right_weight
]),
modifier_rank=0,
enabled=zero_stage_3):
module.fuse_lora_weight()
return model
def only_optimize_lora_parameters(model):
# turn off the gradient of all the parameters except the LoRA parameters
for name, param in model.named_parameters():
if "lora_right_weight" in name or "lora_left_weight" in name:
param.requires_grad = True
else:
param.requires_grad = False
return model
================================================
FILE: train/dschat_train_v1/utils/utils.py
================================================
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: Apache-2.0
# DeepSpeed Team
import os
import torch
import random
import numpy as np
from transformers import set_seed
import deepspeed
from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus
def print_rank_0(msg, rank=0):
if rank <= 0:
print(msg)
def to_device(batch, device):
output = {}
for k, v in batch.items():
try:
output[k] = v.to(device)
except:
output[k] = v
return output
class MovingAverage:
def __init__(self):
self.count = 0
self.total = 0
self.mean = 0
def update(self, num):
self.total += num
self.count += 1
self.mean = self.total / self.count
return self.mean
def save_hf_format(model, tokenizer, args, sub_folder=""):
# used to save huggingface format, so we can use it for hf.from_pretrained
model_to_save = model.module if hasattr(model, 'module') else model
CONFIG_NAME = "config.json"
WEIGHTS_NAME = "pytorch_model.bin"
output_dir = os.path.join(args.output_dir, sub_folder)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
output_model_file = os.path.join(output_dir, WEIGHTS_NAME)
output_config_file = os.path.join(output_dir, CONFIG_NAME)
save_dict = model_to_save.state_dict()
for key in list(save_dict.keys()):
if "lora" in key:
del save_dict[key]
torch.save(save_dict, output_model_file)
model_to_save.config.to_json_file(output_config_file)
tokenizer.save_vocabulary(output_dir)
def set_random_seed(seed):
if seed is not None:
set_seed(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
def get_all_reduce_mean(tensor):
torch.distributed.all_reduce(tensor, op=torch.distributed.ReduceOp.SUM)
tensor = tensor / torch.distributed.get_world_size()
return tensor
def get_optimizer_grouped_parameters(model,
weight_decay,
no_decay_name_list=[
"bias", "LayerNorm.weight"
]):
optimizer_grouped_parameters = [
{
"params": [
p for n, p in model.named_parameters()
if (not any(nd in n
for nd in no_decay_name_list) and p.requires_grad)
],
"weight_decay":
weight_decay,
},
{
"params": [
p for n, p in model.named_parameters()
if (any(nd in n
for nd in no_decay_name_list) and p.requires_grad)
],
"weight_decay":
0.0,
},
]
return optimizer_grouped_parameters
def _z3_params_to_fetch(param_list):
return [
p for p in param_list
if hasattr(p, 'ds_id') and p.ds_status == ZeroParamStatus.NOT_AVAILABLE
]
def moving_average(model, model_ema, beta=0.992, device=None, zero_stage=0):
zero_stage_3 = (zero_stage == 3)
with torch.no_grad():
for param, param_ema in zip(model.parameters(),
model_ema.parameters()):
# TODO: use prefiltering for efficiency
params_to_fetch = _z3_params_to_fetch([param, param_ema
]) if zero_stage_3 else []
should_gather_param = len(params_to_fetch) > 0
with deepspeed.zero.GatheredParameters(
params_to_fetch, enabled=should_gather_param):
data = param.data
if device is not None:
data = data.to(device)
param_ema.data.copy_(torch.lerp(data, param_ema.data, beta))
def save_zero_three_model(model_ema, global_rank, save_dir, zero_stage=0):
zero_stage_3 = (zero_stage == 3)
os.makedirs(save_dir, exist_ok=True)
WEIGHTS_NAME = "pytorch_model.bin"
output_model_file = os.path.join(save_dir, WEIGHTS_NAME)
model_to_save = model_ema.module if hasattr(model_ema,
'module') else model_ema
if not zero_stage_3:
if global_rank == 0:
torch.save(model_to_save.state_dict(), output_model_file)
else:
output_state_dict = {}
for k, v in model_to_save.named_parameters():
if hasattr(v, 'ds_id'):
with deepspeed.zero.GatheredParameters(_z3_params_to_fetch([v
]),
enabled=zero_stage_3):
v_p = v.data.cpu()
else:
v_p = v.cpu()
if global_rank == 0 and "lora" not in k:
output_state_dict[k] = v_p
if global_rank == 0:
torch.save(output_state_dict, output_model_file)
del output_state_dict
================================================
FILE: train/reproduce_our_papers/Towards Better Instruction Following Language Models for Chinese: Investigating the Impact of Training Data and Evaluation.md
================================================
### [Towards Better Instruction Following Language Models for Chinese: Investigating the Impact of Training Data and Evaluation](https://github.com/LianjiaTech/BELLE/blob/main/docs/Towards%20Better%20Instruction%20Following%20Language%20Models%20for%20Chinese.pdf)
# 论文简介
这篇论文研究了基于当前公开的指令数据训练得到的模型，能达到怎样的效果。我们在自有的1000条测试集上进行了量化评估，同时，为了提高模型在中文领域的性能和训练/推理效率，我们进一步扩展了LLaMA的词汇表，并在34亿个中文词汇上进行了二次预训练。
我们使用到的公开指令训练数据有：
1. GPT-3.5生成的Stanford alpaca 中文以及英文数据
2. GPT-4生成的Alpaca 中文以及英文数据
3. 用户分享的与ChatGPT的真实对话数据sharegpt
我们着眼于探究训练数据类别对模型性能的影响。具体而言，我们考察了训练数据的数量、质量和语言分布等因素。
实验结果如下：
Factor
Base model
Training data
Score_w/o_others
词表扩充
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B
zh(alpaca-3.5&4) + sharegpt
0.652
数据质量
LLaMA-7B-EXT
zh(alpaca-3.5)
0.642
LLaMA-7B-EXT
zh(alpaca-4)
0.693
数据语言分布
LLaMA-7B-EXT
cn(alpaca-3.5&4)
0.679
LLaMA-7B-EXT
en(alpaca-3.5&4)
0.659
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B-EXT
en(alpaca-3.5&4) + sharegpt
0.668
数据规模
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.670
LLaMA-7B-EXT
zh(alpaca-3.5&4) + sharegpt
0.762
-
ChatGPT
-
0.824
其中**BELLE-0.5M-CLEAN**是从我们内部的230万指令数据中清洗得到0.5M数据，其中包含单轮和多轮对话数据，和之前开放的0.5M数据不是同一批数据。这份数据还未开源，但是我们已经将实验中效果最好的模型 (score 0.762) 开源在[Hugging Face](https://huggingface.co/BelleGroup/BELLE-on-Open-Datasets).
# 准备数据集
### 下载数据集
我们的论文中使用了五个开源数据集：
| Data | URL |
| -------------- | -------------------------------------------------------------------------------------------------- |
| alpaca-3.5-en | https://github.com/tatsu-lab/stanford_alpaca/blob/main/alpaca_data.json |
| alpaca-3.5-zh | https://github.com/ymcui/Chinese-LLaMA-Alpaca/tree/main/dat |
| alpaca-4-en | https://github.com/Instruction-Tuning-with-GPT-4/GPT-4-LLM/blob/main/data/alpaca_gpt4_data.json |
| alpaca-4-zh | https://github.com/Instruction-Tuning-with-GPT-4/GPT-4-LLM/blob/main/data/alpaca_gpt4_data_zh.json |
| sharegpt$^1$ | https://huggingface.co/datasets/anon8231489123/ShareGPT_Vicuna_unfiltered/tree/main |
$^1$:请注意，sharegpt 数据集可能会持续更新，使得与我们论文中使用的略有不同，但不会对实验结论有大的影响。
### 预处理
##### 清洗 sharegpt 数据集
我们采用了[Vicuna](https://github.com/lm-sys/FastChat/blob/main/docs/commands/data_cleaning.md)中的数据清洗方法。
1. 通过 `fastchat.data.clean_sharegpt` 将 html 转换为 markdown
2. 通过 `fastchat.data.optional_clean` 删除除英文和中文之外的其他语言
3. 通过 `fastchat.data.split_long_conversation` 将最大长度为 2048 个令牌的对话分割开
#### 统一数据格式
我们将所有数据集统一为以下形式：
```python
{
"id": "uniq_sample_id",
"conversations": [
{"from": "human", "value": "你好"},
{"from": "assistant", "value": "你好，有什么可以帮助你的吗？"},
{"from": "human", "value": "今天天气怎么样？"},
{"from": "assistant", "value": "不好意思，我无法回答你的问题，因为我不知道你的位置信息，同时我目前还无法获取到最新的天气信息。"}
]
}
```
# 下载 LLaMA-EXT-7B
LLaMA-EXT-7B 是基于 [LLaMA](https://ai.facebook.com/blog/large-language-model-llama-meta-ai/) 的模型，进一步在 34 亿中文词汇上进行预训练，将模型词表大小扩展为 79,458。
现在它已经在[Hugging Face上线](https://huggingface.co/BelleGroup/BELLE-LLaMA-EXT-7B)，你应该基于它进行后续的模型训练。
# 训练
以 LLaMA-EXT-7B 为基础模型，我们以如下超参数对模型进行训练。
| Hyper parameter | Value |
| ----------------- | ------ |
| Precision | bf16 |
| Epochs | 3 |
| Batch size | 32 |
| Learning rate | 5e-6 |
| Weight decay | 0 |
| Warmup ratio | 0.03 |
| LR scheduler type | cosine |
| Max length | 2048 |
可以使用我们开源的[代码](../README.md)进行模型训练。
================================================
FILE: train/scripts/convert_llama_weights_to_hf.py
================================================
# Copyright 2022 EleutherAI and The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import gc
import json
import math
import os
import shutil
import torch
from transformers import LlamaConfig, LlamaForCausalLM
"""
Sample usage:
```
python src/transformers/models/llama/convert_llama_weights_to_hf.py \
--input_dir /path/to/downloaded/llama/weights --model_size 7B --output_dir /output/path
```
Thereafter, models can be loaded via:
```py
from transformers import LlamaForCausalLM, LlamaForTokenizer
model = LlamaForCausalLM.from_pretrained("/output/path")
tokenizer = LlamaTokenizer.from_pretrained("/output/path")
```
Important note: you need to be able to host the whole model in RAM to execute this script (even if the biggest versions
come in several checkpoints they each contain a part of each weight of the model, so we need to load them all in RAM).
"""
INTERMEDIATE_SIZE_MAP = {
"7B": 11008,
"13B": 13824,
"33B": 17920,
"65B": 22016,
}
NUM_SHARDS = {
"7B": 1,
"13B": 2,
"33B": 4,
"65B": 8,
}
def compute_intermediate_size(n):
return int(math.ceil(n * 8 / 3) + 255) // 256 * 256
def read_json(path):
with open(path, "r") as f:
return json.load(f)
def write_json(text, path):
with open(path, "w") as f:
json.dump(text, f)
def write_model(model_path, input_base_path, model_size):
os.makedirs(model_path, exist_ok=True)
tmp_model_path = os.path.join(model_path, "tmp")
os.makedirs(tmp_model_path, exist_ok=True)
params = read_json(os.path.join(input_base_path, "params.json"))
num_shards = NUM_SHARDS[model_size]
n_layers = params["n_layers"]
n_heads = params["n_heads"]
n_heads_per_shard = n_heads // num_shards
dim = params["dim"]
dims_per_head = dim // n_heads
base = 10000.0
inv_freq = 1.0 / (base ** (torch.arange(0, dims_per_head, 2).float() / dims_per_head))
# permute for sliced rotary
def permute(w):
return w.view(n_heads, dim // n_heads // 2, 2, dim).transpose(1, 2).reshape(dim, dim)
print(f"Fetching all parameters from the checkpoint at {input_base_path}.")
# Load weights
if model_size == "7B":
# Not shared
# (The sharded implementation would also work, but this is simpler.)
loaded = torch.load(os.path.join(input_base_path, "consolidated.00.pth"), map_location="cpu")
else:
# Sharded
loaded = [
torch.load(os.path.join(input_base_path, f"consolidated.{i:02d}.pth"), map_location="cpu")
for i in range(num_shards)
]
param_count = 0
index_dict = {"weight_map": {}}
for layer_i in range(n_layers):
filename = f"pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"
if model_size == "7B":
# Unsharded
state_dict = {
f"model.layers.{layer_i}.self_attn.q_proj.weight": permute(
loaded[f"layers.{layer_i}.attention.wq.weight"]
),
f"model.layers.{layer_i}.self_attn.k_proj.weight": permute(
loaded[f"layers.{layer_i}.attention.wk.weight"]
),
f"model.layers.{layer_i}.self_attn.v_proj.weight": loaded[f"layers.{layer_i}.attention.wv.weight"],
f"model.layers.{layer_i}.self_attn.o_proj.weight": loaded[f"layers.{layer_i}.attention.wo.weight"],
f"model.layers.{layer_i}.mlp.gate_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w1.weight"],
f"model.layers.{layer_i}.mlp.down_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w2.weight"],
f"model.layers.{layer_i}.mlp.up_proj.weight": loaded[f"layers.{layer_i}.feed_forward.w3.weight"],
f"model.layers.{layer_i}.input_layernorm.weight": loaded[f"layers.{layer_i}.attention_norm.weight"],
f"model.layers.{layer_i}.post_attention_layernorm.weight": loaded[f"layers.{layer_i}.ffn_norm.weight"],
}
else:
# Sharded
# Note that in the 13B checkpoint, not cloning the two following weights will result in the checkpoint
# becoming 37GB instead of 26GB for some reason.
state_dict = {
f"model.layers.{layer_i}.input_layernorm.weight": loaded[0][
f"layers.{layer_i}.attention_norm.weight"
].clone(),
f"model.layers.{layer_i}.post_attention_layernorm.weight": loaded[0][
f"layers.{layer_i}.ffn_norm.weight"
].clone(),
}
state_dict[f"model.layers.{layer_i}.self_attn.q_proj.weight"] = permute(
torch.cat(
[
loaded[i][f"layers.{layer_i}.attention.wq.weight"].view(n_heads_per_shard, dims_per_head, dim)
for i in range(num_shards)
],
dim=0,
).reshape(dim, dim)
)
state_dict[f"model.layers.{layer_i}.self_attn.k_proj.weight"] = permute(
torch.cat(
[
loaded[i][f"layers.{layer_i}.attention.wk.weight"].view(n_heads_per_shard, dims_per_head, dim)
for i in range(num_shards)
],
dim=0,
).reshape(dim, dim)
)
state_dict[f"model.layers.{layer_i}.self_attn.v_proj.weight"] = torch.cat(
[
loaded[i][f"layers.{layer_i}.attention.wv.weight"].view(n_heads_per_shard, dims_per_head, dim)
for i in range(num_shards)
],
dim=0,
).reshape(dim, dim)
state_dict[f"model.layers.{layer_i}.self_attn.o_proj.weight"] = torch.cat(
[loaded[i][f"layers.{layer_i}.attention.wo.weight"] for i in range(num_shards)], dim=1
)
state_dict[f"model.layers.{layer_i}.mlp.gate_proj.weight"] = torch.cat(
[loaded[i][f"layers.{layer_i}.feed_forward.w1.weight"] for i in range(num_shards)], dim=0
)
state_dict[f"model.layers.{layer_i}.mlp.down_proj.weight"] = torch.cat(
[loaded[i][f"layers.{layer_i}.feed_forward.w2.weight"] for i in range(num_shards)], dim=1
)
state_dict[f"model.layers.{layer_i}.mlp.up_proj.weight"] = torch.cat(
[loaded[i][f"layers.{layer_i}.feed_forward.w3.weight"] for i in range(num_shards)], dim=0
)
state_dict[f"model.layers.{layer_i}.self_attn.rotary_emb.inv_freq"] = inv_freq
for k, v in state_dict.items():
index_dict["weight_map"][k] = filename
param_count += v.numel()
torch.save(state_dict, os.path.join(tmp_model_path, filename))
filename = f"pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin"
if model_size == "7B":
# Unsharded
state_dict = {
"model.embed_tokens.weight": loaded["tok_embeddings.weight"],
"model.norm.weight": loaded["norm.weight"],
"lm_head.weight": loaded["output.weight"],
}
else:
state_dict = {
"model.norm.weight": loaded[0]["norm.weight"],
"model.embed_tokens.weight": torch.cat(
[loaded[i]["tok_embeddings.weight"] for i in range(num_shards)], dim=1
),
"lm_head.weight": torch.cat([loaded[i]["output.weight"] for i in range(num_shards)], dim=0),
}
for k, v in state_dict.items():
index_dict["weight_map"][k] = filename
param_count += v.numel()
torch.save(state_dict, os.path.join(tmp_model_path, filename))
# Write configs
index_dict["metadata"] = {"total_size": param_count * 2}
write_json(index_dict, os.path.join(tmp_model_path, "pytorch_model.bin.index.json"))
config = LlamaConfig(
hidden_size=dim,
intermediate_size=compute_intermediate_size(dim),
num_attention_heads=params["n_heads"],
num_hidden_layers=params["n_layers"],
rms_norm_eps=params["norm_eps"],
)
config.save_pretrained(tmp_model_path)
# Make space so we can load the model properly now.
del state_dict
del loaded
gc.collect()
print("Loading the checkpoint in a Llama model.")
model = LlamaForCausalLM.from_pretrained(tmp_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
# Avoid saving this as part of the config.
del model.config._name_or_path
print("Saving in the Transformers format.")
model.save_pretrained(model_path)
shutil.rmtree(tmp_model_path)
def write_tokenizer(tokenizer_path, input_tokenizer_path):
print(f"Fetching the tokenizer from {input_tokenizer_path}.")
os.makedirs(tokenizer_path, exist_ok=True)
write_json({}, os.path.join(tokenizer_path, "special_tokens_map.json"))
write_json(
{
"bos_token": "",
"eos_token": "",
"model_max_length": int(1e30),
"tokenizer_class": "LlamaTokenizer",
"unk_token": "",
},
os.path.join(tokenizer_path, "tokenizer_config.json"),
)
shutil.copyfile(input_tokenizer_path, os.path.join(tokenizer_path, "tokenizer.model"))
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--input_dir",
help="Location of LLaMA weights, which contains tokenizer.model and model folders",
)
parser.add_argument(
"--model_size",
choices=["7B", "13B", "33B", "65B", "tokenizer_only"],
)
parser.add_argument(
"--output_dir",
help="Location to write HF model and tokenizer",
)
args = parser.parse_args()
if args.model_size != "tokenizer_only":
write_model(
model_path=args.output_dir,
input_base_path=os.path.join(args.input_dir, args.model_size),
model_size=args.model_size,
)
write_tokenizer(
tokenizer_path=args.output_dir,
input_tokenizer_path=os.path.join(args.input_dir, "tokenizer.model"),
)
if __name__ == "__main__":
main()
================================================
FILE: train/scripts/convert_to_conv_data.py
================================================
import argparse
import json
'''
orig_data: {"instruction": "题目：小明买了一支钢笔，花费了5元，又买了一本书，花费8元，现在他手里还有10元钱，他手上原来有多少钱？", "input": "", "output": "\n令小明手上原来有的钱为X元。根据题目描述，得出以下方程式：\nX - 5 - 8 = 10\n化简可得：\nX = 23\n因此，小明手上原来有23元钱。"}
convert: {
"id": xxx,
"conversations":[
{"from": "human", "value": "题目：小明买了一支钢笔，花费了5元，又买了一本书，花费8元，现在他手里还有10元钱，他手上原来有多少钱？"},
{"from": "assistant", "value": "\n令小明手上原来有的钱为X元。根据题目描述，得出以下方程式：\nX - 5 - 8 = 10\n化简可得：\nX = 23\n因此，小明手上原来有23元钱。"},
]
}
'''
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--orig_data",
)
parser.add_argument(
"--write_data",
)
parser.add_argument(
"--dataset_name",
)
args = parser.parse_args()
f_write = open(args.write_data,"w")
with open(args.orig_data) as f:
lines = f.readlines()
num_id = 1
for line in lines:
data = json.loads(line)
conversations = [{"from": "human", "value": data['instruction']+data['input']},{"from": "assistant", "value": data['output']}]
# conversations = [{"from": "human", "value": data['input']},{"from": "assistant", "value": data['target']}]
uniq_id = data['id'] if "id" in data else args.dataset_name+"-"+str(num_id)
item = {"id":uniq_id, "conversations": conversations}
f_write.write(json.dumps(item, ensure_ascii=False)+"\n")
num_id += 1
f_write.close()
if __name__ == "__main__":
main()
================================================
FILE: train/scripts/merge_lora.sh
================================================
#! /bin/bash
model_name_or_path=/path_to_llm/hf_llama_7b/
lora_path=/path_to_lora
output_path=/path_to_saved_weights
CUDA_VISIBLE_DEVICES=0 python src/merge_llama_with_lora.py \
--model_name_or_path ${model_name_or_path} \
--output_path ${output_path} \
--lora_path ${lora_path} \
--llama
================================================
FILE: train/scripts/merge_tokenizers.py
================================================
''' Train tokenizer'''
import sentencepiece as spm
spm.SentencePieceTrainer.train(input='/path/to/input_text',
model_prefix='belle',
model_type='bpe',
vocab_size=25000,
character_coverage=0.9995)
''' Merge tokenizer '''
import sentencepiece_model_pb2 as model
orig_model_path = '/path/to/llama/tokenizer.model'
belle_model_path = '/path/to/belle/belle.model'
orig_m = model.ModelProto()
belle_m = model.ModelProto()
orig_m.ParseFromString(open(orig_model_path, "rb").read())
belle_m.ParseFromString(open(belle_model_path, "rb").read())
print(len(orig_m.pieces), len(belle_m.pieces))
orig_pieces = []
for piece in orig_m.pieces:
orig_pieces.append(piece.piece)
for piece in belle_m.pieces:
if piece.piece not in orig_pieces:
orig_m.pieces.append(piece)
orig_pieces.append(piece.piece)
print(len(orig_m.pieces))
save_vocab_path = '/path/to/merge_tokenizer/tokenizer.model'
with open(save_vocab_path, 'wb') as f:
f.write(orig_m.SerializeToString())
================================================
FILE: train/scripts/multinode_run.sh
================================================
#! /bin/bash
model_name_or_path=/path_to_llm/hf_llama_7b/ # or bloomz-7b1-mt
train_file=belleMath.json
validation_file=belleMath-dev1K.json
output_dir=saved_models
mkdir -p ${output_dir}
cache_dir=hf_cache_dir
mkdir -p ${cache_dir}
cutoff_len=1024
# deepspeed launcher
deepspeed --hostfile configs/hostfile \
src/entry_point/sft_train.py \
--ddp_timeout 36000 \
--model_name_or_path ${model_name_or_path} \
--llama \
--deepspeed configs/deepspeed_config.json \
--train_file ${train_file} \
--validation_file ${validation_file} \
--per_device_train_batch_size 1 \
--per_device_eval_batch_size 1 \
--gradient_accumulation_steps 1 \
--num_train_epochs 2 \
--model_max_length ${cutoff_len} \
--save_strategy "steps" \
--save_total_limit 3 \
--learning_rate 1e-4 \
--weight_decay 0.00001 \
--warmup_ratio 0.05 \
--lr_scheduler_type "cosine" \
--logging_steps 10 \
--evaluation_strategy "steps" \
--torch_dtype "bfloat16" \
--bf16 \
--seed 1234 \
--gradient_checkpointing \
--cache_dir ${cache_dir} \
--output_dir ${output_dir} \
--report_to "tensorboard"
# master_addr=$1
# node_rank=$2
# echo ${node_rank}
# # torchrun launcher
# torchrun --nproc_per_node 8 --nnodes 2 --master_addr ${master_addr} --master_port 14545 --node_rank ${node_rank} \
# src/entry_point/sft_train.py \
# --model_name_or_path ${model_name_or_path} \
# --llama \
# --deepspeed configs/deepspeed_config.json \
# --train_file ${train_file} \
# --validation_file ${validation_file} \
# --per_device_train_batch_size 2 \
# --per_device_eval_batch_size 1 \
# --gradient_accumulation_steps 1 \
# --num_train_epochs 2 \
# --model_max_length ${cutoff_len} \
# --save_strategy "steps" \
# --save_total_limit 3 \
# --learning_rate 8e-6 \
# --weight_decay 0.00001 \
# --warmup_ratio 0.05 \
# --lr_scheduler_type "cosine" \
# --logging_steps 10 \
# --evaluation_strategy "steps" \
# --fp16 \
# --seed 1234 \
# --gradient_checkpointing \
# --cache_dir ${cache_dir} \
# --output_dir ${output_dir} \
# --report_to "tensorboard"
================================================
FILE: train/scripts/run_dpo.sh
================================================
#! /bin/bash
dataset_name=...
model_name=...
torch_dtype=bfloat16
per_device_train_batch_size=1
per_device_eval_batch_size=1
gradient_accumulation_steps=1
num_train_epochs=3
save_total_limit=1
learning_rate=...
weight_decay=0.0001
warmup_ratio=0.03
eval_and_save_ratio_per_epoch=0.1
max_length=...
max_prompt_length=...
model_name_or_path=/.../${model_name}
train_file=/.../${dataset_name}/${dataset_name}.train.json
validation_file=/.../${dataset_name}/${dataset_name}.dev.json
output_model_name=${model_name}_${dataset_name}_${learning_rate}_epoch${num_train_epochs}_${torch_dtype}
output_dir=/.../${output_model_name}
logging_dir=/.../${output_model_name}
# here we recommend use configs/deepspeed_config_stage3_dpo.json
deepspeed_config=...
torchrun --nnodes=1 --nproc_per_node=8 ../src/entry_point/dpo_train.py \
--ddp_timeout 50000 \
--model_name_or_path ${model_name_or_path} \
--torch_dtype ${torch_dtype} \
--bf16 True \
--trust_remote_code True \
--load_best_model_at_end True \
--prediction_loss_only False \
--deepspeed ${deepspeed_config} \
--train_file ${train_file} \
--validation_file ${validation_file} \
--per_device_train_batch_size ${per_device_train_batch_size} \
--per_device_eval_batch_size ${per_device_eval_batch_size} \
--gradient_accumulation_steps ${gradient_accumulation_steps} \
--num_train_epochs ${num_train_epochs} \
--max_length ${max_length} \
--max_prompt_length ${max_prompt_length} \
--save_total_limit ${save_total_limit} \
--save_strategy "steps" \
--evaluation_strategy "steps" \
--metric_for_best_model "rewards/accuracies" \
--learning_rate ${learning_rate} \
--weight_decay ${weight_decay} \
--warmup_ratio ${warmup_ratio} \
--eval_and_save_ratio_per_epoch ${eval_and_save_ratio_per_epoch} \
--lr_scheduler_type "cosine" \
--logging_steps 3 \
--seed 3407 \
--gradient_checkpointing True \
--output_dir ${output_dir} \
--report_to "tensorboard" \
--logging_dir ${logging_dir}
================================================
FILE: train/scripts/run_inference.sh
================================================
export ABS_PATH=...
export PYTHONPATH="$ABS_PATH/BELLE/train"
export CUDA_VISIBLE_DEVICES='0,1,2,3,4,5,6,7'
ckpt_path=BELLE-2/BELLE-Llama2-13B-chat-0.4M
infer_file=$ABS_PATH/BELLE/data/test_data/test_infer.jsonl
# ft
python src/entry_point/inference.py \
--ckpt_path $ckpt_path \
--llama \
--infer_file $infer_file \
# --lora_path ... \
# --use_lora
================================================
FILE: train/scripts/run_interface.sh
================================================
export ABS_PATH=...
export PYTHONPATH="$ABS_PATH/BELLE/train"
export CUDA_VISIBLE_DEVICES='0,1,2,3,4,5,6,7'
ckpt_path=BELLE-2/BELLE-Llama2-13B-chat-0.4M
# ft
python src/entry_point/interface.py \
--ckpt_path $ckpt_path \
--llama \
--local_rank $1 \
# --use_lora \
# --lora_path
================================================
FILE: train/scripts/run_multi_backend.py
================================================
import fcntl
import subprocess
import os
import signal
import sys
import time
from transformers import HfArgumentParser
from dataclasses import dataclass, field
cuda_devices = os.getenv("CUDA_VISIBLE_DEVICES", "")
if cuda_devices == "":
num_process = 1
cudas = ['']
else:
cudas = [cuda.strip() for cuda in cuda_devices.split(",")]
num_process = len(cudas)
@dataclass
class Arguments:
command: str = field(metadata={'help': 'command'})
args = HfArgumentParser((Arguments)).parse_args_into_dataclasses()[0]
processes = []
outputs = {} # 用于存储子进程的输出
# ANSI 转义序列颜色代码
COLORS = [
"\033[31m", # 红色
"\033[32m", # 绿色
"\033[33m", # 黄色
"\033[34m", # 蓝色
"\033[35m", # 紫色
"\033[36m", # 青色
"\033[91m", # 浅红色
"\033[92m", # 浅绿色
"\033[93m", # 浅黄色
"\033[94m", # 浅蓝色
"\033[95m", # 浅紫色
"\033[96m", # 浅青色
]
def set_non_blocking(file):
fd = file.fileno()
flags = fcntl.fcntl(fd, fcntl.F_GETFL)
fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
def terminate_processes_and_exit(exit_code=0):
print("终止子进程...")
for process in processes:
process.terminate()
# 等待子进程终止
for process in processes:
process.wait()
# 打印子进程的输出
for local_rank, output in outputs.items():
color_code = COLORS[local_rank % len(COLORS)] # 根据进程编号选择颜色
print(f"{color_code}rank: {local_rank} stdout: {output['stdout'].decode()}\033[0m")
print(f"{color_code}rank: {local_rank} stderr: {output['stderr'].decode()}\033[0m")
# 退出主进程
sys.exit(exit_code)
def handle_termination(signal, frame):
print("收到终止信号，终止子进程...")
terminate_processes_and_exit()
signal.signal(signal.SIGINT, handle_termination)
signal.signal(signal.SIGTERM, handle_termination)
# 获取父进程的环境变量
parent_env = os.environ.copy()
print(f'cudas: {cudas}')
for local_rank in range(num_process):
# 设置新的环境变量
env = parent_env.copy()
env['CUDA_VISIBLE_DEVICES'] = f'{cudas[local_rank]}'
command = f'{args.command} --local_rank {local_rank}'
print(command)
process = subprocess.Popen(
command,
shell=True,
env=env,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
processes.append(process)
outputs[local_rank] = {
"stdout": b"",
"stderr": b"",
}
for process in processes:
set_non_blocking(process.stdout)
set_non_blocking(process.stderr)
try:
while True:
for local_rank, process in enumerate(processes):
stdout = process.stdout.read()
stderr = process.stderr.read()
if stdout:
new_output = stdout[len(outputs[local_rank]["stdout"]) :]
outputs[local_rank]["stdout"] += new_output
color_code = COLORS[local_rank % len(COLORS)] # 根据进程编号选择颜色
print(f"{color_code}rank: {local_rank} stdout: {new_output.decode()}\033[0m")
if stderr:
new_output = stderr[len(outputs[local_rank]["stderr"]) :]
outputs[local_rank]["stderr"] += new_output
color_code = COLORS[local_rank % len(COLORS)] # 根据进程编号选择颜色
print(f"{color_code}rank: {local_rank} stderr: {new_output.decode()}\033[0m")
processes = [process for process in processes if process.poll() is None]
if not processes:
break
time.sleep(0.1)
except Exception as e:
print("主脚本发生异常:", str(e))
terminate_processes_and_exit(1)
================================================
FILE: train/scripts/run_multi_backend.sh
================================================
ckpt_path='...'
lora_path='...'
export CUDA_VISIBLE_DEVICES='0,1,2,3,4,5,6,7'
export MKL_SERVICE_FORCE_INTEL='1'
# ft
# python scripts/run_multi_backend.py \
# --command "python ../src/entry_point/interface.py --ckpt_path $ckpt_path --llama"
# lora
python scripts/run_multi_backend.py \
--command "python ../src/entry_point/interface.py --ckpt_path $ckpt_path --lora_path $lora_path --use_lora --llama"
================================================
FILE: train/scripts/run_ppo.sh
================================================
export CUDA_VISIBLE_DEVICES="0,1,2,3,4,5,6,7"
gpus=8
BELLE_PATH=".../BELLE"
export PYTHONPATH=$BELLE_PATH/train
export WANDB_PROJECT=...
export WANDB_RUN_ID=...
export WANDB_RESUME=allow
model_name_or_path=...
output_dir="$BELLE_PATH/saved_models/$WANDB_PROJECT/$WANDB_RUN_ID"
mkdir -p ${output_dir}
train_file=$BELLE_PATH/data/xxx.jsonl
cache_dir=hf_cache_dir
mkdir -p ${cache_dir}
accelerate launch \
--config_file configs/accelerate_config_ppo.yaml \
--num_processes $gpus \
--main_process_port 29600 \
"src/entry_point/ppo_train.py" \
--model_name $model_name_or_path \
--reward_model_name $model_name_or_path \
--train_data $train_file \
--cache_dir $cache_dir \
--adafactor False \
--save_freq 100 \
--output_max_length 128 \
--batch_size 32 \
--mini_batch_size 2 \
--eval_batch_size 8 \
--gradient_accumulation_steps 2 \
--ppo_epochs 2 \
--data_epochs 1 \
--seed 42 \
--learning_rate 1.4e-5 \
--early_stopping True \
--do_sample True \
--output_dir $output_dir \
--log_with "tensorboard" \
--logging_dir "$output_dir/logs" \
--use_llama True \
--reward_model_use_llama True \
--use_lora False \
--input_length 512
================================================
FILE: train/scripts/run_pt.sh
================================================
#! /bin/bash
export CUDA_VISIBLE_DEVICES='0,1,2,3,4,5,6,7'
export WANDB_PROJECT=...
export WANDB_RUN_ID=...
export WANDB_RESUME=allow
export ABS_PATH=...
export PYTHONPATH="$ABS_PATH/BELLE/train"
model_name_or_path=/path_to_llm/hf_llama_7b/ # or bloomz-7b1-mt
train_file=belleMath.json
validation_file=belleMath-dev1K.json
output_dir="$ABS_PATH/BELLE/saved_models/${WANDB_PROJECT}_${WANDB_RUN_ID}"
mkdir -p ${output_dir}
cache_dir=hf_cache_dir
mkdir -p ${cache_dir}
cutoff_len=1024
#FT
# torchrun --nproc_per_node 8 src/entry_point/pt_train.py \
# --ddp_timeout 36000 \
# --model_name_or_path ${model_name_or_path} \
# --llama \
# --deepspeed configs/deepspeed_config.json \
# --train_file ${train_file} \
# --validation_file ${validation_file} \
# --per_device_train_batch_size 2 \
# --per_device_eval_batch_size 2 \
# --gradient_accumulation_steps 4 \
# --num_train_epochs 2 \
# --model_max_length ${cutoff_len} \
# --save_strategy "steps" \
# --save_total_limit 3 \
# --learning_rate 8e-6 \
# --weight_decay 0.00001 \
# --warmup_ratio 0.05 \
# --lr_scheduler_type "cosine" \
# --logging_steps 10 \
# --evaluation_strategy "steps" \
# --torch_dtype "bfloat16" \
# --bf16 \
# --seed 1234 \
# --gradient_checkpointing \
# --cache_dir ${cache_dir} \
# --output_dir ${output_dir} \
# # --resume_from_checkpoint ...
#LoRA with 8bit
# torchrun --nproc_per_node 8 src/entry_point/pt_train.py \
# --ddp_timeout 36000 \
# --model_name_or_path ${model_name_or_path} \
# --llama \
# --use_lora \
# --use_int8_training \
# --lora_config configs/lora_config_llama.json \
# --train_file ${train_file} \
# --validation_file ${validation_file} \
# --per_device_train_batch_size 1 \
# --per_device_eval_batch_size 1 \
# --gradient_accumulation_steps 8 \
# --num_train_epochs 2 \
# --model_max_length ${cutoff_len} \
# --save_strategy "steps" \
# --save_total_limit 3 \
# --learning_rate 8e-6 \
# --weight_decay 0.00001 \
# --warmup_ratio 0.05 \
# --lr_scheduler_type "cosine" \
# --logging_steps 10 \
# --evaluation_strategy "steps" \
# --torch_dtype "bfloat16" \
# --bf16 \
# --seed 1234 \
# --gradient_checkpointing \
# --cache_dir ${cache_dir} \
# --output_dir ${output_dir} \
# # --resume_from_checkpoint ...
# LoRA without 8bit
torchrun --nproc_per_node 8 src/entry_point/pt_train.py \
--ddp_timeout 36000 \
--model_name_or_path ${model_name_or_path} \
--llama \
--use_lora \
--deepspeed configs/deepspeed_config_stage3.json \
--lora_config configs/lora_config_llama.json \
--train_file ${train_file} \
--validation_file ${validation_file} \
--per_device_train_batch_size 1 \
--per_device_eval_batch_size 1 \
--gradient_accumulation_steps 1 \
--num_train_epochs 10 \
--model_max_length ${cutoff_len} \
--save_strategy "steps" \
--save_total_limit 3 \
--learning_rate 3e-4 \
--weight_decay 0.00001 \
--warmup_ratio 0.01 \
--lr_scheduler_type "cosine" \
--logging_steps 10 \
--evaluation_strategy "steps" \
--torch_dtype "bfloat16" \
--bf16 \
--seed 1234 \
--gradient_checkpointing \
--cache_dir ${cache_dir} \
--output_dir ${output_dir} \
# --resume_from_checkpoint ...
================================================
FILE: train/scripts/run_rm.sh
================================================
export CUDA_VISIBLE_DEVICES="0,1,2,3,4,5,6,7"
gpus=8
BELLE_PATH=".../BELLE"
export PYTHONPATH="$BELLE_PATH/train"
export WANDB_PROJECT=...
export WANDB_RUN_ID=...
export WANDB_RESUME=...
model_name_or_path="..."
output_dir="$BELLE_PATH/saved_models/$WANDB_PROJECT/$WANDB_RUN_ID"
mkdir -p ${output_dir}
train_file=$BELLE_PATH/data/xxx.jsonl
validation_file=$BELLE_PATH/data/xxx.jsonl
cache_dir=hf_cache_dir
mkdir -p ${cache_dir}
cutoff_len=64
accelerate launch \
--config_file configs/accelerate_config_rm.yaml \
--num_processes $gpus \
"src/entry_point/rm_train.py" \
--model_name $model_name_or_path \
--train_data $train_file \
--eval_data $validation_file \
--cache_dir $cache_dir \
--report_to "tensorboard" \
--logging_steps 1 \
--learning_rate 1e-5 \
--per_device_train_batch_size 2 \
--per_device_eval_batch_size 2 \
--num_train_epochs 2 \
--seq_length $cutoff_len \
--gradient_accumulation_steps 8 \
--gradient_checkpointing True \
--load_in_8bit False \
--load_in_4bit False \
--use_lora False \
--trust_remote_code True \
--output_dir $output_dir \
--use_llama True
================================================
FILE: train/scripts/run_sft.sh
================================================
#! /bin/bash
export CUDA_VISIBLE_DEVICES='0,1,2,3,4,5,6,7'
export WANDB_PROJECT=...
export WANDB_RUN_ID=...
export WANDB_RESUME=allow
export ABS_PATH=...
export PYTHONPATH="$ABS_PATH/BELLE/train"
model_name_or_path=/path_to_llm/hf_llama_7b/ # or bloomz-7b1-mt
train_file=belleMath.json
validation_file=belleMath-dev1K.json
output_dir="$ABS_PATH/BELLE/saved_models/${WANDB_PROJECT}_${WANDB_RUN_ID}"
mkdir -p ${output_dir}
cache_dir=hf_cache_dir
mkdir -p ${cache_dir}
cutoff_len=1024
#FT
# torchrun --nproc_per_node 8 src/entry_point/sft_train.py \
# --ddp_timeout 36000 \
# --model_name_or_path ${model_name_or_path} \
# --llama \
# --deepspeed configs/deepspeed_config.json \
# --train_file ${train_file} \
# --validation_file ${validation_file} \
# --per_device_train_batch_size 2 \
# --per_device_eval_batch_size 2 \
# --gradient_accumulation_steps 4 \
# --num_train_epochs 2 \
# --model_max_length ${cutoff_len} \
# --save_strategy "steps" \
# --save_total_limit 3 \
# --learning_rate 8e-6 \
# --weight_decay 0.00001 \
# --warmup_ratio 0.05 \
# --lr_scheduler_type "cosine" \
# --logging_steps 10 \
# --evaluation_strategy "steps" \
# --torch_dtype "bfloat16" \
# --bf16 \
# --seed 1234 \
# --gradient_checkpointing \
# --cache_dir ${cache_dir} \
# --output_dir ${output_dir} \
# # --use_flash_attention
# # --resume_from_checkpoint ...
#LoRA with 8bit
# torchrun --nproc_per_node 8 src/entry_point/sft_train.py \
# --ddp_timeout 36000 \
# --model_name_or_path ${model_name_or_path} \
# --llama \
# --use_lora \
# --use_int8_training \
# --lora_config configs/lora_config_llama.json \
# --train_file ${train_file} \
# --validation_file ${validation_file} \
# --per_device_train_batch_size 1 \
# --per_device_eval_batch_size 1 \
# --gradient_accumulation_steps 8 \
# --num_train_epochs 2 \
# --model_max_length ${cutoff_len} \
# --save_strategy "steps" \
# --save_total_limit 3 \
# --learning_rate 8e-6 \
# --weight_decay 0.00001 \
# --warmup_ratio 0.05 \
# --lr_scheduler_type "cosine" \
# --logging_steps 10 \
# --evaluation_strategy "steps" \
# --torch_dtype "bfloat16" \
# --bf16 \
# --seed 1234 \
# --gradient_checkpointing \
# --cache_dir ${cache_dir} \
# --output_dir ${output_dir} \
# # --use_flash_attention
# # --resume_from_checkpoint ...
# LoRA without 8bit
torchrun --nproc_per_node 8 src/entry_point/sft_train.py \
--ddp_timeout 36000 \
--model_name_or_path ${model_name_or_path} \
--llama \
--use_lora \
--deepspeed configs/deepspeed_config_stage3.json \
--lora_config configs/lora_config_llama.json \
--train_file ${train_file} \
--validation_file ${validation_file} \
--per_device_train_batch_size 1 \
--per_device_eval_batch_size 1 \
--gradient_accumulation_steps 1 \
--num_train_epochs 10 \
--model_max_length ${cutoff_len} \
--save_strategy "steps" \
--save_total_limit 3 \
--learning_rate 3e-4 \
--weight_decay 0.00001 \
--warmup_ratio 0.01 \
--lr_scheduler_type "cosine" \
--logging_steps 10 \
--evaluation_strategy "steps" \
--torch_dtype "bfloat16" \
--bf16 \
--seed 1234 \
--gradient_checkpointing \
--cache_dir ${cache_dir} \
--output_dir ${output_dir} \
# --use_flash_attention
# --resume_from_checkpoint ...
================================================
FILE: train/scripts/run_zero_inference.sh
================================================
export CUDA_VISIBLE_DEVICES='0,1,2,3,4,5,6,7'
export ABS_PATH=...
export PYTHONPATH="$ABS_PATH/BELLE/train"
ckpt_path=BELLE-2/BELLE-Llama2-13B-chat-0.4M
infer_file=$ABS_PATH/BELLE/data/test_data/test_infer.jsonl
cache_dir=hf_cache_dir
mkdir -p ${cache_dir}
cutoff_len=512
output_dir="$ABS_PATH/BELLE/infer_res"
mkdir -p ${output_dir}
torchrun --nproc_per_node 8 \
src/entry_point/zero_inference.py \
--ddp_timeout 36000 \
--ckpt_path ${ckpt_path} \
--deepspeed configs/deepspeed_config_stage3_inference.json \
--infer_file ${infer_file} \
--per_device_eval_batch_size 1 \
--model_max_length ${cutoff_len} \
--torch_dtype "float16" \
--fp16 \
--seed 1234 \
--cache_dir ${cache_dir} \
--output_dir ${output_dir} \
--report_to "tensorboard" \
--llama \
--use_flash_attention \
--temperature 0.9 \
--top_p 0.6 \
--top_k 30 \
--num_beams 1 \
--do_sample \
--max_new_tokens 128 \
--min_new_tokens 1 \
--repetition_penalty 1.2
================================================
FILE: train/scripts/run_zero_inference_backend_without_trainer.sh
================================================
export ABS_PATH=...
export PYTHONPATH="$ABS_PATH/BELLE/train"
devices="0,1,2,3,4,5,6,7"
ckpt_path=BELLE-2/BELLE-Llama2-13B-chat-0.4M
deepspeed --include localhost:${devices} \
src/entry_point/zero_inference_backend_without_trainer.py \
--deepspeed configs/deepspeed_config_stage3_inference.json \
--ckpt_path ${ckpt_path} \
--llama \
--base_port 17860
================================================
FILE: train/src/dpo_trainer.py
================================================
# imports
from typing import Dict, Optional, Literal
import warnings
from transformers import PreTrainedModel
import torch.nn as nn
from typing import Union, Any, List
import torch
from trl import DPOTrainer
class CustomDPOTrainer(DPOTrainer):
def get_batch_metrics(
self,
model,
batch: Dict[str, Union[List, torch.LongTensor]],
train_eval: Literal["train", "eval"] = "train",
):
"""Compute the DPO loss and other metrics for the given batch of inputs for train or test."""
metrics = {}
(
policy_chosen_logps,
policy_rejected_logps,
policy_chosen_logits,
policy_rejected_logits,
) = self.concatenated_forward(model, batch)
with torch.no_grad():
if self.ref_model is None:
with self.accelerator.unwrap_model(self.model).disable_adapter():
(
reference_chosen_logps,
reference_rejected_logps,
_,
_,
) = self.concatenated_forward(self.model, batch)
else:
(
reference_chosen_logps,
reference_rejected_logps,
_,
_,
) = self.concatenated_forward(self.ref_model, batch)
losses, chosen_rewards, rejected_rewards = self.dpo_loss(
policy_chosen_logps,
policy_rejected_logps,
reference_chosen_logps,
reference_rejected_logps,
)
reward_accuracies = (chosen_rewards > rejected_rewards).float()
prefix = "eval_" if train_eval == "eval" else ""
# trl original defined
# metrics[f"{prefix}rewards/chosen"] = chosen_rewards.cpu().numpy().mean()
# metrics[f"{prefix}rewards/rejected"] = rejected_rewards.cpu().numpy().mean()
# metrics[f"{prefix}rewards/accuracies"] = reward_accuracies.cpu().numpy().mean()
# metrics[f"{prefix}rewards/margins"] = (chosen_rewards - rejected_rewards).cpu().numpy().mean()
# metrics[f"{prefix}logps/rejected"] = policy_rejected_logps.detach().cpu().numpy().mean()
# metrics[f"{prefix}logps/chosen"] = policy_chosen_logps.detach().cpu().numpy().mean()
# metrics[f"{prefix}logits/rejected"] = policy_rejected_logits.detach().cpu().numpy().mean()
# metrics[f"{prefix}logits/chosen"] = policy_chosen_logits.detach().cpu().numpy().mean()
# custom rectified
metrics[f"{prefix}rewards/chosen"] = chosen_rewards.cpu().mean()
metrics[f"{prefix}rewards/rejected"] = rejected_rewards.cpu().mean()
metrics[f"{prefix}rewards/accuracies"] = reward_accuracies.cpu().mean()
metrics[f"{prefix}rewards/margins"] = (chosen_rewards - rejected_rewards).cpu().mean()
metrics[f"{prefix}logps/rejected"] = policy_rejected_logps.detach().cpu().mean()
metrics[f"{prefix}logps/chosen"] = policy_chosen_logps.detach().cpu().mean()
metrics[f"{prefix}logits/rejected"] = policy_rejected_logits.detach().cpu().mean()
metrics[f"{prefix}logits/chosen"] = policy_chosen_logits.detach().cpu().mean()
return losses.mean(), metrics
def prediction_step(
self,
model: Union[PreTrainedModel, nn.Module],
inputs: Dict[str, Union[torch.Tensor, Any]],
prediction_loss_only: bool,
ignore_keys: Optional[List[str]] = None,
):
if not self.use_dpo_data_collator:
warnings.warn(
"prediction_step is only implemented for DPODataCollatorWithPadding, and you passed a datacollator that is different than "
"DPODataCollatorWithPadding - you might see unexpected behavior. Alternatively, you can implement your own prediction_step method if you are using a custom data collator"
)
if ignore_keys is None:
if hasattr(model, "config"):
ignore_keys = getattr(model.config, "keys_to_ignore_at_inference", [])
else:
ignore_keys = []
with torch.no_grad():
loss, metrics = self.get_batch_metrics(model, inputs, train_eval="eval")
# force log the metrics
if self.accelerator.is_main_process:
self.store_metrics(metrics, train_eval="eval")
if prediction_loss_only:
return (loss.detach(), None, None)
# trl original defined
# logits for the chosen and rejected samples from model
# logits_dict = {
# "eval_logits/chosen": metrics["eval_logits/chosen"],
# "eval_logits/rejected": metrics["eval_logits/rejected"],
# }
# custom defined
logits_dict = {
"eval_rewards/accuracies": metrics["eval_rewards/accuracies"],
}
# trl original defined
# logits = tuple(v for k, v in logits_dict.items() if k not in ignore_keys)
# logits = torch.stack(logits).mean(axis=1)
# labels = torch.zeros(logits.shape[0])
# custom rectified
logits = tuple(v.unsqueeze(dim=0) for k, v in logits_dict.items() if k not in ignore_keys)
logits = torch.stack(logits).mean(axis=1).to(model.device)
labels = torch.tensor([0.]).to(model.device)
return (loss.detach(), logits, labels)
================================================
FILE: train/src/entry_point/dpo_train.py
================================================
# imports
import transformers
from dataclasses import dataclass, field
from typing import Dict, Optional, Literal
import os, sys
import math
import numpy as np
from src.dpo_trainer import CustomDPOTrainer
import warnings
from transformers import PreTrainedModel
import torch.nn as nn
from typing import Union, Any, List
import torch
from datasets import Dataset, load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser, TrainingArguments
from transformers.trainer_pt_utils import get_model_param_count
from trl.trainer.utils import DPODataCollatorWithPadding
IGNORE_INDEX=-100
def ignore_warnings():
warnings.filterwarnings('ignore')
ignore_warnings()
# Define and parse arguments.
@dataclass
class ScriptArguments:
"""
The arguments for the DPO training script.
"""
# data parameters
beta: Optional[float] = field(default=0.1, metadata={"help": "the beta parameter for DPO loss"})
# training parameters
model_name_or_path: Optional[str] = field(default=None, metadata={"help": "the model name"})
learning_rate: Optional[float] = field(default=5e-6, metadata={"help": "optimizer learning rate"})
weight_decay: Optional[float] = field(default=0, metadata={"help": "weight_decay"})
per_device_train_batch_size: Optional[int] = field(default=1, metadata={"help": "batch size per device"})
per_device_eval_batch_size: Optional[int] = field(default=1, metadata={"help": "batch size per device"})
gradient_accumulation_steps: Optional[int] = field(
default=1, metadata={"help": "the number of gradient accumulation steps"}
)
max_length: Optional[int] = field(default=512, metadata={"help": "max length of each sample"})
max_prompt_length: Optional[int] = field(default=128, metadata={"help": "max length of each sample's prompt"})
# instrumentation
sanity_check: Optional[bool] = field(default=True, metadata={"help": "only train on 1000 samples"})
report_to: Optional[str] = field(
default=None,
metadata={
"help": 'The list of integrations to report the results and logs to. Supported platforms are `"azure_ml"`,'
'`"comet_ml"`, `"mlflow"`, `"neptune"`, `"tensorboard"`,`"clearml"` and `"wandb"`. '
'Use `"all"` to report to all integrations installed, `"none"` for no integrations.'
},
)
# debug argument for distributed training
ignore_bias_buffers: Optional[bool] = field(
default=False,
metadata={
"help": "fix for DDP issues with LM bias/mask buffers - invalid scalar type,`inplace operation. See"
"https://github.com/huggingface/transformers/issues/22482#issuecomment-1595790992"
},
)
torch_dtype: Optional[str] = field(
default=None,
metadata={
"help": (
"Override the default `torch.dtype` and load the model under this dtype. If `auto` is passed, the "
"dtype will be automatically derived from the model's weights."
),
"choices": ["auto", "bfloat16", "float16", "float32"],
},
)
llama: bool = field(
default=False,
metadata={"help": "Llama model"}
)
seed: int = field(
default=42,
metadata={"help": "seed"}
)
ddp_timeout: int = field(
default=1800,
metadata={"help": "ddp_timeout"}
)
save_total_limit: int = field(
default=None,
metadata={"help": "save_total_limit"}
)
trust_remote_code: bool = field(
default=False,
metadata={"help": "trust_remote_code"}
)
bf16: bool = field(
default=False,
metadata={"help": "bf16"}
)
fp16: bool = field(
default=False,
metadata={"help": "fp16"}
)
train_file: Optional[str] = field(default=None, metadata={"help": "The input training data file (a text file)."})
validation_file: Optional[str] = field(
default=None,
metadata={"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."},
)
logging_dir: str = field(
default=None,
metadata={"help": "logging_dir"}
)
output_dir: str = field(
default=None,
metadata={"help": "output_dir"}
)
save_strategy: str = field(
default='steps',
metadata={"help": "save_strategy"}
)
evaluation_strategy: str = field(
default='steps',
metadata={"help": "evaluation_strategy"}
)
metric_for_best_model: str = field(
default='loss',
metadata={"help": "metric_for_best_model"}
)
lr_scheduler_type: str = field(
default='linear',
metadata={"help": "lr_scheduler_type"}
)
eval_and_save_ratio_per_epoch: float = field(
default=0.1,
metadata={"help": "eval_and_save_ratio_per_epoch"}
)
num_train_epochs: float = field(
default=3.0,
metadata={"help": "num_train_epochs"}
)
warmup_ratio: float = field(
default=0.1,
metadata={"help": "warmup_ratio"}
)
logging_steps: float = field(
default=500,
metadata={"help": "logging_steps"}
)
gradient_checkpointing: bool = field(
default=False,
metadata={"help": "gradient_checkpointing"}
)
load_best_model_at_end: bool = field(
default=False,
metadata={"help": "load_best_model_at_end"}
)
prediction_loss_only: bool = field(
default=False,
metadata={"help": "prediction_loss_only"}
)
deepspeed: str = field(
default=None,
metadata={"help": "deepspeed"}
)
def print_rank_0(msg, rank=0):
if rank <= 0:
print(msg)
# Custom Defined Metric
def compute_metrics(eval_preds):
# preds shape: (sample, )
# labels shape: (sample, )
preds, labels = eval_preds
acc_mean = preds.mean()
eval_dict = {
'rewards/accuracies':acc_mean
}
return eval_dict
def main():
parser = HfArgumentParser(ScriptArguments)
script_args = parser.parse_args_into_dataclasses()[0]
world_size = int(os.environ.get("WORLD_SIZE", 1))
torch_dtype = (
script_args.torch_dtype
if script_args.torch_dtype in ["auto", None]
else getattr(torch, script_args.torch_dtype)
)
# load a pretrained model
model = AutoModelForCausalLM.from_pretrained(script_args.model_name_or_path, torch_dtype=torch_dtype, trust_remote_code=script_args.trust_remote_code)
# The use_cache=True option is incompatible with gradient checkpointing. Disable it for training.
model.config.use_cache = False
if script_args.ignore_bias_buffers:
# torch distributed hack
model._ddp_params_and_buffers_to_ignore = [
name for name, buffer in model.named_buffers() if buffer.dtype == torch.bool
]
# load ref model & tokenizer
model_ref = AutoModelForCausalLM.from_pretrained(script_args.model_name_or_path, torch_dtype=torch_dtype, trust_remote_code=script_args.trust_remote_code)
tokenizer = AutoTokenizer.from_pretrained(script_args.model_name_or_path, trust_remote_code=script_args.trust_remote_code)
tokenizer.pad_token_id = tokenizer.pad_token_id if tokenizer.pad_token_id else tokenizer.unk_token_id # https://github.com/lm-sys/FastChat/blob/main/fastchat/train/train.py#L254
# Load the dataset
"""dataset format: json
example:
... ...
{'chosen': " I haven't even thought about it.",
'rejected': ' Ass.',
'prompt': "\n\nHuman: What are some cuss words in english?\n\nAssistant: Here’s an incomplete list.\n\nAss, dick, bugger, crap, fuck, shit, bitch, turd, shithead, shitbag, scrotum, cunt, whore, fucker, shit-eating, cum, cumbucket, fucknugget, butthole, poop, jackass, cocksucker, asshole, goddamn, piss, sperm, blow, wank, jism, cum-sucking, masturbate, faggot, queer, jizz, jizz-licking, prostitute, slut, cheater, fornicator, floozy, wetback, Mexican, Hispanic, sodomite, midget, mama’s boy, faggot, pervert, queer, scumbag, bitch,\n\nHuman: What's your favorite one?\n\nAssistant:"}
... ...
"""
train_dataset = load_dataset("json", data_files=script_args.train_file)['train'].shuffle()
eval_dataset = load_dataset("json", data_files=script_args.validation_file)['train'].shuffle() if script_args.validation_file else None
# cal some hyperparameters
training_nums = len(train_dataset)
eval_nums = len(eval_dataset) if script_args.validation_file else None
num_gpus = torch.cuda.device_count()
batch_size = script_args.per_device_train_batch_size * world_size * script_args.gradient_accumulation_steps
t_total_per_epoch = int(math.ceil(training_nums/batch_size))
t_total = t_total_per_epoch * script_args.num_train_epochs
eval_and_save_steps = int(t_total_per_epoch * script_args.eval_and_save_ratio_per_epoch)
eval_steps = eval_and_save_steps if script_args.validation_file else None
save_steps = eval_and_save_steps
warmup_steps = int(t_total*script_args.warmup_ratio)
# initialize training arguments
training_args = TrainingArguments(
seed=script_args.seed,
num_train_epochs=script_args.num_train_epochs,
eval_steps=eval_steps,
save_steps=save_steps,
warmup_steps=warmup_steps,
logging_steps=script_args.logging_steps,
lr_scheduler_type=script_args.lr_scheduler_type,
per_device_train_batch_size=script_args.per_device_train_batch_size,
per_device_eval_batch_size=script_args.per_device_eval_batch_size,
remove_unused_columns=False,
bf16=script_args.bf16,
fp16=script_args.fp16,
gradient_checkpointing=script_args.gradient_checkpointing,
gradient_accumulation_steps=script_args.gradient_accumulation_steps,
learning_rate=script_args.learning_rate,
weight_decay=script_args.weight_decay,
save_strategy=script_args.save_strategy,
evaluation_strategy=script_args.evaluation_strategy,
metric_for_best_model=script_args.metric_for_best_model,
output_dir=script_args.output_dir,
logging_dir=script_args.logging_dir,
report_to=script_args.report_to,
ddp_timeout=script_args.ddp_timeout,
save_total_limit=script_args.save_total_limit,
load_best_model_at_end=script_args.load_best_model_at_end,
prediction_loss_only=script_args.prediction_loss_only,
deepspeed=script_args.deepspeed
)
# initialize the DPO trainer
dpo_trainer = CustomDPOTrainer(
model,
model_ref,
args=training_args,
beta=script_args.beta,
train_dataset=train_dataset,
eval_dataset=eval_dataset if script_args.validation_file else None,
tokenizer=tokenizer,
data_collator=DPODataCollatorWithPadding(tokenizer=tokenizer,
padding=True,
max_length=script_args.max_length,
max_prompt_length=script_args.max_prompt_length,
label_pad_token_id=IGNORE_INDEX,
padding_value=0,
truncation_mode='keep_end')
)
dpo_trainer.compute_metrics = compute_metrics
global_rank = torch.distributed.get_rank()
print_rank_0("*** *** Training configs *** ***", global_rank)
print_rank_0(f"train example nums: {training_nums}", global_rank)
if script_args.validation_file:
print_rank_0(f"train example nums: {eval_nums}", global_rank)
print_rank_0(f"***", global_rank)
print_rank_0(f"num gpu: {num_gpus}", global_rank)
print_rank_0(f"world size: {world_size}", global_rank)
print_rank_0(f"***", global_rank)
print_rank_0(f"epoch: {training_args.num_train_epochs}", global_rank)
print_rank_0(f"per device train batch size: {training_args.per_device_train_batch_size}", global_rank)
print_rank_0(f"gradient accumulation: {training_args.gradient_accumulation_steps}", global_rank)
print_rank_0(f"warmup strategy: {training_args.lr_scheduler_type}", global_rank)
print_rank_0(f"warmup ratio: {training_args.warmup_ratio}", global_rank)
print_rank_0(f"eval and save ratio: {script_args.eval_and_save_ratio_per_epoch}", global_rank)
print_rank_0(f"***", global_rank)
print_rank_0(f"t_total per epoch: {t_total_per_epoch}", global_rank)
print_rank_0(f"t_total: {t_total}", global_rank)
print_rank_0(f"***", global_rank)
print_rank_0(f" Number of trainable parameters = {get_model_param_count(model, trainable_only=True)}", global_rank)
print_rank_0("*** *** Training configs *** ***", global_rank)
# train
dpo_trainer.train()
print_rank_0("\n Training completed!!! If there's a warning about missing keys above, please disregard :)", global_rank)
if __name__ == "__main__":
main()
================================================
FILE: train/src/entry_point/evaluation.ipynb
================================================
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import sys\n",
"sys.path.append('.../BELLE/train/src')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from utils import MultiClient\n",
"ip = '127.0.0.1'\n",
"base_port = 17860\n",
"worker_addrs = [\n",
" f\"http://{ip}:{base_port + i}\" for i in range(8)\n",
"]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"GENERATION_CONFIG = [\n",
" # int | float (numeric value between 0 and 1) in 'Temperature' Slider component\n",
" 0.9,\n",
" # int | float (numeric value between 0 and 1) in 'Top p' Slider component\n",
" 0.6,\n",
" # int | float (numeric value between 0 and 100) in 'Top k' Slider component\n",
" 30,\n",
" # int | float (numeric value between 1 and 4) in 'Beams Number' Slider component\n",
" 1,\n",
" # do sample\n",
" True,\n",
" # int | float (numeric value between 1 and 2000) in 'Max New Tokens' Slider component\n",
" 128,\n",
" # int | float (numeric value between 1 and 300) in 'Min New Tokens' Slider component\n",
" 1,\n",
" # int | float (numeric value between 1.0 and 2.0) in 'Repetition Penalty' Slider component\n",
" 1.2,\n",
"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# ZeRO Inference"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"data = pd.read_json('.../BELLE/data/test_data/test_infer.jsonl', lines=True)\n",
"data = data['text'].tolist()\n",
"data"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"client = MultiClient(worker_addrs, synced_worker=True)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"template = \\\n",
"\"\"\"Human: \n",
"{text}\n",
"\n",
"Assistant: \n",
"\"\"\""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"GENERATION_CONFIG"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"tasks = []\n",
"for i in range(len(data)):\n",
" tasks.append([template.format(text=data[i])] + GENERATION_CONFIG)\n",
"answers = client.predict(tasks)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"answers"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 普通多进程并行推理"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"data = pd.read_json('.../BELLE/data/test_data/test_infer.jsonl', lines=True)\n",
"data = data['text'].tolist()\n",
"data"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"client = MultiClient(worker_addrs, synced_worker=False)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"template = \\\n",
"\"\"\"Human: \n",
"{text}\n",
"\n",
"Assistant: \n",
"\"\"\""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"GENERATION_CONFIG"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"tasks = []\n",
"for i in range(len(data)):\n",
" tasks.append([template.format(text=data[i])] + GENERATION_CONFIG)\n",
"answers = client.predict(tasks)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"answers"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.11"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
================================================
FILE: train/src/entry_point/inference.py
================================================
import torch
from tqdm import tqdm
from transformers import LlamaTokenizer, AutoTokenizer, AutoModelForCausalLM, AutoConfig
from peft import PeftModel
import argparse
import pandas as pd
parser = argparse.ArgumentParser()
parser.add_argument('--ckpt_path', type=str, required=True)
parser.add_argument('--lora_path', type=str, default=None)
parser.add_argument('--use_lora', action="store_true")
parser.add_argument('--llama', action="store_true")
parser.add_argument('--infer_file', type=str, required=True)
args = parser.parse_args()
max_new_tokens = 128
generation_config = dict(
temperature=0.9,
top_k=30,
top_p=0.6,
do_sample=True,
num_beams=1,
repetition_penalty=1.2,
max_new_tokens=max_new_tokens
)
infer_data = pd.read_json(args.infer_file, lines=True)
instruction_list = infer_data.apply(
lambda row: pd.Series(
{'instruction': f"Human: \n" + row['text'] + "\n\nAssistant: \n"}
), axis=1
)['instruction'].to_list()
if __name__ == '__main__':
load_type = torch.float16 #Sometimes may need torch.float32
if torch.cuda.is_available():
device = torch.device(0)
else:
device = torch.device('cpu')
if args.llama:
tokenizer = LlamaTokenizer.from_pretrained(args.ckpt_path)
else:
tokenizer = AutoTokenizer.from_pretrained(args.ckpt_path)
tokenizer.pad_token_id = 0
tokenizer.bos_token_id = 1
tokenizer.eos_token_id = 2
tokenizer.padding_side = "left"
model_config = AutoConfig.from_pretrained(args.ckpt_path)
if args.use_lora:
base_model = AutoModelForCausalLM.from_pretrained(args.ckpt_path, torch_dtype=load_type, device_map='auto')
model = PeftModel.from_pretrained(base_model, args.lora_path, torch_dtype=load_type)
else:
model = AutoModelForCausalLM.from_pretrained(args.ckpt_path, torch_dtype=load_type, config=model_config, device_map='auto')
if device==torch.device('cpu'):
model.float()
model.eval()
print("Load model successfully")
for instruction in tqdm(instruction_list):
inputs = tokenizer(
instruction,
add_special_tokens=False,
return_tensors="pt"
)
generation_output = model.generate(
input_ids = inputs["input_ids"].to(device),
**generation_config
)[0]
generate_text = tokenizer.decode(generation_output,skip_special_tokens=True)
print(generate_text)
print("-"*100)
================================================
FILE: train/src/entry_point/interface.py
================================================
import argparse
from functools import partial
import gradio as gr
import torch
from peft import PeftModel
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
GenerationConfig,
LlamaTokenizer,
)
from src.models.llama.modeling_llama import LlamaForCausalLM
parser = argparse.ArgumentParser()
parser.add_argument("--local_rank", type=int, default=0)
parser.add_argument("--ckpt_path", type=str, required=True)
parser.add_argument("--lora_path", type=str, default=None)
parser.add_argument("--use_lora", action="store_true")
parser.add_argument("--llama", action="store_true")
parser.add_argument("--base_port", default=17860, type=int)
parser.add_argument("--use_raw_prompt", action="store_true")
args = parser.parse_args()
def generate_prompt(input_text):
if not args.use_raw_prompt:
return f"Human: \n{input_text}\n\nAssistant: \n"
else:
return input_text
def evaluate(
model,
tokenizer,
input: str,
temperature=0.1,
top_p=0.75,
top_k=40,
num_beams=4,
do_sample=False,
max_new_tokens=128,
min_new_tokens=1,
repetition_penalty=1.2,
):
prompt = generate_prompt(input)
inputs = tokenizer(prompt, add_special_tokens=False, return_tensors="pt")
input_ids = inputs["input_ids"].to(getattr(model, "module", model).device)
generation_config = GenerationConfig(
temperature=temperature,
top_p=top_p,
top_k=top_k,
num_beams=num_beams,
bos_token_id=tokenizer.bos_token_id,
eos_token_id=tokenizer.eos_token_id,
pad_token_id=tokenizer.pad_token_id,
max_new_tokens=max_new_tokens, # max_length=max_new_tokens+input_sequence
min_new_tokens=min_new_tokens, # min_length=min_new_tokens+input_sequence
repetition_penalty=repetition_penalty,
do_sample=do_sample,
)
with torch.no_grad():
generation_output = model.generate(
input_ids=input_ids,
generation_config=generation_config,
return_dict_in_generate=True,
output_scores=False,
)
output = generation_output.sequences[0]
output = tokenizer.decode(
output,
skip_special_tokens=True
)[len(prompt):].strip()
return output
if __name__ == "__main__":
load_type = torch.float16 # Sometimes may need torch.float32
if args.llama:
tokenizer = LlamaTokenizer.from_pretrained(args.ckpt_path)
tokenizer.add_special_tokens(
{
"bos_token": "",
"eos_token": " ",
"unk_token": "",
"pad_token": "",
}
)
else:
tokenizer = AutoTokenizer.from_pretrained(args.ckpt_path)
tokenizer.add_special_tokens({"pad_token": tokenizer.unk_token})
print(f"Rank {args.local_rank} loading model...")
if args.llama:
model = LlamaForCausalLM.from_pretrained(args.ckpt_path, torch_dtype=load_type)
model.config.use_flash_attention = True
else:
model = AutoModelForCausalLM.from_pretrained(args.ckpt_path, torch_dtype=load_type)
model.config.pad_token_id = tokenizer.pad_token_id
model.config.eos_token_id = tokenizer.eos_token_id
# peft model
if args.use_lora:
model = PeftModel.from_pretrained(model, args.lora_path, torch_dtype=load_type)
if torch.cuda.is_available():
device = torch.device(f"cuda")
else:
device = torch.device("cpu")
if device == torch.device("cpu"):
model.float()
print(f"device: {device}")
model.to(device)
model.eval()
print("Load model successfully")
# https://gradio.app/docs/
gr.Interface(
fn=partial(evaluate, model, tokenizer),
inputs=[
gr.components.Textbox(
lines=2, label="Input", placeholder="Welcome to the BELLE model"
),
gr.components.Slider(minimum=0, maximum=1, value=0.1, label="Temperature"),
gr.components.Slider(minimum=0, maximum=1, value=0.75, label="Top p"),
gr.components.Slider(
minimum=0, maximum=100, step=1, value=40, label="Top k"
),
gr.components.Slider(
minimum=1, maximum=4, step=1, value=1, label="Beams Number"
),
gr.components.Checkbox(value=False, label="Do sample"),
gr.components.Slider(
minimum=1, maximum=2000, step=10, value=512, label="Max New Tokens"
),
gr.components.Slider(
minimum=1, maximum=300, step=10, value=1, label="Min New Tokens"
),
gr.components.Slider(
minimum=1.0,
maximum=2.0,
step=0.1,
value=1.2,
label="Repetition Penalty",
),
],
outputs=[
gr.components.Textbox(
lines=25,
label="Output",
)
],
title="BELLE: Be Everyone's Large Language model Engine",
).queue().launch(
share=True, server_name="0.0.0.0", server_port=args.base_port + args.local_rank
)
================================================
FILE: train/src/entry_point/ppo_train.py
================================================
# coding=utf-8
from dataclasses import dataclass, field
import os
from typing import Any, Dict, List, Optional, Union
import torch
from accelerate import Accelerator
from accelerate.utils import DummyOptim
from datasets import load_dataset
from peft import LoraConfig
from tqdm import tqdm
from transformers import (
Adafactor,
AutoTokenizer,
HfArgumentParser,
LlamaTokenizer,
PreTrainedTokenizerBase,
AutoModelForSequenceClassification,
)
from transformers.utils import PaddingStrategy
from trl import AutoModelForCausalLMWithValueHead, PPOConfig, set_seed
from trl.core import LengthSampler
from multiprocessing import cpu_count
from src.utils import prepare_deepspeed, zero_infer
from src.ppo_trainer import PPOTrainerForZero3 as PPOTrainer
accelerator = Accelerator()
tqdm.pandas()
import logging
logging.basicConfig(
format=f"[%(asctime)s] [%(levelname)s] [%(filename)s:%(lineno)d:%(funcName)s] [Rank {accelerator.process_index}] %(message)s"
)
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
def print_rank_0(msg, log_file):
if accelerator.is_main_process:
with open(log_file, "a") as f:
print(msg)
f.write(msg + "\n")
@dataclass
class ScriptArguments:
"""
The name of the Casual LM model we wish to fine with PPO
"""
# NOTE: gpt2 models use Conv1D instead of Linear layers which are not yet supported in 8 bit mode
# models like gpt-neo* models are more suitable.
model_name: Optional[str] = field(default="", metadata={"help": "the model name"})
reward_model_name: Optional[str] = field(
default="", metadata={"help": "the reward model name"}
)
log_with: Optional[str] = field(
default=None, metadata={"help": "use 'wandb' to log with wandb"}
)
learning_rate: Optional[float] = field(
default=1.41e-5, metadata={"help": "the learning rate"}
)
output_max_length: Optional[int] = field(
default=128, metadata={"help": "maximum length for generation"}
)
mini_batch_size: Optional[int] = field(
default=1, metadata={"help": "the PPO minibatch size"}
)
eval_batch_size: Optional[int] = field(
default=1,
metadata={
"help": "the batch size for reward model rating and actor generating"
},
)
batch_size: Optional[int] = field(default=32, metadata={"help": "the batch size"})
ppo_epochs: Optional[int] = field(
default=4, metadata={"help": "the number of ppo epochs"}
)
data_epochs: Optional[int] = field(
default=1, metadata={"help": "the number of data epochs"}
)
gradient_accumulation_steps: Optional[int] = field(
default=4, metadata={"help": "the number of gradient accumulation steps"}
)
adafactor: Optional[bool] = field(
default=False, metadata={"help": "whether to use the adafactor optimizer"}
)
early_stopping: Optional[bool] = field(
default=False, metadata={"help": "whether to early stop"}
)
target_kl: Optional[float] = field(
default=0.1, metadata={"help": "kl target for early stopping"}
)
reward_baseline: Optional[float] = field(
default=0.0,
metadata={"help": "a baseline value that is subtracted from the reward"},
)
save_freq: Optional[int] = field(
default=None, metadata={"help": "n steps to save the model"}
)
output_dir: Optional[str] = field(
default="runs/", metadata={"help": "n steps to save the model"}
)
seed: Optional[int] = field(default=0, metadata={"help": "the seed"})
steps: Optional[int] = field(default=20000, metadata={"help": "number of epochs"})
init_kl_coef: Optional[float] = field(
default=0.2,
metadata={
"help": "Initial KL penalty coefficient (used for adaptive and linear control)"
},
)
adap_kl_ctrl: Optional[bool] = field(
default=True, metadata={"help": "Use adaptive KL control, otherwise linear"}
)
do_sample: Optional[bool] = field(
default=True, metadata={"help": "Do sample when generating"}
)
logging_dir: Optional[str] = field(default="logs", metadata={"help": "Logging dir"})
use_llama: Optional[bool] = field(default=True, metadata={"help": "Use llama"})
reward_model_use_llama: Optional[bool] = field(
default=True, metadata={"help": "Reward model use llama"}
)
use_lora: Optional[bool] = field(default=False, metadata={"help": "Use lora"})
train_data: str = field(default="", metadata={"help": "Train file"})
cache_dir: Optional[str] = field(
default="hf_cache_dir", metadata={"help": "Dataset cache dir"}
)
input_length: Optional[int] = field(
default=512, metadata={"help": "Input token length"}
)
def build_dataset(tokenizer, dataset_name, input_length, cache_dir="hf_cache_dir"):
"""
Build dataset for training. This builds the dataset from `load_dataset`, one should
customize this function to train the model on its own dataset.
Args:
dataset_name (`str`):
The name of the dataset to be loaded.
Returns:
dataloader (`torch.utils.data.DataLoader`):
The dataloader for the dataset.
"""
train_dataset = load_dataset(
"json",
data_files=dataset_name,
cache_dir=cache_dir,
)["train"]
original_columns = train_dataset.column_names
num_proc = max(cpu_count() // 2, 1)
def preprocess_function(examples):
new_examples = {
"query": [],
"input_ids": [],
}
for text in examples["text"]:
tokens = tokenizer(text, add_special_tokens=False, truncation=True)[
"input_ids"
]
new_examples["query"].append(text)
new_examples["input_ids"].append(tokens)
return new_examples
ds = train_dataset.map(
preprocess_function,
batched=True,
num_proc=num_proc,
remove_columns=original_columns,
)
ds = ds.filter(lambda x: len(x["input_ids"]) <= input_length)
return ds
@dataclass
class DataCollatorWithPadding:
tokenizer: PreTrainedTokenizerBase
padding: Union[bool, str, PaddingStrategy] = True
max_length: Optional[int] = None
pad_to_multiple_of: Optional[int] = 8
return_tensors: str = "pt"
def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, Any]:
batch: Dict[str, Any] = {"query": [feature["query"] for feature in features]}
input_ids = [{"input_ids": feature["input_ids"]} for feature in features]
input_ids = self.tokenizer.pad(
input_ids,
padding=self.padding,
max_length=self.max_length,
pad_to_multiple_of=self.pad_to_multiple_of,
return_tensors=self.return_tensors,
)["input_ids"].unbind(0)
batch["input_ids"] = list(input_ids)
return batch
def main():
parser = HfArgumentParser(ScriptArguments)
script_args: ScriptArguments = parser.parse_args_into_dataclasses()[0]
log_file = os.path.join(script_args.output_dir, "print_log.txt")
if script_args.use_llama:
tokenizer = LlamaTokenizer.from_pretrained(script_args.model_name)
tokenizer.add_special_tokens(
{
"bos_token": "",
"eos_token": " ",
"unk_token": "",
"pad_token": "",
}
)
else:
tokenizer = AutoTokenizer.from_pretrained(script_args.model_name)
tokenizer.add_special_tokens({"pad_token": tokenizer.unk_token})
tokenizer.padding_side = "left"
print_rank_0(
f"unk token: {tokenizer.unk_token}, "
f"unk token id: {tokenizer.unk_token_id}, "
f"pad token: {tokenizer.pad_token}, "
f"pad token id: {tokenizer.pad_token_id}",
log_file,
)
with accelerator.main_process_first():
# We retrieve the dataloader by calling the `build_dataset` function.
dataset = build_dataset(
tokenizer,
dataset_name=script_args.train_data,
input_length=script_args.input_length,
cache_dir=script_args.cache_dir,
)
for i in range(2):
print_rank_0("Train tokenized example: {}".format(dataset[i]), log_file)
print_rank_0(f"Train dataset length: {len(dataset)}", log_file)
config = PPOConfig(
steps=len(dataset) // accelerator.num_processes,
model_name=script_args.model_name,
learning_rate=script_args.learning_rate,
log_with=script_args.log_with,
batch_size=script_args.batch_size,
mini_batch_size=script_args.mini_batch_size,
gradient_accumulation_steps=script_args.gradient_accumulation_steps,
optimize_cuda_cache=True,
early_stopping=script_args.early_stopping,
target_kl=script_args.target_kl,
ppo_epochs=script_args.ppo_epochs,
seed=script_args.seed,
init_kl_coef=script_args.init_kl_coef,
adap_kl_ctrl=script_args.adap_kl_ctrl,
project_kwargs={"logging_dir": script_args.logging_dir},
)
# set seed before initializing value head for deterministic eval
set_seed(config.seed)
# Now let's build the model, the reference model, and the tokenizer.
if script_args.use_lora:
lora_config = LoraConfig(
r=16,
lora_alpha=32,
lora_dropout=0.05,
bias="none",
task_type="CAUSAL_LM",
)
else:
lora_config = None
model = AutoModelForCausalLMWithValueHead.from_pretrained(
config.model_name,
peft_config=lora_config,
)
model.config.pad_token_id = tokenizer.pad_token_id
model.config.eos_token_id = tokenizer.eos_token_id
model.config.use_cache = True
ref_model = AutoModelForCausalLMWithValueHead.from_pretrained(
config.model_name,
peft_config=lora_config,
)
ref_model.config.pad_token_id = tokenizer.pad_token_id
ref_model.config.use_cache = False
optimizer = DummyOptim(
filter(lambda p: p.requires_grad, model.parameters()), lr=config.learning_rate
)
if script_args.adafactor:
optimizer = Adafactor(
filter(lambda p: p.requires_grad, model.parameters()),
scale_parameter=False,
relative_step=False,
warmup_init=False,
lr=config.learning_rate,
)
# We then build the PPOTrainer, passing the model, the reference model, the tokenizer
ppo_trainer = PPOTrainer(
config,
model,
ref_model=ref_model,
tokenizer=tokenizer,
dataset=dataset,
data_collator=DataCollatorWithPadding(
tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True
),
optimizer=optimizer,
)
ppo_trainer.current_device = accelerator.device
logger.debug("After ppo_trainer initialized")
# We then build the text classification pipeline using our reward model, passing the
# model name and the text classification pipeline arguments. Let's also make sure to
# set the device to the same device as the PPOTrainer.
if script_args.reward_model_use_llama:
rw_tokenizer = LlamaTokenizer.from_pretrained(script_args.reward_model_name)
rw_tokenizer.add_special_tokens(
{
"bos_token": "",
"eos_token": " ",
"unk_token": "",
"pad_token": "",
}
)
else:
rw_tokenizer = AutoTokenizer.from_pretrained(script_args.reward_model_name)
rw_tokenizer.add_special_tokens({"pad_token": tokenizer.unk_token})
# 使用deepspeed做reward model的inference
reward_model = AutoModelForSequenceClassification.from_pretrained(
script_args.reward_model_name, num_labels=1
)
reward_model.config.pad_token_id = rw_tokenizer.pad_token_id
reward_model = prepare_deepspeed(accelerator, reward_model)
# We then define the arguments to pass to the `generate` function. These arguments
# are passed to the `generate` function of the PPOTrainer, which is a wrapper around
# the `generate` function of the trained model.
generation_kwargs = {
# "min_length": -1,
"top_k": 0,
"top_p": 1.0,
"do_sample": script_args.do_sample,
"pad_token_id": tokenizer.pad_token_id,
"eos_token_id": tokenizer.eos_token_id,
}
output_min_length = 32
output_max_length = script_args.output_max_length
output_length_sampler = LengthSampler(output_min_length, output_max_length)
for data_epoch in tqdm(
range(script_args.data_epochs),
desc=f"rank: {accelerator.process_index}, data_epoch",
):
# batch: 因为dataloader用accelerate prepare，prepare调用prepare_data_loader，prepare_data_loader会为dataloader加入分布式采样，因此每个进程都是不一样的batch
for ppo_epoch, batch in tqdm(
enumerate(ppo_trainer.dataloader),
total=config.total_ppo_epochs,
desc=f"rank: {accelerator.process_index}, ppo_epoch",
):
# actor生成回复
question_tensors = batch["input_ids"]
logger.debug("Begin ppo_trainer.generate")
output_strs = []
response_tensors = []
for i in range(0, script_args.batch_size, script_args.eval_batch_size):
input_ids = batch["input_ids"][i : i + script_args.eval_batch_size]
output_ids = ppo_trainer.generate(
input_ids,
return_prompt=False,
length_sampler=output_length_sampler,
**generation_kwargs,
)
response_tensors.extend(output_ids)
output_strs.extend(
tokenizer.batch_decode(output_ids, skip_special_tokens=True)
)
batch["response"] = output_strs
logger.debug("After ppo_trainer.generate")
# 获得rewards
texts = [q + r for q, r in zip(batch["query"], batch["response"])]
outputs: List[Dict[str, Any]] = zero_infer(
accelerator,
reward_model,
rw_tokenizer,
texts,
script_args.eval_batch_size,
)
rewards = []
for output in outputs:
rewards.extend(output.logits.tolist())
rewards = [
torch.tensor(reward, device=accelerator.device)
- script_args.reward_baseline
for reward in rewards
]
# Run PPO step
logger.debug("Begin ppo_trainer.step")
stats = ppo_trainer.step(question_tensors, response_tensors, rewards)
logger.debug("After ppo_trainer.step")
ppo_trainer.log_stats(stats, batch, rewards)
accelerator.wait_for_everyone()
# 保存
total_ppo_epoch = data_epoch * config.total_ppo_epochs + ppo_epoch
if (
script_args.save_freq
and (total_ppo_epoch + 1) % script_args.save_freq == 0
):
ppo_trainer.save_pretrained(
f"{script_args.output_dir}/step_{total_ppo_epoch}"
)
ppo_trainer.save_pretrained(script_args.output_dir)
accelerator.wait_for_everyone()
if __name__ == "__main__":
main()
================================================
FILE: train/src/entry_point/pt_train.py
================================================
from transformers.utils import add_start_docstrings
from transformers.trainer_utils import get_last_checkpoint
from transformers.trainer_pt_utils import torch_distributed_zero_first
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
HfArgumentParser,
LlamaTokenizer,
TrainingArguments,
set_seed,
)
from peft import LoraConfig, get_peft_model, prepare_model_for_int8_training
from datasets import load_dataset
import transformers
import torch
from packaging import version
from typing import Optional
from functools import partial
from dataclasses import dataclass, field
import os
import math
import logging
import json
import sys
from src.utils import get_model_param_count
from src.sample_generator import batch_grouped_pretrain_generate
from src.models.llama.modeling_llama import LlamaForCausalLM
if version.parse(transformers.__version__) <= version.parse("4.30.2"):
from src.trainer import MyTrainer as Trainer
else:
from transformers import Trainer
logger = logging.getLogger(__name__)
@dataclass
class ModelArguments:
"""
Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.
"""
model_name_or_path: Optional[str] = field(
default=None,
metadata={
"help": (
"The model checkpoint for weights initialization.Don't set if you want to train a model from scratch."
)
},
)
cache_dir: Optional[str] = field(
default=None,
metadata={
"help": "Where do you want to store the pretrained models downloaded from huggingface.co"
},
)
torch_dtype: Optional[str] = field(
default=None,
metadata={
"help": (
"Override the default `torch.dtype` and load the model under this dtype. If `auto` is passed, the "
"dtype will be automatically derived from the model's weights."
),
"choices": ["auto", "bfloat16", "float16", "float32"],
},
)
llama: bool = field(default=False, metadata={"help": "Llama model"})
@dataclass
class DataArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
"""
train_file: Optional[str] = field(
default=None, metadata={"help": "The input training data file (a text file)."}
)
validation_file: Optional[str] = field(
default=None,
metadata={
"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."
},
)
@dataclass
@add_start_docstrings(TrainingArguments.__doc__)
class TrainingArguments(TrainingArguments):
model_max_length: int = field(
default=512,
metadata={"help": "Maximum sequence length."},
)
use_lora: bool = field(default=False, metadata={"help": "Whether to use LoRA."})
use_int8_training: bool = field(
default=False, metadata={"help": "Whether to use int8 training."}
)
lora_config: Optional[str] = field(
default=None,
metadata={"help": "LoRA config file."},
)
ddp_find_unused_parameters: bool = field(
default=False, metadata={"help": "ddp_find_unused_parameters"}
)
gradient_checkpointing: bool = field(
default=False, metadata={"help": "gradient_checkpointing"}
)
# https://discuss.huggingface.co/t/wandb-does-not-display-train-eval-loss-except-for-last-one/9170
evaluation_strategy: str = field(
default="steps", metadata={"help": "The evaluation strategy to use."}
)
save_total_limit: Optional[int] = field(
default=3,
metadata={
"help": (
"If a value is passed, will limit the total amount of checkpoints. Deletes the older checkpoints in"
" `output_dir`. When `load_best_model_at_end` is enabled, the 'best' checkpoint according to"
" `metric_for_best_model` will always be retained in addition to the most recent ones. For example,"
" for `save_total_limit=5` and `load_best_model_at_end=True`, the four last checkpoints will always be"
" retained alongside the best model. When `save_total_limit=1` and `load_best_model_at_end=True`,"
" it is possible that two checkpoints are saved: the last one and the best one (if they are different)."
" Default is unlimited checkpoints"
)
},
)
report_to: str = field(
default="wandb",
metadata={
"help": "The list of integrations to report the results and logs to."
},
)
deepspeed: str = field(
default=None,
metadata={
"help": (
"Enable deepspeed and pass the path to deepspeed json config file (e.g. `ds_config.json`) or an already"
" loaded json file as a dict"
)
},
)
do_train: bool = field(default=True, metadata={"help": "Whether to run training."})
def print_rank_0(msg, log_file, rank=0):
if rank <= 0:
with open(log_file, "a") as f:
print(msg)
f.write(msg + "\n")
def main():
parser = HfArgumentParser((ModelArguments, DataArguments, TrainingArguments))
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
world_size = int(os.environ.get("WORLD_SIZE", 1))
global_rank = torch.distributed.get_rank()
log_file = os.path.join(training_args.output_dir, "print_log.txt")
# Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
handlers=[logging.StreamHandler(sys.stdout)],
)
if training_args.should_log:
# The default of training_args.log_level is passive, so we set log level at info here to have that default.
transformers.utils.logging.set_verbosity_info()
log_level = training_args.get_process_log_level()
logger.setLevel(log_level)
transformers.utils.logging.set_verbosity(log_level)
transformers.utils.logging.enable_default_handler()
transformers.utils.logging.enable_explicit_format()
# Log on each process the small summary:
logger.warning(
f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}, distributed training: {bool(training_args.local_rank != -1)}, fp16-bits training: {training_args.fp16}, bf16-bits training: {training_args.bf16}"
)
logger.info(f"Training/evaluation parameters {training_args}")
# Detecting last checkpoint.
last_checkpoint = None
if (
os.path.isdir(training_args.output_dir)
and training_args.do_train
and not training_args.overwrite_output_dir
):
last_checkpoint = get_last_checkpoint(training_args.output_dir)
if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
raise ValueError(
f"Output directory ({training_args.output_dir}) already exists and is not empty. "
"Use --overwrite_output_dir to overcome."
)
elif (
last_checkpoint is not None and training_args.resume_from_checkpoint is None
):
logger.info(
f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
"the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
)
# Set seed before initializing model.
set_seed(training_args.seed)
training_args._frozen = False
training_args.data_seed = training_args.seed
torch_dtype = (
model_args.torch_dtype
if model_args.torch_dtype in ["auto", None]
else getattr(torch, model_args.torch_dtype)
)
# int8 is not compatible with DeepSpeed (require not to pass device_map)
if training_args.use_int8_training:
print_rank_0("int8 is not compatible with DeepSpeed. ", log_file, global_rank)
device_map = (
{"": int(os.environ.get("LOCAL_RANK") or 0)} if world_size != 1 else "auto"
)
# device_map = "auto"
model = AutoModelForCausalLM.from_pretrained(
model_args.model_name_or_path,
load_in_8bit=True, # xxx: int8 load in
device_map=device_map, # xxx: int8 requires passing device_map
torch_dtype=torch_dtype,
)
else:
if model_args.llama:
model = LlamaForCausalLM.from_pretrained(
model_args.model_name_or_path,
torch_dtype=torch_dtype,
)
else:
model = AutoModelForCausalLM.from_pretrained(
model_args.model_name_or_path,
torch_dtype=torch_dtype,
)
if model_args.llama:
tokenizer = LlamaTokenizer.from_pretrained(model_args.model_name_or_path)
print_rank_0(
"Set the eos_token_id and bos_token_id of LLama model tokenizer",
log_file,
global_rank,
)
tokenizer.add_special_tokens({'bos_token': '', 'eos_token': ' ', 'unk_token': '', 'pad_token': ''})
else:
tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path)
tokenizer.add_special_tokens({"pad_token": tokenizer.unk_token})
tokenizer.padding_side = "left" # Allow batched inference
print_rank_0(
"tokenizer.eos_token_id = {}".format(tokenizer.eos_token_id),
log_file,
global_rank,
)
print_rank_0(
"tokenizer.pad_token_id = {}".format(tokenizer.pad_token_id),
log_file,
global_rank,
)
print_rank_0(
"tokenizer.bos_token_id = {}".format(tokenizer.bos_token_id),
log_file,
global_rank,
)
# peft model
if training_args.use_lora:
print_rank_0(
"Loading lora config from {}".format(training_args.lora_config),
log_file,
global_rank,
)
lora_config = json.load(open(training_args.lora_config))
print_rank_0("Lora config: {}".format(lora_config), log_file, global_rank)
if training_args.use_int8_training:
print_rank_0(
"training_args.use_int8_training!!! (int8 is not compatible with DeepSpeed)",
log_file,
global_rank,
)
model = prepare_model_for_int8_training(model)
config = LoraConfig(
r=lora_config["lora_r"],
lora_alpha=lora_config["lora_alpha"],
target_modules=lora_config["lora_target_modules"],
lora_dropout=lora_config["lora_dropout"],
bias="none",
task_type="CAUSAL_LM",
)
# "RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn"
if hasattr(model, "enable_input_require_grads"):
model.enable_input_require_grads()
else:
def make_inputs_require_grad(module, input, output):
output.requires_grad_(True)
model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
model = get_peft_model(model, config)
model.print_trainable_parameters()
if training_args.gradient_checkpointing:
model.gradient_checkpointing_enable()
# model.is_parallelizable = True
# model.model_parallel = True
assert os.path.exists(data_args.train_file), "{} file not exists".format(
data_args.train_file
)
with torch_distributed_zero_first(global_rank):
train_data = load_dataset(
"json", data_files=data_args.train_file, cache_dir=model_args.cache_dir
)
val_data = load_dataset(
"json", data_files=data_args.validation_file, cache_dir=model_args.cache_dir
)
train_data = (
train_data["train"]
.shuffle()
.map(
partial(
batch_grouped_pretrain_generate,
training_args.model_max_length,
tokenizer,
),
batched=True,
desc=f"Grouping texts in chunks of {training_args.model_max_length}",
remove_columns="text",
)
)
val_data = (
val_data["train"]
.map(
partial(
batch_grouped_pretrain_generate,
training_args.model_max_length,
tokenizer,
),
batched=True,
desc=f"Grouping texts in chunks of {training_args.model_max_length}",
remove_columns="text",
)
)
for i in range(2):
print_rank_0(
"Eval tokenized example: {}".format(val_data[i]), log_file, global_rank
)
for i in range(2):
print_rank_0(
"Train tokenized example: {}".format(train_data[i]), log_file, global_rank
)
training_nums = len(train_data)
num_gpus = torch.cuda.device_count()
batch_size = (
training_args.per_device_train_batch_size
* training_args.world_size
* training_args.gradient_accumulation_steps
)
# train steps
t_total = math.ceil(training_nums / batch_size) * training_args.num_train_epochs
# eval steps
training_args.eval_steps = max(t_total // (training_args.num_train_epochs * 4), 5)
# save steps
training_args.save_steps = training_args.eval_steps
training_args.warmup_steps = (
int(t_total * training_args.warmup_ratio)
if training_args.warmup_ratio > 0.0
else training_args.warmup_steps
)
print_rank_0(
"num_gpus = {}, training_nums = {}, t_total = {}, warmup_steps = {}, eval_steps = {}, save_steps = {}".format(
num_gpus,
training_nums,
t_total,
training_args.warmup_steps,
training_args.eval_steps,
training_args.save_steps,
),
log_file,
global_rank,
)
print_rank_0(
"val data nums = {}, training_nums = {}, batch_size = {}".format(
len(val_data), training_nums, batch_size
),
log_file,
global_rank,
)
# Trainer
# https://github.com/huggingface/transformers/blob/main/src/transformers/training_args.py
# https://github.com/huggingface/transformers/blob/main/src/transformers/data/data_collator.py
# https://github.com/huggingface/transformers/blob/main/src/transformers/trainer.py
# https://www.deepspeed.ai/docs/config-json/
# https://huggingface.co/docs/accelerate/usage_guides/deepspeed
# https://huggingface.co/transformers/v4.10.1/main_classes/deepspeed.html
# https://github.com/tatsu-lab/stanford_alpaca/issues/176
trainer = Trainer(
model=model,
tokenizer=tokenizer,
args=training_args,
train_dataset=train_data,
eval_dataset=val_data,
data_collator=transformers.DataCollatorForSeq2Seq(
tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True
),
)
print_rank_0(
f"Using {training_args.half_precision_backend} half precision backend",
log_file,
global_rank,
)
# Train!
len_dataloader = len(trainer.get_train_dataloader())
num_update_steps_per_epoch = (
len_dataloader // training_args.gradient_accumulation_steps
)
total_train_batch_size = (
training_args.train_batch_size
* training_args.gradient_accumulation_steps
* training_args.world_size
)
num_examples = trainer.num_examples(trainer.get_train_dataloader())
num_train_samples = num_examples * training_args.num_train_epochs
max_steps = math.ceil(training_args.num_train_epochs * num_update_steps_per_epoch)
print_rank_0("***** Running training *****", log_file, global_rank)
print_rank_0(f" Num examples = {num_examples}", log_file, global_rank)
print_rank_0(f" Num train samples = {num_train_samples}", log_file, global_rank)
print_rank_0(f" world_size = {world_size}", log_file, global_rank)
print_rank_0(
f" Total train batch size (w. parallel, distributed & accumulation) = {total_train_batch_size}",
log_file,
global_rank,
)
print_rank_0(
f" Gradient Accumulation steps = {training_args.gradient_accumulation_steps}",
log_file,
global_rank,
)
print_rank_0(f" Total optimization steps = {max_steps}", log_file, global_rank)
print_rank_0(
f" Number of trainable parameters = {get_model_param_count(model, trainable_only=True)}",
log_file,
global_rank,
)
# https://discuss.huggingface.co/t/what-is-the-purpose-of-use-cache-in-decoder/958/3
model.config.use_cache = False
checkpoint = None
if training_args.resume_from_checkpoint is not None:
checkpoint = training_args.resume_from_checkpoint
elif last_checkpoint is not None:
checkpoint = last_checkpoint
trainer.train(resume_from_checkpoint=checkpoint)
trainer.save_model(training_args.output_dir)
print_rank_0(
"\n Training completed!!! If there's a warning about missing keys above, please disregard :)",
log_file,
global_rank,
)
if __name__ == "__main__":
main()
================================================
FILE: train/src/entry_point/rm_train.py
================================================
# coding=utf-8
from dataclasses import dataclass, field
from functools import partial
import math
import os
import sys
from typing import Any, Dict, List, Optional, Union
from accelerate import Accelerator
from datasets import load_dataset
from peft import LoraConfig, get_peft_model
from tqdm import tqdm
from transformers import (
AutoModelForSequenceClassification,
AutoTokenizer,
BitsAndBytesConfig,
HfArgumentParser,
PreTrainedTokenizerBase,
LlamaTokenizer,
)
from transformers.utils import PaddingStrategy
from transformers.trainer_utils import get_last_checkpoint
from trl import RewardConfig, RewardTrainer
from trl.trainer.utils import RewardDataCollatorWithPadding
import logging
from multiprocessing import cpu_count
tqdm.pandas()
accelerator = Accelerator()
# Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
handlers=[logging.StreamHandler(sys.stdout)],
)
logger = logging.getLogger(__name__)
def print_rank_0(msg, log_file):
if accelerator.is_main_process:
with open(log_file, "a") as f:
print(msg)
f.write(msg + "\n")
@dataclass
class ScriptArguments:
"""
Hyperparameters to fine-tune a reward model on a given dataset with the `RewardTrainer`.
"""
# Training arguments
report_to: Optional[str] = field(
default=None, metadata={"help": "use 'wandb' to log with wandb"}
)
logging_steps: Optional[int] = field(
default=500, metadata={"help": "the number of update steps between two logs"}
)
learning_rate: Optional[float] = field(
default=1.41e-5, metadata={"help": "the learning rate"}
)
per_device_train_batch_size: Optional[int] = field(
default=1, metadata={"help": "the batch size"}
)
per_device_eval_batch_size: Optional[int] = field(
default=1, metadata={"help": "evaluating batch size"}
)
num_train_epochs: Optional[int] = field(
default=1, metadata={"help": "the number of training epochs"}
)
gradient_accumulation_steps: Optional[int] = field(
default=16, metadata={"help": "the number of gradient accumulation steps"}
)
gradient_checkpointing: Optional[bool] = field(
default=True, metadata={"help": "Enable gradient checkpointing"}
)
output_dir: Optional[str] = field(
default="output", metadata={"help": "the output directory"}
)
fp16: Optional[bool] = field(default=False, metadata={"help": "float16"})
bf16: Optional[bool] = field(default=True, metadata={"help": "bfloat16"})
lr_scheduler_type: Optional[str] = field(
default="linear",
metadata={"help": "The lr scheduler"},
)
weight_decay: float = field(
default=0.001, metadata={"help": "Weight decay for AdamW if we apply some."}
)
warmup_steps: int = field(
default=1000, metadata={"help": "Linear warmup over warmup_steps."}
)
overwrite_output_dir: bool = field(
default=False,
metadata={
"help": (
"Overwrite the content of the output directory. "
"Use this to continue training if output_dir points to a checkpoint directory."
)
},
)
resume_from_checkpoint: Optional[str] = field(
default=None,
metadata={
"help": "The path to a folder with a valid checkpoint for your model."
},
)
seed: int = field(
default=42,
metadata={"help": "Random seed that will be set at the beginning of training."},
)
dataloader_drop_last: Optional[bool] = field(
default=True,
metadata={
"help": "Drop the last incomplete batch if it is not divisible by the batch size."
},
)
save_total_limit: Optional[int] = field(
default=3,
metadata={
"help": (
"If a value is passed, will limit the total amount of checkpoints. Deletes the older checkpoints in"
" `output_dir`. When `load_best_model_at_end` is enabled, the 'best' checkpoint according to"
" `metric_for_best_model` will always be retained in addition to the most recent ones. For example,"
" for `save_total_limit=5` and `load_best_model_at_end=True`, the four last checkpoints will always be"
" retained alongside the best model. When `save_total_limit=1` and `load_best_model_at_end=True`,"
" it is possible that two checkpoints are saved: the last one and the best one (if they are different)."
" Default is unlimited checkpoints"
)
},
)
# Other arguments
model_name: Optional[str] = field(
default="facebook/opt-350m", metadata={"help": "the model name"}
)
train_data: str = field(default="", metadata={"help": "train data path"})
eval_data: str = field(default="", metadata={"help": "eval data path"})
cache_dir: str = field(default="", metadata={"help": "cache dir"})
use_llama: Optional[bool] = field(default=True, metadata={"help": "bfloat16"})
load_in_8bit: Optional[bool] = field(
default=False, metadata={"help": "load the model in 8 bits precision"}
)
load_in_4bit: Optional[bool] = field(
default=False, metadata={"help": "load the model in 4 bits precision"}
)
use_lora: Optional[bool] = field(
default=False, metadata={"help": "Wether to use LoRA or not to train adapters"}
)
trust_remote_code: Optional[bool] = field(
default=True, metadata={"help": "Enable `trust_remote_code`"}
)
seq_length: Optional[int] = field(
default=512, metadata={"help": "Input sequence length"}
)
# Tokenize chosen/rejected pairs of inputs
# Adapt this section to your needs for custom datasets
def preprocess_function(tokenizer: PreTrainedTokenizerBase, examples: Dict[str, Any]):
new_examples = {
"input_ids_chosen": [],
"attention_mask_chosen": [],
"input_ids_rejected": [],
"attention_mask_rejected": [],
}
for chosen, rejected in zip(examples["chosen"], examples["rejected"]):
tokenized_chosen = tokenizer(chosen, add_special_tokens=False)
tokenized_rejected = tokenizer(rejected, add_special_tokens=False)
new_examples["input_ids_chosen"].append(tokenized_chosen["input_ids"])
new_examples["attention_mask_chosen"].append(tokenized_chosen["attention_mask"])
new_examples["input_ids_rejected"].append(tokenized_rejected["input_ids"])
new_examples["attention_mask_rejected"].append(
tokenized_rejected["attention_mask"]
)
return new_examples
def main():
parser = HfArgumentParser(ScriptArguments)
script_args = parser.parse_args_into_dataclasses()[0]
log_file = os.path.join(script_args.output_dir, "print_log.txt")
local_rank = accelerator.local_process_index
# Load the dataset and pre-process it
if script_args.use_llama:
tokenizer = LlamaTokenizer.from_pretrained(script_args.model_name)
tokenizer.add_special_tokens(
{
"bos_token": "",
"eos_token": " ",
"unk_token": "",
"pad_token": "",
}
)
else:
tokenizer = AutoTokenizer.from_pretrained(script_args.model_name)
tokenizer.add_special_tokens({"pad_token": tokenizer.unk_token})
tokenizer.padding_side = "left"
print_rank_0(
f"unk token: {tokenizer.unk_token}, "
f"unk token id: {tokenizer.unk_token_id}, "
f"pad token: {tokenizer.pad_token}, "
f"pad token id: {tokenizer.pad_token_id}",
log_file,
)
with accelerator.main_process_first():
train_dataset = load_dataset(
"json", data_files=script_args.train_data, cache_dir=script_args.cache_dir
)["train"]
eval_dataset = load_dataset(
"json", data_files=script_args.eval_data, cache_dir=script_args.cache_dir
)["train"]
# Preprocess the dataset and filter out examples that are longer than script_args.max_length
train_dataset = train_dataset.map(
partial(preprocess_function, tokenizer),
batched=True,
num_proc=max(cpu_count() // 2, 1),
remove_columns=["chosen", "rejected"],
)
train_dataset = train_dataset.filter(
lambda x: len(x["input_ids_chosen"]) <= script_args.seq_length
and len(x["input_ids_rejected"]) <= script_args.seq_length
)
eval_dataset = eval_dataset.map(
partial(preprocess_function, tokenizer),
batched=True,
num_proc=max(cpu_count() // 2, 1),
remove_columns=["chosen", "rejected"],
)
eval_dataset = eval_dataset.filter(
lambda x: len(x["input_ids_chosen"]) <= script_args.seq_length
and len(x["input_ids_rejected"]) <= script_args.seq_length
)
for i in range(2):
print_rank_0("Eval tokenized example: {}".format(train_dataset[i]), log_file)
for i in range(2):
print_rank_0("Train tokenized example: {}".format(eval_dataset[i]), log_file)
# Define the training arguments
training_nums = len(train_dataset)
global_batch_size = (
accelerator.num_processes
* script_args.gradient_accumulation_steps
* script_args.per_device_train_batch_size
)
if script_args.dataloader_drop_last:
num_steps = (
math.floor(training_nums / global_batch_size) * script_args.num_train_epochs
)
else:
num_steps = (
math.ceil(training_nums / global_batch_size) * script_args.num_train_epochs
)
eval_steps = max(num_steps // (script_args.num_train_epochs * 4), 5)
print_rank_0(
"num_gpus = {}, training_nums = {}, num_steps = {}, warmup_steps = {}, eval_steps = {}, save_steps = {}".format(
accelerator.num_processes,
training_nums,
num_steps,
script_args.warmup_steps,
eval_steps,
eval_steps,
),
log_file,
)
# `TrainingArguments` must be instantiated before loading model!!!
training_args = RewardConfig(
output_dir=script_args.output_dir,
per_device_train_batch_size=script_args.per_device_train_batch_size,
per_device_eval_batch_size=script_args.per_device_eval_batch_size,
num_train_epochs=script_args.num_train_epochs,
gradient_accumulation_steps=script_args.gradient_accumulation_steps,
gradient_checkpointing=script_args.gradient_checkpointing,
learning_rate=script_args.learning_rate,
report_to="wandb" if script_args.report_to == "wandb" else "tensorboard",
remove_unused_columns=False,
optim="adamw_torch",
logging_steps=script_args.logging_steps,
evaluation_strategy="steps",
save_strategy="steps",
max_length=script_args.seq_length,
bf16=script_args.bf16,
fp16=script_args.fp16,
weight_decay=script_args.weight_decay,
lr_scheduler_type=script_args.lr_scheduler_type,
eval_steps=eval_steps,
save_steps=eval_steps,
warmup_steps=script_args.warmup_steps,
overwrite_output_dir=script_args.overwrite_output_dir,
resume_from_checkpoint=script_args.resume_from_checkpoint,
save_total_limit=script_args.save_total_limit,
load_best_model_at_end=True,
ddp_timeout=3600,
seed=script_args.seed,
dataloader_drop_last=script_args.dataloader_drop_last,
)
print_rank_0(
"world_size = {}".format(training_args.world_size),
log_file,
)
# Load the model
if script_args.load_in_8bit and script_args.load_in_4bit:
raise ValueError(
"You can't load the model in 8 bits and 4 bits at the same time"
)
elif script_args.load_in_8bit or script_args.load_in_4bit:
quantization_config = BitsAndBytesConfig(
load_in_8bit=script_args.load_in_8bit, load_in_4bit=script_args.load_in_4bit
)
# Copy the model to each device
device_map = {"": local_rank}
else:
device_map = None
quantization_config = None
# Model must be loaded after create `TrainingArguments`!!!
model = AutoModelForSequenceClassification.from_pretrained(
script_args.model_name,
quantization_config=quantization_config,
device_map=device_map,
trust_remote_code=script_args.trust_remote_code,
num_labels=1,
)
model.config.pad_token_id = tokenizer.pad_token_id
# Define the LoraConfig
if script_args.use_lora:
peft_config = LoraConfig(
r=16,
lora_alpha=16,
bias="none",
task_type="SEQ_CLS",
modules_to_save=["scores"],
)
model = get_peft_model(model, peft_config)
model.print_trainable_parameters()
# Define the Trainer
model.config.use_cache = False
trainer = RewardTrainer(
model=model,
tokenizer=tokenizer,
args=training_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
data_collator=RewardDataCollatorWithPadding(
tokenizer=tokenizer, pad_to_multiple_of=8
),
)
# Detecting last checkpoint.
last_checkpoint = None
if (
os.path.isdir(training_args.output_dir)
and training_args.do_train
and not training_args.overwrite_output_dir
):
last_checkpoint = get_last_checkpoint(training_args.output_dir)
if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
raise ValueError(
f"Output directory ({training_args.output_dir}) already exists and is not empty. "
"Use --overwrite_output_dir to overcome."
)
elif (
last_checkpoint is not None and training_args.resume_from_checkpoint is None
):
logger.info(
f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
"the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
)
checkpoint = None
if training_args.resume_from_checkpoint is not None:
checkpoint = training_args.resume_from_checkpoint
elif last_checkpoint is not None:
checkpoint = last_checkpoint
trainer.train(resume_from_checkpoint=checkpoint)
trainer.save_model(training_args.output_dir)
accelerator.wait_for_everyone()
print_rank_0(
"\n Training completed!!! If there's a warning about missing keys above, please disregard :)",
log_file,
)
if __name__ == "__main__":
main()
================================================
FILE: train/src/entry_point/sft_train.py
================================================
from transformers.utils import add_start_docstrings
from transformers.trainer_utils import get_last_checkpoint
from transformers.trainer_pt_utils import torch_distributed_zero_first
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
HfArgumentParser,
LlamaTokenizer,
TrainingArguments,
set_seed,
)
from peft import LoraConfig, get_peft_model, prepare_model_for_int8_training
from datasets import load_dataset
import transformers
import torch
from packaging import version
from typing import Optional
from functools import partial
from dataclasses import dataclass, field
import os
import math
import logging
import json
import sys
from src.utils import get_model_param_count
from src.sample_generator import (
batch_grouped_sft_generate,
generate_and_tokenize_prompt,
)
from src.models.llama.modeling_llama import LlamaForCausalLM
if version.parse(transformers.__version__) <= version.parse("4.30.2"):
from src.trainer import MyTrainer as Trainer
else:
from transformers import Trainer
logger = logging.getLogger(__name__)
@dataclass
class ModelArguments:
"""
Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.
"""
model_name_or_path: Optional[str] = field(
default=None,
metadata={
"help": (
"The model checkpoint for weights initialization.Don't set if you want to train a model from scratch."
)
},
)
cache_dir: Optional[str] = field(
default=None,
metadata={
"help": "Where do you want to store the pretrained models downloaded from huggingface.co"
},
)
torch_dtype: Optional[str] = field(
default=None,
metadata={
"help": (
"Override the default `torch.dtype` and load the model under this dtype. If `auto` is passed, the "
"dtype will be automatically derived from the model's weights."
),
"choices": ["auto", "bfloat16", "float16", "float32"],
},
)
use_flash_attention: bool = field(
default=False, metadata={"help": ("Whether to use memory efficient attention.")}
)
llama: bool = field(default=False, metadata={"help": "Llama model"})
@dataclass
class DataArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
"""
train_file: Optional[str] = field(
default=None, metadata={"help": "The input training data file (a text file)."}
)
validation_file: Optional[str] = field(
default=None,
metadata={
"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."
},
)
@dataclass
@add_start_docstrings(TrainingArguments.__doc__)
class TrainingArguments(TrainingArguments):
model_max_length: int = field(
default=512,
metadata={"help": "Maximum sequence length."},
)
use_lora: bool = field(default=False, metadata={"help": "Whether to use LoRA."})
use_int8_training: bool = field(
default=False, metadata={"help": "Whether to use int8 training."}
)
lora_config: Optional[str] = field(
default=None,
metadata={"help": "LoRA config file."},
)
ddp_find_unused_parameters: bool = field(
default=False, metadata={"help": "ddp_find_unused_parameters"}
)
gradient_checkpointing: bool = field(
default=False, metadata={"help": "gradient_checkpointing"}
)
# https://discuss.huggingface.co/t/wandb-does-not-display-train-eval-loss-except-for-last-one/9170
evaluation_strategy: str = field(
default="steps", metadata={"help": "The evaluation strategy to use."}
)
save_total_limit: Optional[int] = field(
default=3,
metadata={
"help": (
"If a value is passed, will limit the total amount of checkpoints. Deletes the older checkpoints in"
" `output_dir`. When `load_best_model_at_end` is enabled, the 'best' checkpoint according to"
" `metric_for_best_model` will always be retained in addition to the most recent ones. For example,"
" for `save_total_limit=5` and `load_best_model_at_end=True`, the four last checkpoints will always be"
" retained alongside the best model. When `save_total_limit=1` and `load_best_model_at_end=True`,"
" it is possible that two checkpoints are saved: the last one and the best one (if they are different)."
" Default is unlimited checkpoints"
)
},
)
report_to: str = field(
default="wandb",
metadata={
"help": "The list of integrations to report the results and logs to."
},
)
deepspeed: str = field(
default=None,
metadata={
"help": (
"Enable deepspeed and pass the path to deepspeed json config file (e.g. `ds_config.json`) or an already"
" loaded json file as a dict"
)
},
)
do_train: bool = field(default=True, metadata={"help": "Whether to run training."})
def print_rank_0(msg, log_file, rank=0):
if rank <= 0:
with open(log_file, "a") as f:
print(msg)
f.write(msg + "\n")
def main():
parser = HfArgumentParser((ModelArguments, DataArguments, TrainingArguments))
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
world_size = int(os.environ.get("WORLD_SIZE", 1))
global_rank = torch.distributed.get_rank()
log_file = os.path.join(training_args.output_dir, "print_log.txt")
# Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
handlers=[logging.StreamHandler(sys.stdout)],
)
if training_args.should_log:
# The default of training_args.log_level is passive, so we set log level at info here to have that default.
transformers.utils.logging.set_verbosity_info()
log_level = training_args.get_process_log_level()
logger.setLevel(log_level)
transformers.utils.logging.set_verbosity(log_level)
transformers.utils.logging.enable_default_handler()
transformers.utils.logging.enable_explicit_format()
# Log on each process the small summary:
logger.warning(
f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}, distributed training: {bool(training_args.local_rank != -1)}, fp16-bits training: {training_args.fp16}, bf16-bits training: {training_args.bf16}"
)
logger.info(f"Training/evaluation parameters {training_args}")
# Detecting last checkpoint.
last_checkpoint = None
if (
os.path.isdir(training_args.output_dir)
and training_args.do_train
and not training_args.overwrite_output_dir
):
last_checkpoint = get_last_checkpoint(training_args.output_dir)
if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
raise ValueError(
f"Output directory ({training_args.output_dir}) already exists and is not empty. "
"Use --overwrite_output_dir to overcome."
)
elif (
last_checkpoint is not None and training_args.resume_from_checkpoint is None
):
logger.info(
f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
"the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
)
# Set seed before initializing model.
set_seed(training_args.seed)
training_args._frozen = False
training_args.data_seed = training_args.seed
torch_dtype = (
model_args.torch_dtype
if model_args.torch_dtype in ["auto", None]
else getattr(torch, model_args.torch_dtype)
)
# int8 is not compatible with DeepSpeed (require not to pass device_map)
if training_args.use_int8_training:
print_rank_0("int8 is not compatible with DeepSpeed. ", log_file, global_rank)
device_map = (
{"": int(os.environ.get("LOCAL_RANK") or 0)} if world_size != 1 else "auto"
)
# device_map = "auto"
model = AutoModelForCausalLM.from_pretrained(
model_args.model_name_or_path,
load_in_8bit=True, # xxx: int8 load in
device_map=device_map, # xxx: int8 requires passing device_map
torch_dtype=torch_dtype,
)
else:
if model_args.llama:
model = LlamaForCausalLM.from_pretrained(
model_args.model_name_or_path,
torch_dtype=torch_dtype,
)
model.config.use_flash_attention = model_args.use_flash_attention
else:
model = AutoModelForCausalLM.from_pretrained(
model_args.model_name_or_path,
torch_dtype=torch_dtype,
)
if model_args.llama:
tokenizer = LlamaTokenizer.from_pretrained(model_args.model_name_or_path)
print_rank_0(
"Set the eos_token_id and bos_token_id of LLama model tokenizer",
log_file,
global_rank,
)
tokenizer.add_special_tokens({'bos_token': '', 'eos_token': ' ', 'unk_token': '', 'pad_token': ''})
else:
tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path)
tokenizer.add_special_tokens({"pad_token": tokenizer.unk_token})
tokenizer.padding_side = "left" # Allow batched inference
print_rank_0(
"tokenizer.eos_token_id = {}".format(tokenizer.eos_token_id),
log_file,
global_rank,
)
print_rank_0(
"tokenizer.pad_token_id = {}".format(tokenizer.pad_token_id),
log_file,
global_rank,
)
print_rank_0(
"tokenizer.bos_token_id = {}".format(tokenizer.bos_token_id),
log_file,
global_rank,
)
# peft model
if training_args.use_lora:
print_rank_0(
"Loading lora config from {}".format(training_args.lora_config),
log_file,
global_rank,
)
lora_config = json.load(open(training_args.lora_config))
print_rank_0("Lora config: {}".format(lora_config), log_file, global_rank)
if training_args.use_int8_training:
print_rank_0(
"training_args.use_int8_training!!! (int8 is not compatible with DeepSpeed)",
log_file,
global_rank,
)
model = prepare_model_for_int8_training(model)
config = LoraConfig(
r=lora_config["lora_r"],
lora_alpha=lora_config["lora_alpha"],
target_modules=lora_config["lora_target_modules"],
lora_dropout=lora_config["lora_dropout"],
bias="none",
task_type="CAUSAL_LM",
)
# "RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn"
if hasattr(model, "enable_input_require_grads"):
model.enable_input_require_grads()
else:
def make_inputs_require_grad(module, input, output):
output.requires_grad_(True)
model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
model = get_peft_model(model, config)
model.print_trainable_parameters()
if training_args.gradient_checkpointing:
model.gradient_checkpointing_enable()
# model.is_parallelizable = True
# model.model_parallel = True
assert os.path.exists(data_args.train_file), "{} file not exists".format(
data_args.train_file
)
with torch_distributed_zero_first(global_rank):
train_data = load_dataset(
"json", data_files=data_args.train_file, cache_dir=model_args.cache_dir
)
val_data = load_dataset(
"json", data_files=data_args.validation_file, cache_dir=model_args.cache_dir
)
if model_args.use_flash_attention:
train_data = (
train_data["train"]
.shuffle()
.map(
partial(
batch_grouped_sft_generate,
training_args.model_max_length,
tokenizer,
),
batched=True,
desc=f"Grouping texts in chunks of {training_args.model_max_length}",
remove_columns=["id", "conversations"],
)
)
val_data = (
val_data["train"]
.map(
partial(
batch_grouped_sft_generate,
training_args.model_max_length,
tokenizer,
),
batched=True,
desc=f"Grouping texts in chunks of {training_args.model_max_length}",
remove_columns=["id", "conversations"],
)
)
else:
train_data = (
train_data["train"]
.shuffle()
.map(
partial(
generate_and_tokenize_prompt,
training_args.model_max_length,
tokenizer,
)
)
)
val_data = (
val_data["train"]
.map(
partial(
generate_and_tokenize_prompt,
training_args.model_max_length,
tokenizer,
)
)
)
for i in range(2):
print_rank_0(
"Eval tokenized example: {}".format(val_data[i]), log_file, global_rank
)
for i in range(2):
print_rank_0(
"Train tokenized example: {}".format(train_data[i]), log_file, global_rank
)
training_nums = len(train_data)
num_gpus = torch.cuda.device_count()
batch_size = (
training_args.per_device_train_batch_size
* training_args.world_size
* training_args.gradient_accumulation_steps
)
# train steps
t_total = math.ceil(training_nums / batch_size) * training_args.num_train_epochs
# eval steps
training_args.eval_steps = max(t_total // (training_args.num_train_epochs * 4), 5)
# save steps
training_args.save_steps = training_args.eval_steps
training_args.warmup_steps = (
int(t_total * training_args.warmup_ratio)
if training_args.warmup_ratio > 0.0
else training_args.warmup_steps
)
print_rank_0(
"num_gpus = {}, training_nums = {}, t_total = {}, warmup_steps = {}, eval_steps = {}, save_steps = {}".format(
num_gpus,
training_nums,
t_total,
training_args.warmup_steps,
training_args.eval_steps,
training_args.save_steps,
),
log_file,
global_rank,
)
print_rank_0(
"val data nums = {}, training_nums = {}, batch_size = {}".format(
len(val_data), training_nums, batch_size
),
log_file,
global_rank,
)
# Trainer
# https://github.com/huggingface/transformers/blob/main/src/transformers/training_args.py
# https://github.com/huggingface/transformers/blob/main/src/transformers/data/data_collator.py
# https://github.com/huggingface/transformers/blob/main/src/transformers/trainer.py
# https://www.deepspeed.ai/docs/config-json/
# https://huggingface.co/docs/accelerate/usage_guides/deepspeed
# https://huggingface.co/transformers/v4.10.1/main_classes/deepspeed.html
# https://github.com/tatsu-lab/stanford_alpaca/issues/176
trainer = Trainer(
model=model,
tokenizer=tokenizer,
args=training_args,
train_dataset=train_data,
eval_dataset=val_data,
data_collator=transformers.DataCollatorForSeq2Seq(
tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True
),
)
print_rank_0(
f"Using {training_args.half_precision_backend} half precision backend",
log_file,
global_rank,
)
# Train!
len_dataloader = len(trainer.get_train_dataloader())
num_update_steps_per_epoch = (
len_dataloader // training_args.gradient_accumulation_steps
)
total_train_batch_size = (
training_args.train_batch_size
* training_args.gradient_accumulation_steps
* training_args.world_size
)
num_examples = trainer.num_examples(trainer.get_train_dataloader())
num_train_samples = num_examples * training_args.num_train_epochs
max_steps = math.ceil(training_args.num_train_epochs * num_update_steps_per_epoch)
print_rank_0("***** Running training *****", log_file, global_rank)
print_rank_0(f" Num examples = {num_examples}", log_file, global_rank)
print_rank_0(f" Num train samples = {num_train_samples}", log_file, global_rank)
print_rank_0(f" world_size = {world_size}", log_file, global_rank)
print_rank_0(
f" Total train batch size (w. parallel, distributed & accumulation) = {total_train_batch_size}",
log_file,
global_rank,
)
print_rank_0(
f" Gradient Accumulation steps = {training_args.gradient_accumulation_steps}",
log_file,
global_rank,
)
print_rank_0(f" Total optimization steps = {max_steps}", log_file, global_rank)
print_rank_0(
f" Number of trainable parameters = {get_model_param_count(model, trainable_only=True)}",
log_file,
global_rank,
)
# https://discuss.huggingface.co/t/what-is-the-purpose-of-use-cache-in-decoder/958/3
model.config.use_cache = False
checkpoint = None
if training_args.resume_from_checkpoint is not None:
checkpoint = training_args.resume_from_checkpoint
elif last_checkpoint is not None:
checkpoint = last_checkpoint
trainer.train(resume_from_checkpoint=checkpoint)
trainer.save_model(training_args.output_dir)
print_rank_0(
"\n Training completed!!! If there's a warning about missing keys above, please disregard :)",
log_file,
global_rank,
)
if __name__ == "__main__":
main()
================================================
FILE: train/src/entry_point/zero_inference.py
================================================
import numpy as np
from transformers.utils import add_start_docstrings
from transformers.trainer_pt_utils import torch_distributed_zero_first
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
HfArgumentParser,
LlamaTokenizer,
TrainingArguments,
set_seed,
)
from transformers import GenerationConfig as HFGenerationConfig
from peft import PeftModel
from datasets import load_dataset
import transformers
import torch
from typing import Optional
from functools import partial
from dataclasses import dataclass, field
import os
import logging
import sys
import pandas as pd
from src.models.llama.modeling_llama import LlamaForCausalLM
from src.sample_generator import inference_generate
from src.trainer import MySeq2SeqTrainer as Seq2SeqTrainer
logger = logging.getLogger(__name__)
# import pudb
# import traceback
# import sys
# # 异常时中断
# def debug_on_exception(exctype, value, tb):
# traceback.print_exception(exctype, value, tb)
# pudb.post_mortem(tb)
# sys.excepthook = debug_on_exception
@dataclass
class ModelArguments:
"""
Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.
"""
ckpt_path: str = field(
default=None,
metadata={"help": "The model checkpoint for weights initialization."},
)
lora_path: Optional[str] = field(default=None, metadata={"help": "Checkpoint path."})
use_lora: bool = field(default=False, metadata={"help": "Whether to use LoRA."})
cache_dir: Optional[str] = field(
default=None,
metadata={
"help": "Where do you want to store the pretrained models downloaded from huggingface.co"
},
)
torch_dtype: Optional[str] = field(
default=None,
metadata={
"help": (
"Override the default `torch.dtype` and load the model under this dtype. If `auto` is passed, the "
"dtype will be automatically derived from the model's weights."
),
"choices": ["auto", "bfloat16", "float16", "float32"],
},
)
llama: bool = field(default=False, metadata={"help": "Llama model."})
use_flash_attention: bool = field(default=False, metadata={"help": "Enable flash attention."})
@dataclass
class DataArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
"""
infer_file: Optional[str] = field(
default=None,
metadata={
"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."
},
)
@dataclass
class GenerationConfig:
max_new_tokens: int = field(
default=512,
metadata={
"help": "The maximum numbers of tokens to generate, ignoring the number of tokens in the prompt."
},
)
min_new_tokens: int = field(
default=0,
metadata={
"help": "The minimum numbers of tokens to generate, ignoring the number of tokens in the prompt."
},
)
do_sample: bool = field(
default=False,
metadata={
"help": "Whether or not to use sampling ; use greedy decoding otherwise."
},
)
num_beams: int = field(
default=1,
metadata={"help": "Number of beams for beam search. 1 means no beam search."},
)
temperature: float = field(
default=1.0,
metadata={"help": "The value used to modulate the next token probabilities."},
)
top_k: int = field(
default=50,
metadata={
"help": "The number of highest probability vocabulary tokens to keep for top-k-filtering."
},
)
top_p: float = field(
default=1.0,
metadata={
"help": "If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to top_p or higher are kept for generation."
},
)
repetition_penalty: float = field(
default=1.0,
metadata={
"help": "The parameter for repetition penalty. 1.0 means no penalty."
},
)
@dataclass
@add_start_docstrings(TrainingArguments.__doc__)
class TrainingArguments(TrainingArguments):
predict_with_generate: bool = field(
default=True,
metadata={"help": "Enable generation"},
)
model_max_length: int = field(
default=512,
metadata={"help": "Maximum sequence length."},
)
report_to: str = field(
default="wandb",
metadata={
"help": "The list of integrations to report the results and logs to."
},
)
deepspeed: str = field(
default=None,
metadata={
"help": (
"Enable deepspeed and pass the path to deepspeed json config file (e.g. `ds_config.json`) or an already"
" loaded json file as a dict"
)
},
)
def print_rank_0(msg, log_file, rank=0):
if rank <= 0:
with open(log_file, "a") as f:
print(msg)
f.write(msg + "\n")
def main():
parser = HfArgumentParser(
(ModelArguments, DataArguments, TrainingArguments, GenerationConfig)
)
(
model_args,
data_args,
training_args,
generation_config,
) = parser.parse_args_into_dataclasses()
global_rank = torch.distributed.get_rank()
log_file = os.path.join(training_args.output_dir, "print_log.txt")
# Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
handlers=[logging.StreamHandler(sys.stdout)],
)
if training_args.should_log:
# The default of training_args.log_level is passive, so we set log level at info here to have that default.
transformers.utils.logging.set_verbosity_info()
log_level = training_args.get_process_log_level()
logger.setLevel(log_level)
transformers.utils.logging.set_verbosity(log_level)
transformers.utils.logging.enable_default_handler()
transformers.utils.logging.enable_explicit_format()
if not model_args.llama and model_args.use_flash_attention:
logger.warning(
"Only implement flash attention in llama-based model currently, "
"set use_flash_attention = False"
)
model_args.use_flash_attention = False
# Log on each process the small summary:
logger.warning(
f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}, distributed training: {bool(training_args.local_rank != -1)}, fp16-bits training: {training_args.fp16}, bf16-bits training: {training_args.bf16}"
)
logger.info(f"Training/evaluation parameters {training_args}")
# Set seed before initializing model.
set_seed(training_args.seed)
training_args.data_seed = training_args.seed
torch_dtype = (
model_args.torch_dtype
if model_args.torch_dtype in ["auto", None]
else getattr(torch, model_args.torch_dtype)
)
if model_args.llama:
tokenizer = LlamaTokenizer.from_pretrained(model_args.ckpt_path)
print_rank_0(
"Set the eos_token_id and bos_token_id of LLama model tokenizer",
log_file,
global_rank,
)
tokenizer.add_special_tokens(
{
"bos_token": "",
"eos_token": " ",
"unk_token": "",
"pad_token": "",
}
)
else:
tokenizer = AutoTokenizer.from_pretrained(model_args.ckpt_path)
tokenizer.add_special_tokens({"pad_token": tokenizer.unk_token})
tokenizer.padding_side = "left" # Allow batched inference
if model_args.llama:
model = LlamaForCausalLM.from_pretrained(
model_args.ckpt_path,
torch_dtype=torch_dtype
)
model.config.use_flash_attention = model_args.use_flash_attention
else:
model = AutoModelForCausalLM.from_pretrained(
model_args.ckpt_path,
torch_dtype=torch_dtype
)
model.config.pad_token_id = tokenizer.pad_token_id
model.config.eos_token_id = tokenizer.eos_token_id
# peft model
if model_args.use_lora:
model = PeftModel.from_pretrained(
model,
model_args.lora_path,
torch_dtype=torch_dtype
)
generation_config = vars(generation_config)
generation_config["bos_token_id"] = tokenizer.bos_token_id
generation_config["eos_token_id"] = tokenizer.eos_token_id
generation_config["pad_token_id"] = tokenizer.pad_token_id
print_rank_0(
"tokenizer.eos_token_id = {}".format(tokenizer.eos_token_id),
log_file,
global_rank,
)
print_rank_0(
"tokenizer.pad_token_id = {}".format(tokenizer.pad_token_id),
log_file,
global_rank,
)
print_rank_0(
"tokenizer.bos_token_id = {}".format(tokenizer.bos_token_id),
log_file,
global_rank,
)
assert os.path.exists(data_args.infer_file), "{} file not exists".format(
data_args.infer_file
)
with torch_distributed_zero_first(global_rank):
infer_data = load_dataset(
"json", data_files=data_args.infer_file, cache_dir=model_args.cache_dir
)
infer_data = infer_data["train"].map(
partial(
inference_generate,
training_args.model_max_length,
tokenizer,
lambda input_text: f"Human: \n" + input_text + "\n\nAssistant:\n",
)
)
for i in range(2):
print_rank_0(
"Eval tokenized example: {}".format(infer_data[i]), log_file, global_rank
)
num_gpus = torch.cuda.device_count()
print_rank_0(
f"val data nums = {len(infer_data)}, num gpus = {num_gpus}, total batch size = {num_gpus * training_args.eval_batch_size}",
log_file,
global_rank,
)
print_rank_0(
f"Using {training_args.half_precision_backend} half precision backend",
log_file,
global_rank,
)
training_args.generation_config = HFGenerationConfig(**generation_config)
# Trainer
# https://github.com/huggingface/transformers/blob/main/src/transformers/training_args.py
# https://github.com/huggingface/transformers/blob/main/src/transformers/data/data_collator.py
# https://github.com/huggingface/transformers/blob/main/src/transformers/trainer.py
# https://www.deepspeed.ai/docs/config-json/
# https://huggingface.co/docs/accelerate/usage_guides/deepspeed
# https://huggingface.co/transformers/v4.10.1/main_classes/deepspeed.html
# https://github.com/tatsu-lab/stanford_alpaca/issues/176
trainer = Seq2SeqTrainer(
model=model,
tokenizer=tokenizer,
args=training_args,
train_dataset=None,
eval_dataset=None,
data_collator=transformers.DataCollatorForSeq2Seq(
tokenizer,
pad_to_multiple_of=8 , return_tensors="pt",
padding=True
),
)
predict_results = trainer.predict(
infer_data,
metric_key_prefix="predict",
**training_args.generation_config.to_dict(),
)
print_rank_0(
f"predict_runtime = {predict_results.metrics['predict_runtime']}, predict_samples_per_second = {predict_results.metrics['predict_samples_per_second']}, predict_steps_per_second = {predict_results.metrics['predict_steps_per_second']}",
log_file,
global_rank,
)
if global_rank in [0, -1]:
predictions = predict_results.predictions
predictions = np.where(predictions != -100, predictions, tokenizer.pad_token_id)
predictions = tokenizer.batch_decode(
predictions, skip_special_tokens=True, clean_up_tokenization_spaces=True
)
predictions = [pred.strip() for pred in predictions]
pd.DataFrame({"output": predictions}).to_json(
f"{training_args.output_dir}/predictions.jsonl",
orient="records",
lines=True,
force_ascii=False,
)
if __name__ == "__main__":
main()
================================================
FILE: train/src/entry_point/zero_inference_backend_without_trainer.py
================================================
#!/usr/bin/env python
# https://huggingface.co/docs/transformers/main/en/main_classes/deepspeed#custom-deepspeed-zero-inference
from functools import partial
import json
import sys
from transformers import (
AutoTokenizer,
AutoModelForCausalLM,
HfArgumentParser,
LlamaTokenizer,
PreTrainedTokenizer,
GenerationConfig,
)
from transformers.deepspeed import HfDeepSpeedConfig
import deepspeed
import os
import torch
from dataclasses import dataclass, field
from typing import Optional
from peft import PeftModel
import gradio as gr
from src.models.llama.modeling_llama import LlamaForCausalLM
from src.models.generation_utils import GenerationMixin
from src.utils import bind_methods_from_class_to_instance
SEP_LINE = "=" * 20
@dataclass
class Arguments:
"""
Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.
"""
ckpt_path: str = field(
default=None,
metadata={"help": "The model checkpoint for weights initialization."},
)
deepspeed: str = field(
default=None,
metadata={"help": "Deepspeed config."},
)
local_rank: int = field(
default=None,
metadata={"help": "Local rank."},
)
lora_path: Optional[str] = field(default=None, metadata={"help": "Checkpoint path."})
use_lora: bool = field(default=False, metadata={"help": "Whether to use LoRA."})
llama: bool = field(default=False, metadata={"help": "Llama model."})
base_port: int = field(default=17860, metadata={"help": "Multi process bose port."})
def generate_prompt(input_text):
return input_text
def evaluate(
model,
deepspeed_model,
tokenizer: PreTrainedTokenizer,
local_rank: int,
input: str,
temperature=0.1,
top_p=0.75,
top_k=40,
num_beams=4,
do_sample=False,
max_new_tokens=128,
min_new_tokens=1,
repetition_penalty=1.2,
):
prompt = generate_prompt(input)
print(SEP_LINE)
print(f"local_rank: {local_rank}\nprompt:\n{prompt}")
print(SEP_LINE)
input_ids = tokenizer.encode(
prompt, add_special_tokens=False, return_tensors="pt"
).to(device=local_rank)
generation_config = GenerationConfig(
temperature=temperature,
top_p=top_p,
top_k=top_k,
num_beams=num_beams,
bos_token_id=tokenizer.bos_token_id,
eos_token_id=tokenizer.eos_token_id,
pad_token_id=tokenizer.pad_token_id,
max_new_tokens=max_new_tokens, # max_length=max_new_tokens+input_sequence
min_new_tokens=min_new_tokens, # min_length=min_new_tokens+input_sequence
repetition_penalty=repetition_penalty,
do_sample=do_sample,
)
with torch.no_grad():
try:
generation_output = model.generate(
input_ids=input_ids,
generation_config=generation_config,
deepspeed_model=deepspeed_model,
synced_gpus=True,
return_dict_in_generate=True,
output_scores=False,
)
except Exception as e:
print(e)
sys.exit(-1)
output = generation_output.sequences[0]
output = tokenizer.decode(
output,
skip_special_tokens=True
)[len(prompt):].strip()
print(SEP_LINE)
print(f"local_rank: {local_rank}\nresult:\n{prompt + output}")
print(SEP_LINE)
return output
def main():
parser = HfArgumentParser((Arguments,))
args = parser.parse_args_into_dataclasses()[0]
# distributed setup
local_rank = int(os.getenv("LOCAL_RANK", "0"))
torch.cuda.set_device(local_rank)
deepspeed.init_distributed()
with open(args.deepspeed, "rt") as f:
ds_config = json.load(f)
# batch size has to be divisible by world_size, but can be bigger than world_size
ds_config["train_batch_size"] = int(os.getenv("WORLD_SIZE", "1"))
ds_config["train_micro_batch_size_per_gpu"] = 1
# next line instructs transformers to partition the model directly over multiple gpus using
# deepspeed.zero.Init when model's `from_pretrained` method is called.
#
# **it has to be run before loading the model AutoModelForSeq2SeqLM.from_pretrained(model_name)**
#
# otherwise the model will first be loaded normally and only partitioned at forward time which is
# less efficient and when there is little CPU RAM may fail
dschf = HfDeepSpeedConfig(ds_config) # keep this object alive
if args.llama:
tokenizer = LlamaTokenizer.from_pretrained(args.ckpt_path)
tokenizer.add_special_tokens(
{
"bos_token": "",
"eos_token": " ",
"unk_token": "",
"pad_token": "",
}
)
else:
tokenizer = AutoTokenizer.from_pretrained(args.ckpt_path)
tokenizer.add_special_tokens({"pad_token": tokenizer.unk_token})
tokenizer.padding_side = "left"
# now a model can be loaded.
if args.llama:
model = LlamaForCausalLM.from_pretrained(args.ckpt_path)
model.config.use_flash_attention = True
else:
model = AutoModelForCausalLM.from_pretrained(args.ckpt_path)
model.config.pad_token_id = tokenizer.pad_token_id
model.config.eos_token_id = tokenizer.eos_token_id
# peft model
if args.use_lora:
model = PeftModel.from_pretrained(model, args.lora_path)
# initialise Deepspeed ZeRO and store only the engine object
ds_engine = deepspeed.initialize(model=model, config_params=ds_config)[0]
# inference
ds_engine.module.eval()
bind_methods_from_class_to_instance(
ds_engine.module,
GenerationMixin,
include=[
"contrastive_search",
"greedy_search",
"sample",
"beam_search",
"beam_sample",
"group_beam_search",
"constrained_beam_search",
"assisted_decoding",
"generate",
],
)
gr.Interface(
fn=partial(evaluate, ds_engine.module, ds_engine, tokenizer, local_rank),
inputs=[
gr.components.Textbox(
lines=2, label="Input", placeholder="Welcome to the BELLE model"
),
gr.components.Slider(minimum=0, maximum=1, value=0.1, label="Temperature"),
gr.components.Slider(minimum=0, maximum=1, value=0.75, label="Top p"),
gr.components.Slider(
minimum=0, maximum=100, step=1, value=40, label="Top k"
),
gr.components.Slider(
minimum=1, maximum=4, step=1, value=1, label="Beams Number"
),
gr.components.Checkbox(value=False, label="Do sample"),
gr.components.Slider(
minimum=1, maximum=2000, step=10, value=512, label="Max New Tokens"
),
gr.components.Slider(
minimum=1, maximum=300, step=10, value=1, label="Min New Tokens"
),
gr.components.Slider(
minimum=1.0,
maximum=2.0,
step=0.1,
value=1.2,
label="Repetition Penalty",
),
],
outputs=[
gr.components.Textbox(
lines=25,
label="Output",
)
],
title="BELLE: Be Everyone's Large Language model Engine",
).queue().launch(
share=True,
server_name="0.0.0.0",
server_port=args.base_port + torch.distributed.get_rank()
)
if __name__ == "__main__":
main()
================================================
FILE: train/src/merge_llama_with_lora.py
================================================
import argparse
import torch
from peft import PeftModel
from transformers import AutoTokenizer, AutoModelForCausalLM, LlamaTokenizer
# Ref: https://github.com/tloen/alpaca-lora/blob/main/export_hf_checkpoint.py
def apply_lora(model_name_or_path, output_path, lora_path):
print(f"Loading the base model from {model_name_or_path}")
base = AutoModelForCausalLM.from_pretrained(
model_name_or_path, torch_dtype=torch.float16, low_cpu_mem_usage=True
)
if args.llama:
base_tokenizer = LlamaTokenizer.from_pretrained(model_name_or_path)
else:
base_tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
print(f"Loading the LoRA adapter from {lora_path}")
lora_model = PeftModel.from_pretrained(
base,
lora_path,
torch_dtype=torch.float16,
)
print("Applying the LoRA")
model = lora_model.merge_and_unload()
print(f"Saving the target model to {output_path}")
model.save_pretrained(output_path)
base_tokenizer.save_pretrained(output_path)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--model_name_or_path", type=str, required=True)
parser.add_argument("--output_path", type=str, required=True)
parser.add_argument("--lora_path", type=str, required=True)
parser.add_argument("--llama", action="store_true", required=True)
args = parser.parse_args()
apply_lora(args.model_name_or_path, args.output_path, args.lora_path)
================================================
FILE: train/src/models/generation_utils.py
================================================
# coding=utf-8
# Copyright 2020 The Google AI Language Team Authors, Facebook AI Research authors and The HuggingFace Inc. team.
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import copy
import inspect
import warnings
from dataclasses import dataclass
from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
import torch
import torch.distributed as dist
from torch import nn
from transformers.deepspeed import is_deepspeed_zero3_enabled
from transformers.modeling_outputs import CausalLMOutputWithPast, Seq2SeqLMOutput
from transformers.models.auto import (
MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
MODEL_FOR_CAUSAL_LM_MAPPING,
MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
MODEL_FOR_VISION_2_SEQ_MAPPING,
)
from transformers.utils import ExplicitEnum, ModelOutput, logging
from transformers.generation.beam_constraints import DisjunctiveConstraint, PhrasalConstraint
from transformers.generation.beam_search import BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
from transformers.generation.configuration_utils import GenerationConfig
from transformers.generation.logits_process import (
EncoderNoRepeatNGramLogitsProcessor,
EncoderRepetitionPenaltyLogitsProcessor,
EpsilonLogitsWarper,
EtaLogitsWarper,
ExponentialDecayLengthPenalty,
ForcedBOSTokenLogitsProcessor,
ForcedEOSTokenLogitsProcessor,
ForceTokensLogitsProcessor,
HammingDiversityLogitsProcessor,
InfNanRemoveLogitsProcessor,
LogitNormalization,
LogitsProcessorList,
MinLengthLogitsProcessor,
MinNewTokensLengthLogitsProcessor,
NoBadWordsLogitsProcessor,
NoRepeatNGramLogitsProcessor,
PrefixConstrainedLogitsProcessor,
RepetitionPenaltyLogitsProcessor,
SequenceBiasLogitsProcessor,
SuppressTokensAtBeginLogitsProcessor,
SuppressTokensLogitsProcessor,
TemperatureLogitsWarper,
TopKLogitsWarper,
TopPLogitsWarper,
TypicalLogitsWarper,
UnbatchedClassifierFreeGuidanceLogitsProcessor
)
from transformers.generation.stopping_criteria import (
MaxLengthCriteria,
MaxTimeCriteria,
StoppingCriteria,
StoppingCriteriaList,
validate_stopping_criteria,
)
from transformers.generation.utils import (
GreedySearchOutput,
SampleOutput,
BeamSearchOutput,
BeamSampleOutput,
ContrastiveSearchOutput,
GenerateOutput,
ContrastiveSearchEncoderDecoderOutput,
ContrastiveSearchDecoderOnlyOutput,
GreedySearchEncoderDecoderOutput,
GreedySearchDecoderOnlyOutput,
SampleEncoderDecoderOutput,
BeamSearchEncoderDecoderOutput,
SampleDecoderOnlyOutput,
BeamSearchDecoderOnlyOutput,
BeamSampleEncoderDecoderOutput,
BeamSampleDecoderOnlyOutput
)
from deepspeed.runtime.engine import DeepSpeedEngine
if TYPE_CHECKING:
from transformers.modeling_utils import PreTrainedModel
from transformers.generation.streamers import BaseStreamer
logger = logging.get_logger(__name__)
class GenerationMode(ExplicitEnum):
"""
Possible generation modes, downstream of the [`~generation.GenerationMixin.generate`] method.
"""
# Non-beam methods
CONTRASTIVE_SEARCH = "contrastive_search"
GREEDY_SEARCH = "greedy_search"
SAMPLE = "sample"
ASSISTED_GENERATION = "assisted_generation"
# Beam methods
BEAM_SEARCH = "beam_search"
BEAM_SAMPLE = "beam_sample"
CONSTRAINED_BEAM_SEARCH = "constrained_beam_search"
GROUP_BEAM_SEARCH = "group_beam_search"
class GenerationMixin:
"""
A class containing all functions for auto-regressive text generation, to be used as a mixin in [`PreTrainedModel`].
The class exposes [`~generation.GenerationMixin.generate`], which can be used for:
- *greedy decoding* by calling [`~generation.GenerationMixin.greedy_search`] if `num_beams=1` and
`do_sample=False`
- *contrastive search* by calling [`~generation.GenerationMixin.contrastive_search`] if `penalty_alpha>0` and
`top_k>1`
- *multinomial sampling* by calling [`~generation.GenerationMixin.sample`] if `num_beams=1` and
`do_sample=True`
- *beam-search decoding* by calling [`~generation.GenerationMixin.beam_search`] if `num_beams>1` and
`do_sample=False`
- *beam-search multinomial sampling* by calling [`~generation.GenerationMixin.beam_sample`] if `num_beams>1`
and `do_sample=True`
- *diverse beam-search decoding* by calling [`~generation.GenerationMixin.group_beam_search`], if `num_beams>1`
and `num_beam_groups>1`
- *constrained beam-search decoding* by calling [`~generation.GenerationMixin.constrained_beam_search`], if
`constraints!=None` or `force_words_ids!=None`
You do not need to call any of the above methods directly. Pass custom parameter values to 'generate' instead. To
learn more about decoding strategies refer to the [text generation strategies guide](../generation_strategies).
"""
def prepare_inputs_for_generation(self, *args, **kwargs):
raise NotImplementedError(
"A model class needs to define a `prepare_inputs_for_generation` method in order to use `.generate()`."
)
def _prepare_model_inputs(
self,
inputs: Optional[torch.Tensor] = None,
bos_token_id: Optional[int] = None,
model_kwargs: Optional[Dict[str, torch.Tensor]] = None,
) -> Tuple[torch.Tensor, Optional[str], Dict[str, torch.Tensor]]:
"""
This function extracts the model-specific `inputs` for generation.
"""
# 1. retrieve all kwargs that are non-None or non-model input related.
# some encoder-decoder models have different names for model and encoder
if (
self.config.is_encoder_decoder
and hasattr(self, "encoder")
and self.encoder.main_input_name != self.main_input_name
):
input_name = self.encoder.main_input_name
else:
input_name = self.main_input_name
model_kwargs = {k: v for k, v in model_kwargs.items() if v is not None or k != input_name}
# 2. check whether model_input_name is passed as kwarg
# if yes and `inputs` is None use kwarg inputs
inputs_kwarg = model_kwargs.pop(input_name, None)
if inputs_kwarg is not None and inputs is not None:
raise ValueError(
f"`inputs`: {inputs}` were passed alongside {input_name} which is not allowed."
f"Make sure to either pass {inputs} or {input_name}=..."
)
elif inputs_kwarg is not None:
inputs = inputs_kwarg
# 3. In the presence of `inputs_embeds` for text models:
# - decoder-only models should complain if the user attempts to pass `inputs_embeds`, but the model
# doesn't have its forwarding implemented. `inputs_embeds` is kept in `model_kwargs` and can coexist with
# input_ids (`inputs_embeds` will be used in the 1st generation step, as opposed to `input_ids`)
# - encoder-decoder models should complain if the user attempts to pass `inputs_embeds` and `input_ids`, and
# pull the former to inputs. It will be used in place of `input_ids` to get the encoder hidden states.
if input_name == "input_ids" and "inputs_embeds" in model_kwargs:
if not self.config.is_encoder_decoder:
has_inputs_embeds_forwarding = "inputs_embeds" in set(
inspect.signature(self.prepare_inputs_for_generation).parameters.keys()
)
if not has_inputs_embeds_forwarding:
raise ValueError(
f"You passed `inputs_embeds` to `.generate()`, but the model class {self.__class__.__name__} "
"doesn't have its forwarding implemented. See the GPT2 implementation for an example "
"(https://github.com/huggingface/transformers/pull/21405), and feel free to open a PR with it!"
)
# In this case, `input_ids` is moved to the `model_kwargs`, so a few automations (like the creation of
# the attention mask) can rely on the actual model input.
model_kwargs["input_ids"] = self._maybe_initialize_input_ids_for_generation(
inputs, bos_token_id, model_kwargs=model_kwargs
)
else:
if inputs is not None:
raise ValueError("You passed `inputs_embeds` and `input_ids` to `.generate()`. Please pick one.")
inputs, input_name = model_kwargs["inputs_embeds"], "inputs_embeds"
# 4. if `inputs` is still None, try to create `input_ids` from BOS token
inputs = self._maybe_initialize_input_ids_for_generation(inputs, bos_token_id, model_kwargs)
return inputs, input_name, model_kwargs
def _maybe_initialize_input_ids_for_generation(
self,
inputs: Optional[torch.Tensor] = None,
bos_token_id: Optional[int] = None,
model_kwargs: Optional[Dict[str, torch.Tensor]] = None,
) -> torch.LongTensor:
"""Initializes input ids for generation, if necessary."""
if inputs is not None:
return inputs
encoder_outputs = model_kwargs.get("encoder_outputs")
if self.config.is_encoder_decoder and encoder_outputs is not None:
# make dummy input_ids with value -100, as a sanity check ensuring that they won't be used for encoding
shape = encoder_outputs.last_hidden_state.size()[:-1]
return torch.ones(shape, dtype=torch.long, device=self.device) * -100
if bos_token_id is None:
raise ValueError("`bos_token_id` has to be defined when no `input_ids` are provided.")
# If there is some tensor in `model_kwargs`, we can infer the batch size from it. This is helpful with
# soft-prompting or in multimodal implementations built on top of decoder-only language models.
batch_size = 1
for value in model_kwargs.values():
if isinstance(value, torch.Tensor):
batch_size = value.shape[0]
break
return torch.ones((batch_size, 1), dtype=torch.long, device=self.device) * bos_token_id
def _prepare_attention_mask_for_generation(
self,
inputs: torch.Tensor,
pad_token_id: Optional[int],
eos_token_id: Optional[Union[int, List[int]]],
) -> torch.LongTensor:
is_input_ids = len(inputs.shape) == 2 and inputs.dtype in [torch.int, torch.long]
is_pad_token_in_inputs = (pad_token_id is not None) and (pad_token_id in inputs)
if isinstance(eos_token_id, int):
eos_token_id = [eos_token_id]
is_pad_token_not_equal_to_eos_token_id = (eos_token_id is None) or (pad_token_id not in eos_token_id)
# Check if input is input_ids and padded -> only then is attention_mask defined
if is_input_ids and is_pad_token_in_inputs and is_pad_token_not_equal_to_eos_token_id:
return inputs.ne(pad_token_id).long()
else:
return torch.ones(inputs.shape[:2], dtype=torch.long, device=inputs.device)
def _prepare_encoder_decoder_kwargs_for_generation(
self, inputs_tensor: torch.Tensor, model_kwargs, model_input_name: Optional[str] = None
) -> Dict[str, Any]:
# 1. get encoder
encoder = self.get_encoder()
# Compatibility with Accelerate big model inference: we need the encoder to outputs stuff on the same device
# as the inputs.
if hasattr(encoder, "_hf_hook"):
encoder._hf_hook.io_same_device = True
# 2. Prepare encoder args and encoder kwargs from model kwargs.
irrelevant_prefix = ["decoder_", "cross_attn", "use_cache"]
encoder_kwargs = {
argument: value
for argument, value in model_kwargs.items()
if not any(argument.startswith(p) for p in irrelevant_prefix)
}
encoder_signature = set(inspect.signature(encoder.forward).parameters)
encoder_accepts_wildcard = "kwargs" in encoder_signature or "model_kwargs" in encoder_signature
if not encoder_accepts_wildcard:
encoder_kwargs = {
argument: value for argument, value in encoder_kwargs.items() if argument in encoder_signature
}
# 3. make sure that encoder returns `ModelOutput`
model_input_name = model_input_name if model_input_name is not None else self.main_input_name
encoder_kwargs["return_dict"] = True
encoder_kwargs[model_input_name] = inputs_tensor
model_kwargs["encoder_outputs"]: ModelOutput = encoder(**encoder_kwargs)
return model_kwargs
def _prepare_decoder_input_ids_for_generation(
self,
batch_size: int,
model_input_name: str,
model_kwargs: Dict[str, torch.Tensor],
decoder_start_token_id: int = None,
bos_token_id: int = None,
device: torch.device = None,
) -> Tuple[torch.LongTensor, Dict[str, torch.Tensor]]:
"""Prepares `decoder_input_ids` for generation with encoder-decoder models"""
# 1. Check whether the user has defined `decoder_input_ids` manually. To facilitate in terms of input naming,
# we also allow the user to pass it under `input_ids`, if the encoder does not use it as the main input.
if model_kwargs is not None and "decoder_input_ids" in model_kwargs:
decoder_input_ids = model_kwargs.pop("decoder_input_ids")
elif "input_ids" in model_kwargs and model_input_name != "input_ids":
decoder_input_ids = model_kwargs.pop("input_ids")
else:
decoder_input_ids = None
# 2. Encoder-decoder models expect the `decoder_input_ids` to start with a special token. Let's ensure that.
decoder_start_token_id = self._get_decoder_start_token_id(decoder_start_token_id, bos_token_id)
if device is None:
device = self.device
decoder_input_ids_start = torch.ones((batch_size, 1), dtype=torch.long, device=device) * decoder_start_token_id
# no user input -> use decoder_start_token_id as decoder_input_ids
if decoder_input_ids is None:
decoder_input_ids = decoder_input_ids_start
# exception: Donut checkpoints have task-specific decoder starts and don't expect a BOS token
elif self.config.model_type == "vision-encoder-decoder" and "donut" in self.name_or_path.lower():
pass
# user input but doesn't start with decoder_start_token_id -> prepend decoder_start_token_id (and adjust
# decoder_attention_mask if provided)
elif (decoder_input_ids[:, 0] != decoder_start_token_id).all().item():
decoder_input_ids = torch.cat([decoder_input_ids_start, decoder_input_ids], dim=-1)
if "decoder_attention_mask" in model_kwargs:
decoder_attention_mask = model_kwargs["decoder_attention_mask"]
decoder_attention_mask = torch.cat(
(torch.ones_like(decoder_attention_mask)[:, :1], decoder_attention_mask),
dim=-1,
)
model_kwargs["decoder_attention_mask"] = decoder_attention_mask
return decoder_input_ids, model_kwargs
def _get_decoder_start_token_id(self, decoder_start_token_id: int = None, bos_token_id: int = None) -> int:
decoder_start_token_id = (
decoder_start_token_id
if decoder_start_token_id is not None
else self.generation_config.decoder_start_token_id
)
bos_token_id = bos_token_id if bos_token_id is not None else self.generation_config.bos_token_id
if decoder_start_token_id is not None:
return decoder_start_token_id
elif bos_token_id is not None:
return bos_token_id
raise ValueError(
"`decoder_start_token_id` or `bos_token_id` has to be defined for encoder-decoder generation."
)
@staticmethod
def _expand_inputs_for_generation(
expand_size: int = 1,
is_encoder_decoder: bool = False,
input_ids: Optional[torch.LongTensor] = None,
**model_kwargs,
) -> Tuple[torch.LongTensor, Dict[str, Any]]:
"""Expands tensors from [batch_size, ...] to [batch_size * expand_size, ...]"""
def _expand_dict_for_generation(dict_to_expand):
for key in dict_to_expand:
if dict_to_expand[key] is not None and isinstance(dict_to_expand[key], torch.Tensor):
dict_to_expand[key] = dict_to_expand[key].repeat_interleave(expand_size, dim=0)
return dict_to_expand
if input_ids is not None:
input_ids = input_ids.repeat_interleave(expand_size, dim=0)
model_kwargs = _expand_dict_for_generation(model_kwargs)
if is_encoder_decoder:
if model_kwargs.get("encoder_outputs") is None:
raise ValueError("If `is_encoder_decoder` is True, make sure that `encoder_outputs` is defined.")
model_kwargs["encoder_outputs"] = _expand_dict_for_generation(model_kwargs["encoder_outputs"])
return input_ids, model_kwargs
def _extract_past_from_model_output(self, outputs: ModelOutput, standardize_cache_format: bool = False):
past_key_values = None
if "past_key_values" in outputs:
past_key_values = outputs.past_key_values
elif "mems" in outputs:
past_key_values = outputs.mems
elif "past_buckets_states" in outputs:
past_key_values = outputs.past_buckets_states
# Bloom fix: standardizes the cache format when requested
if standardize_cache_format and hasattr(self, "_convert_to_standard_cache"):
batch_size = outputs.logits.shape[0]
past_key_values = self._convert_to_standard_cache(past_key_values, batch_size=batch_size)
return past_key_values
def _update_model_kwargs_for_generation(
self,
outputs: ModelOutput,
model_kwargs: Dict[str, Any],
is_encoder_decoder: bool = False,
standardize_cache_format: bool = False,
) -> Dict[str, Any]:
# update past_key_values
model_kwargs["past_key_values"] = self._extract_past_from_model_output(
outputs, standardize_cache_format=standardize_cache_format
)
if getattr(outputs, "state", None) is not None:
model_kwargs["state"] = outputs.state
# update token_type_ids with last value
if "token_type_ids" in model_kwargs:
token_type_ids = model_kwargs["token_type_ids"]
model_kwargs["token_type_ids"] = torch.cat([token_type_ids, token_type_ids[:, -1].unsqueeze(-1)], dim=-1)
if not is_encoder_decoder:
# update attention mask
if "attention_mask" in model_kwargs:
attention_mask = model_kwargs["attention_mask"]
model_kwargs["attention_mask"] = torch.cat(
[attention_mask, attention_mask.new_ones((attention_mask.shape[0], 1))], dim=-1
)
else:
# update decoder attention mask
if "decoder_attention_mask" in model_kwargs:
decoder_attention_mask = model_kwargs["decoder_attention_mask"]
model_kwargs["decoder_attention_mask"] = torch.cat(
[decoder_attention_mask, decoder_attention_mask.new_ones((decoder_attention_mask.shape[0], 1))],
dim=-1,
)
return model_kwargs
def _reorder_cache(self, past_key_values, beam_idx):
raise NotImplementedError(
f"Make sure that a `_reorder_cache` function is correctly implemented in {self.__class__.__module__} to"
f" enable beam search for {self.__class__}"
)
def _get_logits_warper(
self,
generation_config: GenerationConfig,
) -> LogitsProcessorList:
"""
This class returns a [`LogitsProcessorList`] list object that contains all relevant [`LogitsWarper`] instances
used for multinomial sampling.
"""
# instantiate warpers list
warpers = LogitsProcessorList()
# the following idea is largely copied from this PR: https://github.com/huggingface/transformers/pull/5420/files
# all samplers can be found in `generation_utils_samplers.py`
if generation_config.temperature is not None and generation_config.temperature != 1.0:
warpers.append(TemperatureLogitsWarper(generation_config.temperature))
min_tokens_to_keep = 2 if generation_config.num_beams > 1 else 1
if generation_config.top_k is not None and generation_config.top_k != 0:
warpers.append(TopKLogitsWarper(top_k=generation_config.top_k, min_tokens_to_keep=min_tokens_to_keep))
if generation_config.top_p is not None and generation_config.top_p < 1.0:
warpers.append(TopPLogitsWarper(top_p=generation_config.top_p, min_tokens_to_keep=min_tokens_to_keep))
if generation_config.typical_p is not None and generation_config.typical_p < 1.0:
warpers.append(
TypicalLogitsWarper(mass=generation_config.typical_p, min_tokens_to_keep=min_tokens_to_keep)
)
if generation_config.epsilon_cutoff is not None and 0.0 < generation_config.epsilon_cutoff < 1.0:
warpers.append(
EpsilonLogitsWarper(epsilon=generation_config.epsilon_cutoff, min_tokens_to_keep=min_tokens_to_keep)
)
if generation_config.eta_cutoff is not None and 0.0 < generation_config.eta_cutoff < 1.0:
warpers.append(
EtaLogitsWarper(epsilon=generation_config.eta_cutoff, min_tokens_to_keep=min_tokens_to_keep)
)
# `LogitNormalization` should always be the last logit processor, when present
if generation_config.renormalize_logits is True:
warpers.append(LogitNormalization())
return warpers
def _get_generation_mode(
self, generation_config: GenerationConfig, assistant_model: Optional["PreTrainedModel"]
) -> GenerationMode:
"""
Returns the generation mode triggered by a [`GenerationConfig`] instance.
"""
if generation_config.constraints is not None or generation_config.force_words_ids is not None:
generation_mode = GenerationMode.CONSTRAINED_BEAM_SEARCH
elif generation_config.num_beams == 1:
if generation_config.do_sample is False:
if (
generation_config.top_k is not None
and generation_config.top_k > 1
and generation_config.penalty_alpha is not None
and generation_config.penalty_alpha > 0
):
generation_mode = GenerationMode.CONTRASTIVE_SEARCH
else:
generation_mode = GenerationMode.GREEDY_SEARCH
else:
generation_mode = GenerationMode.SAMPLE
else:
if generation_config.num_beam_groups > 1:
generation_mode = GenerationMode.GROUP_BEAM_SEARCH
elif generation_config.do_sample is True:
generation_mode = GenerationMode.BEAM_SAMPLE
else:
generation_mode = GenerationMode.BEAM_SEARCH
# Assisted generation may extend some generation modes
if assistant_model is not None:
if generation_mode in ("greedy_search", "sample"):
generation_mode = GenerationMode.ASSISTED_GENERATION
else:
raise ValueError(
"You've set `assistant_model`, which triggers assisted generate. Currently, assisted generate "
"is only supported with Greedy Search and Sample."
)
return generation_mode
def _get_logits_processor(
self,
generation_config: GenerationConfig,
input_ids_seq_length: int,
encoder_input_ids: torch.LongTensor,
prefix_allowed_tokens_fn: Callable[[int, torch.Tensor], List[int]],
logits_processor: Optional[LogitsProcessorList],
model_kwargs: Optional[Dict[str, Any]] = None,
negative_prompt_ids: Optional[torch.Tensor] = None,
negative_prompt_attention_mask: Optional[torch.Tensor] = None,
) -> LogitsProcessorList:
"""
This class returns a [`LogitsProcessorList`] list object that contains all relevant [`LogitsProcessor`]
instances used to modify the scores of the language model head.
"""
# instantiate processors list
processors = LogitsProcessorList()
if generation_config.guidance_scale is not None and generation_config.guidance_scale != 1:
processors.append(
UnbatchedClassifierFreeGuidanceLogitsProcessor(
generation_config.guidance_scale,
self,
unconditional_ids=negative_prompt_ids,
unconditional_attention_mask=negative_prompt_attention_mask,
use_cache=model_kwargs["use_cache"],
)
)
if generation_config.sequence_bias is not None:
processors.append(SequenceBiasLogitsProcessor(sequence_bias=generation_config.sequence_bias))
if generation_config.diversity_penalty is not None and generation_config.diversity_penalty > 0.0:
processors.append(
HammingDiversityLogitsProcessor(
diversity_penalty=generation_config.diversity_penalty,
num_beams=generation_config.num_beams,
num_beam_groups=generation_config.num_beam_groups,
)
)
if (
generation_config.encoder_repetition_penalty is not None
and generation_config.encoder_repetition_penalty != 1.0
):
processors.append(
EncoderRepetitionPenaltyLogitsProcessor(
penalty=generation_config.encoder_repetition_penalty, encoder_input_ids=encoder_input_ids
)
)
if generation_config.repetition_penalty is not None and generation_config.repetition_penalty != 1.0:
processors.append(RepetitionPenaltyLogitsProcessor(penalty=generation_config.repetition_penalty))
if generation_config.no_repeat_ngram_size is not None and generation_config.no_repeat_ngram_size > 0:
processors.append(NoRepeatNGramLogitsProcessor(generation_config.no_repeat_ngram_size))
if (
generation_config.encoder_no_repeat_ngram_size is not None
and generation_config.encoder_no_repeat_ngram_size > 0
):
if self.config.is_encoder_decoder:
processors.append(
EncoderNoRepeatNGramLogitsProcessor(
generation_config.encoder_no_repeat_ngram_size, encoder_input_ids
)
)
else:
raise ValueError(
"It's impossible to use `encoder_no_repeat_ngram_size` with decoder-only architecture"
)
if generation_config.bad_words_ids is not None:
processors.append(
NoBadWordsLogitsProcessor(generation_config.bad_words_ids, generation_config.eos_token_id)
)
if (
generation_config.min_length is not None
and generation_config.eos_token_id is not None
and generation_config.min_length > 0
):
processors.append(MinLengthLogitsProcessor(generation_config.min_length, generation_config.eos_token_id))
if (
generation_config.min_new_tokens is not None
and generation_config.eos_token_id is not None
and generation_config.min_new_tokens > 0
):
processors.append(
MinNewTokensLengthLogitsProcessor(
input_ids_seq_length, generation_config.min_new_tokens, generation_config.eos_token_id
)
)
if prefix_allowed_tokens_fn is not None:
processors.append(
PrefixConstrainedLogitsProcessor(
prefix_allowed_tokens_fn, generation_config.num_beams // generation_config.num_beam_groups
)
)
if generation_config.forced_bos_token_id is not None:
processors.append(ForcedBOSTokenLogitsProcessor(generation_config.forced_bos_token_id))
if generation_config.forced_eos_token_id is not None:
processors.append(
ForcedEOSTokenLogitsProcessor(generation_config.max_length, generation_config.forced_eos_token_id)
)
if generation_config.remove_invalid_values is True:
processors.append(InfNanRemoveLogitsProcessor())
if generation_config.exponential_decay_length_penalty is not None:
processors.append(
ExponentialDecayLengthPenalty(
generation_config.exponential_decay_length_penalty,
generation_config.eos_token_id,
input_ids_seq_length,
)
)
if generation_config.suppress_tokens is not None:
processors.append(SuppressTokensLogitsProcessor(generation_config.suppress_tokens))
if generation_config.begin_suppress_tokens is not None:
begin_index = input_ids_seq_length
begin_index = (
begin_index
if (input_ids_seq_length > 1 or generation_config.forced_bos_token_id is None)
else begin_index + 1
)
if generation_config.forced_decoder_ids is not None:
# generation starts after the last token that is forced
begin_index += generation_config.forced_decoder_ids[-1][0]
processors.append(
SuppressTokensAtBeginLogitsProcessor(generation_config.begin_suppress_tokens, begin_index)
)
if generation_config.forced_decoder_ids is not None:
processors.append(ForceTokensLogitsProcessor(generation_config.forced_decoder_ids))
processors = self._merge_criteria_processor_list(processors, logits_processor)
# `LogitNormalization` should always be the last logit processor, when present
if generation_config.renormalize_logits is True:
processors.append(LogitNormalization())
return processors
def _get_stopping_criteria(
self, generation_config: GenerationConfig, stopping_criteria: Optional[StoppingCriteriaList]
) -> StoppingCriteriaList:
criteria = StoppingCriteriaList()
if generation_config.max_length is not None:
max_position_embeddings = getattr(self.config, "max_position_embeddings", None)
criteria.append(
MaxLengthCriteria(
max_length=generation_config.max_length,
max_position_embeddings=max_position_embeddings,
)
)
if generation_config.max_time is not None:
criteria.append(MaxTimeCriteria(max_time=generation_config.max_time))
criteria = self._merge_criteria_processor_list(criteria, stopping_criteria)
return criteria
def _merge_criteria_processor_list(
self,
default_list: Union[LogitsProcessorList, StoppingCriteriaList],
custom_list: Union[LogitsProcessorList, StoppingCriteriaList],
) -> Union[LogitsProcessorList, StoppingCriteriaList]:
if len(custom_list) == 0:
return default_list
for default in default_list:
for custom in custom_list:
if type(custom) is type(default):
object_type = "stopping criteria" if isinstance(custom, StoppingCriteria) else "logits processor"
raise ValueError(
f"A custom {object_type} of type {type(custom)} with values {custom} has been passed to"
f" `.generate()`, but it has already been created with the values {default}. {default} has been"
" created by passing the corresponding arguments to generate or by the model's config default"
f" values. If you just want to change the default values of {object_type} consider passing"
f" them as arguments to `.generate()` instead of using a custom {object_type}."
)
default_list.extend(custom_list)
return default_list
def compute_transition_scores(
self,
sequences: torch.Tensor,
scores: Tuple[torch.Tensor],
beam_indices: Optional[torch.Tensor] = None,
normalize_logits: bool = False,
) -> torch.Tensor:
"""
Computes the transition scores of sequences given the generation scores (and beam indices, if beam search was
used). This is a convenient method to quicky obtain the scores of the selected tokens at generation time.
Parameters:
sequences (`torch.LongTensor`):
The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or
shorter if all batches finished early due to the `eos_token_id`.
scores (`tuple(torch.FloatTensor)`):
Transition scores for each vocabulary token at each generation step. Beam transition scores consisting
of log probabilities of tokens conditioned on log softmax of previously generated tokens Tuple of
`torch.FloatTensor` with up to `max_new_tokens` elements (one element for each generated token), with
each tensor of shape `(batch_size*num_beams, config.vocab_size)`.
beam_indices (`torch.LongTensor`, *optional*):
Beam indices of generated token id at each generation step. `torch.LongTensor` of shape
`(batch_size*num_return_sequences, sequence_length)`. Only required if a `num_beams>1` at
generate-time.
normalize_logits (`bool`, *optional*, defaults to `False`):
Whether to normalize the logits (which, for legacy reasons, may be unnormalized).
Return:
`torch.Tensor`: A `torch.Tensor` of shape `(batch_size*num_return_sequences, sequence_length)` containing
the transition scores (logits)
Examples:
```python
>>> from transformers import GPT2Tokenizer, AutoModelForCausalLM
>>> import numpy as np
>>> tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("gpt2")
>>> tokenizer.pad_token_id = tokenizer.eos_token_id
>>> inputs = tokenizer(["Today is"], return_tensors="pt")
>>> # Example 1: Print the scores for each token generated with Greedy Search
>>> outputs = model.generate(**inputs, max_new_tokens=5, return_dict_in_generate=True, output_scores=True)
>>> transition_scores = model.compute_transition_scores(
... outputs.sequences, outputs.scores, normalize_logits=True
... )
>>> # input_length is the length of the input prompt for decoder-only models, like the GPT family, and 1 for
>>> # encoder-decoder models, like BART or T5.
>>> input_length = 1 if model.config.is_encoder_decoder else inputs.input_ids.shape[1]
>>> generated_tokens = outputs.sequences[:, input_length:]
>>> for tok, score in zip(generated_tokens[0], transition_scores[0]):
... # | token | token string | logits | probability
... print(f"| {tok:5d} | {tokenizer.decode(tok):8s} | {score.numpy():.3f} | {np.exp(score.numpy()):.2%}")
| 262 | the | -1.414 | 24.33%
| 1110 | day | -2.609 | 7.36%
| 618 | when | -2.010 | 13.40%
| 356 | we | -1.859 | 15.58%
| 460 | can | -2.508 | 8.14%
>>> # Example 2: Reconstruct the sequence scores from Beam Search
>>> outputs = model.generate(
... **inputs,
... max_new_tokens=5,
... num_beams=4,
... num_return_sequences=4,
... return_dict_in_generate=True,
... output_scores=True,
... )
>>> transition_scores = model.compute_transition_scores(
... outputs.sequences, outputs.scores, outputs.beam_indices, normalize_logits=False
... )
>>> # If you sum the generated tokens' scores and apply the length penalty, you'll get the sequence scores.
>>> # Tip: recomputing the scores is only guaranteed to match with `normalize_logits=False`. Depending on the
>>> # use case, you might want to recompute it with `normalize_logits=True`.
>>> output_length = input_length + np.sum(transition_scores.numpy() < 0, axis=1)
>>> length_penalty = model.generation_config.length_penalty
>>> reconstructed_scores = transition_scores.sum(axis=1) / (output_length**length_penalty)
>>> print(np.allclose(outputs.sequences_scores, reconstructed_scores))
True
```"""
# 1. In absence of `beam_indices`, we can assume that we come from e.g. greedy search, which is equivalent
# to a beam search approach were the first (and only) beam is always selected
if beam_indices is None:
beam_indices = torch.arange(scores[0].shape[0]).view(-1, 1).to(sequences.device)
beam_indices = beam_indices.expand(-1, len(scores))
# 2. reshape scores as [batch_size*vocab_size, # generation steps] with # generation steps being
# seq_len - input_length
scores = torch.stack(scores).reshape(len(scores), -1).transpose(0, 1)
# 3. Optionally normalize the logits (across the vocab dimension)
if normalize_logits:
scores = scores.reshape(-1, self.config.vocab_size, scores.shape[-1])
scores = torch.nn.functional.log_softmax(scores, dim=1)
scores = scores.reshape(-1, scores.shape[-1])
# 4. cut beam_indices to longest beam length
beam_indices_mask = beam_indices < 0
max_beam_length = (1 - beam_indices_mask.long()).sum(-1).max()
beam_indices = beam_indices.clone()[:, :max_beam_length]
beam_indices_mask = beam_indices_mask[:, :max_beam_length]
# 5. Set indices of beams that finished early to 0; such indices will be masked correctly afterwards
beam_indices[beam_indices_mask] = 0
# 6. multiply beam_indices with vocab size to gather correctly from scores
beam_sequence_indices = beam_indices * self.config.vocab_size
# 7. Define which indices contributed to scores
cut_idx = sequences.shape[-1] - max_beam_length
indices = sequences[:, cut_idx:] + beam_sequence_indices
# 8. Compute scores
transition_scores = scores.gather(0, indices)
# 9. Mask out transition_scores of beams that stopped early
transition_scores[beam_indices_mask] = 0
return transition_scores
def _validate_model_class(self):
"""
Confirms that the model class is compatible with generation. If not, raises an exception that points to the
right class to use.
"""
if not self.can_generate():
generate_compatible_mappings = [
MODEL_FOR_CAUSAL_LM_MAPPING,
MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
MODEL_FOR_VISION_2_SEQ_MAPPING,
MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
]
generate_compatible_classes = set()
for model_mapping in generate_compatible_mappings:
supported_models = model_mapping.get(type(self.config), default=None)
if supported_models is not None:
generate_compatible_classes.add(supported_models.__name__)
exception_message = (
f"The current model class ({self.__class__.__name__}) is not compatible with `.generate()`, as "
"it doesn't have a language model head."
)
if generate_compatible_classes:
exception_message += f" Please use one of the following classes instead: {generate_compatible_classes}"
raise TypeError(exception_message)
def _validate_model_kwargs(self, model_kwargs: Dict[str, Any]):
"""Validates model kwargs for generation. Generate argument typos will also be caught here."""
# Excludes arguments that are handled before calling any model function
if self.config.is_encoder_decoder:
for key in ["decoder_input_ids"]:
model_kwargs.pop(key, None)
unused_model_args = []
model_args = set(inspect.signature(self.prepare_inputs_for_generation).parameters)
# `kwargs`/`model_kwargs` is often used to handle optional forward pass inputs like `attention_mask`. If
# `prepare_inputs_for_generation` doesn't accept them, then a stricter check can be made ;)
if "kwargs" in model_args or "model_kwargs" in model_args:
model_args |= set(inspect.signature(self.forward).parameters)
# Encoder-Decoder models may also need Encoder arguments from `model_kwargs`
if self.config.is_encoder_decoder:
base_model = getattr(self, self.base_model_prefix, None)
# allow encoder kwargs
encoder = getattr(self, "encoder", None)
# `MusicgenForConditionalGeneration` has `text_encoder` and `audio_encoder`.
# Also, it has `base_model_prefix = "encoder_decoder"` but there is no `self.encoder_decoder`
# TODO: A better way to handle this.
if encoder is None and base_model is not None:
encoder = getattr(base_model, "encoder", None)
if encoder is not None:
encoder_model_args = set(inspect.signature(encoder.forward).parameters)
model_args |= encoder_model_args
# allow decoder kwargs
decoder = getattr(self, "decoder", None)
if decoder is None and base_model is not None:
decoder = getattr(base_model, "decoder", None)
if decoder is not None:
decoder_model_args = set(inspect.signature(decoder.forward).parameters)
model_args |= {f"decoder_{x}" for x in decoder_model_args}
for key, value in model_kwargs.items():
if value is not None and key not in model_args:
unused_model_args.append(key)
if unused_model_args:
raise ValueError(
f"The following `model_kwargs` are not used by the model: {unused_model_args} (note: typos in the"
" generate arguments will also show up in this list)"
)
def _validate_generated_length(self, generation_config, input_ids_length, has_default_max_length):
"""Performs validation related to the resulting generated length"""
# 1. Max length warnings related to poor parameterization
if has_default_max_length and generation_config.max_new_tokens is None and generation_config.max_length == 20:
# 20 is the default max_length of the generation config
warnings.warn(
f"Using the model-agnostic default `max_length` (={generation_config.max_length}) to control the"
"generation length. We recommend setting `max_new_tokens` to control the maximum length of the "
"generation.",
UserWarning,
)
if input_ids_length >= generation_config.max_length:
input_ids_string = "decoder_input_ids" if self.config.is_encoder_decoder else "input_ids"
warnings.warn(
f"Input length of {input_ids_string} is {input_ids_length}, but `max_length` is set to"
f" {generation_config.max_length}. This can lead to unexpected behavior. You should consider"
" increasing `max_new_tokens`.",
UserWarning,
)
# 2. Min length warnings due to unfeasible parameter combinations
min_length_error_suffix = (
" Generation will stop at the defined maximum length. You should decrease the minimum length and/or "
"increase the maximum length."
)
if has_default_max_length:
min_length_error_suffix += (
f" Note that `max_length` is set to {generation_config.max_length}, its default value."
)
if generation_config.min_length is not None and generation_config.min_length > generation_config.max_length:
warnings.warn(
f"Unfeasible length constraints: `min_length` ({generation_config.min_length}) is larger than"
f" the maximum possible length ({generation_config.max_length})." + min_length_error_suffix,
UserWarning,
)
if generation_config.min_new_tokens is not None:
min_length = generation_config.min_new_tokens + input_ids_length
if min_length > generation_config.max_length:
warnings.warn(
f"Unfeasible length constraints: `min_new_tokens` ({generation_config.min_new_tokens}), when "
f"added to the prompt length ({input_ids_length}), is larger than"
f" the maximum possible length ({generation_config.max_length})." + min_length_error_suffix,
UserWarning,
)
@torch.no_grad()
def generate(
self,
inputs: Optional[torch.Tensor] = None,
generation_config: Optional[GenerationConfig] = None,
logits_processor: Optional[LogitsProcessorList] = None,
stopping_criteria: Optional[StoppingCriteriaList] = None,
prefix_allowed_tokens_fn: Optional[Callable[[int, torch.Tensor], List[int]]] = None,
synced_gpus: Optional[bool] = None,
assistant_model: Optional["PreTrainedModel"] = None,
streamer: Optional["BaseStreamer"] = None,
deepspeed_model: Optional[DeepSpeedEngine] = None,
negative_prompt_ids: Optional[torch.Tensor] = None,
negative_prompt_attention_mask: Optional[torch.Tensor] = None,
**kwargs,
) -> Union[GenerateOutput, torch.LongTensor]:
r"""
Generates sequences of token ids for models with a language modeling head.
Most generation-controlling parameters are set in `generation_config` which, if not passed, will be set to the
model's default generation configuration. You can override any `generation_config` by passing the corresponding
parameters to generate(), e.g. `.generate(inputs, num_beams=4, do_sample=True)`.
For an overview of generation strategies and code examples, check out the [following
guide](../generation_strategies).
Parameters:
inputs (`torch.Tensor` of varying shape depending on the modality, *optional*):
The sequence used as a prompt for the generation or as model inputs to the encoder. If `None` the
method initializes it with `bos_token_id` and a batch size of 1. For decoder-only models `inputs`
should of in the format of `input_ids`. For encoder-decoder models *inputs* can represent any of
`input_ids`, `input_values`, `input_features`, or `pixel_values`.
generation_config (`~generation.GenerationConfig`, *optional*):
The generation configuration to be used as base parametrization for the generation call. `**kwargs`
passed to generate matching the attributes of `generation_config` will override them. If
`generation_config` is not provided, the default will be used, which had the following loading
priority: 1) from the `generation_config.json` model file, if it exists; 2) from the model
configuration. Please note that unspecified parameters will inherit [`~generation.GenerationConfig`]'s
default values, whose documentation should be checked to parameterize generation.
logits_processor (`LogitsProcessorList`, *optional*):
Custom logits processors that complement the default logits processors built from arguments and
generation config. If a logit processor is passed that is already created with the arguments or a
generation config an error is thrown. This feature is intended for advanced users.
stopping_criteria (`StoppingCriteriaList`, *optional*):
Custom stopping criteria that complement the default stopping criteria built from arguments and a
generation config. If a stopping criteria is passed that is already created with the arguments or a
generation config an error is thrown. This feature is intended for advanced users.
prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], List[int]]`, *optional*):
If provided, this function constraints the beam search to allowed tokens only at each step. If not
provided no constraint is applied. This function takes 2 arguments: the batch ID `batch_id` and
`input_ids`. It has to return a list with the allowed tokens for the next generation step conditioned
on the batch ID `batch_id` and the previously generated tokens `inputs_ids`. This argument is useful
for constrained generation conditioned on the prefix, as described in [Autoregressive Entity
Retrieval](https://arxiv.org/abs/2010.00904).
synced_gpus (`bool`, *optional*):
Whether to continue running the while loop until max_length. Unless overridden this flag will be set to
`True` under DeepSpeed ZeRO Stage 3 multiple GPUs environment to avoid hanging if one GPU finished
generating before other GPUs. Otherwise it'll be set to `False`.
assistant_model (`PreTrainedModel`, *optional*):
An assistant model that can be used to accelerate generation. The assistant model must have the exact
same tokenizer. The acceleration is achieved when forecasting candidate tokens with the assistent model
is much faster than running generation with the model you're calling generate from. As such, the
assistant model should be much smaller.
streamer (`BaseStreamer`, *optional*):
Streamer object that will be used to stream the generated sequences. Generated tokens are passed
through `streamer.put(token_ids)` and the streamer is responsible for any further processing.
negative_prompt_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
The negative prompt needed for some processors such as CFG. The batch size must match the input batch
size. This is an experimental feature, subject to breaking API changes in future versions.
negative_prompt_attention_mask (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
Attention_mask for `negative_prompt_ids`.
kwargs (`Dict[str, Any]`, *optional*):
Ad hoc parametrization of `generate_config` and/or additional model-specific kwargs that will be
forwarded to the `forward` function of the model. If the model is an encoder-decoder model, encoder
specific kwargs should not be prefixed and decoder specific kwargs should be prefixed with *decoder_*.
Return:
[`~utils.ModelOutput`] or `torch.LongTensor`: A [`~utils.ModelOutput`] (if `return_dict_in_generate=True`
or when `config.return_dict_in_generate=True`) or a `torch.FloatTensor`.
If the model is *not* an encoder-decoder model (`model.config.is_encoder_decoder=False`), the possible
[`~utils.ModelOutput`] types are:
- [`~generation.GreedySearchDecoderOnlyOutput`],
- [`~generation.SampleDecoderOnlyOutput`],
- [`~generation.BeamSearchDecoderOnlyOutput`],
- [`~generation.BeamSampleDecoderOnlyOutput`]
If the model is an encoder-decoder model (`model.config.is_encoder_decoder=True`), the possible
[`~utils.ModelOutput`] types are:
- [`~generation.GreedySearchEncoderDecoderOutput`],
- [`~generation.SampleEncoderDecoderOutput`],
- [`~generation.BeamSearchEncoderDecoderOutput`],
- [`~generation.BeamSampleEncoderDecoderOutput`]
"""
if synced_gpus is None:
if is_deepspeed_zero3_enabled() and dist.get_world_size() > 1:
synced_gpus = True
else:
synced_gpus = False
# 1. Handle `generation_config` and kwargs that might update it, and validate the `.generate()` call
self._validate_model_class()
# priority: `generation_config` argument > `model.generation_config` (the default generation config)
if generation_config is None:
# legacy: users may modify the model configuration to control generation -- update the generation config
# model attribute accordingly, if it was created from the model config
if self.generation_config._from_model_config:
new_generation_config = GenerationConfig.from_model_config(self.config)
if new_generation_config != self.generation_config:
warnings.warn(
"You have modified the pretrained model configuration to control generation. This is a"
" deprecated strategy to control generation and will be removed soon, in a future version."
" Please use a generation configuration file (see"
" https://huggingface.co/docs/transformers/main_classes/text_generation )"
)
self.generation_config = new_generation_config
generation_config = self.generation_config
generation_config = copy.deepcopy(generation_config)
model_kwargs = generation_config.update(**kwargs) # All unused kwargs must be model kwargs
generation_config.validate()
self._validate_model_kwargs(model_kwargs.copy())
if deepspeed_model is not None:
model_kwargs["deepspeed_model"] = deepspeed_model
# 2. Set generation parameters if not already defined
logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
if generation_config.pad_token_id is None and generation_config.eos_token_id is not None:
if model_kwargs.get("attention_mask", None) is None:
logger.warning(
"The attention mask and the pad token id were not set. As a consequence, you may observe "
"unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results."
)
eos_token_id = generation_config.eos_token_id
if isinstance(eos_token_id, list):
eos_token_id = eos_token_id[0]
logger.warning(f"Setting `pad_token_id` to `eos_token_id`:{eos_token_id} for open-end generation.")
generation_config.pad_token_id = eos_token_id
# 3. Define model inputs
# inputs_tensor has to be defined
# model_input_name is defined if model-specific keyword input is passed
# otherwise model_input_name is None
# all model-specific keyword inputs are removed from `model_kwargs`
inputs_tensor, model_input_name, model_kwargs = self._prepare_model_inputs(
inputs, generation_config.bos_token_id, model_kwargs
)
batch_size = inputs_tensor.shape[0]
# 4. Define other model kwargs
model_kwargs["output_attentions"] = generation_config.output_attentions
model_kwargs["output_hidden_states"] = generation_config.output_hidden_states
# decoder-only models with inputs_embeds forwarding must use caching (otherwise we can't detect whether we are
# generating the first new token or not, and we only want to use the embeddings for the first new token)
if not self.config.is_encoder_decoder and model_input_name == "inputs_embeds":
model_kwargs["use_cache"] = True
else:
model_kwargs["use_cache"] = generation_config.use_cache
accepts_attention_mask = "attention_mask" in set(inspect.signature(self.forward).parameters.keys())
requires_attention_mask = "encoder_outputs" not in model_kwargs
if model_kwargs.get("attention_mask", None) is None and requires_attention_mask and accepts_attention_mask:
model_kwargs["attention_mask"] = self._prepare_attention_mask_for_generation(
inputs_tensor, generation_config.pad_token_id, generation_config.eos_token_id
)
# decoder-only models should use left-padding for generation
if not self.config.is_encoder_decoder:
# If `input_ids` was given, check if the last id in any sequence is `pad_token_id`
# Note: If using, `inputs_embeds` this check does not work, because we want to be more hands-off.
if (
generation_config.pad_token_id is not None
and len(inputs_tensor.shape) == 2
and torch.sum(inputs_tensor[:, -1] == generation_config.pad_token_id) > 0
):
logger.warning(
"A decoder-only architecture is being used, but right-padding was detected! For correct "
"generation results, please set `padding_side='left'` when initializing the tokenizer."
)
if self.config.is_encoder_decoder and "encoder_outputs" not in model_kwargs:
# if model is encoder decoder encoder_outputs are created
# and added to `model_kwargs`
model_kwargs = self._prepare_encoder_decoder_kwargs_for_generation(
inputs_tensor, model_kwargs, model_input_name
)
# 5. Prepare `input_ids` which will be used for auto-regressive generation
if self.config.is_encoder_decoder:
input_ids, model_kwargs = self._prepare_decoder_input_ids_for_generation(
batch_size=batch_size,
model_input_name=model_input_name,
model_kwargs=model_kwargs,
decoder_start_token_id=generation_config.decoder_start_token_id,
bos_token_id=generation_config.bos_token_id,
device=inputs_tensor.device,
)
else:
input_ids = inputs_tensor if model_input_name == "input_ids" else model_kwargs.pop("input_ids")
if streamer is not None:
streamer.put(input_ids.cpu())
# 6. Prepare `max_length` depending on other stopping criteria.
input_ids_length = input_ids.shape[-1]
has_default_max_length = kwargs.get("max_length") is None and generation_config.max_length is not None
if generation_config.max_new_tokens is not None:
if not has_default_max_length:
logger.warning(
f"Both `max_new_tokens` (={generation_config.max_new_tokens}) and `max_length`(="
f"{generation_config.max_length}) seem to have been set. `max_new_tokens` will take precedence. "
"Please refer to the documentation for more information. "
"(https://huggingface.co/docs/transformers/main/en/main_classes/text_generation)"
)
generation_config.max_length = generation_config.max_new_tokens + input_ids_length
self._validate_generated_length(generation_config, input_ids_length, has_default_max_length)
# 7. determine generation mode
generation_mode = self._get_generation_mode(generation_config, assistant_model)
if streamer is not None and (generation_config.num_beams > 1):
raise ValueError(
"`streamer` cannot be used with beam search (yet!). Make sure that `num_beams` is set to 1."
)
if self.device.type != input_ids.device.type:
warnings.warn(
"You are calling .generate() with the `input_ids` being on a device type different"
f" than your model's device. `input_ids` is on {input_ids.device.type}, whereas the model"
f" is on {self.device.type}. You may experience unexpected behaviors or slower generation."
" Please make sure that you have put `input_ids` to the"
f" correct device by calling for example input_ids = input_ids.to('{self.device.type}') before"
" running `.generate()`.",
UserWarning,
)
# 8. prepare distribution pre_processing samplers
logits_processor = self._get_logits_processor(
generation_config=generation_config,
input_ids_seq_length=input_ids_length,
encoder_input_ids=inputs_tensor,
prefix_allowed_tokens_fn=prefix_allowed_tokens_fn,
logits_processor=logits_processor,
model_kwargs=model_kwargs,
negative_prompt_ids=negative_prompt_ids,
negative_prompt_attention_mask=negative_prompt_attention_mask,
)
# 9. prepare stopping criteria
stopping_criteria = self._get_stopping_criteria(
generation_config=generation_config, stopping_criteria=stopping_criteria
)
# 10. go into different generation modes
if generation_mode == GenerationMode.ASSISTED_GENERATION:
if generation_config.num_return_sequences > 1:
raise ValueError(
"num_return_sequences has to be 1 when doing assisted generate, "
f"but is {generation_config.num_return_sequences}."
)
if batch_size > 1:
raise ValueError("assisted generate is only supported for batch_size = 1")
if not model_kwargs["use_cache"]:
raise ValueError("assisted generate requires `use_cache=True`")
# 11. If the assistant model is an encoder-decoder, prepare its encoder outputs
if assistant_model.config.is_encoder_decoder:
assistant_model_kwargs = copy.deepcopy(model_kwargs)
inputs_tensor, model_input_name, assistant_model_kwargs = assistant_model._prepare_model_inputs(
inputs_tensor, assistant_model.generation_config.bos_token_id, assistant_model_kwargs
)
assistant_model_kwargs = assistant_model._prepare_encoder_decoder_kwargs_for_generation(
inputs_tensor, assistant_model_kwargs, model_input_name
)
model_kwargs["assistant_encoder_outputs"] = assistant_model_kwargs["encoder_outputs"]
# 12. run assisted generate
return self.assisted_decoding(
input_ids,
assistant_model=assistant_model,
do_sample=generation_config.do_sample,
logits_processor=logits_processor,
logits_warper=self._get_logits_warper(generation_config) if generation_config.do_sample else None,
stopping_criteria=stopping_criteria,
pad_token_id=generation_config.pad_token_id,
eos_token_id=generation_config.eos_token_id,
output_scores=generation_config.output_scores,
return_dict_in_generate=generation_config.return_dict_in_generate,
synced_gpus=synced_gpus,
streamer=streamer,
**model_kwargs,
)
if generation_mode == GenerationMode.GREEDY_SEARCH:
# 11. run greedy search
return self.greedy_search(
input_ids,
logits_processor=logits_processor,
stopping_criteria=stopping_criteria,
pad_token_id=generation_config.pad_token_id,
eos_token_id=generation_config.eos_token_id,
output_scores=generation_config.output_scores,
return_dict_in_generate=generation_config.return_dict_in_generate,
synced_gpus=synced_gpus,
streamer=streamer,
**model_kwargs,
)
elif generation_mode == GenerationMode.CONTRASTIVE_SEARCH:
if not model_kwargs["use_cache"]:
raise ValueError("Contrastive search requires `use_cache=True`")
return self.contrastive_search(
input_ids,
top_k=generation_config.top_k,
penalty_alpha=generation_config.penalty_alpha,
logits_processor=logits_processor,
stopping_criteria=stopping_criteria,
pad_token_id=generation_config.pad_token_id,
eos_token_id=generation_config.eos_token_id,
output_scores=generation_config.output_scores,
return_dict_in_generate=generation_config.return_dict_in_generate,
synced_gpus=synced_gpus,
streamer=streamer,
sequential=generation_config.low_memory,
**model_kwargs,
)
elif generation_mode == GenerationMode.SAMPLE:
# 11. prepare logits warper
logits_warper = self._get_logits_warper(generation_config)
# 12. expand input_ids with `num_return_sequences` additional sequences per batch
input_ids, model_kwargs = self._expand_inputs_for_generation(
input_ids=input_ids,
expand_size=generation_config.num_return_sequences,
is_encoder_decoder=self.config.is_encoder_decoder,
**model_kwargs,
)
# 13. run sample
return self.sample(
input_ids,
logits_processor=logits_processor,
logits_warper=logits_warper,
stopping_criteria=stopping_criteria,
pad_token_id=generation_config.pad_token_id,
eos_token_id=generation_config.eos_token_id,
output_scores=generation_config.output_scores,
return_dict_in_generate=generation_config.return_dict_in_generate,
synced_gpus=synced_gpus,
streamer=streamer,
**model_kwargs,
)
elif generation_mode == GenerationMode.BEAM_SEARCH:
# 11. prepare beam search scorer
beam_scorer = BeamSearchScorer(
batch_size=batch_size,
num_beams=generation_config.num_beams,
device=inputs_tensor.device,
length_penalty=generation_config.length_penalty,
do_early_stopping=generation_config.early_stopping,
num_beam_hyps_to_keep=generation_config.num_return_sequences,
max_length=generation_config.max_length,
)
# 12. interleave input_ids with `num_beams` additional sequences per batch
input_ids, model_kwargs = self._expand_inputs_for_generation(
input_ids=input_ids,
expand_size=generation_config.num_beams,
is_encoder_decoder=self.config.is_encoder_decoder,
**model_kwargs,
)
# 13. run beam search
return self.beam_search(
input_ids,
beam_scorer,
logits_processor=logits_processor,
stopping_criteria=stopping_criteria,
pad_token_id=generation_config.pad_token_id,
eos_token_id=generation_config.eos_token_id,
output_scores=generation_config.output_scores,
return_dict_in_generate=generation_config.return_dict_in_generate,
synced_gpus=synced_gpus,
**model_kwargs,
)
elif generation_mode == GenerationMode.BEAM_SAMPLE:
# 11. prepare logits warper
logits_warper = self._get_logits_warper(generation_config)
# 12. prepare beam search scorer
beam_scorer = BeamSearchScorer(
batch_size=batch_size,
num_beams=generation_config.num_beams,
device=inputs_tensor.device,
length_penalty=generation_config.length_penalty,
do_early_stopping=generation_config.early_stopping,
num_beam_hyps_to_keep=generation_config.num_return_sequences,
max_length=generation_config.max_length,
)
# 13. interleave input_ids with `num_beams` additional sequences per batch
input_ids, model_kwargs = self._expand_inputs_for_generation(
input_ids=input_ids,
expand_size=generation_config.num_beams,
is_encoder_decoder=self.config.is_encoder_decoder,
**model_kwargs,
)
# 14. run beam sample
return self.beam_sample(
input_ids,
beam_scorer,
logits_processor=logits_processor,
logits_warper=logits_warper,
stopping_criteria=stopping_criteria,
pad_token_id=generation_config.pad_token_id,
eos_token_id=generation_config.eos_token_id,
output_scores=generation_config.output_scores,
return_dict_in_generate=generation_config.return_dict_in_generate,
synced_gpus=synced_gpus,
**model_kwargs,
)
elif generation_mode == GenerationMode.GROUP_BEAM_SEARCH:
# 11. prepare beam search scorer
beam_scorer = BeamSearchScorer(
batch_size=batch_size,
num_beams=generation_config.num_beams,
device=inputs_tensor.device,
length_penalty=generation_config.length_penalty,
do_early_stopping=generation_config.early_stopping,
num_beam_hyps_to_keep=generation_config.num_return_sequences,
num_beam_groups=generation_config.num_beam_groups,
max_length=generation_config.max_length,
)
# 12. interleave input_ids with `num_beams` additional sequences per batch
input_ids, model_kwargs = self._expand_inputs_for_generation(
input_ids=input_ids,
expand_size=generation_config.num_beams,
is_encoder_decoder=self.config.is_encoder_decoder,
**model_kwargs,
)
# 13. run beam search
return self.group_beam_search(
input_ids,
beam_scorer,
logits_processor=logits_processor,
stopping_criteria=stopping_criteria,
pad_token_id=generation_config.pad_token_id,
eos_token_id=generation_config.eos_token_id,
output_scores=generation_config.output_scores,
return_dict_in_generate=generation_config.return_dict_in_generate,
synced_gpus=synced_gpus,
**model_kwargs,
)
elif generation_mode == GenerationMode.CONSTRAINED_BEAM_SEARCH:
final_constraints = []
if generation_config.constraints is not None:
final_constraints = generation_config.constraints
if generation_config.force_words_ids is not None:
def typeerror():
raise ValueError(
"`force_words_ids` has to either be a `List[List[List[int]]]` or `List[List[int]]`"
f"of positive integers, but is {generation_config.force_words_ids}."
)
if (
not isinstance(generation_config.force_words_ids, list)
or len(generation_config.force_words_ids) == 0
):
typeerror()
for word_ids in generation_config.force_words_ids:
if isinstance(word_ids[0], list):
if not isinstance(word_ids, list) or len(word_ids) == 0:
typeerror()
if any(not isinstance(token_ids, list) for token_ids in word_ids):
typeerror()
if any(
any((not isinstance(token_id, int) or token_id < 0) for token_id in token_ids)
for token_ids in word_ids
):
typeerror()
constraint = DisjunctiveConstraint(word_ids)
else:
if not isinstance(word_ids, list) or len(word_ids) == 0:
typeerror()
if any((not isinstance(token_id, int) or token_id < 0) for token_id in word_ids):
typeerror()
constraint = PhrasalConstraint(word_ids)
final_constraints.append(constraint)
# 11. prepare beam search scorer
constrained_beam_scorer = ConstrainedBeamSearchScorer(
constraints=final_constraints,
batch_size=batch_size,
num_beams=generation_config.num_beams,
device=inputs_tensor.device,
length_penalty=generation_config.length_penalty,
do_early_stopping=generation_config.early_stopping,
num_beam_hyps_to_keep=generation_config.num_return_sequences,
max_length=generation_config.max_length,
)
# 12. interleave input_ids with `num_beams` additional sequences per batch
input_ids, model_kwargs = self._expand_inputs_for_generation(
input_ids=input_ids,
expand_size=generation_config.num_beams,
is_encoder_decoder=self.config.is_encoder_decoder,
**model_kwargs,
)
# 13. run beam search
return self.constrained_beam_search(
input_ids,
constrained_beam_scorer=constrained_beam_scorer,
logits_processor=logits_processor,
stopping_criteria=stopping_criteria,
pad_token_id=generation_config.pad_token_id,
eos_token_id=generation_config.eos_token_id,
output_scores=generation_config.output_scores,
return_dict_in_generate=generation_config.return_dict_in_generate,
synced_gpus=synced_gpus,
**model_kwargs,
)
@torch.no_grad()
def contrastive_search(
self,
input_ids: torch.LongTensor,
top_k: Optional[int] = 1,
penalty_alpha: Optional[float] = 0,
logits_processor: Optional[LogitsProcessorList] = None,
logits_warper: Optional[LogitsProcessorList] = None,
stopping_criteria: Optional[StoppingCriteriaList] = None,
pad_token_id: Optional[int] = None,
eos_token_id: Optional[Union[int, List[int]]] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
output_scores: Optional[bool] = None,
return_dict_in_generate: Optional[bool] = None,
synced_gpus: bool = False,
streamer: Optional["BaseStreamer"] = None,
sequential: Optional[bool] = None,
**model_kwargs,
) -> Union[ContrastiveSearchOutput, torch.LongTensor]:
r"""
Generates sequences of token ids for models with a language modeling head using **contrastive search** and can
be used for text-decoder, text-to-text, speech-to-text, and vision-to-text models.
In most cases, you do not need to call [`~generation.GenerationMixin.contrastive_search`] directly. Use
generate() instead. For an overview of generation strategies and code examples, check the [following
guide](../generation_strategies).
Parameters:
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
The sequence used as a prompt for the generation.
top_k (`int`, *optional*, defaults to 1):
The size of the candidate set that is used to re-rank for contrastive search
penalty_alpha (`float`, *optional*, defaults to 0):
The degeneration penalty for contrastive search; activate when it is larger than 0
logits_processor (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsProcessor`]
used to modify the prediction scores of the language modeling head applied at each generation step.
logits_warper (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsWarper`] used
to warp the prediction score distribution of the language modeling head applied before multinomial
sampling at each generation step.
stopping_criteria (`StoppingCriteriaList`, *optional*):
An instance of [`StoppingCriteriaList`]. List of instances of class derived from [`StoppingCriteria`]
used to tell if the generation loop should stop.
pad_token_id (`int`, *optional*):
The id of the *padding* token.
eos_token_id (`Union[int, List[int]]`, *optional*):
The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
output_attentions (`bool`, *optional*, defaults to `False`):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under
returned tensors for more details.
output_hidden_states (`bool`, *optional*, defaults to `False`):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
for more details.
output_scores (`bool`, *optional*, defaults to `False`):
Whether or not to return the prediction scores. See `scores` under returned tensors for more details.
return_dict_in_generate (`bool`, *optional*, defaults to `False`):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
synced_gpus (`bool`, *optional*, defaults to `False`):
Whether to continue running the while loop until max_length (needed for ZeRO stage 3)
streamer (`BaseStreamer`, *optional*):
Streamer object that will be used to stream the generated sequences. Generated tokens are passed
through `streamer.put(token_ids)` and the streamer is responsible for any further processing.
sequential (`bool`, *optional*):
Switches topk hidden state computation from parallel to sequential to reduce memory if True.
model_kwargs:
Additional model specific keyword arguments will be forwarded to the `forward` function of the model.
If model is an encoder-decoder model the kwargs should include `encoder_outputs`.
Return:
[`~generation.ContrastiveSearchDecoderOnlyOutput`], [`~generation.ContrastiveSearchEncoderDecoderOutput`]
or `torch.LongTensor`: A `torch.LongTensor` containing the generated tokens (default behaviour) or a
[`~generation.ContrastiveSearchDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and
`return_dict_in_generate=True` or a [`~generation.ContrastiveSearchEncoderDecoderOutput`] if
`model.config.is_encoder_decoder=True`.
Examples:
```python
>>> from transformers import (
... AutoTokenizer,
... AutoModelForCausalLM,
... StoppingCriteriaList,
... MaxLengthCriteria,
... )
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/opt-125m")
>>> model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
>>> # set pad_token_id to eos_token_id because OPT does not have a PAD token
>>> model.config.pad_token_id = model.config.eos_token_id
>>> input_prompt = "DeepMind Company is"
>>> input_ids = tokenizer(input_prompt, return_tensors="pt")
>>> stopping_criteria = StoppingCriteriaList([MaxLengthCriteria(max_length=64)])
>>> outputs = model.contrastive_search(
... **input_ids, penalty_alpha=0.6, top_k=4, stopping_criteria=stopping_criteria
... )
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['DeepMind Company is a company that focuses on the development and commercialization of artificial intelligence (AI). DeepMind’s mission is to help people understand and solve problems that are difficult to solve in the world today.\n\nIn this post, we talk about the benefits of deep learning in business and how it']
```"""
# init values
logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
logits_warper = logits_warper if logits_warper is not None else LogitsProcessorList()
stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
sequential = sequential if sequential is not None else self.generation_config.low_memory
if isinstance(eos_token_id, int):
eos_token_id = [eos_token_id]
eos_token_id_tensor = torch.tensor(eos_token_id).to(input_ids.device) if eos_token_id is not None else None
output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
output_attentions = (
output_attentions if output_attentions is not None else self.generation_config.output_attentions
)
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
)
return_dict_in_generate = (
return_dict_in_generate
if return_dict_in_generate is not None
else self.generation_config.return_dict_in_generate
)
# init attention / hidden states / scores tuples
scores = () if (return_dict_in_generate and output_scores) else None
decoder_attentions = () if (return_dict_in_generate and output_attentions) else None
cross_attentions = () if (return_dict_in_generate and output_attentions) else None
decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None
# if model is an encoder-decoder, retrieve encoder attention weights and hidden states
if return_dict_in_generate and self.config.is_encoder_decoder:
encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
encoder_hidden_states = (
model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
)
# keep track of which sequences are already finished
unfinished_sequences = torch.ones(input_ids.shape[0], dtype=torch.long, device=input_ids.device)
this_peer_finished = False # used by synced_gpus only
batch_size = input_ids.shape[0]
while True:
if synced_gpus:
# Under synced_gpus the `forward` call must continue until all gpus complete their sequence.
# The following logic allows an early break if all peers finished generating their sequence
this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)
# send 0.0 if we finished, 1.0 otherwise
dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)
# did all peers finish? the reduced sum will be 0.0 then
if this_peer_finished_flag.item() == 0.0:
break
# if the first step in the loop, encode all the prefix and obtain: (1) past_key_values;
# (2) last_hidden_states; (3) logit_for_next_step; (4) update model kwargs for the next step
if model_kwargs.get("past_key_values") is None:
# prepare inputs
model_kwargs["use_cache"] = True
model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
# encode the given prefix and prepare model inputs; encoder-decoder model process the prefix and save
# the `encoder_outputs`
model = model_kwargs.get("deepspeed_model", self)
outputs = model(
**model_inputs, return_dict=True, output_hidden_states=True, output_attentions=output_attentions
)
# last decoder hidden states will be used to compute the degeneration penalty (cosine similarity with
# previous tokens)
if self.config.is_encoder_decoder:
last_hidden_states = outputs.decoder_hidden_states[-1]
else:
last_hidden_states = outputs.hidden_states[-1]
# next logit for contrastive search to select top-k candidate tokens
logit_for_next_step = outputs.logits[:, -1, :]
model_kwargs = self._update_model_kwargs_for_generation(
outputs,
model_kwargs,
is_encoder_decoder=self.config.is_encoder_decoder,
standardize_cache_format=True,
)
if not sequential:
# Expands model inputs top_k times, for batched forward passes (akin to beam search).
_, model_kwargs = self._expand_inputs_for_generation(
expand_size=top_k, is_encoder_decoder=self.config.is_encoder_decoder, **model_kwargs
)
past_key_values = model_kwargs.get("past_key_values")
if past_key_values is None:
raise ValueError(
f"{self.__class__.__name__} does not support caching and therefore **can't** be used "
"for contrastive search."
)
elif (
not isinstance(past_key_values[0], (tuple, torch.Tensor))
or past_key_values[0][0].shape[0] != batch_size
):
raise ValueError(
f"{self.__class__.__name__} does not have a standard cache format and therefore **can't** be "
"used for contrastive search without further modifications."
)
# contrastive_search main logic start:
# contrastive search decoding consists of two steps: (1) candidate tokens recall; (2) candidate re-rank by
# degeneration penalty
logit_for_next_step = logits_processor(input_ids, logit_for_next_step)
logit_for_next_step = logits_warper(input_ids, logit_for_next_step)
next_probs = nn.functional.softmax(logit_for_next_step, dim=-1)
top_k_probs, top_k_ids = torch.topk(next_probs, dim=-1, k=top_k)
# Store scores, attentions and hidden_states when required
if return_dict_in_generate:
if output_scores:
scores += (logit_for_next_step,)
if output_attentions:
decoder_attentions += (
(outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)
)
if self.config.is_encoder_decoder:
cross_attentions += (outputs.cross_attentions,)
if output_hidden_states:
decoder_hidden_states += (
(outputs.decoder_hidden_states,)
if self.config.is_encoder_decoder
else (outputs.hidden_states,)
)
# Replicates the new past_key_values to match the `top_k` candidates
new_key_values = []
for layer in model_kwargs["past_key_values"]:
items = []
# item is either the key or the value matrix
for item in layer:
if sequential:
items.append(item.repeat_interleave(1, dim=0))
else:
items.append(item.repeat_interleave(top_k, dim=0))
new_key_values.append(items)
model_kwargs["past_key_values"] = new_key_values
if sequential:
all_outputs = {key: [] for key in outputs} # defined in first loop iteration
all_last_hstates, all_hstates, all_logits = [], [], []
for i in range(top_k):
# compute the candidate tokens by the language model and collect their hidden_states
next_model_inputs = self.prepare_inputs_for_generation(top_k_ids[:, i].view(-1, 1), **model_kwargs)
model = model_kwargs.get("deepspeed_model", self)
outputs = model(
**next_model_inputs,
return_dict=True,
output_hidden_states=True,
output_attentions=output_attentions,
)
for key in all_outputs:
all_outputs[key].append(outputs[key])
if self.config.is_encoder_decoder:
next_hidden = outputs.decoder_hidden_states[-1]
full_hidden_states = outputs.decoder_hidden_states
else:
next_hidden = outputs.hidden_states[-1]
full_hidden_states = outputs.hidden_states
all_last_hstates.append(torch.squeeze(next_hidden, 0))
all_hstates.append(full_hidden_states)
all_logits.append(outputs.logits[:, -1, :])
# stack hidden states
next_hidden = torch.stack([all_last_hstates[i] for i in range(top_k)], dim=0)
final_full_hstates = [0 for i in range(len(full_hidden_states))]
for layer in range(len(full_hidden_states)):
final_full_hstates[layer] = torch.stack(
[torch.squeeze(all_hstates[i][layer], 0) for i in range(top_k)], dim=0
)
full_hidden_states = tuple(final_full_hstates)
# stack logits
logits = torch.cat(all_logits, dim=0)
else:
# compute the candidate tokens by the language model and collect their hidden_states
# assembles top_k_ids into batch of size k
next_model_inputs = self.prepare_inputs_for_generation(top_k_ids.view(-1, 1), **model_kwargs)
model = model_kwargs.get("deepspeed_model", self)
outputs = model(
**next_model_inputs,
return_dict=True,
output_hidden_states=True,
output_attentions=output_attentions,
)
# name is different for encoder-decoder and decoder-only models
if self.config.is_encoder_decoder:
next_hidden = outputs.decoder_hidden_states[-1]
full_hidden_states = outputs.decoder_hidden_states
else:
next_hidden = outputs.hidden_states[-1]
full_hidden_states = outputs.hidden_states
logits = outputs.logits[:, -1, :]
context_hidden = last_hidden_states.repeat_interleave(top_k, dim=0)
# compute the degeneration penalty and re-rank the candidates based on the degeneration penalty and the
# model confidence. Keeping `selected_idx` on CPU enables multi-device contrastive search and doesn't
# introduce (noticeable) slowdowns on single-device runs.
selected_idx = _ranking_fast(context_hidden, next_hidden, top_k_probs, penalty_alpha, top_k)
selected_idx = selected_idx.to("cpu")
# prepare for the next step: (1) next token_id; (2) past_key_values; (3) last_hidden_states for computing
# the degeneration penalty; (4) logits for selecting next top-k candidates; (5) selected tokens scores
# (model confidence minus degeneration penalty); (6) decoder hidden_states
next_tokens = top_k_ids[range(len(top_k_ids)), selected_idx]
next_hidden = torch.stack(torch.split(next_hidden.squeeze(dim=1), top_k))
next_hidden = next_hidden[range(batch_size), selected_idx, :]
last_hidden_states = torch.cat([last_hidden_states, next_hidden.unsqueeze(1)], dim=1)
next_decoder_hidden_states = ()
for layer in full_hidden_states:
layer = torch.stack(torch.split(layer, top_k))[range(batch_size), selected_idx, :]
next_decoder_hidden_states += (layer,)
# generate past_key_values cache of only the selected token
if sequential:
next_model_input = self.prepare_inputs_for_generation(
top_k_ids[:, selected_idx].view(-1, 1), **model_kwargs
)
model = model_kwargs.get("deepspeed_model", self)
selected_outputs = model(
**next_model_input,
return_dict=True,
output_hidden_states=False,
output_attentions=False,
)
next_past_key_values = selected_outputs["past_key_values"]
else:
next_past_key_values = self._extract_past_from_model_output(outputs, standardize_cache_format=True)
new_key_values = ()
for layer in next_past_key_values:
items = ()
# item is either the key or the value matrix
for item in layer:
item = torch.stack(torch.split(item, top_k, dim=0)) # [B, K, num_head, seq_len, esz]
item = item[range(batch_size), selected_idx, ...] # [B, num_head, seq_len, esz]
items += (item,)
new_key_values += (items,)
next_past_key_values = new_key_values
logit_for_next_step = torch.stack(torch.split(logits, top_k))[range(batch_size), selected_idx, :]
# Rebuilds the relevant parts of the model output for the selected token, for use in the next iteration
if self.config.is_encoder_decoder:
next_step_cross_attentions = ()
next_step_decoder_attentions = ()
if output_attentions:
for layer in outputs.cross_attentions:
layer = torch.stack(torch.split(layer, top_k, dim=0))[range(batch_size), selected_idx, ...]
next_step_cross_attentions += (layer,)
for layer in outputs.decoder_attentions:
layer = torch.stack(torch.split(layer, top_k, dim=0))[range(batch_size), selected_idx, ...]
next_step_decoder_attentions += (layer,)
outputs = Seq2SeqLMOutput(
past_key_values=next_past_key_values,
decoder_hidden_states=next_decoder_hidden_states,
decoder_attentions=next_step_decoder_attentions or None,
cross_attentions=next_step_cross_attentions or None,
)
else:
next_step_attentions = ()
if output_attentions:
for layer in outputs.attentions:
layer = torch.stack(torch.split(layer, top_k, dim=0))[range(batch_size), selected_idx, ...]
next_step_attentions += (layer,)
outputs = CausalLMOutputWithPast(
past_key_values=next_past_key_values,
hidden_states=next_decoder_hidden_states,
attentions=next_step_attentions or None,
)
# contrastive_search main logic end
if synced_gpus and this_peer_finished:
continue # don't waste resources running the code we don't need
# finished sentences should have their next token be a padding token
if eos_token_id is not None:
if pad_token_id is None:
raise ValueError("If `eos_token_id` is defined, make sure that `pad_token_id` is defined.")
next_tokens = next_tokens * unfinished_sequences + pad_token_id * (1 - unfinished_sequences)
# update generated ids, model inputs, and length for next step
input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1)
if streamer is not None:
streamer.put(next_tokens.cpu())
model_kwargs = self._update_model_kwargs_for_generation(
outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
)
# if eos_token was found in one sentence, set sentence to finished
if eos_token_id_tensor is not None:
unfinished_sequences = unfinished_sequences.mul(
next_tokens.tile(eos_token_id_tensor.shape[0], 1).ne(eos_token_id_tensor.unsqueeze(1)).prod(dim=0)
)
# stop when each sentence is finished
if unfinished_sequences.max() == 0:
this_peer_finished = True
# stop if we exceed the maximum length
if stopping_criteria(input_ids, scores):
this_peer_finished = True
if this_peer_finished and not synced_gpus:
break
if streamer is not None:
streamer.end()
if return_dict_in_generate:
if self.config.is_encoder_decoder:
return ContrastiveSearchEncoderDecoderOutput(
sequences=input_ids,
scores=scores,
encoder_attentions=encoder_attentions,
encoder_hidden_states=encoder_hidden_states,
decoder_attentions=decoder_attentions,
cross_attentions=cross_attentions,
decoder_hidden_states=decoder_hidden_states,
)
else:
return ContrastiveSearchDecoderOnlyOutput(
sequences=input_ids,
scores=scores,
attentions=decoder_attentions,
hidden_states=decoder_hidden_states,
)
else:
return input_ids
def greedy_search(
self,
input_ids: torch.LongTensor,
logits_processor: Optional[LogitsProcessorList] = None,
stopping_criteria: Optional[StoppingCriteriaList] = None,
max_length: Optional[int] = None,
pad_token_id: Optional[int] = None,
eos_token_id: Optional[Union[int, List[int]]] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
output_scores: Optional[bool] = None,
return_dict_in_generate: Optional[bool] = None,
synced_gpus: bool = False,
streamer: Optional["BaseStreamer"] = None,
**model_kwargs,
) -> Union[GreedySearchOutput, torch.LongTensor]:
r"""
Generates sequences of token ids for models with a language modeling head using **greedy decoding** and can be
used for text-decoder, text-to-text, speech-to-text, and vision-to-text models.
In most cases, you do not need to call [`~generation.GenerationMixin.greedy_search`] directly. Use generate()
instead. For an overview of generation strategies and code examples, check the [following
guide](../generation_strategies).
Parameters:
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
The sequence used as a prompt for the generation.
logits_processor (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsProcessor`]
used to modify the prediction scores of the language modeling head applied at each generation step.
stopping_criteria (`StoppingCriteriaList`, *optional*):
An instance of [`StoppingCriteriaList`]. List of instances of class derived from [`StoppingCriteria`]
used to tell if the generation loop should stop.
max_length (`int`, *optional*, defaults to 20):
**DEPRECATED**. Use `logits_processor` or `stopping_criteria` directly to cap the number of generated
tokens. The maximum length of the sequence to be generated.
pad_token_id (`int`, *optional*):
The id of the *padding* token.
eos_token_id (`Union[int, List[int]]`, *optional*):
The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
output_attentions (`bool`, *optional*, defaults to `False`):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under
returned tensors for more details.
output_hidden_states (`bool`, *optional*, defaults to `False`):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
for more details.
output_scores (`bool`, *optional*, defaults to `False`):
Whether or not to return the prediction scores. See `scores` under returned tensors for more details.
return_dict_in_generate (`bool`, *optional*, defaults to `False`):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
synced_gpus (`bool`, *optional*, defaults to `False`):
Whether to continue running the while loop until max_length (needed for ZeRO stage 3)
streamer (`BaseStreamer`, *optional*):
Streamer object that will be used to stream the generated sequences. Generated tokens are passed
through `streamer.put(token_ids)` and the streamer is responsible for any further processing.
model_kwargs:
Additional model specific keyword arguments will be forwarded to the `forward` function of the model.
If model is an encoder-decoder model the kwargs should include `encoder_outputs`.
Return:
[`~generation.GreedySearchDecoderOnlyOutput`], [`~generation.GreedySearchEncoderDecoderOutput`] or
`torch.LongTensor`: A `torch.LongTensor` containing the generated tokens (default behaviour) or a
[`~generation.GreedySearchDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and
`return_dict_in_generate=True` or a [`~generation.GreedySearchEncoderDecoderOutput`] if
`model.config.is_encoder_decoder=True`.
Examples:
```python
>>> from transformers import (
... AutoTokenizer,
... AutoModelForCausalLM,
... LogitsProcessorList,
... MinLengthLogitsProcessor,
... StoppingCriteriaList,
... MaxLengthCriteria,
... )
>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("gpt2")
>>> # set pad_token_id to eos_token_id because GPT2 does not have a PAD token
>>> model.generation_config.pad_token_id = model.generation_config.eos_token_id
>>> input_prompt = "It might be possible to"
>>> input_ids = tokenizer(input_prompt, return_tensors="pt").input_ids
>>> # instantiate logits processors
>>> logits_processor = LogitsProcessorList(
... [
... MinLengthLogitsProcessor(10, eos_token_id=model.generation_config.eos_token_id),
... ]
... )
>>> stopping_criteria = StoppingCriteriaList([MaxLengthCriteria(max_length=20)])
>>> outputs = model.greedy_search(
... input_ids, logits_processor=logits_processor, stopping_criteria=stopping_criteria
... )
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
["It might be possible to get a better understanding of the nature of the problem, but it's not"]
```"""
# init values
logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
if max_length is not None:
warnings.warn(
"`max_length` is deprecated in this function, use"
" `stopping_criteria=StoppingCriteriaList([MaxLengthCriteria(max_length=max_length)])` instead.",
UserWarning,
)
stopping_criteria = validate_stopping_criteria(stopping_criteria, max_length)
pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
if isinstance(eos_token_id, int):
eos_token_id = [eos_token_id]
eos_token_id_tensor = torch.tensor(eos_token_id).to(input_ids.device) if eos_token_id is not None else None
output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
output_attentions = (
output_attentions if output_attentions is not None else self.generation_config.output_attentions
)
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
)
return_dict_in_generate = (
return_dict_in_generate
if return_dict_in_generate is not None
else self.generation_config.return_dict_in_generate
)
# init attention / hidden states / scores tuples
scores = () if (return_dict_in_generate and output_scores) else None
decoder_attentions = () if (return_dict_in_generate and output_attentions) else None
cross_attentions = () if (return_dict_in_generate and output_attentions) else None
decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None
# if model is an encoder-decoder, retrieve encoder attention weights and hidden states
if return_dict_in_generate and self.config.is_encoder_decoder:
encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
encoder_hidden_states = (
model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
)
# keep track of which sequences are already finished
unfinished_sequences = torch.ones(input_ids.shape[0], dtype=torch.long, device=input_ids.device)
this_peer_finished = False # used by synced_gpus only
while True:
if logger.level == logging.DEBUG:
rank = torch.distributed.get_rank()
logger.debug(
f"rank = {rank}, "
f"this_peer_finished = {this_peer_finished}, length = {input_ids.shape}\n"
f"input_ids: {input_ids}\n"
)
if synced_gpus:
# Under synced_gpus the `forward` call must continue until all gpus complete their sequence.
# The following logic allows an early break if all peers finished generating their sequence
this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)
# send 0.0 if we finished, 1.0 otherwise
dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)
# did all peers finish? the reduced sum will be 0.0 then
if this_peer_finished_flag.item() == 0.0:
break
# prepare model inputs
model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
# forward pass to get next token
model = model_kwargs.get("deepspeed_model", self)
outputs = model(
**model_inputs,
return_dict=True,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
)
if synced_gpus and this_peer_finished:
continue # don't waste resources running the code we don't need
next_token_logits = getattr(outputs, "logits", outputs[0])[:, -1, :]
# pre-process distribution
next_tokens_scores = logits_processor(input_ids, next_token_logits)
# Store scores, attentions and hidden_states when required
if return_dict_in_generate:
if output_scores:
scores += (next_tokens_scores,)
if output_attentions:
decoder_attentions += (
(outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)
)
if self.config.is_encoder_decoder:
cross_attentions += (outputs.cross_attentions,)
if output_hidden_states:
decoder_hidden_states += (
(outputs.decoder_hidden_states,)
if self.config.is_encoder_decoder
else (outputs.hidden_states,)
)
# argmax
next_tokens = torch.argmax(next_tokens_scores, dim=-1)
if logger.level == logging.DEBUG:
rank = torch.distributed.get_rank()
next_tokens_scores = torch.gather(next_tokens_scores, dim=1, index=next_tokens.view(next_tokens_scores.shape[0], 1))
logger.debug(
f"rank = {rank}, hasinf = {next_tokens_scores.isinf().any()}, "
f"hasnan = {next_tokens_scores.isnan().any()}, "
f"next_token_scores = {next_tokens_scores}"
)
# finished sentences should have their next token be a padding token
if eos_token_id is not None:
if pad_token_id is None:
raise ValueError("If `eos_token_id` is defined, make sure that `pad_token_id` is defined.")
next_tokens = next_tokens * unfinished_sequences + pad_token_id * (1 - unfinished_sequences)
# update generated ids, model inputs, and length for next step
input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1)
if streamer is not None:
streamer.put(next_tokens.cpu())
model_kwargs = self._update_model_kwargs_for_generation(
outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
)
# if eos_token was found in one sentence, set sentence to finished
if eos_token_id_tensor is not None:
unfinished_sequences = unfinished_sequences.mul(
next_tokens.tile(eos_token_id_tensor.shape[0], 1).ne(eos_token_id_tensor.unsqueeze(1)).prod(dim=0)
)
# stop when each sentence is finished
if unfinished_sequences.max() == 0:
this_peer_finished = True
# stop if we exceed the maximum length
if stopping_criteria(input_ids, scores):
this_peer_finished = True
if this_peer_finished and not synced_gpus:
break
if streamer is not None:
streamer.end()
if return_dict_in_generate:
if self.config.is_encoder_decoder:
return GreedySearchEncoderDecoderOutput(
sequences=input_ids,
scores=scores,
encoder_attentions=encoder_attentions,
encoder_hidden_states=encoder_hidden_states,
decoder_attentions=decoder_attentions,
cross_attentions=cross_attentions,
decoder_hidden_states=decoder_hidden_states,
)
else:
return GreedySearchDecoderOnlyOutput(
sequences=input_ids,
scores=scores,
attentions=decoder_attentions,
hidden_states=decoder_hidden_states,
)
else:
return input_ids
def sample(
self,
input_ids: torch.LongTensor,
logits_processor: Optional[LogitsProcessorList] = None,
stopping_criteria: Optional[StoppingCriteriaList] = None,
logits_warper: Optional[LogitsProcessorList] = None,
max_length: Optional[int] = None,
pad_token_id: Optional[int] = None,
eos_token_id: Optional[Union[int, List[int]]] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
output_scores: Optional[bool] = None,
return_dict_in_generate: Optional[bool] = None,
synced_gpus: bool = False,
streamer: Optional["BaseStreamer"] = None,
**model_kwargs,
) -> Union[SampleOutput, torch.LongTensor]:
r"""
Generates sequences of token ids for models with a language modeling head using **multinomial sampling** and
can be used for text-decoder, text-to-text, speech-to-text, and vision-to-text models.
In most cases, you do not need to call [`~generation.GenerationMixin.sample`] directly. Use generate() instead.
For an overview of generation strategies and code examples, check the [following
guide](../generation_strategies).
Parameters:
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
The sequence used as a prompt for the generation.
logits_processor (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsProcessor`]
used to modify the prediction scores of the language modeling head applied at each generation step.
stopping_criteria (`StoppingCriteriaList`, *optional*):
An instance of [`StoppingCriteriaList`]. List of instances of class derived from [`StoppingCriteria`]
used to tell if the generation loop should stop.
logits_warper (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsWarper`] used
to warp the prediction score distribution of the language modeling head applied before multinomial
sampling at each generation step.
max_length (`int`, *optional*, defaults to 20):
**DEPRECATED**. Use `logits_processor` or `stopping_criteria` directly to cap the number of generated
tokens. The maximum length of the sequence to be generated.
pad_token_id (`int`, *optional*):
The id of the *padding* token.
eos_token_id (`Union[int, List[int]]`, *optional*):
The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
output_attentions (`bool`, *optional*, defaults to `False`):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under
returned tensors for more details.
output_hidden_states (`bool`, *optional*, defaults to `False`):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
for more details.
output_scores (`bool`, *optional*, defaults to `False`):
Whether or not to return the prediction scores. See `scores` under returned tensors for more details.
return_dict_in_generate (`bool`, *optional*, defaults to `False`):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
synced_gpus (`bool`, *optional*, defaults to `False`):
Whether to continue running the while loop until max_length (needed for ZeRO stage 3)
streamer (`BaseStreamer`, *optional*):
Streamer object that will be used to stream the generated sequences. Generated tokens are passed
through `streamer.put(token_ids)` and the streamer is responsible for any further processing.
model_kwargs:
Additional model specific kwargs will be forwarded to the `forward` function of the model. If model is
an encoder-decoder model the kwargs should include `encoder_outputs`.
Return:
[`~generation.SampleDecoderOnlyOutput`], [`~generation.SampleEncoderDecoderOutput`] or `torch.LongTensor`:
A `torch.LongTensor` containing the generated tokens (default behaviour) or a
[`~generation.SampleDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and
`return_dict_in_generate=True` or a [`~generation.SampleEncoderDecoderOutput`] if
`model.config.is_encoder_decoder=True`.
Examples:
```python
>>> from transformers import (
... AutoTokenizer,
... AutoModelForCausalLM,
... LogitsProcessorList,
... MinLengthLogitsProcessor,
... TopKLogitsWarper,
... TemperatureLogitsWarper,
... StoppingCriteriaList,
... MaxLengthCriteria,
... )
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("gpt2")
>>> # set pad_token_id to eos_token_id because GPT2 does not have a EOS token
>>> model.config.pad_token_id = model.config.eos_token_id
>>> model.generation_config.pad_token_id = model.config.eos_token_id
>>> input_prompt = "Today is a beautiful day, and"
>>> input_ids = tokenizer(input_prompt, return_tensors="pt").input_ids
>>> # instantiate logits processors
>>> logits_processor = LogitsProcessorList(
... [
... MinLengthLogitsProcessor(15, eos_token_id=model.generation_config.eos_token_id),
... ]
... )
>>> # instantiate logits processors
>>> logits_warper = LogitsProcessorList(
... [
... TopKLogitsWarper(50),
... TemperatureLogitsWarper(0.7),
... ]
... )
>>> stopping_criteria = StoppingCriteriaList([MaxLengthCriteria(max_length=20)])
>>> torch.manual_seed(0) # doctest: +IGNORE_RESULT
>>> outputs = model.sample(
... input_ids,
... logits_processor=logits_processor,
... logits_warper=logits_warper,
... stopping_criteria=stopping_criteria,
... )
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['Today is a beautiful day, and we must do everything possible to make it a day of celebration.']
```"""
# init values
logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
if max_length is not None:
warnings.warn(
"`max_length` is deprecated in this function, use"
" `stopping_criteria=StoppingCriteriaList(MaxLengthCriteria(max_length=max_length))` instead.",
UserWarning,
)
stopping_criteria = validate_stopping_criteria(stopping_criteria, max_length)
logits_warper = logits_warper if logits_warper is not None else LogitsProcessorList()
pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
if isinstance(eos_token_id, int):
eos_token_id = [eos_token_id]
eos_token_id_tensor = torch.tensor(eos_token_id).to(input_ids.device) if eos_token_id is not None else None
output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
output_attentions = (
output_attentions if output_attentions is not None else self.generation_config.output_attentions
)
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
)
return_dict_in_generate = (
return_dict_in_generate
if return_dict_in_generate is not None
else self.generation_config.return_dict_in_generate
)
# init attention / hidden states / scores tuples
scores = () if (return_dict_in_generate and output_scores) else None
decoder_attentions = () if (return_dict_in_generate and output_attentions) else None
cross_attentions = () if (return_dict_in_generate and output_attentions) else None
decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None
# if model is an encoder-decoder, retrieve encoder attention weights and hidden states
if return_dict_in_generate and self.config.is_encoder_decoder:
encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
encoder_hidden_states = (
model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
)
# keep track of which sequences are already finished
unfinished_sequences = torch.ones(input_ids.shape[0], dtype=torch.long, device=input_ids.device)
this_peer_finished = False # used by synced_gpus only
# auto-regressive generation
while True:
if logger.level == logging.DEBUG:
rank = torch.distributed.get_rank()
logger.debug(
f"rank = {rank}, "
f"this_peer_finished = {this_peer_finished}, length = {input_ids.shape}\n"
f"input_ids: {input_ids}\n"
)
if synced_gpus:
# Under synced_gpus the `forward` call must continue until all gpus complete their sequence.
# The following logic allows an early break if all peers finished generating their sequence
this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)
# send 0.0 if we finished, 1.0 otherwise
dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)
# did all peers finish? the reduced sum will be 0.0 then
if this_peer_finished_flag.item() == 0.0:
break
# prepare model inputs
model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
# forward pass to get next token
model = model_kwargs.get("deepspeed_model", self)
outputs = model(
**model_inputs,
return_dict=True,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
)
if synced_gpus and this_peer_finished:
continue # don't waste resources running the code we don't need
next_token_logits = getattr(outputs, "logits", outputs[0])[:, -1, :]
# pre-process distribution
next_token_scores = logits_processor(input_ids, next_token_logits)
next_token_scores = logits_warper(input_ids, next_token_scores)
# Store scores, attentions and hidden_states when required
if return_dict_in_generate:
if output_scores:
scores += (next_token_scores,)
if output_attentions:
decoder_attentions += (
(outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)
)
if self.config.is_encoder_decoder:
cross_attentions += (outputs.cross_attentions,)
if output_hidden_states:
decoder_hidden_states += (
(outputs.decoder_hidden_states,)
if self.config.is_encoder_decoder
else (outputs.hidden_states,)
)
# sample
probs = nn.functional.softmax(next_token_scores, dim=-1)
next_tokens = torch.multinomial(probs, num_samples=1).squeeze(1)
# finished sentences should have their next token be a padding token
if eos_token_id is not None:
if pad_token_id is None:
raise ValueError("If `eos_token_id` is defined, make sure that `pad_token_id` is defined.")
next_tokens = next_tokens * unfinished_sequences + pad_token_id * (1 - unfinished_sequences)
# update generated ids, model inputs, and length for next step
input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1)
if streamer is not None:
streamer.put(next_tokens.cpu())
model_kwargs = self._update_model_kwargs_for_generation(
outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
)
# if eos_token was found in one sentence, set sentence to finished
if eos_token_id_tensor is not None:
unfinished_sequences = unfinished_sequences.mul(
next_tokens.tile(eos_token_id_tensor.shape[0], 1).ne(eos_token_id_tensor.unsqueeze(1)).prod(dim=0)
)
# stop when each sentence is finished
if unfinished_sequences.max() == 0:
this_peer_finished = True
# stop if we exceed the maximum length
if stopping_criteria(input_ids, scores):
this_peer_finished = True
if this_peer_finished and not synced_gpus:
break
if streamer is not None:
streamer.end()
if return_dict_in_generate:
if self.config.is_encoder_decoder:
return SampleEncoderDecoderOutput(
sequences=input_ids,
scores=scores,
encoder_attentions=encoder_attentions,
encoder_hidden_states=encoder_hidden_states,
decoder_attentions=decoder_attentions,
cross_attentions=cross_attentions,
decoder_hidden_states=decoder_hidden_states,
)
else:
return SampleDecoderOnlyOutput(
sequences=input_ids,
scores=scores,
attentions=decoder_attentions,
hidden_states=decoder_hidden_states,
)
else:
return input_ids
def beam_search(
self,
input_ids: torch.LongTensor,
beam_scorer: BeamScorer,
logits_processor: Optional[LogitsProcessorList] = None,
stopping_criteria: Optional[StoppingCriteriaList] = None,
max_length: Optional[int] = None,
pad_token_id: Optional[int] = None,
eos_token_id: Optional[Union[int, List[int]]] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
output_scores: Optional[bool] = None,
return_dict_in_generate: Optional[bool] = None,
synced_gpus: bool = False,
**model_kwargs,
) -> Union[BeamSearchOutput, torch.LongTensor]:
r"""
Generates sequences of token ids for models with a language modeling head using **beam search decoding** and
can be used for text-decoder, text-to-text, speech-to-text, and vision-to-text models.
In most cases, you do not need to call [`~generation.GenerationMixin.beam_search`] directly. Use generate()
instead. For an overview of generation strategies and code examples, check the [following
guide](../generation_strategies).
Parameters:
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
The sequence used as a prompt for the generation.
beam_scorer (`BeamScorer`):
An derived instance of [`BeamScorer`] that defines how beam hypotheses are constructed, stored and
sorted during generation. For more information, the documentation of [`BeamScorer`] should be read.
logits_processor (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsProcessor`]
used to modify the prediction scores of the language modeling head applied at each generation step.
stopping_criteria (`StoppingCriteriaList`, *optional*):
An instance of [`StoppingCriteriaList`]. List of instances of class derived from [`StoppingCriteria`]
used to tell if the generation loop should stop.
max_length (`int`, *optional*, defaults to 20):
**DEPRECATED**. Use `logits_processor` or `stopping_criteria` directly to cap the number of generated
tokens. The maximum length of the sequence to be generated.
pad_token_id (`int`, *optional*):
The id of the *padding* token.
eos_token_id (`Union[int, List[int]]`, *optional*):
The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
output_attentions (`bool`, *optional*, defaults to `False`):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under
returned tensors for more details.
output_hidden_states (`bool`, *optional*, defaults to `False`):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
for more details.
output_scores (`bool`, *optional*, defaults to `False`):
Whether or not to return the prediction scores. See `scores` under returned tensors for more details.
return_dict_in_generate (`bool`, *optional*, defaults to `False`):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
synced_gpus (`bool`, *optional*, defaults to `False`):
Whether to continue running the while loop until max_length (needed for ZeRO stage 3)
model_kwargs:
Additional model specific kwargs will be forwarded to the `forward` function of the model. If model is
an encoder-decoder model the kwargs should include `encoder_outputs`.
Return:
[`generation.BeamSearchDecoderOnlyOutput`], [`~generation.BeamSearchEncoderDecoderOutput`] or
`torch.LongTensor`: A `torch.LongTensor` containing the generated tokens (default behaviour) or a
[`~generation.BeamSearchDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and
`return_dict_in_generate=True` or a [`~generation.BeamSearchEncoderDecoderOutput`] if
`model.config.is_encoder_decoder=True`.
Examples:
```python
>>> from transformers import (
... AutoTokenizer,
... AutoModelForSeq2SeqLM,
... LogitsProcessorList,
... MinLengthLogitsProcessor,
... BeamSearchScorer,
... )
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> encoder_input_str = "translate English to German: How old are you?"
>>> encoder_input_ids = tokenizer(encoder_input_str, return_tensors="pt").input_ids
>>> # lets run beam search using 3 beams
>>> num_beams = 3
>>> # define decoder start token ids
>>> input_ids = torch.ones((num_beams, 1), device=model.device, dtype=torch.long)
>>> input_ids = input_ids * model.config.decoder_start_token_id
>>> # add encoder_outputs to model keyword arguments
>>> model_kwargs = {
... "encoder_outputs": model.get_encoder()(
... encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True
... )
... }
>>> # instantiate beam scorer
>>> beam_scorer = BeamSearchScorer(
... batch_size=1,
... num_beams=num_beams,
... device=model.device,
... )
>>> # instantiate logits processors
>>> logits_processor = LogitsProcessorList(
... [
... MinLengthLogitsProcessor(5, eos_token_id=model.config.eos_token_id),
... ]
... )
>>> outputs = model.beam_search(input_ids, beam_scorer, logits_processor=logits_processor, **model_kwargs)
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['Wie alt bist du?']
```"""
# init values
logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
if max_length is not None:
warnings.warn(
"`max_length` is deprecated in this function, use"
" `stopping_criteria=StoppingCriteriaList(MaxLengthCriteria(max_length=max_length))` instead.",
UserWarning,
)
stopping_criteria = validate_stopping_criteria(stopping_criteria, max_length)
if len(stopping_criteria) == 0:
warnings.warn("You don't have defined any stopping_criteria, this will likely loop forever", UserWarning)
pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
if isinstance(eos_token_id, int):
eos_token_id = [eos_token_id]
output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
output_attentions = (
output_attentions if output_attentions is not None else self.generation_config.output_attentions
)
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
)
return_dict_in_generate = (
return_dict_in_generate
if return_dict_in_generate is not None
else self.generation_config.return_dict_in_generate
)
batch_size = len(beam_scorer._beam_hyps)
num_beams = beam_scorer.num_beams
batch_beam_size, cur_len = input_ids.shape
if num_beams * batch_size != batch_beam_size:
raise ValueError(
f"Batch dimension of `input_ids` should be {num_beams * batch_size}, but is {batch_beam_size}."
)
# init attention / hidden states / scores tuples
scores = () if (return_dict_in_generate and output_scores) else None
beam_indices = (
tuple(() for _ in range(batch_beam_size)) if (return_dict_in_generate and output_scores) else None
)
decoder_attentions = () if (return_dict_in_generate and output_attentions) else None
cross_attentions = () if (return_dict_in_generate and output_attentions) else None
decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None
# if model is an encoder-decoder, retrieve encoder attention weights and hidden states
if return_dict_in_generate and self.config.is_encoder_decoder:
encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
encoder_hidden_states = (
model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
)
# initialise score of first beam with 0 and the rest with -1e9. This makes sure that only tokens
# of the first beam are considered to avoid sampling the exact same tokens across all beams.
beam_scores = torch.zeros((batch_size, num_beams), dtype=torch.float, device=input_ids.device)
beam_scores[:, 1:] = -1e9
beam_scores = beam_scores.view((batch_size * num_beams,))
this_peer_finished = False # used by synced_gpus only
while True:
if synced_gpus:
# Under synced_gpus the `forward` call must continue until all gpus complete their sequence.
# The following logic allows an early break if all peers finished generating their sequence
this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)
# send 0.0 if we finished, 1.0 otherwise
dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)
# did all peers finish? the reduced sum will be 0.0 then
if this_peer_finished_flag.item() == 0.0:
break
model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
model = model_kwargs.get("deepspeed_model", self)
outputs = model(
**model_inputs,
return_dict=True,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
)
if synced_gpus and this_peer_finished:
cur_len = cur_len + 1
continue # don't waste resources running the code we don't need
next_token_logits = outputs.logits[:, -1, :]
next_token_scores = nn.functional.log_softmax(
next_token_logits, dim=-1
) # (batch_size * num_beams, vocab_size)
next_token_scores_processed = logits_processor(input_ids, next_token_scores)
next_token_scores = next_token_scores_processed + beam_scores[:, None].expand_as(next_token_scores)
# Store scores, attentions and hidden_states when required
if return_dict_in_generate:
if output_scores:
scores += (next_token_scores_processed,)
if output_attentions:
decoder_attentions += (
(outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)
)
if self.config.is_encoder_decoder:
cross_attentions += (outputs.cross_attentions,)
if output_hidden_states:
decoder_hidden_states += (
(outputs.decoder_hidden_states,)
if self.config.is_encoder_decoder
else (outputs.hidden_states,)
)
# reshape for beam search
vocab_size = next_token_scores.shape[-1]
next_token_scores = next_token_scores.view(batch_size, num_beams * vocab_size)
# Sample 1 + len(eos_token_id) next tokens for each beam so we have at least 1 non eos token per beam.
n_eos_tokens = len(eos_token_id) if eos_token_id else 0
next_token_scores, next_tokens = torch.topk(
next_token_scores, max(2, 1 + n_eos_tokens) * num_beams, dim=1, largest=True, sorted=True
)
next_indices = torch.div(next_tokens, vocab_size, rounding_mode="floor")
next_tokens = next_tokens % vocab_size
# stateless
beam_outputs = beam_scorer.process(
input_ids,
next_token_scores,
next_tokens,
next_indices,
pad_token_id=pad_token_id,
eos_token_id=eos_token_id,
beam_indices=beam_indices,
)
beam_scores = beam_outputs["next_beam_scores"]
beam_next_tokens = beam_outputs["next_beam_tokens"]
beam_idx = beam_outputs["next_beam_indices"]
input_ids = torch.cat([input_ids[beam_idx, :], beam_next_tokens.unsqueeze(-1)], dim=-1)
model_kwargs = self._update_model_kwargs_for_generation(
outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
)
if model_kwargs["past_key_values"] is not None:
model_kwargs["past_key_values"] = self._reorder_cache(model_kwargs["past_key_values"], beam_idx)
if return_dict_in_generate and output_scores:
beam_indices = tuple((beam_indices[beam_idx[i]] + (beam_idx[i],) for i in range(len(beam_indices))))
# increase cur_len
cur_len = cur_len + 1
if beam_scorer.is_done or stopping_criteria(input_ids, scores):
if not synced_gpus:
break
else:
this_peer_finished = True
sequence_outputs = beam_scorer.finalize(
input_ids,
beam_scores,
next_tokens,
next_indices,
pad_token_id=pad_token_id,
eos_token_id=eos_token_id,
max_length=stopping_criteria.max_length,
beam_indices=beam_indices,
)
if return_dict_in_generate:
if not output_scores:
sequence_outputs["sequence_scores"] = None
if self.config.is_encoder_decoder:
return BeamSearchEncoderDecoderOutput(
sequences=sequence_outputs["sequences"],
sequences_scores=sequence_outputs["sequence_scores"],
scores=scores,
beam_indices=sequence_outputs["beam_indices"],
encoder_attentions=encoder_attentions,
encoder_hidden_states=encoder_hidden_states,
decoder_attentions=decoder_attentions,
cross_attentions=cross_attentions,
decoder_hidden_states=decoder_hidden_states,
)
else:
return BeamSearchDecoderOnlyOutput(
sequences=sequence_outputs["sequences"],
sequences_scores=sequence_outputs["sequence_scores"],
scores=scores,
beam_indices=sequence_outputs["beam_indices"],
attentions=decoder_attentions,
hidden_states=decoder_hidden_states,
)
else:
return sequence_outputs["sequences"]
def beam_sample(
self,
input_ids: torch.LongTensor,
beam_scorer: BeamScorer,
logits_processor: Optional[LogitsProcessorList] = None,
stopping_criteria: Optional[StoppingCriteriaList] = None,
logits_warper: Optional[LogitsProcessorList] = None,
max_length: Optional[int] = None,
pad_token_id: Optional[int] = None,
eos_token_id: Optional[Union[int, List[int]]] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
output_scores: Optional[bool] = None,
return_dict_in_generate: Optional[bool] = None,
synced_gpus: bool = False,
**model_kwargs,
) -> Union[BeamSampleOutput, torch.LongTensor]:
r"""
Generates sequences of token ids for models with a language modeling head using **beam search multinomial
sampling** and can be used for text-decoder, text-to-text, speech-to-text, and vision-to-text models.
In most cases, you do not need to call [`~generation.GenerationMixin.beam_sample`] directly. Use generate()
instead. For an overview of generation strategies and code examples, check the [following
guide](../generation_strategies).
Parameters:
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
The sequence used as a prompt for the generation.
beam_scorer (`BeamScorer`):
A derived instance of [`BeamScorer`] that defines how beam hypotheses are constructed, stored and
sorted during generation. For more information, the documentation of [`BeamScorer`] should be read.
logits_processor (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsProcessor`]
used to modify the prediction scores of the language modeling head applied at each generation step.
stopping_criteria (`StoppingCriteriaList`, *optional*):
An instance of [`StoppingCriteriaList`]. List of instances of class derived from [`StoppingCriteria`]
used to tell if the generation loop should stop.
logits_warper (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsWarper`] used
to warp the prediction score distribution of the language modeling head applied before multinomial
sampling at each generation step.
max_length (`int`, *optional*, defaults to 20):
**DEPRECATED**. Use `logits_processor` or `stopping_criteria` directly to cap the number of generated
tokens. The maximum length of the sequence to be generated.
pad_token_id (`int`, *optional*):
The id of the *padding* token.
eos_token_id (`Union[int, List[int]]`, *optional*):
The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
output_attentions (`bool`, *optional*, defaults to `False`):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under
returned tensors for more details.
output_hidden_states (`bool`, *optional*, defaults to `False`):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
for more details.
output_scores (`bool`, *optional*, defaults to `False`):
Whether or not to return the prediction scores. See `scores` under returned tensors for more details.
return_dict_in_generate (`bool`, *optional*, defaults to `False`):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
synced_gpus (`bool`, *optional*, defaults to `False`):
Whether to continue running the while loop until max_length (needed for ZeRO stage 3)
model_kwargs:
Additional model specific kwargs will be forwarded to the `forward` function of the model. If model is
an encoder-decoder model the kwargs should include `encoder_outputs`.
Return:
[`~generation.BeamSampleDecoderOnlyOutput`], [`~generation.BeamSampleEncoderDecoderOutput`] or
`torch.LongTensor`: A `torch.LongTensor` containing the generated tokens (default behaviour) or a
[`~generation.BeamSampleDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and
`return_dict_in_generate=True` or a [`~generation.BeamSampleEncoderDecoderOutput`] if
`model.config.is_encoder_decoder=True`.
Examples:
```python
>>> from transformers import (
... AutoTokenizer,
... AutoModelForSeq2SeqLM,
... LogitsProcessorList,
... MinLengthLogitsProcessor,
... TopKLogitsWarper,
... TemperatureLogitsWarper,
... BeamSearchScorer,
... )
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> encoder_input_str = "translate English to German: How old are you?"
>>> encoder_input_ids = tokenizer(encoder_input_str, return_tensors="pt").input_ids
>>> # lets run beam search using 3 beams
>>> num_beams = 3
>>> # define decoder start token ids
>>> input_ids = torch.ones((num_beams, 1), device=model.device, dtype=torch.long)
>>> input_ids = input_ids * model.config.decoder_start_token_id
>>> # add encoder_outputs to model keyword arguments
>>> model_kwargs = {
... "encoder_outputs": model.get_encoder()(
... encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True
... )
... }
>>> # instantiate beam scorer
>>> beam_scorer = BeamSearchScorer(
... batch_size=1,
... max_length=model.config.max_length,
... num_beams=num_beams,
... device=model.device,
... )
>>> # instantiate logits processors
>>> logits_processor = LogitsProcessorList(
... [MinLengthLogitsProcessor(5, eos_token_id=model.config.eos_token_id)]
... )
>>> # instantiate logits processors
>>> logits_warper = LogitsProcessorList(
... [
... TopKLogitsWarper(50),
... TemperatureLogitsWarper(0.7),
... ]
... )
>>> outputs = model.beam_sample(
... input_ids, beam_scorer, logits_processor=logits_processor, logits_warper=logits_warper, **model_kwargs
... )
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['Wie alt bist du?']
```"""
# init values
logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
if max_length is not None:
warnings.warn(
"`max_length` is deprecated in this function, use"
" `stopping_criteria=StoppingCriteriaList(MaxLengthCriteria(max_length=max_length))` instead.",
UserWarning,
)
stopping_criteria = validate_stopping_criteria(stopping_criteria, max_length)
pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
if isinstance(eos_token_id, int):
eos_token_id = [eos_token_id]
output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
output_attentions = (
output_attentions if output_attentions is not None else self.generation_config.output_attentions
)
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
)
return_dict_in_generate = (
return_dict_in_generate
if return_dict_in_generate is not None
else self.generation_config.return_dict_in_generate
)
batch_size = len(beam_scorer._beam_hyps)
num_beams = beam_scorer.num_beams
batch_beam_size, cur_len = input_ids.shape
# init attention / hidden states / scores tuples
scores = () if (return_dict_in_generate and output_scores) else None
beam_indices = (
tuple(() for _ in range(batch_beam_size)) if (return_dict_in_generate and output_scores) else None
)
decoder_attentions = () if (return_dict_in_generate and output_attentions) else None
cross_attentions = () if (return_dict_in_generate and output_attentions) else None
decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None
# if model is an encoder-decoder, retrieve encoder attention weights and hidden states
if return_dict_in_generate and self.config.is_encoder_decoder:
encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
encoder_hidden_states = (
model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
)
beam_scores = torch.zeros((batch_size, num_beams), dtype=torch.float, device=input_ids.device)
beam_scores = beam_scores.view((batch_size * num_beams,))
this_peer_finished = False # used by synced_gpus only
while True:
if synced_gpus:
# Under synced_gpus the `forward` call must continue until all gpus complete their sequence.
# The following logic allows an early break if all peers finished generating their sequence
this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)
# send 0.0 if we finished, 1.0 otherwise
dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)
# did all peers finish? the reduced sum will be 0.0 then
if this_peer_finished_flag.item() == 0.0:
break
model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
model = model_kwargs.get("deepspeed_model", self)
outputs = model(
**model_inputs,
return_dict=True,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
)
if synced_gpus and this_peer_finished:
cur_len = cur_len + 1
continue # don't waste resources running the code we don't need
next_token_logits = outputs.logits[:, -1, :]
next_token_scores = nn.functional.log_softmax(
next_token_logits, dim=-1
) # (batch_size * num_beams, vocab_size)
next_token_scores_processed = logits_processor(input_ids, next_token_scores)
next_token_scores = next_token_scores_processed + beam_scores[:, None].expand_as(next_token_scores)
# Note: logits warpers are intentionally applied after adding running beam scores. On some logits warpers
# (like top_p) this is indiferent, but on others (like temperature) it is not. For reference, see
# https://github.com/huggingface/transformers/pull/5420#discussion_r449779867
next_token_scores = logits_warper(input_ids, next_token_scores)
# Store scores, attentions and hidden_states when required
if return_dict_in_generate:
if output_scores:
scores += (logits_warper(input_ids, next_token_scores_processed),)
if output_attentions:
decoder_attentions += (
(outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)
)
if self.config.is_encoder_decoder:
cross_attentions += (outputs.cross_attentions,)
if output_hidden_states:
decoder_hidden_states += (
(outputs.decoder_hidden_states,)
if self.config.is_encoder_decoder
else (outputs.hidden_states,)
)
# reshape for beam search
vocab_size = next_token_scores.shape[-1]
next_token_scores = next_token_scores.view(batch_size, num_beams * vocab_size)
probs = nn.functional.softmax(next_token_scores, dim=-1)
next_tokens = torch.multinomial(probs, num_samples=2 * num_beams)
next_token_scores = torch.gather(next_token_scores, -1, next_tokens)
next_token_scores, _indices = torch.sort(next_token_scores, descending=True, dim=1)
next_tokens = torch.gather(next_tokens, -1, _indices)
next_indices = torch.div(next_tokens, vocab_size, rounding_mode="floor")
next_tokens = next_tokens % vocab_size
# stateless
beam_outputs = beam_scorer.process(
input_ids,
next_token_scores,
next_tokens,
next_indices,
pad_token_id=pad_token_id,
eos_token_id=eos_token_id,
beam_indices=beam_indices,
)
beam_scores = beam_outputs["next_beam_scores"]
beam_next_tokens = beam_outputs["next_beam_tokens"]
beam_idx = beam_outputs["next_beam_indices"]
input_ids = torch.cat([input_ids[beam_idx, :], beam_next_tokens.unsqueeze(-1)], dim=-1)
model_kwargs = self._update_model_kwargs_for_generation(
outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
)
if model_kwargs["past_key_values"] is not None:
model_kwargs["past_key_values"] = self._reorder_cache(model_kwargs["past_key_values"], beam_idx)
if return_dict_in_generate and output_scores:
beam_indices = tuple((beam_indices[beam_idx[i]] + (beam_idx[i],) for i in range(len(beam_indices))))
# increase cur_len
cur_len = cur_len + 1
if beam_scorer.is_done or stopping_criteria(input_ids, scores):
if not synced_gpus:
break
else:
this_peer_finished = True
sequence_outputs = beam_scorer.finalize(
input_ids,
beam_scores,
next_tokens,
next_indices,
pad_token_id=pad_token_id,
eos_token_id=eos_token_id,
max_length=stopping_criteria.max_length,
beam_indices=beam_indices,
)
if return_dict_in_generate:
if not output_scores:
sequence_outputs["sequence_scores"] = None
if self.config.is_encoder_decoder:
return BeamSampleEncoderDecoderOutput(
sequences=sequence_outputs["sequences"],
sequences_scores=sequence_outputs["sequence_scores"],
scores=scores,
beam_indices=sequence_outputs["beam_indices"],
encoder_attentions=encoder_attentions,
encoder_hidden_states=encoder_hidden_states,
decoder_attentions=decoder_attentions,
cross_attentions=cross_attentions,
decoder_hidden_states=decoder_hidden_states,
)
else:
return BeamSampleDecoderOnlyOutput(
sequences=sequence_outputs["sequences"],
sequences_scores=sequence_outputs["sequence_scores"],
scores=scores,
beam_indices=sequence_outputs["beam_indices"],
attentions=decoder_attentions,
hidden_states=decoder_hidden_states,
)
else:
return sequence_outputs["sequences"]
def group_beam_search(
self,
input_ids: torch.LongTensor,
beam_scorer: BeamScorer,
logits_processor: Optional[LogitsProcessorList] = None,
stopping_criteria: Optional[StoppingCriteriaList] = None,
max_length: Optional[int] = None,
pad_token_id: Optional[int] = None,
eos_token_id: Optional[Union[int, List[int]]] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
output_scores: Optional[bool] = None,
return_dict_in_generate: Optional[bool] = None,
synced_gpus: bool = False,
**model_kwargs,
):
r"""
Generates sequences of token ids for models with a language modeling head using **diverse beam search
decoding** and can be used for text-decoder, text-to-text, speech-to-text, and vision-to-text models.
In most cases, you do not need to call [`~generation.GenerationMixin.group_beam_search`] directly. Use
generate() instead. For an overview of generation strategies and code examples, check the [following
guide](../generation_strategies).
Parameters:
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
The sequence used as a prompt for the generation.
beam_scorer (`BeamScorer`):
An derived instance of [`BeamScorer`] that defines how beam hypotheses are constructed, stored and
sorted during generation. For more information, the documentation of [`BeamScorer`] should be read.
logits_processor (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsProcessor`]
used to modify the prediction scores of the language modeling head applied at each generation step.
stopping_criteria (`StoppingCriteriaList`, *optional*):
An instance of [`StoppingCriteriaList`]. List of instances of class derived from [`StoppingCriteria`]
used to tell if the generation loop should stop.
max_length (`int`, *optional*, defaults to 20):
**DEPRECATED**. Use `logits_processor` or `stopping_criteria` directly to cap the number of generated
tokens. The maximum length of the sequence to be generated.
pad_token_id (`int`, *optional*):
The id of the *padding* token.
eos_token_id (`Union[int, List[int]]`, *optional*):
The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
output_attentions (`bool`, *optional*, defaults to `False`):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under
returned tensors for more details.
output_hidden_states (`bool`, *optional*, defaults to `False`):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
for more details.
output_scores (`bool`, *optional*, defaults to `False`):
Whether or not to return the prediction scores. See `scores` under returned tensors for more details.
return_dict_in_generate (`bool`, *optional*, defaults to `False`):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
synced_gpus (`bool`, *optional*, defaults to `False`):
Whether to continue running the while loop until max_length (needed for ZeRO stage 3)
model_kwargs:
Additional model specific kwargs that will be forwarded to the `forward` function of the model. If
model is an encoder-decoder model the kwargs should include `encoder_outputs`.
Return:
[`~generation.BeamSearchDecoderOnlyOutput`], [`~generation.BeamSearchEncoderDecoderOutput`] or
`torch.LongTensor`: A `torch.LongTensor` containing the generated tokens (default behaviour) or a
[`~generation.BeamSearchDecoderOnlyOutput`] if [`~generation.BeamSearchDecoderOnlyOutput`] if
`model.config.is_encoder_decoder=False` and `return_dict_in_generate=True` or a
[`~generation.BeamSearchEncoderDecoderOutput`] if `model.config.is_encoder_decoder=True`.
Examples:
```python
>>> from transformers import (
... AutoTokenizer,
... AutoModelForSeq2SeqLM,
... LogitsProcessorList,
... MinLengthLogitsProcessor,
... HammingDiversityLogitsProcessor,
... BeamSearchScorer,
... )
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> encoder_input_str = "translate English to German: How old are you?"
>>> encoder_input_ids = tokenizer(encoder_input_str, return_tensors="pt").input_ids
>>> # lets run diverse beam search using 6 beams
>>> num_beams = 6
>>> # define decoder start token ids
>>> input_ids = torch.ones((num_beams, 1), device=model.device, dtype=torch.long)
>>> input_ids = input_ids * model.config.decoder_start_token_id
>>> # add encoder_outputs to model keyword arguments
>>> model_kwargs = {
... "encoder_outputs": model.get_encoder()(
... encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True
... )
... }
>>> # instantiate beam scorer
>>> beam_scorer = BeamSearchScorer(
... batch_size=1,
... max_length=model.config.max_length,
... num_beams=num_beams,
... device=model.device,
... num_beam_groups=3,
... )
>>> # instantiate logits processors
>>> logits_processor = LogitsProcessorList(
... [
... HammingDiversityLogitsProcessor(5.5, num_beams=6, num_beam_groups=3),
... MinLengthLogitsProcessor(5, eos_token_id=model.config.eos_token_id),
... ]
... )
>>> outputs = model.group_beam_search(
... input_ids, beam_scorer, logits_processor=logits_processor, **model_kwargs
... )
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['Wie alt bist du?']
```"""
# init values
logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
if max_length is not None:
warnings.warn(
"`max_length` is deprecated in this function, use"
" `stopping_criteria=StoppingCriteriaList(MaxLengthCriteria(max_length=max_length))` instead.",
UserWarning,
)
stopping_criteria = validate_stopping_criteria(stopping_criteria, max_length)
pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
if isinstance(eos_token_id, int):
eos_token_id = [eos_token_id]
output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
output_attentions = (
output_attentions if output_attentions is not None else self.generation_config.output_attentions
)
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
)
return_dict_in_generate = (
return_dict_in_generate
if return_dict_in_generate is not None
else self.generation_config.return_dict_in_generate
)
num_beams = beam_scorer.num_beams
num_beam_groups = beam_scorer.num_beam_groups
num_sub_beams = num_beams // num_beam_groups
batch_size = len(beam_scorer._beam_hyps) // num_beam_groups
device = input_ids.device
batch_beam_size, cur_len = input_ids.shape
if return_dict_in_generate and output_scores:
beam_indices = [tuple(() for _ in range(num_sub_beams * batch_size)) for _ in range(num_beam_groups)]
else:
beam_indices = None
if num_beams * batch_size != batch_beam_size:
raise ValueError(
f"Batch dimension of `input_ids` should be {num_beams * batch_size}, but is {batch_beam_size}."
)
# init attention / hidden states / scores tuples
scores = () if (return_dict_in_generate and output_scores) else None
decoder_attentions = () if (return_dict_in_generate and output_attentions) else None
cross_attentions = () if (return_dict_in_generate and output_attentions) else None
decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None
# if model is an encoder-decoder, retrieve encoder attention weights and hidden states
if return_dict_in_generate and self.config.is_encoder_decoder:
encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
encoder_hidden_states = (
model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
)
# initialise score of first beam of each group with 0 and the rest with -1e9. This ensures that the beams in
# the same group don't produce same tokens everytime.
beam_scores = torch.full((batch_size, num_beams), -1e9, dtype=torch.float, device=device)
beam_scores[:, ::num_sub_beams] = 0
beam_scores = beam_scores.view((batch_size * num_beams,))
this_peer_finished = False # used by synced_gpus only
while True:
if synced_gpus:
# Under synced_gpus the `forward` call must continue until all gpus complete their sequence.
# The following logic allows an early break if all peers finished generating their sequence
this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)
# send 0.0 if we finished, 1.0 otherwise
dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)
# did all peers finish? the reduced sum will be 0.0 then
if this_peer_finished_flag.item() == 0.0:
break
# predicted tokens in cur_len step
current_tokens = torch.zeros(batch_size * num_beams, dtype=input_ids.dtype, device=device)
# indices which will form the beams in the next time step
reordering_indices = torch.zeros(batch_size * num_beams, dtype=torch.long, device=device)
# do one decoder step on all beams of all sentences in batch
model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
model = model_kwargs.get("deepspeed_model", self)
outputs = model(
**model_inputs,
return_dict=True,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
)
if synced_gpus and this_peer_finished:
cur_len = cur_len + 1
continue # don't waste resources running the code we don't need
if output_scores:
processed_score = torch.zeros_like(outputs.logits[:, -1, :])
for beam_group_idx in range(num_beam_groups):
group_start_idx = beam_group_idx * num_sub_beams
group_end_idx = min(group_start_idx + num_sub_beams, num_beams)
group_size = group_end_idx - group_start_idx
# indices of beams of current group among all sentences in batch
batch_group_indices = []
for batch_idx in range(batch_size):
batch_group_indices.extend(
[batch_idx * num_beams + idx for idx in range(group_start_idx, group_end_idx)]
)
group_input_ids = input_ids[batch_group_indices]
# select outputs of beams of current group only
next_token_logits = outputs.logits[batch_group_indices, -1, :]
next_token_scores = nn.functional.log_softmax(
next_token_logits, dim=-1
) # (batch_size * group_size, vocab_size)
vocab_size = next_token_scores.shape[-1]
next_token_scores_processed = logits_processor(
group_input_ids, next_token_scores, current_tokens=current_tokens, beam_group_idx=beam_group_idx
)
next_token_scores = next_token_scores_processed + beam_scores[batch_group_indices].unsqueeze(-1)
next_token_scores = next_token_scores.expand_as(next_token_scores_processed)
if output_scores:
processed_score[batch_group_indices] = next_token_scores_processed
# reshape for beam search
next_token_scores = next_token_scores.view(batch_size, group_size * vocab_size)
# Sample 1 + len(eos_token_id) next tokens for each beam so we have at least 1 non eos token per beam.
n_eos_tokens = len(eos_token_id) if eos_token_id else 0
next_token_scores, next_tokens = torch.topk(
next_token_scores, max(2, 1 + n_eos_tokens) * group_size, dim=1, largest=True, sorted=True
)
next_indices = torch.div(next_tokens, vocab_size, rounding_mode="floor")
next_tokens = next_tokens % vocab_size
# stateless
process_beam_indices = sum(beam_indices, ()) if beam_indices is not None else None
beam_outputs = beam_scorer.process(
group_input_ids,
next_token_scores,
next_tokens,
next_indices,
pad_token_id=pad_token_id,
eos_token_id=eos_token_id,
beam_indices=process_beam_indices,
group_index=beam_group_idx,
)
beam_scores[batch_group_indices] = beam_outputs["next_beam_scores"]
beam_next_tokens = beam_outputs["next_beam_tokens"]
beam_idx = beam_outputs["next_beam_indices"]
if return_dict_in_generate and output_scores:
beam_indices[beam_group_idx] = tuple(
beam_indices[beam_group_idx][beam_idx[i]] + (beam_idx[i],) for i in range(len(beam_indices[0]))
)
input_ids[batch_group_indices] = group_input_ids[beam_idx]
group_input_ids = torch.cat([group_input_ids[beam_idx, :], beam_next_tokens.unsqueeze(-1)], dim=-1)
current_tokens[batch_group_indices] = group_input_ids[:, -1]
# (beam_idx // group_size) -> batch_idx
# (beam_idx % group_size) -> offset of idx inside the group
reordering_indices[batch_group_indices] = (
num_beams * torch.div(beam_idx, group_size, rounding_mode="floor")
+ group_start_idx
+ (beam_idx % group_size)
)
# Store scores, attentions and hidden_states when required
if return_dict_in_generate:
if output_scores:
scores += (processed_score,)
if output_attentions:
decoder_attentions += (
(outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)
)
if self.config.is_encoder_decoder:
cross_attentions += (outputs.cross_attentions,)
if output_hidden_states:
decoder_hidden_states += (
(outputs.decoder_hidden_states,)
if self.config.is_encoder_decoder
else (outputs.hidden_states,)
)
input_ids = torch.cat([input_ids, current_tokens.unsqueeze(-1)], dim=-1)
model_kwargs = self._update_model_kwargs_for_generation(
outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
)
if model_kwargs["past_key_values"] is not None:
model_kwargs["past_key_values"] = self._reorder_cache(
model_kwargs["past_key_values"], reordering_indices
)
# increase cur_len
cur_len = cur_len + 1
if beam_scorer.is_done or stopping_criteria(input_ids, scores):
if not synced_gpus:
break
else:
this_peer_finished = True
final_beam_indices = sum(beam_indices, ()) if beam_indices is not None else None
sequence_outputs = beam_scorer.finalize(
input_ids,
beam_scores,
next_tokens,
next_indices,
pad_token_id=pad_token_id,
eos_token_id=eos_token_id,
max_length=stopping_criteria.max_length,
beam_indices=final_beam_indices,
)
if return_dict_in_generate:
if not output_scores:
sequence_outputs["sequence_scores"] = None
if self.config.is_encoder_decoder:
return BeamSearchEncoderDecoderOutput(
sequences=sequence_outputs["sequences"],
sequences_scores=sequence_outputs["sequence_scores"],
scores=scores,
beam_indices=sequence_outputs["beam_indices"],
encoder_attentions=encoder_attentions,
encoder_hidden_states=encoder_hidden_states,
decoder_attentions=decoder_attentions,
cross_attentions=cross_attentions,
decoder_hidden_states=decoder_hidden_states,
)
else:
return BeamSearchDecoderOnlyOutput(
sequences=sequence_outputs["sequences"],
sequences_scores=sequence_outputs["sequence_scores"],
scores=scores,
beam_indices=sequence_outputs["beam_indices"],
attentions=decoder_attentions,
hidden_states=decoder_hidden_states,
)
else:
return sequence_outputs["sequences"]
def constrained_beam_search(
self,
input_ids: torch.LongTensor,
constrained_beam_scorer: ConstrainedBeamSearchScorer,
logits_processor: Optional[LogitsProcessorList] = None,
stopping_criteria: Optional[StoppingCriteriaList] = None,
max_length: Optional[int] = None,
pad_token_id: Optional[int] = None,
eos_token_id: Optional[Union[int, List[int]]] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
output_scores: Optional[bool] = None,
return_dict_in_generate: Optional[bool] = None,
synced_gpus: Optional[bool] = None,
**model_kwargs,
) -> Union[BeamSearchOutput, torch.LongTensor]:
r"""
Generates sequences of token ids for models with a language modeling head using **constrained beam search
decoding** and can be used for text-decoder, text-to-text, speech-to-text, and vision-to-text models.
In most cases, you do not need to call [`~generation.GenerationMixin.constrained_beam_search`] directly. Use
generate() instead. For an overview of generation strategies and code examples, check the [following
guide](../generation_strategies).
Parameters:
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
The sequence used as a prompt for the generation.
constrained_beam_scorer (`ConstrainedBeamSearchScorer`):
A derived instance of [`BeamScorer`] that defines how beam hypotheses are constructed, stored and
sorted during generation, while satisfying a list of positive constraints. For more information, the
documentation of [`ConstrainedBeamSearchScorer`] should be read.
logits_processor (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsProcessor`]
used to modify the prediction scores of the language modeling head applied at each generation step.
stopping_criteria (`StoppingCriteriaList`, *optional*):
An instance of [`StoppingCriteriaList`]. List of instances of class derived from [`StoppingCriteria`]
used to tell if the generation loop should stop.
logits_warper (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsWarper`] used
to warp the prediction score distribution of the language modeling head applied before multinomial
sampling at each generation step.
max_length (`int`, *optional*, defaults to 20):
**DEPRECATED**. Use `logits_processor` or `stopping_criteria` directly to cap the number of generated
tokens. The maximum length of the sequence to be generated.
pad_token_id (`int`, *optional*):
The id of the *padding* token.
eos_token_id (`Union[int, List[int]]`, *optional*):
The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
output_attentions (`bool`, *optional*, defaults to `False`):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under
returned tensors for more details.
output_hidden_states (`bool`, *optional*, defaults to `False`):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
for more details.
output_scores (`bool`, *optional*, defaults to `False`):
Whether or not to return the prediction scores. See `scores` under returned tensors for more details.
return_dict_in_generate (`bool`, *optional*, defaults to `False`):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
synced_gpus (`bool`, *optional*, defaults to `False`):
Whether to continue running the while loop until max_length (needed for ZeRO stage 3)
model_kwargs:
Additional model specific kwargs will be forwarded to the `forward` function of the model. If model is
an encoder-decoder model the kwargs should include `encoder_outputs`.
Return:
[`generation.BeamSearchDecoderOnlyOutput`], [`~generation.BeamSearchEncoderDecoderOutput`] or
`torch.LongTensor`: A `torch.LongTensor` containing the generated tokens (default behaviour) or a
[`~generation.BeamSearchDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and
`return_dict_in_generate=True` or a [`~generation.BeamSearchEncoderDecoderOutput`] if
`model.config.is_encoder_decoder=True`.
Examples:
```python
>>> from transformers import (
... AutoTokenizer,
... AutoModelForSeq2SeqLM,
... LogitsProcessorList,
... MinLengthLogitsProcessor,
... ConstrainedBeamSearchScorer,
... PhrasalConstraint,
... )
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("t5-base")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> encoder_input_str = "translate English to German: How old are you?"
>>> encoder_input_ids = tokenizer(encoder_input_str, return_tensors="pt").input_ids
>>> # lets run beam search using 3 beams
>>> num_beams = 3
>>> # define decoder start token ids
>>> input_ids = torch.ones((num_beams, 1), device=model.device, dtype=torch.long)
>>> input_ids = input_ids * model.config.decoder_start_token_id
>>> # add encoder_outputs to model keyword arguments
>>> model_kwargs = {
... "encoder_outputs": model.get_encoder()(
... encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True
... )
... }
>>> constraint_str = "Sie"
>>> constraint_token_ids = tokenizer.encode(constraint_str)[:-1] # slice to remove eos token
>>> constraints = [PhrasalConstraint(token_ids=constraint_token_ids)]
>>> # instantiate beam scorer
>>> beam_scorer = ConstrainedBeamSearchScorer(
... batch_size=1, num_beams=num_beams, device=model.device, constraints=constraints
... )
>>> # instantiate logits processors
>>> logits_processor = LogitsProcessorList(
... [
... MinLengthLogitsProcessor(5, eos_token_id=model.config.eos_token_id),
... ]
... )
>>> outputs = model.constrained_beam_search(
... input_ids, beam_scorer, constraints=constraints, logits_processor=logits_processor, **model_kwargs
... )
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
['Wie alt sind Sie?']
```"""
# init values
logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
if max_length is not None:
warnings.warn(
"`max_length` is deprecated in this function, use"
" `stopping_criteria=StoppingCriteriaList(MaxLengthCriteria(max_length=max_length))` instead.",
UserWarning,
)
stopping_criteria = validate_stopping_criteria(stopping_criteria, max_length)
if len(stopping_criteria) == 0:
warnings.warn("You don't have defined any stopping_criteria, this will likely loop forever", UserWarning)
pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
if isinstance(eos_token_id, int):
eos_token_id = [eos_token_id]
output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
output_attentions = (
output_attentions if output_attentions is not None else self.generation_config.output_attentions
)
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
)
return_dict_in_generate = (
return_dict_in_generate
if return_dict_in_generate is not None
else self.generation_config.return_dict_in_generate
)
batch_size = len(constrained_beam_scorer._beam_hyps)
num_beams = constrained_beam_scorer.num_beams
batch_beam_size, cur_len = input_ids.shape
if num_beams * batch_size != batch_beam_size:
raise ValueError(
f"Batch dimension of `input_ids` should be {num_beams * batch_size}, but is {batch_beam_size}."
)
# init attention / hidden states / scores tuples
scores = () if (return_dict_in_generate and output_scores) else None
beam_indices = (
tuple(() for _ in range(batch_beam_size)) if (return_dict_in_generate and output_scores) else None
)
decoder_attentions = () if (return_dict_in_generate and output_attentions) else None
cross_attentions = () if (return_dict_in_generate and output_attentions) else None
decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None
# if model is an encoder-decoder, retrieve encoder attention weights and hidden states
if return_dict_in_generate and self.config.is_encoder_decoder:
encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
encoder_hidden_states = (
model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
)
# initialise score of first beam with 0 and the rest with -1e9. This makes sure that only tokens
# of the first beam are considered to avoid sampling the exact same tokens across all beams.
beam_scores = torch.zeros((batch_size, num_beams), dtype=torch.float, device=input_ids.device)
beam_scores[:, 1:] = -1e9
beam_scores = beam_scores.view((batch_size * num_beams,))
this_peer_finished = False # used by synced_gpus only
while True:
if synced_gpus:
# Under synced_gpus the `forward` call must continue until all gpus complete their sequence.
# The following logic allows an early break if all peers finished generating their sequence
this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)
# send 0.0 if we finished, 1.0 otherwise
dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)
# did all peers finish? the reduced sum will be 0.0 then
if this_peer_finished_flag.item() == 0.0:
break
model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
model = model_kwargs.get("deepspeed_model", self)
outputs = model(
**model_inputs,
return_dict=True,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
)
if synced_gpus and this_peer_finished:
cur_len = cur_len + 1
continue # don't waste resources running the code we don't need
next_token_logits = outputs.logits[:, -1, :]
next_token_scores = nn.functional.log_softmax(
next_token_logits, dim=-1
) # (batch_size * num_beams, vocab_size)
next_token_scores_processed = logits_processor(input_ids, next_token_scores)
next_token_scores = next_token_scores_processed + beam_scores[:, None].expand_as(next_token_scores)
scores_for_all_vocab = next_token_scores.clone()
# Store scores, attentions and hidden_states when required
if return_dict_in_generate:
if output_scores:
scores += (next_token_scores,)
if output_attentions:
decoder_attentions += (
(outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)
)
if self.config.is_encoder_decoder:
cross_attentions += (outputs.cross_attentions,)
if output_hidden_states:
decoder_hidden_states += (
(outputs.decoder_hidden_states,)
if self.config.is_encoder_decoder
else (outputs.hidden_states,)
)
# reshape for beam search
vocab_size = next_token_scores.shape[-1]
next_token_scores = next_token_scores.view(batch_size, num_beams * vocab_size)
# Sample 1 + len(eos_token_id) next tokens for each beam so we have at least 1 non eos token per beam.
n_eos_tokens = len(eos_token_id) if eos_token_id else 0
next_token_scores, next_tokens = torch.topk(
next_token_scores, max(2, 1 + n_eos_tokens) * num_beams, dim=1, largest=True, sorted=True
)
next_indices = (next_tokens / vocab_size).long()
next_tokens = next_tokens % vocab_size
# stateless
beam_outputs = constrained_beam_scorer.process(
input_ids,
next_token_scores,
next_tokens,
next_indices,
scores_for_all_vocab,
pad_token_id=pad_token_id,
eos_token_id=eos_token_id,
beam_indices=beam_indices,
)
beam_scores = beam_outputs["next_beam_scores"]
beam_next_tokens = beam_outputs["next_beam_tokens"]
beam_idx = beam_outputs["next_beam_indices"]
input_ids = torch.cat([input_ids[beam_idx, :], beam_next_tokens.unsqueeze(-1)], dim=-1)
model_kwargs = self._update_model_kwargs_for_generation(
outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
)
if model_kwargs["past_key_values"] is not None:
model_kwargs["past_key_values"] = self._reorder_cache(model_kwargs["past_key_values"], beam_idx)
if return_dict_in_generate and output_scores:
beam_indices = tuple((beam_indices[beam_idx[i]] + (beam_idx[i],) for i in range(len(beam_indices))))
# increase cur_len
cur_len = cur_len + 1
if constrained_beam_scorer.is_done or stopping_criteria(input_ids, scores):
if not synced_gpus:
break
else:
this_peer_finished = True
sequence_outputs = constrained_beam_scorer.finalize(
input_ids,
beam_scores,
next_tokens,
next_indices,
pad_token_id=pad_token_id,
eos_token_id=eos_token_id,
max_length=stopping_criteria.max_length,
beam_indices=beam_indices,
)
if return_dict_in_generate:
if not output_scores:
sequence_outputs["sequence_scores"] = None
if self.config.is_encoder_decoder:
return BeamSearchEncoderDecoderOutput(
sequences=sequence_outputs["sequences"],
sequences_scores=sequence_outputs["sequence_scores"],
scores=scores,
beam_indices=sequence_outputs["beam_indices"],
encoder_attentions=encoder_attentions,
encoder_hidden_states=encoder_hidden_states,
decoder_attentions=decoder_attentions,
cross_attentions=cross_attentions,
decoder_hidden_states=decoder_hidden_states,
)
else:
return BeamSearchDecoderOnlyOutput(
sequences=sequence_outputs["sequences"],
sequences_scores=sequence_outputs["sequence_scores"],
scores=scores,
beam_indices=sequence_outputs["beam_indices"],
attentions=decoder_attentions,
hidden_states=decoder_hidden_states,
)
else:
return sequence_outputs["sequences"]
def assisted_decoding(
self,
input_ids: torch.LongTensor,
assistant_model: "PreTrainedModel",
do_sample: bool = False,
logits_processor: Optional[LogitsProcessorList] = None,
logits_warper: Optional[LogitsProcessorList] = None,
stopping_criteria: Optional[StoppingCriteriaList] = None,
pad_token_id: Optional[int] = None,
eos_token_id: Optional[Union[int, List[int]]] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
output_scores: Optional[bool] = None,
return_dict_in_generate: Optional[bool] = None,
synced_gpus: bool = False,
streamer: Optional["BaseStreamer"] = None,
**model_kwargs,
):
r"""
Generates sequences of token ids for models with a language modeling head using **greedy decoding** or
**sample** (depending on `do_sample`), assisted by a smaller model. Can be used for text-decoder, text-to-text,
speech-to-text, and vision-to-text models.
In most cases, you do not need to call [`~generation.GenerationMixin.assisted_decoding`] directly. Use
generate() instead. For an overview of generation strategies and code examples, check the [following
guide](../generation_strategies).
Parameters:
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
The sequence used as a prompt for the generation.
assistant_model (`PreTrainedModel`, *optional*):
An assistant model that can be used to accelerate generation. The assistant model must have the exact
same tokenizer. The acceleration is achieved when forecasting candidate tokens with the assistent model
is much faster than running generation with the model you're calling generate from. As such, the
assistant model should be much smaller.
do_sample (`bool`, *optional*, defaults to `False`):
Whether or not to use sampling ; use greedy decoding otherwise.
logits_processor (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsProcessor`]
used to modify the prediction scores of the language modeling head applied at each generation step.
logits_warper (`LogitsProcessorList`, *optional*):
An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsWarper`] used
to warp the prediction score distribution of the language modeling head applied before multinomial
sampling at each generation step.
stopping_criteria (`StoppingCriteriaList`, *optional*):
An instance of [`StoppingCriteriaList`]. List of instances of class derived from [`StoppingCriteria`]
used to tell if the generation loop should stop.
pad_token_id (`int`, *optional*):
The id of the *padding* token.
eos_token_id (`Union[int, List[int]]`, *optional*):
The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
output_attentions (`bool`, *optional*, defaults to `False`):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under
returned tensors for more details.
output_hidden_states (`bool`, *optional*, defaults to `False`):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
for more details.
output_scores (`bool`, *optional*, defaults to `False`):
Whether or not to return the prediction scores. See `scores` under returned tensors for more details.
return_dict_in_generate (`bool`, *optional*, defaults to `False`):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
synced_gpus (`bool`, *optional*, defaults to `False`):
Whether to continue running the while loop until max_length (needed for ZeRO stage 3)
streamer (`BaseStreamer`, *optional*):
Streamer object that will be used to stream the generated sequences. Generated tokens are passed
through `streamer.put(token_ids)` and the streamer is responsible for any further processing.
model_kwargs:
Additional model specific keyword arguments will be forwarded to the `forward` function of the model.
If model is an encoder-decoder model the kwargs should include `encoder_outputs`.
Return:
[`~generation.GreedySearchDecoderOnlyOutput`], [`~generation.GreedySearchEncoderDecoderOutput`] or
`torch.LongTensor`: A `torch.LongTensor` containing the generated tokens (default behaviour) or a
[`~generation.GreedySearchDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and
`return_dict_in_generate=True` or a [`~generation.GreedySearchEncoderDecoderOutput`] if
`model.config.is_encoder_decoder=True`.
Examples:
```python
>>> from transformers import (
... AutoTokenizer,
... AutoModelForCausalLM,
... LogitsProcessorList,
... MinLengthLogitsProcessor,
... StoppingCriteriaList,
... MaxLengthCriteria,
... )
>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("gpt2")
>>> assistant_model = AutoModelForCausalLM.from_pretrained("distilgpt2")
>>> # set pad_token_id to eos_token_id because GPT2 does not have a PAD token
>>> model.generation_config.pad_token_id = model.generation_config.eos_token_id
>>> input_prompt = "It might be possible to"
>>> input_ids = tokenizer(input_prompt, return_tensors="pt").input_ids
>>> # instantiate logits processors
>>> logits_processor = LogitsProcessorList(
... [
... MinLengthLogitsProcessor(10, eos_token_id=model.generation_config.eos_token_id),
... ]
... )
>>> stopping_criteria = StoppingCriteriaList([MaxLengthCriteria(max_length=20)])
>>> outputs = model.assisted_decoding(
... input_ids,
... assistant_model=assistant_model,
... logits_processor=logits_processor,
... stopping_criteria=stopping_criteria,
... )
>>> tokenizer.batch_decode(outputs, skip_special_tokens=True)
["It might be possible to get a better understanding of the nature of the problem, but it's not"]
```"""
# Assistant: initialize assistant-related variables
if not hasattr(assistant_model, "max_assistant_tokens"):
assistant_model.max_assistant_tokens = 5 # this value, which will be updated, persists across calls
# init values
logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
logits_warper = logits_warper if logits_warper is not None else LogitsProcessorList()
stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
if eos_token_id is not None and pad_token_id is None:
raise ValueError("If `eos_token_id` is defined, make sure that `pad_token_id` is defined.")
if isinstance(eos_token_id, int):
eos_token_id = [eos_token_id]
eos_token_id_tensor = torch.tensor(eos_token_id).to(input_ids.device) if eos_token_id is not None else None
output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
output_attentions = (
output_attentions if output_attentions is not None else self.generation_config.output_attentions
)
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
)
return_dict_in_generate = (
return_dict_in_generate
if return_dict_in_generate is not None
else self.generation_config.return_dict_in_generate
)
# init attention / hidden states / scores tuples
scores = () if (return_dict_in_generate and output_scores) else None
decoder_attentions = () if (return_dict_in_generate and output_attentions) else None
cross_attentions = () if (return_dict_in_generate and output_attentions) else None
decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None
# if model is an encoder-decoder, retrieve encoder attention weights and hidden states
if return_dict_in_generate and self.config.is_encoder_decoder:
encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
encoder_hidden_states = (
model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
)
# keep track of which sequences are already finished
unfinished_sequences = input_ids.new(input_ids.shape[0]).fill_(1)
# other auxiliary variables
max_len = stopping_criteria[0].max_length
assistant_kv_indexing = (
1
if "bloom" in assistant_model.__class__.__name__.lower()
or (
assistant_model.config.architectures is not None
and "bloom" in assistant_model.config.architectures[0].lower()
)
else 0
)
this_peer_finished = False # used by synced_gpus only
while True:
if synced_gpus:
# Under synced_gpus the `forward` call must continue until all gpus complete their sequence.
# The following logic allows an early break if all peers finished generating their sequence
this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)
# send 0.0 if we finished, 1.0 otherwise
dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)
# did all peers finish? the reduced sum will be 0.0 then
if this_peer_finished_flag.item() == 0.0:
break
# Assistant: main logic start
cur_len = input_ids.shape[-1]
# 1. Forecast next N tokens using the assistant model. This `for` block can be replaced with a
# `.generate()` call if we decide to add `past_key_values` as a possible output of generate, as we
# need access to the assistant cache to secure strong speedups.
candidate_input_ids = input_ids
for _ in range(int(assistant_model.max_assistant_tokens)):
# 1.1. use the assistant model to obtain the next candidate logits
if "assistant_past_key_values" in model_kwargs:
prev_seq_len = model_kwargs["assistant_past_key_values"][0][assistant_kv_indexing].shape[-2]
# `new_token_len` can be 1 or 2 (next token in assistant + last token picked by the larger model)
new_token_len = candidate_input_ids.shape[1] - prev_seq_len
assist_inputs = candidate_input_ids[:, -new_token_len:]
assist_attn = torch.ones_like(candidate_input_ids)
# TODO (joao): make it compatible with models that use unconventional fwd pass logic, like blip2
if assistant_model.config.is_encoder_decoder:
assistant_model_outputs = assistant_model(
decoder_input_ids=assist_inputs,
decoder_attention_mask=assist_attn,
past_key_values=model_kwargs["assistant_past_key_values"],
encoder_outputs=model_kwargs["assistant_encoder_outputs"],
)
else:
assistant_model_outputs = assistant_model(
assist_inputs,
attention_mask=assist_attn,
past_key_values=model_kwargs["assistant_past_key_values"],
)
else:
if assistant_model.config.is_encoder_decoder:
assistant_model_outputs = assistant_model(
decoder_input_ids=candidate_input_ids,
encoder_outputs=model_kwargs["assistant_encoder_outputs"],
)
else:
assistant_model_outputs = assistant_model(candidate_input_ids)
# 1.2. greedily select the next candidate token
model_kwargs["assistant_past_key_values"] = assistant_model_outputs.past_key_values
if len(logits_processor) > 0:
assistant_model_outputs.logits[:, -1, :] = logits_processor(
candidate_input_ids, assistant_model_outputs.logits[:, -1, :]
)
new_token = assistant_model_outputs.logits[:, -1, :].argmax(dim=-1)
candidate_input_ids = torch.cat((candidate_input_ids, new_token[:, None]), dim=-1)
# 1.3. stop assistant generation on EOS
if eos_token_id_tensor is not None:
last_assistant_token_is_eos = new_token.tile(eos_token_id_tensor.shape[0], 1)
last_assistant_token_is_eos = (
~last_assistant_token_is_eos.ne(eos_token_id_tensor.unsqueeze(1)).prod(dim=0).bool()
)
if last_assistant_token_is_eos:
break
else:
last_assistant_token_is_eos = False
candidate_length = candidate_input_ids.shape[1] - input_ids.shape[1]
# 2. Use the original model to obtain the next token logits given the candidate sequence. We obtain
# `candidate_length + 1` relevant logits from this process: in the event that all candidates are correct,
# we use this forward pass to also pick the subsequent logits in the original model.
# 2.1. Run a forward pass on the candidate sequence
model = model_kwargs.get("deepspeed_model", self)
if "past_key_values" in model_kwargs:
model_attn = torch.ones_like(candidate_input_ids)
model_input_ids = candidate_input_ids[:, -candidate_length - 1 :]
if self.config.is_encoder_decoder:
outputs = model(
decoder_input_ids=model_input_ids,
decoder_attention_mask=model_attn,
past_key_values=model_kwargs["past_key_values"],
encoder_outputs=model_kwargs["encoder_outputs"],
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
use_cache=True,
)
else:
outputs = model(
model_input_ids,
attention_mask=model_attn,
past_key_values=model_kwargs["past_key_values"],
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
use_cache=True,
)
else:
if self.config.is_encoder_decoder:
outputs = model(
decoder_input_ids=candidate_input_ids,
encoder_outputs=model_kwargs["encoder_outputs"],
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
use_cache=True,
)
else:
outputs = model(
candidate_input_ids,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
use_cache=True,
)
# 2.2. Process the new logits
new_logits = outputs.logits[:, -candidate_length - 1 :] # excludes the input prompt if present
if len(logits_processor) > 0:
for i in range(candidate_length):
new_logits[:, i, :] = logits_processor(candidate_input_ids[:, : cur_len + i], new_logits[:, i, :])
if len(logits_warper) > 0:
for i in range(candidate_length):
new_logits[:, i, :] = logits_warper(candidate_input_ids[:, : cur_len + i], new_logits[:, i, :])
# 3. Obtain the next tokens from the original model logits.
if do_sample:
probs = new_logits[:, -candidate_length - 1 :, :].softmax(dim=-1)
selected_tokens = torch.multinomial(probs[0, :, :], num_samples=1).squeeze(1)[None, :]
else:
selected_tokens = new_logits[:, -candidate_length - 1 :, :].argmax(dim=-1)
# 4. Compare the argmax from the original model logits with the assistant forecasted tokens. We can keep
# the assistant forecasted tokens until the first mismatch, or until the max length is reached.
candidate_new_tokens = candidate_input_ids[:, -candidate_length:]
n_matches = ((~(candidate_new_tokens == selected_tokens[:, :-1])).cumsum(dim=-1) < 1).sum()
# 5. Update variables according to the number of matching assistant tokens. Remember: the token generated
# by the model after the last candidate match is also valid, as it is generated from a correct sequence.
# Because of this last token, assisted generation search reduces to a normal greedy search/sample if there
# is no match.
# 5.1. Ensure we don't generate beyond max_len or an EOS token
if last_assistant_token_is_eos and n_matches == candidate_length:
n_matches -= 1
n_matches = min(n_matches, max_len - cur_len - 1)
# 5.2. Get the valid continuation, after the matching tokens
valid_tokens = selected_tokens[:, : n_matches + 1]
input_ids = torch.cat((input_ids, valid_tokens), dim=-1)
if streamer is not None:
streamer.put(valid_tokens.cpu())
new_cur_len = input_ids.shape[-1]
# 5.3. Discard past key values relative to unused assistant tokens
new_cache_size = new_cur_len - 1
outputs.past_key_values = _crop_past_key_values(self, outputs.past_key_values, new_cache_size)
model_kwargs["assistant_past_key_values"] = _crop_past_key_values(
assistant_model, model_kwargs["assistant_past_key_values"], new_cache_size - 1
) # the assistant does not have the token after the last match, hence the -1
# 6. Adjust the max number of assistant tokens to use in the next iteration. This is a simple heuristic,
# probably can be improved -- we want to balance the benefits of getting assistant tokens correct with the
# cost of forecasting incorrect assistant tokens.
if n_matches == int(assistant_model.max_assistant_tokens):
assistant_model.max_assistant_tokens += 2.0
else:
assistant_model.max_assistant_tokens = max(1.0, assistant_model.max_assistant_tokens - 1.0)
# Assistant: main logic end
if synced_gpus and this_peer_finished:
continue # don't waste resources running the code we don't need
# Store scores, attentions and hidden_states when required
# Assistant: modified to append one tuple element per token, as in the other generation methods.
if return_dict_in_generate:
if output_scores:
scores += tuple(new_logits[:, i, :] for i in range(n_matches + 1))
if "past_key_values" not in model_kwargs:
added_len = new_cur_len
else:
added_len = n_matches + 1
if output_attentions:
if self.config.is_encoder_decoder:
cross_attentions = _split_model_outputs(
cross_attentions, outputs.cross_attentions, cur_len, added_len
)
decoder_attentions = _split_model_outputs(
decoder_attentions,
outputs.decoder_attentions,
cur_len,
added_len,
is_decoder_attention=True,
)
else:
decoder_attentions = _split_model_outputs(
decoder_attentions,
outputs.attentions,
cur_len,
added_len,
is_decoder_attention=True,
)
if output_hidden_states:
if self.config.is_encoder_decoder:
decoder_hidden_states = _split_model_outputs(
decoder_hidden_states, outputs.decoder_hidden_states, cur_len, added_len
)
else:
decoder_hidden_states = _split_model_outputs(
decoder_hidden_states, outputs.hidden_states, cur_len, added_len
)
model_kwargs = self._update_model_kwargs_for_generation(
outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
)
# if eos_token was found in one sentence, set sentence to finished
if eos_token_id_tensor is not None:
unfinished_sequences = unfinished_sequences.mul(
input_ids[:, -1]
.tile(eos_token_id_tensor.shape[0], 1)
.ne(eos_token_id_tensor.unsqueeze(1))
.prod(dim=0)
)
# stop when each sentence is finished
if unfinished_sequences.max() == 0:
this_peer_finished = True
# stop if we exceed the maximum length
if stopping_criteria(input_ids, scores):
this_peer_finished = True
if this_peer_finished and not synced_gpus:
break
if streamer is not None:
streamer.end()
if return_dict_in_generate:
if self.config.is_encoder_decoder:
return GreedySearchEncoderDecoderOutput(
sequences=input_ids,
scores=scores,
encoder_attentions=encoder_attentions,
encoder_hidden_states=encoder_hidden_states,
decoder_attentions=decoder_attentions,
cross_attentions=cross_attentions,
decoder_hidden_states=decoder_hidden_states,
)
else:
return GreedySearchDecoderOnlyOutput(
sequences=input_ids,
scores=scores,
attentions=decoder_attentions,
hidden_states=decoder_hidden_states,
)
else:
return input_ids
def _crop_past_key_values(model, past_key_values, maximum_length):
"""Crops the past key values up to a certain maximum length."""
new_past = []
if model.config.is_encoder_decoder:
for idx in range(len(past_key_values)):
new_past.append(
(
past_key_values[idx][0][:, :, :maximum_length, :],
past_key_values[idx][1][:, :, :maximum_length, :],
past_key_values[idx][2],
past_key_values[idx][3],
)
)
past_key_values = tuple(new_past)
# bloom is special
elif "bloom" in model.__class__.__name__.lower() or (
model.config.architectures is not None and "bloom" in model.config.architectures[0].lower()
):
for idx in range(len(past_key_values)):
new_past.append(
(
past_key_values[idx][0][:, :, :maximum_length],
past_key_values[idx][1][:, :maximum_length, :],
)
)
past_key_values = tuple(new_past)
# gptbigcode is too
elif "gptbigcode" in model.__class__.__name__.lower() or (
model.config.architectures is not None and "gptbigcode" in model.config.architectures[0].lower()
):
if model.config.multi_query:
for idx in range(len(past_key_values)):
past_key_values[idx] = past_key_values[idx][:, :maximum_length, :]
else:
for idx in range(len(past_key_values)):
past_key_values[idx] = past_key_values[idx][:, :, :maximum_length, :]
else:
for idx in range(len(past_key_values)):
new_past.append(
(
past_key_values[idx][0][:, :, :maximum_length, :],
past_key_values[idx][1][:, :, :maximum_length, :],
)
)
past_key_values = tuple(new_past)
return past_key_values
def _split_model_outputs(outputs, new_outputs, cur_len, added_len, is_decoder_attention=False):
"""
Given the (decoder/cross attentions)/(decoder hidden states) for multiple generated tokens, splits it into a tuple
where each member corresponds to a single generated token.
"""
# Retrocompatibility: in our generation functions, the first iteration includes the attention/hidden states for the
# prompt.
if len(outputs) == 0:
new_tuple = ()
for layer in new_outputs:
last_dim_size = cur_len if is_decoder_attention else layer.shape[-1]
new_tuple += (layer[..., :cur_len, :last_dim_size],)
outputs += (new_tuple,)
# The first iteration contains the prompt + 1 generated token, let's update the length variables accordingly
cur_len += 1
added_len -= cur_len
for i in range(added_len):
new_tuple = ()
for layer in new_outputs:
last_dim_size = cur_len + i if is_decoder_attention else layer.shape[-1]
new_tuple += (layer[..., i : i + 1, :last_dim_size],)
outputs += (new_tuple,)
return outputs
def top_k_top_p_filtering(
logits: torch.FloatTensor,
top_k: int = 0,
top_p: float = 1.0,
filter_value: float = -float("Inf"),
min_tokens_to_keep: int = 1,
) -> torch.FloatTensor:
"""
Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (batch size, vocabulary size)
top_k (`int`, *optional*, defaults to 0):
If > 0, only keep the top k tokens with highest probability (top-k filtering)
top_p (`float`, *optional*, defaults to 1.0):
If < 1.0, only keep the top tokens with cumulative probability >= top_p (nucleus filtering). Nucleus
filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
min_tokens_to_keep (`int`, *optional*, defaults to 1):
Minimumber of tokens we keep per batch example in the output.
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
if top_k > 0:
logits = TopKLogitsWarper(top_k=top_k, filter_value=filter_value, min_tokens_to_keep=min_tokens_to_keep)(
None, logits
)
if 0 <= top_p <= 1.0:
logits = TopPLogitsWarper(top_p=top_p, filter_value=filter_value, min_tokens_to_keep=min_tokens_to_keep)(
None, logits
)
return logits
def _ranking_fast(
context_hidden: torch.FloatTensor,
next_hidden: torch.FloatTensor,
next_top_k_probs: torch.FloatTensor,
alpha: float,
beam_width: int,
) -> torch.FloatTensor:
"""
Reranks the top_k candidates based on a degeneration penalty (cosine similarity with previous tokens), as described
in the paper "A Contrastive Framework for Neural Text Generation". Returns the index of the best candidate for each
row in the batch.
"""
norm_context_hidden = context_hidden / context_hidden.norm(dim=2, keepdim=True)
norm_next_hidden = next_hidden / next_hidden.norm(dim=2, keepdim=True)
cosine_matrix = torch.matmul(norm_context_hidden, norm_next_hidden.transpose(1, 2)).squeeze(-1) # [B*K, S]
degeneration_penalty, _ = torch.max(cosine_matrix, dim=-1) # [B*K]
next_top_k_probs = next_top_k_probs.view(-1) # [B*K]
contrastive_score = (1.0 - alpha) * next_top_k_probs - alpha * degeneration_penalty
contrastive_score = torch.stack(torch.split(contrastive_score, beam_width)) # [B, K]
_, selected_idx = contrastive_score.max(dim=-1) # [B]
return selected_idx
================================================
FILE: train/src/models/llama/modeling_llama.py
================================================
# coding=utf-8
# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.
#
# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX
# and OPT implementations in this library. It has been modified from its
# original forms to accommodate minor architectural differences compared
# to GPT-NeoX and OPT used by the Meta AI team that trained the model.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
PyTorch LLaMA model.
Add FlashAttention
"""
import math
from typing import List, Optional, Tuple, Union
import torch
import torch.nn.functional as F
import torch.utils.checkpoint
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
from transformers.activations import ACT2FN
from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast, SequenceClassifierOutputWithPast
from transformers.modeling_utils import PreTrainedModel
from transformers.utils import add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings
from transformers.models.llama.configuration_llama import LlamaConfig
from flash_attn import flash_attn_func
try:
from flash_attn.flash_attn_interface import flash_attn_varlen_func
except ImportError:
flash_attn_varlen_func = None
print(
"Warning: import flash_attn fail, please install FlashAttention "
"https://github.com/Dao-AILab/flash-attention"
)
try:
from einops import rearrange
except ImportError:
rearrange = None
logger = logging.get_logger(__name__)
_CONFIG_FOR_DOC = "LlamaConfig"
# Copied from transformers.models.bart.modeling_bart._make_causal_mask
def _make_causal_mask(
input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0
):
"""
Make causal mask used for bi-directional self-attention.
"""
bsz, tgt_len = input_ids_shape
mask = torch.full((tgt_len, tgt_len), torch.finfo(dtype).min, device=device)
mask_cond = torch.arange(mask.size(-1), device=device)
mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)
mask = mask.to(dtype)
if past_key_values_length > 0:
mask = torch.cat([torch.zeros(tgt_len, past_key_values_length, dtype=dtype, device=device), mask], dim=-1)
return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len + past_key_values_length)
# Copied from transformers.models.bart.modeling_bart._expand_mask
def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
"""
Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.
"""
bsz, src_len = mask.size()
tgt_len = tgt_len if tgt_len is not None else src_len
expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)
inverted_mask = 1.0 - expanded_mask
return inverted_mask.masked_fill(inverted_mask.to(torch.bool), torch.finfo(dtype).min)
class LlamaRMSNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-6):
"""
LlamaRMSNorm is equivalent to T5LayerNorm
"""
super().__init__()
self.weight = nn.Parameter(torch.ones(hidden_size))
self.variance_epsilon = eps
def forward(self, hidden_states):
input_dtype = hidden_states.dtype
hidden_states = hidden_states.to(torch.float32)
variance = hidden_states.pow(2).mean(-1, keepdim=True)
hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
return self.weight * hidden_states.to(input_dtype)
class LlamaRotaryEmbedding(torch.nn.Module):
def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):
super().__init__()
self.dim = dim
self.max_position_embeddings = max_position_embeddings
self.base = base
inv_freq = 1.0 / (self.base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim))
self.register_buffer("inv_freq", inv_freq, persistent=False)
# Build here to make `torch.jit.trace` work.
self._set_cos_sin_cache(
seq_len=max_position_embeddings, device=self.inv_freq.device, dtype=torch.get_default_dtype()
)
def _set_cos_sin_cache(self, seq_len, device, dtype):
self.max_seq_len_cached = seq_len
t = torch.arange(self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype)
freqs = torch.einsum("i,j->ij", t, self.inv_freq)
# Different from paper, but it uses a different permutation in order to obtain the same calculation
emb = torch.cat((freqs, freqs), dim=-1)
self.register_buffer("cos_cached", emb.cos()[None, None, :, :].to(dtype), persistent=False)
self.register_buffer("sin_cached", emb.sin()[None, None, :, :].to(dtype), persistent=False)
def forward(self, x, seq_len=None):
# x: [bs, num_attention_heads, seq_len, head_size]
if seq_len > self.max_seq_len_cached:
self._set_cos_sin_cache(seq_len=seq_len, device=x.device, dtype=x.dtype)
return (
self.cos_cached[:, :, :seq_len, ...].to(dtype=x.dtype),
self.sin_cached[:, :, :seq_len, ...].to(dtype=x.dtype),
)
class LlamaLinearScalingRotaryEmbedding(LlamaRotaryEmbedding):
"""LlamaRotaryEmbedding extended with linear scaling. Credits to the Reddit user /u/kaiokendev"""
def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None, scaling_factor=1.0):
self.scaling_factor = scaling_factor
super().__init__(dim, max_position_embeddings, base, device)
def _set_cos_sin_cache(self, seq_len, device, dtype):
self.max_seq_len_cached = seq_len
t = torch.arange(self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype)
t = t / self.scaling_factor
freqs = torch.einsum("i,j->ij", t, self.inv_freq)
# Different from paper, but it uses a different permutation in order to obtain the same calculation
emb = torch.cat((freqs, freqs), dim=-1)
self.register_buffer("cos_cached", emb.cos()[None, None, :, :].to(dtype), persistent=False)
self.register_buffer("sin_cached", emb.sin()[None, None, :, :].to(dtype), persistent=False)
class LlamaDynamicNTKScalingRotaryEmbedding(LlamaRotaryEmbedding):
"""LlamaRotaryEmbedding extended with Dynamic NTK scaling. Credits to the Reddit users /u/bloc97 and /u/emozilla"""
def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None, scaling_factor=1.0):
self.scaling_factor = scaling_factor
super().__init__(dim, max_position_embeddings, base, device)
def _set_cos_sin_cache(self, seq_len, device, dtype):
self.max_seq_len_cached = seq_len
if seq_len > self.max_position_embeddings:
base = self.base * (
(self.scaling_factor * seq_len / self.max_position_embeddings) - (self.scaling_factor - 1)
) ** (self.dim / (self.dim - 2))
inv_freq = 1.0 / (base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim))
self.register_buffer("inv_freq", inv_freq, persistent=False)
t = torch.arange(self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype)
freqs = torch.einsum("i,j->ij", t, self.inv_freq)
# Different from paper, but it uses a different permutation in order to obtain the same calculation
emb = torch.cat((freqs, freqs), dim=-1)
self.register_buffer("cos_cached", emb.cos()[None, None, :, :].to(dtype), persistent=False)
self.register_buffer("sin_cached", emb.sin()[None, None, :, :].to(dtype), persistent=False)
def rotate_half(x):
"""Rotates half the hidden dims of the input."""
x1 = x[..., : x.shape[-1] // 2]
x2 = x[..., x.shape[-1] // 2 :]
return torch.cat((-x2, x1), dim=-1)
def apply_rotary_pos_emb(q, k, cos, sin, position_ids):
# The first two dimensions of cos and sin are always 1, so we can `squeeze` them.
cos = cos.squeeze(1).squeeze(0) # [seq_len, dim]
sin = sin.squeeze(1).squeeze(0) # [seq_len, dim]
cos = cos[position_ids].unsqueeze(1) # [bs, 1, seq_len, dim]
sin = sin[position_ids].unsqueeze(1) # [bs, 1, seq_len, dim]
q_embed = (q * cos) + (rotate_half(q) * sin)
k_embed = (k * cos) + (rotate_half(k) * sin)
return q_embed, k_embed
class LlamaMLP(nn.Module):
def __init__(self, config):
super().__init__()
self.config = config
self.hidden_size = config.hidden_size
self.intermediate_size = config.intermediate_size
self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
self.act_fn = ACT2FN[config.hidden_act]
def forward(self, x):
if self.config.pretraining_tp > 1:
slice = self.intermediate_size // self.config.pretraining_tp
gate_proj_slices = self.gate_proj.weight.split(slice, dim=0)
up_proj_slices = self.up_proj.weight.split(slice, dim=0)
down_proj_slices = self.down_proj.weight.split(slice, dim=1)
gate_proj = torch.cat(
[F.linear(x, gate_proj_slices[i]) for i in range(self.config.pretraining_tp)], dim=-1
)
up_proj = torch.cat([F.linear(x, up_proj_slices[i]) for i in range(self.config.pretraining_tp)], dim=-1)
intermediate_states = (self.act_fn(gate_proj) * up_proj).split(slice, dim=2)
down_proj = [
F.linear(intermediate_states[i], down_proj_slices[i]) for i in range(self.config.pretraining_tp)
]
down_proj = sum(down_proj)
else:
down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
return down_proj
def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
"""
This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
"""
batch, num_key_value_heads, slen, head_dim = hidden_states.shape
if n_rep == 1:
return hidden_states
hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
class FlashSelfAttention(torch.nn.Module):
def __init__(
self,
causal=False,
softmax_scale=None,
attention_dropout=0.0,
):
super().__init__()
assert flash_attn_varlen_func is not None, (
"Please install FlashAttention first, " "e.g., with pip install flash-attn"
)
assert (
rearrange is not None
), "Please install einops first, e.g., with pip install einops"
self.causal = causal
self.softmax_scale = softmax_scale
self.dropout_p = attention_dropout
def forward(self, q, k, v):
assert all((i.dtype in [torch.float16, torch.bfloat16] for i in (q, k, v)))
assert all((i.is_cuda for i in (q, k, v)))
batch_size, seqlen_q = q.shape[0], q.shape[1]
seqlen_k = k.shape[1]
q, k, v = [rearrange(x, "b s ... -> (b s) ...") for x in [q, k, v]]
cu_seqlens_q = torch.arange(
0,
(batch_size + 1) * seqlen_q,
step=seqlen_q,
dtype=torch.int32,
device=q.device,
)
if self.training:
assert seqlen_k == seqlen_q
is_causal = self.causal
cu_seqlens_k = cu_seqlens_q
else:
is_causal = seqlen_q == seqlen_k
cu_seqlens_k = torch.arange(
0,
(batch_size + 1) * seqlen_k,
step=seqlen_k,
dtype=torch.int32,
device=q.device,
)
self.dropout_p = 0
output = flash_attn_varlen_func(
q,
k,
v,
cu_seqlens_q,
cu_seqlens_k,
seqlen_q,
seqlen_k,
self.dropout_p,
softmax_scale=self.softmax_scale,
causal=is_causal,
)
output = rearrange(output, "(b s) ... -> b s ...", b=batch_size)
return output
class LlamaAttention(nn.Module):
"""
Multi-headed attention from 'Attention Is All You Need' paper
Add FlashAttention
"""
def __init__(self, config: LlamaConfig):
super().__init__()
self.config = config
self.hidden_size = config.hidden_size
self.num_heads = config.num_attention_heads
self.head_dim = self.hidden_size // self.num_heads
self.num_key_value_heads = config.num_key_value_heads
self.num_key_value_groups = self.num_heads // self.num_key_value_heads
self.max_position_embeddings = config.max_position_embeddings
if (self.head_dim * self.num_heads) != self.hidden_size:
raise ValueError(
f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}"
f" and `num_heads`: {self.num_heads})."
)
self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
self.k_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False)
self.v_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False)
self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=False)
self.flash_attention = FlashSelfAttention(
causal=True
)
self._init_rope()
def _init_rope(self):
if self.config.rope_scaling is None:
self.rotary_emb = LlamaRotaryEmbedding(self.head_dim, max_position_embeddings=self.max_position_embeddings)
else:
scaling_type = self.config.rope_scaling["type"]
scaling_factor = self.config.rope_scaling["factor"]
if scaling_type == "linear":
self.rotary_emb = LlamaLinearScalingRotaryEmbedding(
self.head_dim, max_position_embeddings=self.max_position_embeddings, scaling_factor=scaling_factor
)
elif scaling_type == "dynamic":
self.rotary_emb = LlamaDynamicNTKScalingRotaryEmbedding(
self.head_dim, max_position_embeddings=self.max_position_embeddings, scaling_factor=scaling_factor
)
else:
raise ValueError(f"Unknown RoPE scaling type {scaling_type}")
def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
def forward(
self,
hidden_states: torch.Tensor,
attention_mask: Optional[torch.Tensor] = None,
position_ids: Optional[torch.LongTensor] = None,
past_key_value: Optional[Tuple[torch.Tensor]] = None,
output_attentions: bool = False,
use_cache: bool = False,
) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
bsz, q_len, _ = hidden_states.size()
if self.config.pretraining_tp > 1:
key_value_slicing = (self.num_key_value_heads * self.head_dim) // self.config.pretraining_tp
query_slices = self.q_proj.weight.split(
(self.num_heads * self.head_dim) // self.config.pretraining_tp, dim=0
)
key_slices = self.k_proj.weight.split(key_value_slicing, dim=0)
value_slices = self.v_proj.weight.split(key_value_slicing, dim=0)
query_states = [F.linear(hidden_states, query_slices[i]) for i in range(self.config.pretraining_tp)]
query_states = torch.cat(query_states, dim=-1)
key_states = [F.linear(hidden_states, key_slices[i]) for i in range(self.config.pretraining_tp)]
key_states = torch.cat(key_states, dim=-1)
value_states = [F.linear(hidden_states, value_slices[i]) for i in range(self.config.pretraining_tp)]
value_states = torch.cat(value_states, dim=-1)
else:
query_states = self.q_proj(hidden_states)
key_states = self.k_proj(hidden_states)
value_states = self.v_proj(hidden_states)
query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
kv_seq_len = key_states.shape[-2]
if past_key_value is not None:
kv_seq_len += past_key_value[0].shape[-2]
cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)
if past_key_value is not None:
# reuse k, v, self_attention
key_states = torch.cat([past_key_value[0], key_states], dim=2)
value_states = torch.cat([past_key_value[1], value_states], dim=2)
past_key_value = (key_states, value_states) if use_cache else None
if getattr(self.config, "use_flash_attention", False):
# Flash attiontion
# q, k, v: [batch_size, head_size, seq_len, hidden_size]
query_states = query_states.transpose(1, 2)
key_states = key_states.transpose(1, 2)
value_states = value_states.transpose(1, 2)
attn_output = self.flash_attention(
query_states,
key_states,
value_states
)
attn_output = attn_output.transpose(1, 2)
else:
# Pytorch attention
# repeat k/v heads if n_kv_heads < n_heads
key_states = repeat_kv(key_states, self.num_key_value_groups)
value_states = repeat_kv(value_states, self.num_key_value_groups)
attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)
if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len):
raise ValueError(
f"Attention weights should be of size {(bsz, self.num_heads, q_len, kv_seq_len)}, but is"
f" {attn_weights.size()}"
)
if attention_mask is not None:
if attention_mask.size() != (bsz, 1, q_len, kv_seq_len):
raise ValueError(
f"Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}"
)
attn_weights = attn_weights + attention_mask
# upcast attention to fp32
attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
attn_output = torch.matmul(attn_weights, value_states)
if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):
raise ValueError(
f"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is"
f" {attn_output.size()}"
)
attn_output = attn_output.transpose(1, 2).contiguous()
attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)
if self.config.pretraining_tp > 1:
attn_output = attn_output.split(self.hidden_size // self.config.pretraining_tp, dim=2)
o_proj_slices = self.o_proj.weight.split(self.hidden_size // self.config.pretraining_tp, dim=1)
attn_output = sum([F.linear(attn_output[i], o_proj_slices[i]) for i in range(self.config.pretraining_tp)])
else:
attn_output = self.o_proj(attn_output)
if not output_attentions:
attn_weights = None
return attn_output, attn_weights, past_key_value
class LlamaDecoderLayer(nn.Module):
def __init__(self, config: LlamaConfig):
super().__init__()
self.hidden_size = config.hidden_size
self.self_attn = LlamaAttention(config=config)
self.mlp = LlamaMLP(config)
self.input_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
self.post_attention_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
def forward(
self,
hidden_states: torch.Tensor,
attention_mask: Optional[torch.Tensor] = None,
position_ids: Optional[torch.LongTensor] = None,
past_key_value: Optional[Tuple[torch.Tensor]] = None,
output_attentions: Optional[bool] = False,
use_cache: Optional[bool] = False,
) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]:
"""
Args:
hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
attention_mask (`torch.FloatTensor`, *optional*): attention mask of size
`(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
output_attentions (`bool`, *optional*):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under
returned tensors for more detail.
use_cache (`bool`, *optional*):
If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
(see `past_key_values`).
past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states
"""
residual = hidden_states
hidden_states = self.input_layernorm(hidden_states)
# Self Attention
hidden_states, self_attn_weights, present_key_value = self.self_attn(
hidden_states=hidden_states,
attention_mask=attention_mask,
position_ids=position_ids,
past_key_value=past_key_value,
output_attentions=output_attentions,
use_cache=use_cache,
)
hidden_states = residual + hidden_states
# Fully Connected
residual = hidden_states
hidden_states = self.post_attention_layernorm(hidden_states)
hidden_states = self.mlp(hidden_states)
hidden_states = residual + hidden_states
outputs = (hidden_states,)
if output_attentions:
outputs += (self_attn_weights,)
if use_cache:
outputs += (present_key_value,)
return outputs
LLAMA_START_DOCSTRING = r"""
This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
etc.)
This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.
Parameters:
config ([`LlamaConfig`]):
Model configuration class with all the parameters of the model. Initializing with a config file does not
load the weights associated with the model, only the configuration. Check out the
[`~PreTrainedModel.from_pretrained`] method to load the model weights.
"""
@add_start_docstrings(
"The bare LLaMA Model outputting raw hidden-states without any specific head on top.",
LLAMA_START_DOCSTRING,
)
class LlamaPreTrainedModel(PreTrainedModel):
config_class = LlamaConfig
base_model_prefix = "model"
supports_gradient_checkpointing = True
_no_split_modules = ["LlamaDecoderLayer"]
_skip_keys_device_placement = "past_key_values"
def _init_weights(self, module):
std = self.config.initializer_range
if isinstance(module, nn.Linear):
module.weight.data.normal_(mean=0.0, std=std)
if module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.Embedding):
module.weight.data.normal_(mean=0.0, std=std)
if module.padding_idx is not None:
module.weight.data[module.padding_idx].zero_()
def _set_gradient_checkpointing(self, module, value=False):
if isinstance(module, LlamaModel):
module.gradient_checkpointing = value
LLAMA_INPUTS_DOCSTRING = r"""
Args:
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
it.
Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
[`PreTrainedTokenizer.__call__`] for details.
[What are input IDs?](../glossary#input-ids)
attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
- 1 for tokens that are **not masked**,
- 0 for tokens that are **masked**.
[What are attention masks?](../glossary#attention-mask)
Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
[`PreTrainedTokenizer.__call__`] for details.
If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see
`past_key_values`).
If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]
and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more
information on the default strategy.
- 1 indicates the head is **not masked**,
- 0 indicates the head is **masked**.
position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
config.n_positions - 1]`.
[What are position IDs?](../glossary#position-ids)
past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
`(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape
`(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`.
Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
`decoder_input_ids` of shape `(batch_size, sequence_length)`.
inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
model's internal embedding lookup matrix.
use_cache (`bool`, *optional*):
If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
`past_key_values`).
output_attentions (`bool`, *optional*):
Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
tensors for more detail.
output_hidden_states (`bool`, *optional*):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
more detail.
return_dict (`bool`, *optional*):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""
@add_start_docstrings(
"The bare LLaMA Model outputting raw hidden-states without any specific head on top.",
LLAMA_START_DOCSTRING,
)
class LlamaModel(LlamaPreTrainedModel):
"""
Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`LlamaDecoderLayer`]
Args:
config: LlamaConfig
"""
def __init__(self, config: LlamaConfig):
super().__init__(config)
self.padding_idx = config.pad_token_id
self.vocab_size = config.vocab_size
self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
self.layers = nn.ModuleList([LlamaDecoderLayer(config) for _ in range(config.num_hidden_layers)])
self.norm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
self.gradient_checkpointing = False
# Initialize weights and apply final processing
self.post_init()
def get_input_embeddings(self):
return self.embed_tokens
def set_input_embeddings(self, value):
self.embed_tokens = value
# Copied from transformers.models.bart.modeling_bart.BartDecoder._prepare_decoder_attention_mask
def _prepare_decoder_attention_mask(self, attention_mask, input_shape, inputs_embeds, past_key_values_length):
# create causal mask
# [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
combined_attention_mask = None
if input_shape[-1] > 1:
combined_attention_mask = _make_causal_mask(
input_shape,
inputs_embeds.dtype,
device=inputs_embeds.device,
past_key_values_length=past_key_values_length,
)
if attention_mask is not None:
# [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
expanded_attn_mask = _expand_mask(attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(
inputs_embeds.device
)
combined_attention_mask = (
expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask
)
return combined_attention_mask
@add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)
def forward(
self,
input_ids: torch.LongTensor = None,
attention_mask: Optional[torch.Tensor] = None,
position_ids: Optional[torch.LongTensor] = None,
past_key_values: Optional[List[torch.FloatTensor]] = None,
inputs_embeds: Optional[torch.FloatTensor] = None,
use_cache: Optional[bool] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[Tuple, BaseModelOutputWithPast]:
output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
)
use_cache = use_cache if use_cache is not None else self.config.use_cache
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
# retrieve input_ids and inputs_embeds
if input_ids is not None and inputs_embeds is not None:
raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time")
elif input_ids is not None:
batch_size, seq_length = input_ids.shape
elif inputs_embeds is not None:
batch_size, seq_length, _ = inputs_embeds.shape
else:
raise ValueError("You have to specify either decoder_input_ids or decoder_inputs_embeds")
seq_length_with_past = seq_length
past_key_values_length = 0
if past_key_values is not None:
past_key_values_length = past_key_values[0][0].shape[2]
seq_length_with_past = seq_length_with_past + past_key_values_length
if position_ids is None:
device = input_ids.device if input_ids is not None else inputs_embeds.device
position_ids = torch.arange(
past_key_values_length, seq_length + past_key_values_length, dtype=torch.long, device=device
)
position_ids = position_ids.unsqueeze(0).view(-1, seq_length)
else:
position_ids = position_ids.view(-1, seq_length).long()
if inputs_embeds is None:
inputs_embeds = self.embed_tokens(input_ids)
# embed positions
if attention_mask is None:
attention_mask = torch.ones(
(batch_size, seq_length_with_past), dtype=torch.bool, device=inputs_embeds.device
)
attention_mask = self._prepare_decoder_attention_mask(
attention_mask, (batch_size, seq_length), inputs_embeds, past_key_values_length
)
hidden_states = inputs_embeds
if self.gradient_checkpointing and self.training:
if use_cache:
logger.warning_once(
"`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
)
use_cache = False
# decoder layers
all_hidden_states = () if output_hidden_states else None
all_self_attns = () if output_attentions else None
next_decoder_cache = () if use_cache else None
for idx, decoder_layer in enumerate(self.layers):
if output_hidden_states:
all_hidden_states += (hidden_states,)
past_key_value = past_key_values[idx] if past_key_values is not None else None
if self.gradient_checkpointing and self.training:
def create_custom_forward(module):
def custom_forward(*inputs):
# None for past_key_value
return module(*inputs, past_key_value, output_attentions)
return custom_forward
layer_outputs = torch.utils.checkpoint.checkpoint(
create_custom_forward(decoder_layer),
hidden_states,
attention_mask,
position_ids,
)
else:
layer_outputs = decoder_layer(
hidden_states,
attention_mask=attention_mask,
position_ids=position_ids,
past_key_value=past_key_value,
output_attentions=output_attentions,
use_cache=use_cache,
)
hidden_states = layer_outputs[0]
if use_cache:
next_decoder_cache += (layer_outputs[2 if output_attentions else 1],)
if output_attentions:
all_self_attns += (layer_outputs[1],)
hidden_states = self.norm(hidden_states)
# add hidden states from the last decoder layer
if output_hidden_states:
all_hidden_states += (hidden_states,)
next_cache = next_decoder_cache if use_cache else None
if not return_dict:
return tuple(v for v in [hidden_states, next_cache, all_hidden_states, all_self_attns] if v is not None)
return BaseModelOutputWithPast(
last_hidden_state=hidden_states,
past_key_values=next_cache,
hidden_states=all_hidden_states,
attentions=all_self_attns,
)
class LlamaForCausalLM(LlamaPreTrainedModel):
_tied_weights_keys = ["lm_head.weight"]
def __init__(self, config):
super().__init__(config)
self.model = LlamaModel(config)
self.vocab_size = config.vocab_size
self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
# Initialize weights and apply final processing
self.post_init()
def get_input_embeddings(self):
return self.model.embed_tokens
def set_input_embeddings(self, value):
self.model.embed_tokens = value
def get_output_embeddings(self):
return self.lm_head
def set_output_embeddings(self, new_embeddings):
self.lm_head = new_embeddings
def set_decoder(self, decoder):
self.model = decoder
def get_decoder(self):
return self.model
@add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)
@replace_return_docstrings(output_type=CausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC)
def forward(
self,
input_ids: torch.LongTensor = None,
attention_mask: Optional[torch.Tensor] = None,
position_ids: Optional[torch.LongTensor] = None,
past_key_values: Optional[List[torch.FloatTensor]] = None,
inputs_embeds: Optional[torch.FloatTensor] = None,
labels: Optional[torch.LongTensor] = None,
use_cache: Optional[bool] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[Tuple, CausalLMOutputWithPast]:
r"""
Args:
labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
(masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
Returns:
Example:
```python
>>> from transformers import AutoTokenizer, LlamaForCausalLM
>>> model = LlamaForCausalLM.from_pretrained(PATH_TO_CONVERTED_WEIGHTS)
>>> tokenizer = AutoTokenizer.from_pretrained(PATH_TO_CONVERTED_TOKENIZER)
>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."
```"""
output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
output_hidden_states = (
output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
)
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
# decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
outputs = self.model(
input_ids=input_ids,
attention_mask=attention_mask,
position_ids=position_ids,
past_key_values=past_key_values,
inputs_embeds=inputs_embeds,
use_cache=use_cache,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_states = outputs[0]
if self.config.pretraining_tp > 1:
lm_head_slices = self.lm_head.weight.split(self.vocab_size // self.config.pretraining_tp, dim=0)
logits = [F.linear(hidden_states, lm_head_slices[i]) for i in range(self.config.pretraining_tp)]
logits = torch.cat(logits, dim=-1)
else:
logits = self.lm_head(hidden_states)
logits = logits.float()
loss = None
if labels is not None:
# Shift so that tokens < n predict n
shift_logits = logits[..., :-1, :].contiguous()
shift_labels = labels[..., 1:].contiguous()
# Flatten the tokens
loss_fct = CrossEntropyLoss()
shift_logits = shift_logits.view(-1, self.config.vocab_size)
shift_labels = shift_labels.view(-1)
# Enable model parallelism
shift_labels = shift_labels.to(shift_logits.device)
loss = loss_fct(shift_logits, shift_labels)
if not return_dict:
output = (logits,) + outputs[1:]
return (loss,) + output if loss is not None else output
return CausalLMOutputWithPast(
loss=loss,
logits=logits,
past_key_values=outputs.past_key_values,
hidden_states=outputs.hidden_states,
attentions=outputs.attentions,
)
def prepare_inputs_for_generation(
self, input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs
):
if past_key_values:
input_ids = input_ids[:, -1:]
position_ids = kwargs.get("position_ids", None)
if attention_mask is not None and position_ids is None:
# create position_ids on the fly for batch generation
position_ids = attention_mask.long().cumsum(-1) - 1
position_ids.masked_fill_(attention_mask == 0, 1)
if past_key_values:
position_ids = position_ids[:, -1].unsqueeze(-1)
# if `inputs_embeds` are passed, we only want to use them in the 1st generation step
if inputs_embeds is not None and past_key_values is None:
model_inputs = {"inputs_embeds": inputs_embeds}
else:
model_inputs = {"input_ids": input_ids}
model_inputs.update(
{
"position_ids": position_ids,
"past_key_values": past_key_values,
"use_cache": kwargs.get("use_cache"),
"attention_mask": attention_mask,
}
)
return model_inputs
@staticmethod
def _reorder_cache(past_key_values, beam_idx):
reordered_past = ()
for layer_past in past_key_values:
reordered_past += (
tuple(past_state.index_select(0, beam_idx.to(past_state.device)) for past_state in layer_past),
)
return reordered_past
@add_start_docstrings(
"""
The LLaMa Model transformer with a sequence classification head on top (linear layer).
[`LlamaForSequenceClassification`] uses the last token in order to do the classification, as other causal models
(e.g. GPT-2) do.
Since it does classification on the last token, it requires to know the position of the last token. If a
`pad_token_id` is defined in the configuration, it finds the last token that is not a padding token in each row. If
no `pad_token_id` is defined, it simply takes the last value in each row of the batch. Since it cannot guess the
padding tokens when `inputs_embeds` are passed instead of `input_ids`, it does the same (take the last value in
each row of the batch).
""",
LLAMA_START_DOCSTRING,
)
class LlamaForSequenceClassification(LlamaPreTrainedModel):
def __init__(self, config):
super().__init__(config)
self.num_labels = config.num_labels
self.model = LlamaModel(config)
self.score = nn.Linear(config.hidden_size, self.num_labels, bias=False)
# Initialize weights and apply final processing
self.post_init()
def get_input_embeddings(self):
return self.model.embed_tokens
def set_input_embeddings(self, value):
self.model.embed_tokens = value
@add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)
def forward(
self,
input_ids: torch.LongTensor = None,
attention_mask: Optional[torch.Tensor] = None,
position_ids: Optional[torch.LongTensor] = None,
past_key_values: Optional[List[torch.FloatTensor]] = None,
inputs_embeds: Optional[torch.FloatTensor] = None,
labels: Optional[torch.LongTensor] = None,
use_cache: Optional[bool] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[Tuple, SequenceClassifierOutputWithPast]:
r"""
labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
`config.num_labels > 1` a classification loss is computed (Cross-Entropy).
"""
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
transformer_outputs = self.model(
input_ids,
attention_mask=attention_mask,
position_ids=position_ids,
past_key_values=past_key_values,
inputs_embeds=inputs_embeds,
use_cache=use_cache,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_states = transformer_outputs[0]
logits = self.score(hidden_states)
if input_ids is not None:
batch_size = input_ids.shape[0]
else:
batch_size = inputs_embeds.shape[0]
if self.config.pad_token_id is None and batch_size != 1:
raise ValueError("Cannot handle batch sizes > 1 if no padding token is defined.")
if self.config.pad_token_id is None:
sequence_lengths = -1
else:
if input_ids is not None:
sequence_lengths = (torch.eq(input_ids, self.config.pad_token_id).long().argmax(-1) - 1).to(
logits.device
)
else:
sequence_lengths = -1
pooled_logits = logits[torch.arange(batch_size, device=logits.device), sequence_lengths]
loss = None
if labels is not None:
labels = labels.to(logits.device)
if self.config.problem_type is None:
if self.num_labels == 1:
self.config.problem_type = "regression"
elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
self.config.problem_type = "single_label_classification"
else:
self.config.problem_type = "multi_label_classification"
if self.config.problem_type == "regression":
loss_fct = MSELoss()
if self.num_labels == 1:
loss = loss_fct(pooled_logits.squeeze(), labels.squeeze())
else:
loss = loss_fct(pooled_logits, labels)
elif self.config.problem_type == "single_label_classification":
loss_fct = CrossEntropyLoss()
loss = loss_fct(pooled_logits.view(-1, self.num_labels), labels.view(-1))
elif self.config.problem_type == "multi_label_classification":
loss_fct = BCEWithLogitsLoss()
loss = loss_fct(pooled_logits, labels)
if not return_dict:
output = (pooled_logits,) + transformer_outputs[1:]
return ((loss,) + output) if loss is not None else output
return SequenceClassifierOutputWithPast(
loss=loss,
logits=pooled_logits,
past_key_values=transformer_outputs.past_key_values,
hidden_states=transformer_outputs.hidden_states,
attentions=transformer_outputs.attentions,
)
================================================
FILE: train/src/ppo_trainer.py
================================================
import time
from typing import Callable, List, Union, Optional
from pathlib import Path
import torch
from trl import PPOTrainer
from trl.core import (
logprobs_from_logits,
WANDB_PADDING,
PPODecorators,
convert_to_scalar,
stack_dicts,
stats_to_np,
)
from src.models.generation_utils import GenerationMixin
from transformers.modeling_utils import PreTrainedModel
from src.utils import bind_methods_from_class_to_instance, get_ds_state_dict
import torch.distributed as dist
import numpy as np
class PPOTrainerForZero3(PPOTrainer):
def _generate_batched(
self,
query_tensors: List[torch.Tensor],
length_sampler: Callable = None,
batch_size: int = 4,
return_prompt: bool = True,
pad_to_multiple_of: int = None,
remove_padding: bool = True,
**generation_kwargs,
):
outputs = []
padding_side_default = self.tokenizer.padding_side
if not self.is_encoder_decoder:
self.tokenizer.padding_side = "left"
# in case we have fewer examples than bs
batch_size = min(len(query_tensors), batch_size)
for i in range(0, len(query_tensors), batch_size):
if length_sampler is not None:
generation_kwargs["max_new_tokens"] = length_sampler()
# prevent overflow if query tensors are not even multiple of bs
end_index = min(len(query_tensors), i + batch_size)
batch = query_tensors[i:end_index]
batch_mask = [torch.ones_like(element) for element in batch]
inputs = {"input_ids": batch, "attention_mask": batch_mask}
padded_inputs = self.tokenizer.pad(
inputs,
padding=True,
max_length=None,
pad_to_multiple_of=pad_to_multiple_of,
return_tensors="pt",
).to(self.current_device)
unwrap_model = self.accelerator.unwrap_model(self.model).pretrained_model
bind_methods_from_class_to_instance(
unwrap_model,
GenerationMixin,
include=[
"contrastive_search",
"greedy_search",
"sample",
"beam_search",
"beam_sample",
"group_beam_search",
"constrained_beam_search",
"assisted_decoding",
"generate",
],
)
generations = unwrap_model.generate(
deepspeed_model=self.model,
**padded_inputs,
**generation_kwargs,
synced_gpus=True,
)
# generations = self.accelerator.unwrap_model(self.model).generate(
# **padded_inputs, **generation_kwargs
# )
for generation, mask in zip(generations, padded_inputs["attention_mask"]):
if not self.is_encoder_decoder:
output = generation[(1 - mask).sum() :] # remove padding
else:
output = generation
if not return_prompt and not self.is_encoder_decoder:
output = output[(mask).sum() :] # remove prompt
if remove_padding and self.tokenizer.eos_token_id in output:
pad_mask = output == self.tokenizer.eos_token_id
pad_start = torch.nonzero(pad_mask, as_tuple=False)[0, 0].item()
output = output[: pad_start + 1] # keep the eos token at the end
outputs.append(output)
self.tokenizer.padding_side = padding_side_default
return outputs
@PPODecorators.empty_cuda_cache()
def step(
self,
queries: List[torch.LongTensor],
responses: List[torch.LongTensor],
scores: List[torch.FloatTensor],
response_masks: Optional[List[torch.LongTensor]] = None,
):
"""
Run a PPO optimisation step given a list of queries, model responses, and rewards.
Args:
queries (List[`torch.LongTensor`]):
List of tensors containing the encoded queries of shape (`query_length`)
responses (List[`torch.LongTensor`]):
List of tensors containing the encoded responses of shape (`response_length`)
scores (List[`torch.FloatTensor`]):
List of tensors containing the scores.
response_masks (List[`torch.FloatTensor`], *optional*)):
List of tensors containing masks of the response tokens.
Returns:
`dict[str, Any]`: A summary of the training statistics
"""
bs = self.config.batch_size
queries, responses, scores, response_masks = self._step_safety_checker(
bs, queries, responses, scores, response_masks
)
scores = torch.tensor(scores, device=self.current_device)
if self.config.use_score_scaling:
# Score scaling
scores_mean, scores_std = self.running.update(scores)
tensor_to_kwargs = dict(dtype=scores.dtype, device=scores.device)
score_scaling_factor = (
self.running.std.to(**tensor_to_kwargs) + torch.finfo(scores.dtype).eps
)
if self.config.use_score_norm:
scores = (
scores - self.running.mean.to(**tensor_to_kwargs)
) / score_scaling_factor
else:
scores /= score_scaling_factor
if self.config.score_clip is not None:
# Score clipping
scores_dtype = scores.dtype
scores = torch.clip(
scores.float(), -self.config.score_clip, self.config.score_clip
).to(dtype=scores_dtype)
# if we want to push best model to the hub
if hasattr(self, "highest_reward"):
if self.compare_step % self.config.compare_steps == 0:
curr_mean_reward = scores.mean()
# if the best reward ever seen
if curr_mean_reward > self.highest_reward:
self.highest_reward = curr_mean_reward
# push model to hub
self.push_to_hub(**self.push_to_hub_kwargs)
self.compare_step += 1
timing = dict()
t0 = time.time()
t = time.time()
model_inputs = self.prepare_model_inputs(queries, responses)
if self.is_distributed:
pad_first = self.tokenizer.padding_side == "left"
model_inputs["input_ids"] = self.accelerator.pad_across_processes(
model_inputs["input_ids"],
dim=1,
pad_index=self.tokenizer.pad_token_id,
pad_first=pad_first,
)
model_inputs["attention_mask"] = self.accelerator.pad_across_processes(
model_inputs["attention_mask"], dim=1, pad_index=0, pad_first=pad_first
)
if self.is_encoder_decoder:
model_inputs[
"decoder_input_ids"
] = self.accelerator.pad_across_processes(
model_inputs["decoder_input_ids"],
dim=1,
pad_index=self.tokenizer.pad_token_id,
pad_first=pad_first,
)
model_inputs[
"decoder_attention_mask"
] = self.accelerator.pad_across_processes(
model_inputs["decoder_attention_mask"],
dim=1,
pad_index=0,
pad_first=pad_first,
)
model_inputs_names = list(model_inputs.keys())
full_kl_penalty = self.config.kl_penalty == "full"
with torch.no_grad():
all_logprobs, logits_or_none, values, masks = self.batched_forward_pass(
self.model,
queries,
responses,
model_inputs,
response_masks=response_masks,
return_logits=full_kl_penalty,
)
# for when the model is a peft model
if self.is_peft_model and hasattr(
self.accelerator.unwrap_model(self.model).pretrained_model,
"disable_adapter",
):
with self.accelerator.unwrap_model(
self.model
).pretrained_model.disable_adapter():
ref_logprobs, ref_logits_or_none, _, _ = self.batched_forward_pass(
self.model,
queries,
responses,
model_inputs,
return_logits=full_kl_penalty,
)
elif self.is_peft_model and not hasattr(
self.model.pretrained_model, "disable_adapter"
):
raise ValueError(
"You are using a `peft` version that does not support `disable_adapter`. Please update your `peft` version to the latest version."
)
else:
ref_logprobs, ref_logits_or_none, _, _ = self.batched_forward_pass(
self.ref_model,
queries,
responses,
model_inputs,
return_logits=full_kl_penalty,
)
timing["time/ppo/forward_pass"] = time.time() - t
with torch.no_grad():
t = time.time()
if full_kl_penalty:
active_full_logprobs = logprobs_from_logits(
logits_or_none, None, gather=False
)
ref_full_logprobs = logprobs_from_logits(
ref_logits_or_none, None, gather=False
)
rewards, non_score_reward = self.compute_rewards(
scores, active_full_logprobs, ref_full_logprobs, masks
)
else:
rewards, non_score_reward = self.compute_rewards(
scores, all_logprobs, ref_logprobs, masks
)
timing["time/ppo/compute_rewards"] = time.time() - t
t = time.time()
values, advantages, returns = self.compute_advantages(
values, rewards, masks
)
timing["time/ppo/compute_advantages"] = time.time() - t
# upcast to float32 to avoid dataset issues
batch_dict = {
"queries": queries,
"responses": responses,
"logprobs": all_logprobs.to(torch.float32),
"values": values.to(torch.float32),
"masks": masks,
"advantages": advantages,
"returns": returns,
}
batch_dict.update(model_inputs)
t = time.time()
all_stats = []
early_stop = False
for _ in range(self.config.ppo_epochs):
if early_stop:
break
b_inds = np.random.permutation(bs)
for backward_batch_start in range(0, bs, self.config.backward_batch_size):
backward_batch_end = (
backward_batch_start + self.config.backward_batch_size
)
backward_batch_inds = b_inds[backward_batch_start:backward_batch_end]
for mini_batch_start in range(
0, self.config.backward_batch_size, self.config.mini_batch_size
):
mini_batch_end = mini_batch_start + self.config.mini_batch_size
mini_batch_inds = backward_batch_inds[
mini_batch_start:mini_batch_end
]
mini_batch_dict = {
"logprobs": batch_dict["logprobs"][mini_batch_inds],
"values": batch_dict["values"][mini_batch_inds],
"masks": batch_dict["masks"][mini_batch_inds],
# hacks: the queries and responses are ragged.
"queries": [batch_dict["queries"][i] for i in mini_batch_inds],
"responses": [
batch_dict["responses"][i] for i in mini_batch_inds
],
"advantages": batch_dict["advantages"][mini_batch_inds],
"returns": batch_dict["returns"][mini_batch_inds],
}
for k in model_inputs_names:
mini_batch_dict[k] = batch_dict[k][mini_batch_inds]
with self.accelerator.accumulate(self.model):
model_inputs = {
k: mini_batch_dict[k] for k in model_inputs_names
}
logprobs, logits, vpreds, _ = self.batched_forward_pass(
self.model,
mini_batch_dict["queries"],
mini_batch_dict["responses"],
model_inputs,
return_logits=True,
)
train_stats = self.train_minibatch(
mini_batch_dict["logprobs"],
mini_batch_dict["values"],
logprobs,
logits,
vpreds,
mini_batch_dict["masks"],
mini_batch_dict["advantages"],
mini_batch_dict["returns"],
)
all_stats.append(train_stats)
# typically, early stopping is done at the epoch level
if self.config.early_stopping:
policykl = train_stats["policy/policykl"]
early_stop = self._early_stop(policykl)
if self.is_deepspeed_zero3_enabled():
this_peer_finished_flag = torch.tensor(
0.0 if not early_stop else 1.0
).to(self.current_device)
dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)
if this_peer_finished_flag.item() > 0.0:
break
elif early_stop:
break
timing["time/ppo/optimize_step"] = time.time() - t
t = time.time()
train_stats = stack_dicts(all_stats)
# reshape advantages/ratios such that they are not averaged.
train_stats["policy/advantages"] = torch.flatten(
train_stats["policy/advantages"]
).unsqueeze(0)
train_stats["policy/advantages"] = torch.nan_to_num(
train_stats["policy/advantages"], WANDB_PADDING
)
train_stats["policy/ratio"] = torch.flatten(
train_stats["policy/ratio"]
).unsqueeze(0)
stats = self.record_step_stats(
scores=scores,
logprobs=all_logprobs,
ref_logprobs=ref_logprobs,
non_score_reward=non_score_reward,
train_stats=train_stats,
kl_coef=self.kl_ctl.value,
masks=masks,
queries=queries,
responses=responses,
)
# Gather/Reduce stats from all processes
if self.is_distributed:
stats = self.gather_stats(stats)
stats = stats_to_np(stats)
timing["time/ppo/calc_stats"] = time.time() - t
stats["ppo/learning_rate"] = self.optimizer.param_groups[0]["lr"]
# Update the KL control - multiply the batch_size by the number of processes
self.kl_ctl.update(
stats["objective/kl"],
self.config.batch_size * self.accelerator.num_processes,
)
# Log the total ppo time
timing["time/ppo/total"] = time.time() - t0
stats.update(timing)
# post-process stats for tensorboard and other loggers
if self.config.log_with != "wandb":
stats = convert_to_scalar(stats)
if self.lr_scheduler is not None:
self.lr_scheduler.step()
return stats
def save_pretrained(
self,
save_directory: Union[str, Path],
*,
config: Optional[dict] = None,
repo_id: Optional[str] = None,
push_to_hub: bool = False,
**kwargs,
):
is_deepspeed_used = (
self.accelerator.distributed_type == "DEEPSPEED"
and hasattr(self.accelerator.state, "deepspeed_plugin")
)
if not is_deepspeed_used:
if self.accelerator.is_main_process:
super().save_pretrained(
save_directory,
config=config,
repo_id=repo_id,
push_to_hub=push_to_hub,
**kwargs,
)
else:
if self.is_deepspeed_zero3_enabled():
state_dict = get_ds_state_dict(self.model)
else:
# Only run on rank 0 except stage 3
if self.accelerator.is_main_process:
state_dict = get_ds_state_dict(self.model)
if self.accelerator.is_main_process:
unwrap_model: PreTrainedModel = self.accelerator.unwrap_model(
self.model
).pretrained_model
unwrap_model.save_pretrained(save_directory, state_dict=state_dict)
def is_deepspeed_zero3_enabled(self):
return (
self.accelerator.state.deepspeed_plugin.deepspeed_config[
"zero_optimization"
]["stage"]
== 3
)
================================================
FILE: train/src/sample_generator.py
================================================
from itertools import chain
from typing import Any, Callable, Dict, List
import copy
from transformers import PreTrainedTokenizer
import json
IGNORE_INDEX = -100
def sft_sample_to_ids(conversations: Dict[str, Any], tokenizer: PreTrainedTokenizer):
input_ids = []
labels = []
for sentence in conversations:
sentence_from = sentence["from"].lower()
sentence_value = (
"Human: \n" + sentence["value"] + "\n\nAssistant: \n"
if sentence_from == "human"
else sentence["value"]
) # https://github.com/LianjiaTech/BELLE/issues/337
# conversation += sentence_value
sentence_ids = tokenizer.encode(
sentence_value, add_special_tokens=False
) # do not add bos_token_id
label = (
copy.deepcopy(sentence_ids)
if sentence_from != "human"
else [IGNORE_INDEX] * len(sentence_ids)
)
input_ids += sentence_ids
labels += label
# add eos at every end of assistant sentence
if sentence_from != "human":
input_ids += [tokenizer.eos_token_id] # make sure eos_token_id is correct
labels += [tokenizer.eos_token_id]
return input_ids, labels
def generate_and_tokenize_prompt(
model_max_length: int,
tokenizer: PreTrainedTokenizer,
data_point: Dict[str, Any],
fix_length=False,
padding_side="left",
):
conversations = data_point["conversations"]
input_ids, labels = sft_sample_to_ids(conversations, tokenizer)
input_ids = input_ids[:model_max_length]
labels = labels[:model_max_length]
if all(x == IGNORE_INDEX for x in labels):
labels[18:24] = input_ids[
18:24
] # labels can not have all values being -100. 18 and 24 are just random numbers
attention_mask = [1] * len(input_ids)
if fix_length and model_max_length > len(input_ids):
if padding_side == "left":
input_ids = [tokenizer.pad_token_id] * (
model_max_length - len(input_ids)
) + input_ids
labels = [tokenizer.pad_token_id] * (
model_max_length - len(labels)
) + labels
attention_mask = [0] * (
model_max_length - len(attention_mask)
) + attention_mask
else:
input_ids = input_ids + [tokenizer.pad_token_id] * (
model_max_length - len(input_ids)
)
labels = labels + [tokenizer.pad_token_id] * (
model_max_length - len(labels)
)
attention_mask = attention_mask + [0] * (
model_max_length - len(attention_mask)
)
tokenized_full_prompt = {
"input_ids": input_ids,
"attention_mask": attention_mask,
"labels": labels,
}
return tokenized_full_prompt
def batch_grouped_sft_generate(
model_max_length: int,
tokenizer: PreTrainedTokenizer,
examples: Dict[str, List[Any]],
) -> Dict[str, List[List[int]]]:
input_ids_buffer = []
labels_buffer = []
for conversations in examples["conversations"]:
input_ids, labels = sft_sample_to_ids(conversations, tokenizer)
input_ids = [tokenizer.bos_token_id] + input_ids
labels = [tokenizer.bos_token_id] + labels
input_ids_buffer.extend(input_ids)
labels_buffer.extend(labels)
total_length = (len(input_ids_buffer) // model_max_length) * model_max_length
input_ids_list: List[List[int]] = [
input_ids_buffer[i : i + model_max_length]
for i in range(0, total_length, model_max_length)
]
labels_list: List[List[int]] = [
labels_buffer[i : i + model_max_length]
for i in range(0, total_length, model_max_length)
]
for i, labels in enumerate(labels_list):
if all(x == IGNORE_INDEX for x in labels):
# labels can not have all values being -100. 18 and 24 are just random numbers
labels[18:24] = input_ids_list[i][18:24]
return {"input_ids": input_ids_list, "labels": labels_list}
def batch_grouped_pretrain_generate(
model_max_length: int,
tokenizer: PreTrainedTokenizer,
examples: Dict[str, List[str]],
) -> Dict[str, List[List[int]]]:
# build grouped texts with format `X1 X2 X3 ... X1 X2 X3 ... []`
token_ids_list: List[List[int]] = tokenizer(
examples["text"], add_special_tokens=False
)["input_ids"]
token_ids_list = [
token_ids + [tokenizer.eos_token_id] for token_ids in token_ids_list
]
concatenated_ids = list(chain(*token_ids_list))
# we drop the small remainder, and if the total_length < block_size, we exclude this batch
total_length = (len(concatenated_ids) // model_max_length) * model_max_length
result = [
concatenated_ids[i : i + model_max_length]
for i in range(0, total_length, model_max_length)
]
return {"input_ids": result, "labels": result.copy()}
def exam_generate(model_max_length: int, tokenizer: PreTrainedTokenizer, data_point):
template = "Human: \n{human}\n\nAssistant: \n"
input_str = template.format(
human=f'回答下面的{data_point["type"]}题，用json返回答案，包括原因和答案，如{{"reason":..., "answer":...}}\n{data_point["question"]}\n选项：{" ".join(data_point["candidates"])}'
)
input_ids = tokenizer.encode(input_str, add_special_tokens=False)
labels = [IGNORE_INDEX] * len(input_ids)
bot_ids = tokenizer.encode(
json.dumps(
{"reason": data_point["reason"], "answer": data_point["answer"]},
ensure_ascii=False,
),
add_special_tokens=False,
)
input_ids += bot_ids
labels += bot_ids
input_ids += [tokenizer.eos_token_id]
labels += [tokenizer.eos_token_id]
input_ids = input_ids[: model_max_length - 1]
labels = labels[: model_max_length - 1]
return {
"input_ids": input_ids,
"attention_mask": [1] * len(input_ids),
"labels": labels,
}
def inference_generate(
model_max_length: int,
tokenizer: PreTrainedTokenizer,
model_prompt: Callable,
data_point: Dict[str, Any],
):
text = data_point['text']
if model_prompt is not None:
text = model_prompt(text)
return {
"input_ids": tokenizer.encode(text, add_special_tokens=False)[:model_max_length]
}
================================================
FILE: train/src/trainer.py
================================================
from peft import PeftModel
from transformers.trainer import *
from transformers import Seq2SeqTrainer, __version__
from transformers.deepspeed import is_deepspeed_zero3_enabled
from src.utils import bind_methods_from_class_to_instance, get_ds_state_dict
from src.models.generation_utils import GenerationMixin
class MyTrainer(Trainer):
def save_model(self, output_dir: Optional[str] = None, _internal_call: bool = False):
"""
Add supports for peft + deepspeed zero 3
Will save the model, so you can reload it using `from_pretrained()`.
Will only save from the main process.
"""
if output_dir is None:
output_dir = self.args.output_dir
if is_torch_tpu_available():
self._save_tpu(output_dir)
elif is_sagemaker_mp_enabled():
# Calling the state_dict needs to be done on the wrapped model and on all processes.
os.makedirs(output_dir, exist_ok=True)
state_dict = self.model_wrapped.state_dict()
if self.args.should_save:
self._save(output_dir, state_dict=state_dict)
if IS_SAGEMAKER_MP_POST_1_10:
# 'user_content.pt' indicates model state_dict saved with smp >= 1.10
Path(os.path.join(output_dir, "user_content.pt")).touch()
elif (
ShardedDDPOption.ZERO_DP_2 in self.args.sharded_ddp
or ShardedDDPOption.ZERO_DP_3 in self.args.sharded_ddp
or self.fsdp is not None
or self.is_fsdp_enabled
):
if self.is_fsdp_enabled:
os.makedirs(output_dir, exist_ok=True)
self.accelerator.state.fsdp_plugin.save_model(self.accelerator, self.model, output_dir)
else:
state_dict = self.model.state_dict()
if self.args.should_save:
self._save(output_dir, state_dict=state_dict)
elif self.is_deepspeed_enabled:
# This must be called on all ranks in stage 3
if is_deepspeed_zero3_enabled():
state_dict = get_ds_state_dict(self.deepspeed)
else:
# Only run on rank 0 except stage 3
if self.args.should_save:
state_dict = get_ds_state_dict(self.deepspeed)
# this takes care of everything as long as we aren't under zero3
# Only run on rank 0
if self.args.should_save:
# state_dict is available on rank 0
self._save(output_dir, state_dict=state_dict)
elif self.args.should_save:
self._save(output_dir)
# Push to the Hub when `save_model` is called by the user.
if self.args.push_to_hub and not _internal_call:
self.push_to_hub(commit_message="Model save")
def _load_from_checkpoint(self, resume_from_checkpoint, model=None):
"""
Add supports for peft resume
"""
if model is None:
model = self.model
config_file = os.path.join(resume_from_checkpoint, CONFIG_NAME)
weights_file = os.path.join(resume_from_checkpoint, WEIGHTS_NAME)
weights_index_file = os.path.join(resume_from_checkpoint, WEIGHTS_INDEX_NAME)
adapter_model_path = os.path.join(resume_from_checkpoint, ADAPTER_WEIGHTS_NAME)
safe_weights_file = os.path.join(resume_from_checkpoint, SAFE_WEIGHTS_NAME)
safe_weights_index_file = os.path.join(resume_from_checkpoint, SAFE_WEIGHTS_INDEX_NAME)
safe_adapter_model_path = os.path.join(resume_from_checkpoint, ADAPTER_SAFE_WEIGHTS_NAME)
if not any(
os.path.isfile(f) for f in [weights_file, safe_weights_file, adapter_model_path, weights_index_file, safe_weights_index_file, safe_adapter_model_path]
):
raise ValueError(f"Can't find a valid checkpoint at {resume_from_checkpoint}")
logger.info(f"Loading model from {resume_from_checkpoint}.")
if os.path.isfile(config_file):
config = PretrainedConfig.from_json_file(config_file)
checkpoint_version = config.transformers_version
if checkpoint_version is not None and checkpoint_version != __version__:
logger.warning(
f"You are resuming training from a checkpoint trained with {checkpoint_version} of "
f"Transformers but your current version is {__version__}. This is not recommended and could "
"yield to errors or unwanted behaviors."
)
if os.path.isfile(weights_file) or os.path.isfile(safe_weights_file) or \
os.path.isfile(adapter_model_path) or os.path.isfile(safe_adapter_model_path):
# If the model is on the GPU, it still works!
if is_sagemaker_mp_enabled():
if os.path.isfile(os.path.join(resume_from_checkpoint, "user_content.pt")):
# If the 'user_content.pt' file exists, load with the new smp api.
# Checkpoint must have been saved with the new smp api.
smp.resume_from_checkpoint(
path=resume_from_checkpoint, tag=WEIGHTS_NAME, partial=False, load_optimizer=False
)
else:
# If the 'user_content.pt' file does NOT exist, load with the old smp api.
# Checkpoint must have been saved with the old smp api.
if hasattr(self.args, "fp16") and self.args.fp16 is True:
logger.warning(
"Enabling FP16 and loading from smp < 1.10 checkpoint together is not suppported."
)
state_dict = torch.load(weights_file, map_location="cpu")
# Required for smp to not auto-translate state_dict from hf to smp (is already smp).
state_dict["_smp_is_partial"] = False
load_result = model.load_state_dict(state_dict, strict=True)
# release memory
del state_dict
elif self.is_fsdp_enabled:
self.accelerator.state.fsdp_plugin.load_model(self.accelerator, model, resume_from_checkpoint)
else:
if is_peft_available() and isinstance(model, PeftModel):
model.load_adapter(resume_from_checkpoint, getattr(model, "active_adapter", "default"), is_trainable=True)
else:
# We load the model state dict on the CPU to avoid an OOM error.
if self.args.save_safetensors and os.path.isfile(safe_weights_file):
state_dict = safetensors.torch.load_file(safe_weights_file, device="cpu")
else:
state_dict = torch.load(weights_file, map_location="cpu")
# workaround for FSDP bug https://github.com/pytorch/pytorch/issues/82963
# which takes *args instead of **kwargs
load_result = model.load_state_dict(state_dict, False)
# release memory
del state_dict
self._issue_warnings_after_load(load_result)
else:
# We load the sharded checkpoint
load_result = load_sharded_checkpoint(
model, resume_from_checkpoint, strict=is_sagemaker_mp_enabled(), prefer_safe=self.args.save_safetensors
)
if not is_sagemaker_mp_enabled():
self._issue_warnings_after_load(load_result)
class MySeq2SeqTrainer(Seq2SeqTrainer):
def prediction_step(
self,
model: nn.Module,
inputs: Dict[str, Union[torch.Tensor, Any]],
prediction_loss_only: bool,
ignore_keys: Optional[List[str]] = None,
**gen_kwargs,
) -> Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]:
"""
Perform an evaluation step on `model` using `inputs`.
Subclass and override to inject custom behavior.
Args:
model (`nn.Module`):
The model to evaluate.
inputs (`Dict[str, Union[torch.Tensor, Any]]`):
The inputs and targets of the model.
The dictionary will be unpacked before being fed to the model. Most models expect the targets under the
argument `labels`. Check your model's documentation for all accepted arguments.
prediction_loss_only (`bool`):
Whether or not to return the loss only.
gen_kwargs:
Additional `generate` specific kwargs.
Return:
Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]: A tuple with the loss, logits and
labels (each being optional).
"""
if not self.args.predict_with_generate or prediction_loss_only:
return super().prediction_step(
model, inputs, prediction_loss_only=prediction_loss_only, ignore_keys=ignore_keys
)
has_labels = "labels" in inputs
inputs = self._prepare_inputs(inputs)
# XXX: adapt synced_gpus for fairscale as well
# Priority (handled in generate):
# gen_kwargs > model.generation_config > default GenerationConfig()
if len(gen_kwargs) == 0 and hasattr(self, "_gen_kwargs"):
gen_kwargs = self._gen_kwargs.copy()
if gen_kwargs.get("max_length") is None and gen_kwargs.get("max_new_tokens") is None:
gen_kwargs["max_length"] = self.model.config.max_length
gen_kwargs["num_beams"] = (
gen_kwargs["num_beams"] if gen_kwargs.get("num_beams") is not None else self.model.config.num_beams
)
default_synced_gpus = True if is_deepspeed_zero3_enabled() else False
gen_kwargs["synced_gpus"] = (
gen_kwargs["synced_gpus"] if gen_kwargs.get("synced_gpus") is not None else default_synced_gpus
)
# If the `decoder_input_ids` was created from `labels`, evict the former, so that the model can freely generate
# (otherwise, it would continue generating from the padded `decoder_input_ids`)
if (
"labels" in inputs
and "decoder_input_ids" in inputs
and inputs["labels"].shape == inputs["decoder_input_ids"].shape
):
inputs = {k: v for k, v in inputs.items() if k != "decoder_input_ids"}
bind_methods_from_class_to_instance(
self.model,
GenerationMixin,
include=[
"contrastive_search",
"greedy_search",
"sample",
"beam_search",
"beam_sample",
"group_beam_search",
"constrained_beam_search",
"assisted_decoding",
"generate"
]
)
generated_tokens = self.model.generate(deepspeed_model=model, **inputs, **gen_kwargs)
# generated_tokens = model.generate(**inputs, **gen_kwargs)
# Temporary hack to ensure the generation config is not initialized for each iteration of the evaluation loop
# TODO: remove this hack when the legacy code that initializes generation_config from a model config is
# removed in https://github.com/huggingface/transformers/blob/98d88b23f54e5a23e741833f1e973fdf600cc2c5/src/transformers/generation/utils.py#L1183
if self.model.generation_config._from_model_config:
self.model.generation_config._from_model_config = False
# Retrieves GenerationConfig from model.generation_config
gen_config = self.model.generation_config
# in case the batch is shorter than max length, the output should be padded
if generated_tokens.shape[-1] < gen_config.max_length:
generated_tokens = self._pad_tensors_to_max_len(generated_tokens, gen_config.max_length)
elif gen_config.max_new_tokens is not None and generated_tokens.shape[-1] < gen_config.max_new_tokens + 1:
generated_tokens = self._pad_tensors_to_max_len(generated_tokens, gen_config.max_new_tokens + 1)
with torch.no_grad():
if has_labels:
with self.compute_loss_context_manager():
outputs = model(**inputs)
if self.label_smoother is not None:
loss = self.label_smoother(outputs, inputs["labels"]).mean().detach()
else:
loss = (outputs["loss"] if isinstance(outputs, dict) else outputs[0]).mean().detach()
else:
loss = None
if self.args.prediction_loss_only:
return loss, None, None
if has_labels:
labels = inputs["labels"]
if labels.shape[-1] < gen_config.max_length:
labels = self._pad_tensors_to_max_len(labels, gen_config.max_length)
elif gen_config.max_new_tokens is not None and labels.shape[-1] < gen_config.max_new_tokens + 1:
labels = self._pad_tensors_to_max_len(labels, gen_config.max_new_tokens + 1)
else:
labels = None
return loss, generated_tokens, labels
================================================
FILE: train/src/utils.py
================================================
import copy
import time
import types
from typing import Any, Dict, List, Optional, Union
from gradio_client import Client
from tqdm import tqdm
from transformers import PreTrainedModel, PreTrainedTokenizer
import deepspeed
from accelerate import Accelerator
from transformers.deepspeed import is_deepspeed_zero3_enabled
from deepspeed.runtime.engine import DeepSpeedEngine
import torch
def get_ds_state_dict(ds_engine: DeepSpeedEngine):
"""
如果是zero stage 3，要对所有rank调用，无视掉stage3_gather_16bit_weights_on_model_save参数
"""
if ds_engine.zero_optimization_partition_weights():
# consolidation is expensive in time and memory and therefore isn't a default
state_dict = ds_engine._zero3_consolidated_16bit_state_dict()
else:
state_dict = ds_engine.module.state_dict()
return state_dict
def get_model_param_count(
model: Union[DeepSpeedEngine, torch.nn.Module], trainable_only=False
):
"""
Calculate model's total param count. If trainable_only is True then count only those requiring grads
"""
if is_deepspeed_zero3_enabled() and isinstance(model, DeepSpeedEngine):
def numel(p):
return p.ds_numel
else:
def numel(p):
return p.numel()
return sum(
numel(p) for p in model.parameters() if not trainable_only or p.requires_grad
)
def bind_methods_from_class_to_instance(
to_instance, from_class, include: Optional[List[str]] = None
):
for method_name, method in vars(from_class).items():
if callable(method) and (include is None or method_name in include):
setattr(to_instance, method_name, types.MethodType(method, to_instance))
def prepare_deepspeed(accelerator: Accelerator, model: PreTrainedModel):
# Adapted from accelerate: https://github.com/huggingface/accelerate/blob/739b135f8367becb67ffaada12fe76e3aa60fefd/src/accelerate/accelerator.py#L1473
deepspeed_plugin = accelerator.state.deepspeed_plugin
config_kwargs = deepspeed_plugin.deepspeed_config
if model is not None:
if hasattr(model, "config"):
hidden_size = (
max(model.config.hidden_sizes)
if getattr(model.config, "hidden_sizes", None)
else getattr(model.config, "hidden_size", None)
)
if (
hidden_size is not None
and config_kwargs["zero_optimization"]["stage"] == 3
):
# Note that `stage3_prefetch_bucket_size` can produce DeepSpeed messages like: `Invalidate trace cache @ step 0: expected module 1, but got module 0`
# This is expected and is not an error, see: https://github.com/microsoft/DeepSpeed/discussions/4081
config_kwargs.update(
{
"zero_optimization.reduce_bucket_size": hidden_size
* hidden_size,
"zero_optimization.stage3_param_persistence_threshold": 10
* hidden_size,
"zero_optimization.stage3_prefetch_bucket_size": 0.9
* hidden_size
* hidden_size,
}
)
# If ZeRO-3 is used, we shard both the active and reference model.
# Otherwise, we assume the reference model fits in memory and is initialized on each device with ZeRO disabled (stage 0)
if config_kwargs["zero_optimization"]["stage"] != 3:
config_kwargs["zero_optimization"]["stage"] = 0
model, *_ = deepspeed.initialize(model=model, config=config_kwargs)
model.eval()
return model
def zero_infer(
accelerator: Accelerator,
model: DeepSpeedEngine,
tokenizer: PreTrainedTokenizer,
texts: List[str],
batch_size: int,
pad_to_multiple_of=8,
):
"""
必须要在所有进程同时调用，否则会卡住
"""
model.eval()
num_samples = len(texts)
text_token_ids: Dict[str, List[List[int]]] = tokenizer(
texts,
add_special_tokens=False,
pad_to_multiple_of=pad_to_multiple_of,
padding=True,
)
input_ids_batches: List[List[int]] = []
attention_mask_batches: List[List[int]] = []
for i in range(0, num_samples, batch_size):
input_ids_batches.append(text_token_ids["input_ids"][i : i + batch_size])
attention_mask_batches.append(
text_token_ids["attention_mask"][i : i + batch_size]
)
outputs: List[Dict[str, Any]] = []
with torch.no_grad():
for input_ids, attention_mask in zip(input_ids_batches, attention_mask_batches):
outputs.append(
model(
input_ids=torch.tensor(
input_ids, dtype=torch.int64, device=accelerator.device
),
attention_mask=torch.tensor(
attention_mask, dtype=torch.int64, device=accelerator.device
),
)
)
return outputs
class MultiClient(object):
def __init__(self, worker_addrs, synced_worker=False) -> None:
self.clients = [Client(addr) for addr in worker_addrs]
self.synced_worker = synced_worker
def predict(self, tasks: List[List], max_retries: int = 3) -> List[Any]:
assert len(tasks) >= 1, "No predict tasks!"
num_tasks = len(tasks)
if self.synced_worker and len(tasks) % len(self.clients) != 0:
num_dummy_tasks = len(self.clients) - len(tasks) % len(self.clients)
tasks.extend([copy.deepcopy(tasks[-1]) for _ in range(num_dummy_tasks)])
pbar = tqdm(total=len(tasks))
jobs = {
client: (i, client.submit(*(tasks[i]), api_name="/predict"))
for i, client in enumerate(self.clients)
if i < len(tasks)
}
results = {}
retries = {i: 0 for i in range(len(tasks))}
while jobs:
for client, (i, job) in list(jobs.items()):
if job.done():
pbar.update(1)
del jobs[client]
try:
result = job.result()
results[i] = result
except Exception as e:
print("Job failed with error:", e)
if retries[i] < max_retries:
print("Retrying job...")
retries[i] += 1
new_job = client.submit(*tasks[i], api_name="/predict")
jobs[client] = (i, new_job)
continue # Skip the rest of the loop
else:
results[i] = None
new_i = len(results) + len(jobs)
if new_i < len(tasks):
new_task = tasks[new_i]
new_job = client.submit(*new_task, api_name="/predict")
jobs[client] = (new_i, new_job)
time.sleep(1)
pbar.close()
predicts = [results[i] for i in range(num_tasks)]
return predicts
BELLE: Be Everyone's Large Language model Engine
*Read this in [English](README_en.md).*
## 📝 项目主要内容
### 🚀 训练代码
详见[BELLE/train](train)，尽可能简化的一个训练代码实现，集成了Deepspeed-Chat，支持finetune，lora，并提供了相关的docker
### 📊 数据开放
* 详见[BELLE/data/1.5M](data/1.5M)，参考[Stanford Alpaca](https://github.com/tatsu-lab/stanford_alpaca) 生成的中文数据集[1M](https://huggingface.co/datasets/BelleGroup/train_1M_CN) + [0.5M](https://huggingface.co/datasets/BelleGroup/train_0.5M_CN)；
* 持续开放的数据集，详见[BELLE/data/10M](data/10M)
### 🧐 验证集合&验证方法
详见[BELLE/eval](https://github.com/LianjiaTech/BELLE/tree/main/eval)，一个1k+的测试集合，和对应打分prompt。包含多个类别，采用GPT-4或者ChatGPT打分。同时提供了一个打分的网页，方便针对单个case使用。欢迎大家通过PR提供更多的测试用例。
### 🤖 模型
详见[BELLE/models](models/)
* 基于[Meta LLaMA2](https://github.com/facebookresearch/llama)实现调优的模型：[BELLE-Llama2-13B-chat-0.4M](https://huggingface.co/BELLE-2/BELLE-Llama2-13B-chat-0.4M)
* 基于[Meta LLaMA](https://github.com/facebookresearch/llama)实现调优的模型：[BELLE-LLaMA-7B-0.6M-enc](https://huggingface.co/BelleGroup/BELLE-LLaMA-7B-0.6M-enc)
, [BELLE-LLaMA-7B-2M-enc](https://huggingface.co/BelleGroup/BELLE-LLaMA-7B-2M-enc)
, [BELLE-LLaMA-7B-2M-gptq-enc](https://huggingface.co/BelleGroup/BELLE-LLaMA-7B-2M-gptq-enc)
, [BELLE-LLaMA-13B-2M-enc](https://huggingface.co/BelleGroup/BELLE-LLaMA-13B-2M-enc)
, [BELLE-on-Open-Datasets](https://huggingface.co/BelleGroup/BELLE-on-Open-Datasets) 以及基于LLaMA做了中文词表扩充的预训练模型[BELLE-LLaMA-EXT-7B](https://huggingface.co/BelleGroup/BELLE-LLaMA-EXT-7B)。
* 请参考[Meta LLaMA的License](https://github.com/facebookresearch/llama/blob/main/LICENSE)，目前仅供学习交流。请严遵守LLaMA的使用限制。LLaMA模型不允许发布调优后的完整模型权重，但是可以发布原始的模型的diff。因此，我们使用文件间的XOR，保证拥有LLaMA原始模型授权的人才可以将本项目发布的模型转化成可以使用的格式。格式转化代码参考[BELLE/models](https://github.com/LianjiaTech/BELLE/tree/main/models)
* 基于BLOOMZ-7B1-mt优化后的模型：[BELLE-7B-0.2M](https://huggingface.co/BelleGroup/BELLE-7B-0.2M)，[BELLE-7B-0.6M](https://huggingface.co/BelleGroup/BELLE-7B-0.6M)，[BELLE-7B-1M](https://huggingface.co/BelleGroup/BELLE-7B-1M)，[BELLE-7B-2M](https://huggingface.co/BelleGroup/BELLE-7B-2M)
### ⚖️ 模型量化gptq
详见[BELLE/gptq](https://github.com/LianjiaTech/BELLE/tree/main/models/gptq)，参考gptq的实现，对本项目中相关模型进行了量化
### 🌐 Colab
[](https://colab.research.google.com/github/LianjiaTech/BELLE/blob/main/models/notebook/BELLE_INFER_COLAB.ipynb) 提供了colab上面可运行的推理代码[Colab](https://colab.research.google.com/github/LianjiaTech/BELLE/blob/main/models/notebook/BELLE_INFER_COLAB.ipynb)
### 💬 ChatBELLE App
详见[BELLE/chat](chat/README.md)，基于[BELLE](https://github.com/LianjiaTech/BELLE)模型的跨平台离线大语言模型交谈App。使用量化后的离线端上模型配合Flutter，可在macOS（已支持）、Windows、Android、iOS等设备上运行。
### 📑 研究报告
详见[BELLE/docs](docs/)，其中会定期更新本项目相关的研究报告工作
**欢迎大家通过issue贡献更多的prompts！**
## App下载
请见[Releases](https://github.com/LianjiaTech/BELLE/releases/tag/v0.95)。
各平台对应下载&使用说明请见[使用说明](#使用说明)。
目前仅支持macOS。更多平台即将发布！
## 模型下载
可以去huggingface下载，[ChatBELLE-int4](https://huggingface.co/BelleGroup/ChatBELLE-int4)
**需要先首先执行ChatBELLE app，会建好一个文件夹```~/Library/Containers/com.barius.chatbelle```。然后将下载好的模型重命名并移动至app显示的路径。默认为~/Library/Containers/com.barius.chatbelle/Data/belle-model.bin。**
## 模型量化
使用[llama.cpp的4bit量化](https://github.com/ggerganov/llama.cpp)优化设备端离线推理的速度和内存占用。量化会带来计算精度的损失，影响模型的生成效果。4bit是比较激进的量化方式，目前的4bit模型效果相比fp32和fp16还有明显差距，仅供尝试。随着模型算法的发展和设备端算力的演进，我们相信离线推理的效果会有很大改善，我们也会持续跟进。
### GPTQ
[GPTQ](https://github.com/IST-DASLab/gptq)使用one-shot量化方式来获得更小的量化损失或更高的压缩率。我们将持续跟进基于GPTQ的设备端量化模型。
## 路线图
* 更多设备
* 多轮对话
* 模型选择
* 聊天历史
* 聊天列表
## 使用说明
### macOS
建议使用M1/M2系列芯片配合16G RAM以获得最佳体验。如果推理速度过慢，可能是内存不足，可以尝试关闭其他app以释放内存。8G内存会非常慢。
Intel芯片理论上也可以跑，但是速度较慢。
* 下载[Releases](https://github.com/LianjiaTech/BELLE/releases/tag/v0.95)中的[chatbelle.dmg](https://github.com/LianjiaTech/BELLE/releases/download/v0.95/chatbelle.dmg)，双击打开，把`Chat Belle.dmg`左键拖进`应用程序`文件夹中。
* 右键`应用程序`文件夹中的`Chat Belle`App，按住Ctrl并左键单击`打开`，点`打开`。
* App会显示模型加载失败，并显示模型路径。关闭App。
* 下载量化后的模型[ChatBELLE-int4](https://huggingface.co/BelleGroup/ChatBELLE-int4)。
* 移动并重命名模型至app显示的路径。默认为`~/Library/Containers/com.barius.chatbelle/Data/belle-model.bin`。
* 重新打开App（直接双击）。
### Windows
* 敬请期待
### Android
* 敬请期待
### iOS
* 敬请期待
## 已知问题
* 推理在8GB内存的macOS设备上会非常慢，原因是内存不足导致疯狂swapping。16GB内存的设备在内存占用较高的情况下也可能遇到同样状况。
* 推理在Intel芯片的Mac设备上比较慢。
* iOS的3GB App内存限制导致最小模型(~4.3G)也无法加载。[参考](https://github.com/mikeger/llama-ios)
## 免责声明
本程序仅供学习、研究使用，因使用、传播本程序带来的任何损害，本程序的开发者不负任何责任。
## 致谢
* LLaMa模型设备端推理 [llama.cpp](https://github.com/ggerganov/llama.cpp)
* Flutter聊天UI [flyer.chat](https://github.com/flyerhq/flutter_chat_ui)
================================================
FILE: chat/README_en.md
================================================
# ChatBELLE 跨平台应用
[中文README](README.md)
# ChatBELLE Cross-platform App
A minimal, cross-platform LLM chat app with [BELLE](https://github.com/LianjiaTech/BELLE) using quantized on-device offline models and Flutter UI, running on macOS (done), Windows, Android, iOS(see [Known Issues](#known-issues)) and more.
## App Downloading
Please refer to [Releases](https://github.com/LianjiaTech/BELLE/releases/tag/v0.95).
Downloading and usage for different platforms: [Usage](#Usage).
Only macOS supported by now. More platforms coming soon!
## Model Downloading
You can download from huggingface repo, [ChatBELLE-int4](https://huggingface.co/BelleGroup/ChatBELLE-int4)
You need to first execute the ChatBELLE app, which will create a folder~/Library/Containers/com.barius.chatbelle. Then rename the downloaded model and move it to the path displayed on the app. The default is ~/Library/Containers/com.barius.chatbell/Data/belle-model.bin.
## Model Quantization
Utilizes [llama.cpp's 4bit quantization](https://github.com/ggerganov/llama.cpp) to optimize on-device inferencing speed and RAM occupation. Quantization leads to accuracy loss and model performance degradation. 4-bit quantization trades accuracy for model size, our current 4-bit model sees significant performance gap compared with fp32 or fp16 ones and is just for users to take a try. With better algorithms being developed and more powerful chips landing on mobile devices, we believe on-device model performance will thrive and will keep a close track on this.
### GPTQ
[GPTQ](https://github.com/IST-DASLab/gptq) employs one-shot quantization to achieve lower accuracy loss or higher model compression rate. We will keep track of this line of work.
## Roadmap
* More devices
* Multiround chat
* Model selection
* Chat history
* Chat list
## Usage
### macOS
Recommend using M1/M2 series CPU with 16GB RAM to have the best experience. If you encounter slow inference, try closing other apps to release more memory. Inference on 8G RAM will be very slow.
Intel CPUs could possibly run as well (not tested) but could be very slow.
* Download [chatbelle.dmg](https://github.com/LianjiaTech/BELLE/releases/download/v0.95/chatbelle.dmg) from [Releases](https://github.com/LianjiaTech/BELLE/releases/tag/v0.95) page, double click to open it, then drag `Chat Belle.dmg` into `Applications` folder.
* Open the `Chat Belle` app in `Applications` folder by right click then Ctrl-click `Open`, then click `Open`.
* The app will prompt the intended model file path and fail to load the model. Close the app.
* Download quantized model from [ChatBELLE-int4](https://huggingface.co/BelleGroup/ChatBELLE-int4/blob/main/belle-model.bin).
* Move and rename the model to the path prompted by the app. Defaults to `~/Library/Containers/com.barius.chatbelle/Data/belle-model.bin` .
* Reopen the app again (double clicking is now OK).
### Windows
* Stay tuned
### Android
* Stay tuned
### iOS
* Stay tuned
## Known Issues
* On macOS devices with 8GB RAM, inference is really slow due to constant swapping. 16GB RAM devices might see the same slowdown if RAM occupation by other applications is high.
* Inferencing on Macs with Intel chips is slow.
* The 3GB App RAM constraint on iOS devices won't allow even the smallest model (~4.3G) from loading. [Reference](https://github.com/mikeger/llama-ios)
## Disclaimer
This program is for learning and research purposes only. The devs take no responsibilities in any damage caused by using or distributing this program.
## Thanks
* LLaMa model inferencing code uses [llama.cpp](https://github.com/ggerganov/llama.cpp)
* Flutter chat UI uses [flyer.chat](https://github.com/flyerhq/flutter_chat_ui)
================================================
FILE: docker/README.md
================================================
# docker镜像
## 国内环境自行替换代理
```bash
export https_proxy=...
export http_proxy=...
export all_proxy=...
```
## 构建镜像
```bash
sudo bash build_dockerfile_upon_transfermers.sh
```
## 上传镜像到dockerhub
```bash
sudo bash upload_image.sh
```
## 下载镜像
已经构建好镜像，无需自行构建
```bash
sudo docker pull tothemoon/belle:latest
```
belle镜像中包含sshd，可以远程连接到容器内部
## 运行镜像
### 1. 参考[nvidia安装说明](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)安装container-toolkit
### 2. 自行创建ssh密钥
### 3. 运行容器
```bash
sudo bash docker_run.sh
```
`docker_run.sh`文件主要内容如下
```
docker run --gpus all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 \
--network host \
--privileged \
[--env https_proxy=$https_proxy \]
[--env http_proxy=$http_proxy \]
[--env all_proxy=$all_proxy \]
--env HF_HOME=$hf_home \
-it [--rm] \
--name belle \
-v $belle_path:$belle_path \
-v $hf_home:$hf_home \
-v $ssh_pub_key:/root/.ssh/authorized_keys \
-w $workdir \
$docker_user/belle:$tag \
[--sshd_port 2201 --cmd "echo 'Hello, world!' && /bin/bash"]
```
`[]`中内容可忽略
- `--rm`：容器退出时销毁，如果长期在容器中工作，可忽略
- `--sshd_port`：sshd监听端口，默认是22001
- `--cmd`：容器要执行的命令`"echo 'Hello, world!' && /bin/bash"`，可忽略
- `hf_home`：huggingface缓存目录
- `$ssh_pub_key`：sshd公钥目录
================================================
FILE: docker/belle.dockerfile
================================================
FROM transformers:ds
LABEL maintainer="BELLE"
WORKDIR /workspace
RUN curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | bash
RUN apt update
RUN apt install -y git-lfs
RUN apt install -y htop
RUN apt install -y screen
RUN apt install -y tmux
RUN apt install -y locales \
&& locale-gen en_US.UTF-8 \
&& locale-gen zh_CN.UTF-8 \
&& echo -e 'export LANG=zh_CN.UTF-8' >> /root/.bashrc
RUN apt install -y net-tools
RUN apt install -y openssh-server \
&& sed -i "s/#PermitRootLogin prohibit-password/PermitRootLogin yes/" /etc/ssh/sshd_config \
&& sed -i "s/#PubkeyAuthentication yes/PubkeyAuthentication yes/" /etc/ssh/sshd_config \
&& sed -i "s/#PasswordAuthentication yes/PasswordAuthentication no/" /etc/ssh/sshd_config \
&& echo "StrictHostKeyChecking no" >> /etc/ssh/ssh_config \
&& mkdir -p /run/sshd
RUN apt install -y pdsh \
&& chown root:root /usr/lib/x86_64-linux-gnu/pdsh \
&& chmod 755 /usr/lib/x86_64-linux-gnu/pdsh \
&& chown root:root /usr/lib \
&& chmod 755 /usr/lib
# https://docs.nvidia.com/networking/m/view-rendered-page.action?abstractPageId=15049785
# https://network.nvidia.com/products/infiniband-drivers/linux/mlnx_ofed/
ENV MOFED_VER=23.07-0.5.0.0
ENV PLATFORM=x86_64
RUN OS_VER="ubuntu$(lsb_release -rs)" \
&& wget http://content.mellanox.com/ofed/MLNX_OFED-${MOFED_VER}/MLNX_OFED_LINUX-${MOFED_VER}-${OS_VER}-${PLATFORM}.tgz \
&& tar -xvf MLNX_OFED_LINUX-${MOFED_VER}-${OS_VER}-${PLATFORM}.tgz \
&& MLNX_OFED_LINUX-${MOFED_VER}-${OS_VER}-${PLATFORM}/mlnxofedinstall --user-space-only --without-fw-update -q
RUN python3 -m pip install -U --no-cache-dir pip
RUN python3 -m pip install -U --no-cache-dir peft
RUN python3 -m pip install -U --no-cache-dir gradio
RUN python3 -m pip install -U --no-cache-dir pudb
RUN python3 -m pip install -U --no-cache-dir xformers
RUN python3 -m pip install -U --no-cache-dir bitsandbytes
RUN python3 -m pip install -U --no-build-isolation --no-cache-dir flash-attn
RUN python3 -m pip install -U --no-cache-dir install git+https://github.com/wookayin/gpustat.git@master
RUN python3 -m pip install -U --no-cache-dir ipykernel
RUN python3 -m pip install -U --no-cache-dir ipywidgets
RUN python3 -m pip install -U --no-cache-dir httpx[socks]
RUN python3 -m pip install -U --no-cache-dir wandb
RUN cd /workspace && \
git clone https://github.com/huggingface/accelerate.git && \
python3 -m pip uninstall -y accelerate && \
cd accelerate && \
python3 -m pip install -e .
RUN cd /workspace && \
git clone https://github.com/huggingface/trl.git && \
python3 -m pip uninstall -y trl && \
cd trl && \
python3 -m pip install -e .
RUN cd /workspace/transformers && \
git pull && \
python3 -m pip uninstall -y transformers && \
python3 -m pip install -e .
RUN mkdir -p /scripts && echo -e '#!/bin/bash\n\
SSHD_PORT=22001\n\
CMD_TO_RUN=""\n\
while (( "$#" )); do\n\
case "$1" in\n\
--sshd_port)\n\
if [ -n "$2" ] && [ ${2:0:1} != "-" ]; then\n\
SSHD_PORT=$2\n\
shift 2\n\
else\n\
echo "Error: Argument for $1 is missing" >&2\n\
exit 1\n\
fi\n\
;;\n\
--cmd)\n\
if [ -n "$2" ] && [ ${2:0:1} != "-" ]; then\n\
CMD_TO_RUN=$2\n\
shift 2\n\
else\n\
echo "Error: Argument for $1 is missing" >&2\n\
exit 1\n\
fi\n\
;;\n\
-*|--*=) \n\
echo "Error: Unsupported flag $1" >&2\n\
exit 1\n\
;;\n\
*) \n\
shift\n\
;;\n\
esac\n\
done\n\
sed -i "s/#Port 22/Port $SSHD_PORT/" /etc/ssh/sshd_config\n\
/usr/sbin/sshd\n\
if [ -n "$CMD_TO_RUN" ]; then\n\
bash -c "$CMD_TO_RUN"\n\
else\n\
/bin/bash\n\
fi' > /scripts/startup.sh && chmod +x /scripts/startup.sh
ENTRYPOINT ["/bin/bash", "/scripts/startup.sh"]
================================================
FILE: docker/build_dockerfile_upon_transfermers.sh
================================================
export https_proxy=...
export http_proxy=...
export all_proxy=...
wget https://raw.githubusercontent.com/huggingface/transformers/main/docker/transformers-pytorch-deepspeed-latest-gpu/Dockerfile -O transformers.dockerfile
docker build --network host --build-arg http_proxy=$http_proxy --build-arg https_proxy=$https_proxy --build-arg all_proxy=$all_proxy -t transformers:ds -f transformers.dockerfile .
docker build --network host --build-arg http_proxy=$http_proxy --build-arg https_proxy=$https_proxy --build-arg all_proxy=$all_proxy -t belle -f belle.dockerfile .
================================================
FILE: docker/docker_run.sh
================================================
# 需要先安装container-toolkit
# https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html
export https_proxy=...
export http_proxy=...
export all_proxy=...
belle_path=...
docker_user=...
tag=...
hf_home=".../.cache/huggingface"
ssh_pub_key="/home/.../.ssh/id_rsa.pub"
workdir="$belle_path/train"
chown root:root $ssh_pub_key
# docker run --gpus all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 \
# --privileged \
# --network host \
# --env HTTP_PROXY=$http_proxy \
# --env HF_HOME=$hf_home \
# -it --rm \
# -v $belle_path:$belle_path \
# -v $hf_home:$hf_home \
# -v $ssh_pub_key:/root/.ssh/authorized_keys \
# -w $workdir \
# $docker_user/transformers:$tag \
# /bin/bash
# 前台运行
# docker run --gpus all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 \
# --privileged \
# --network host \
# --env https_proxy=$https_proxy \
# --env http_proxy=$http_proxy \
# --env all_proxy=$all_proxy \
# --env HF_HOME=$hf_home \
# -it --rm \
# --name belle \
# -v $belle_path:$belle_path \
# -v $hf_home:$hf_home \
# -v $ssh_pub_key:/root/.ssh/authorized_keys \
# -w $workdir \
# $docker_user/belle:$tag \
# --sshd_port 2201 --cmd "echo 'export https_proxy=$https_proxy' >> /root/.bashrc && \
# echo 'export http_proxy=$http_proxy' >> /root/.bashrc && \
# echo 'export all_proxy=$all_proxy' >> /root/.bashrc && \
# echo 'export HF_HOME=$hf_home' >> /root/.bashrc && \
# /bin/bash"
# 后台运行
docker run --gpus all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 \
--privileged \
--network host \
--env https_proxy=$https_proxy \
--env http_proxy=$http_proxy \
--env all_proxy=$all_proxy \
--env HF_HOME=$hf_home \
-d --rm \
--name belle \
-v $belle_path:$belle_path \
-v $hf_home:$hf_home \
-v $ssh_pub_key:/root/.ssh/authorized_keys \
-w $workdir \
$docker_user/belle:$tag \
--sshd_port 2201 --cmd "echo 'export https_proxy=$https_proxy' >> /root/.bashrc && \
echo 'export http_proxy=$http_proxy' >> /root/.bashrc && \
echo 'export all_proxy=$all_proxy' >> /root/.bashrc && \
echo 'export HF_HOME=$hf_home' >> /root/.bashrc && \
sleep infinity"
================================================
FILE: docker/transformers.dockerfile
================================================
# https://docs.nvidia.com/deeplearning/frameworks/pytorch-release-notes/rel-22-12.html#rel-22-12
FROM nvcr.io/nvidia/pytorch:22.12-py3
LABEL maintainer="Hugging Face"
ARG DEBIAN_FRONTEND=noninteractive
ARG PYTORCH='2.0.1'
# Example: `cu102`, `cu113`, etc.
ARG CUDA='cu118'
RUN apt -y update
RUN apt install -y libaio-dev
RUN python3 -m pip install --no-cache-dir --upgrade pip
ARG REF=main
RUN git clone https://github.com/huggingface/transformers && cd transformers && git checkout $REF
RUN python3 -m pip uninstall -y torch torchvision torchaudio
# Install latest release PyTorch
# (PyTorch must be installed before pre-compiling any DeepSpeed c++/cuda ops.)
# (https://www.deepspeed.ai/tutorials/advanced-install/#pre-install-deepspeed-ops)
RUN python3 -m pip install --no-cache-dir -U torch==$PYTORCH torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/$CUDA
RUN python3 -m pip install --no-cache-dir ./transformers[deepspeed-testing]
RUN python3 -m pip install --no-cache-dir git+https://github.com/huggingface/accelerate@main#egg=accelerate
# Uninstall `transformer-engine` shipped with the base image
RUN python3 -m pip uninstall -y transformer-engine
# Uninstall `torch-tensorrt` shipped with the base image
RUN python3 -m pip uninstall -y torch-tensorrt
# recompile apex
RUN python3 -m pip uninstall -y apex
RUN git clone https://github.com/NVIDIA/apex
# `MAX_JOBS=1` disables parallel building to avoid cpu memory OOM when building image on GitHub Action (standard) runners
RUN cd apex && git checkout 82ee367f3da74b4cd62a1fb47aa9806f0f47b58b && MAX_JOBS=1 python3 -m pip install --global-option="--cpp_ext" --global-option="--cuda_ext" --no-cache -v --disable-pip-version-check .
# Pre-build **latest** DeepSpeed, so it would be ready for testing (otherwise, the 1st deepspeed test will timeout)
RUN python3 -m pip uninstall -y deepspeed
# This has to be run (again) inside the GPU VMs running the tests.
# The installation works here, but some tests fail, if we don't pre-build deepspeed again in the VMs running the tests.
# TODO: Find out why test fail.
RUN DS_BUILD_CPU_ADAM=1 DS_BUILD_FUSED_ADAM=1 DS_BUILD_UTILS=1 python3 -m pip install deepspeed --global-option="build_ext" --global-option="-j8" --no-cache -v --disable-pip-version-check 2>&1
# When installing in editable mode, `transformers` is not recognized as a package.
# this line must be added in order for python to be aware of transformers.
RUN cd transformers && python3 setup.py develop
# The base image ships with `pydantic==1.8.2` which is not working - i.e. the next command fails
RUN python3 -m pip install -U --no-cache-dir "pydantic<2"
RUN python3 -c "from deepspeed.launcher.runner import main"
================================================
FILE: docker/upload_image.sh
================================================
export https_proxy=...
export http_proxy=...
export all_proxy=...
docker_user=...
tag=$(date +%Y%m%d)
docker tag transformers:ds $docker_user/transformers:ds_$tag
docker push $docker_user/transformers:ds_$tag
docker tag transformers:ds $docker_user/transformers:latest
docker push $docker_user/transformers:latest
docker tag belle $docker_user/belle:$tag
docker push $docker_user/belle:$tag
docker tag belle $docker_user/belle:latest
docker push $docker_user/belle:latest
================================================
FILE: docs/README.md
================================================
# This folder contains recent research papers from BELLE GROUP.
[1] Yunjie Ji, Yan Gong, Yiping Peng, Chao Ni, Peiyan Sun, Dongyu Pan, Baochang Ma, Xiangang Li, "Exploring ChatGPT's Ability to Rank Content: A Preliminary Study on Consistency with Human Preferences", arXiv preprint [arXiv:2303.07610](https://github.com/LianjiaTech/BELLE/blob/main/docs/Exploring%20ChatGPT's%20Ability%20to%20Rank%20Content%20A%20Preliminary%20Study%20on%20Consistency%20with%20Human%20Preferences.pdf).
* **Abstract**
As a natural language assistant, ChatGPT is capable of performing various tasks, including but not limited to article generation, code completion, and data analysis. Furthermore, ChatGPT has consistently demonstrated a remarkable level of accuracy and reliability in terms of content evaluation, exhibiting the capability of mimicking human preferences. To further explore ChatGPT’s potential in this regard, a study is conducted to assess its ability to rank content. In order to do so, a test set consisting of prompts is created, covering a wide range of use cases, and five models are utilized to generate corresponding responses. ChatGPT is then instructed to rank the responses generated by these models. The results on the test set show that ChatGPT’s ranking preferences are consistent with human to a certain extent. This preliminary experimental finding implies that ChatGPT’s zero-shot ranking capability could be used to re-duce annotation pressure in a number of ranking tasks.
