Home/Model Training/P-tuning-v2
P-tuning-v2 logo

P-tuning-v2

THUDM/P-tuning-v2

Optimized deep prompt tuning strategy comparable to fine-tuning across scales and tasks

GraphCanon updated 3w · GitHub synced 3w

2.1k stars213 forksLast push 2y Python Apache-2.0

Decision brief

P-tuning-v2 is an optimized deep prompt tuning strategy that can be used for tasks like natural language processing and parameter-efficient learning where few parameters need to be adjusted compared to full fine-tuning.

Good fit when

  • For scenarios requiring efficient use of resources, as P-tuning v2 requires fewer parameters than traditional fine-tuning methods.
  • When working with small to medium-sized models or tasks that are challenging for sequence tagging where deep prompt tuning can bridge the performance gap without full model fine-tuning.

Avoid when

  • Avoid using P-tuning v2 when you have large-scale datasets and model architectures, as it might not be as effective compared to full fine-tuning methods.
  • If your project requires a high level of customization beyond prompt tuning or continuous prompts do not align with the problem complexity.
Requirements:
Min 8 GB RAM; Experiments were conducted on NVIDIA DGX-A100; however, RTX 3090 or RTX 2080 Ti GPUs can suffice given certain conditions.; CUDA version should be at least 11.1 and specific versions of pytorch (1.7.1), torchvision (0.8.2) and torchaudio (0.7.2).; A conda environment setup with Python 3.8.5 is recommended for optimal performance.

Observed Jul 17, 2026 · Source: enrich:decision_facts

Verify the decision

Maintenance and security

Full trust report
Maintenance
Dormant (990d since push)
As of 3w
Provenance
Not a fork · Organization account
As of 3w
Security (OSV)
50 low (50 low)
As of 1mo

Public GitHub metadata and optional OSV scans. Signals, not a guarantee. Trust methodology.

Install

pip install P-tuning-v2
PyPI

Similar tools

Same-category neighbours. No typed graph edges are catalogued for this tool yet.

Evidence and technical details

Sourced facts, taxonomy, compatibility claims, README excerpt, and machine-readable endpoints.

Overview

Repository for P-tuning v2, an optimized prompt tuning approach that provides performance similar to traditional fine-tuning but with fewer parameters.

Capability facts

Languages
python

Source: github.language · Aug 3, 2026

Categories

Compatibility

Sourced claims from the README excerpt - not unsourced marketing copy.

Python runtimePython

Source: README excerpt (regex_v1, Aug 3, 2026)

conda create -n pt2 python=3.8.5
Source link

Tags

README

P-tuning v2

Source codes and data for

An optimized prompt tuning strategy achieving comparable performance to fine-tuning on small/medium-sized models and sequence tagging challenges.

Find our previous version P-tuning v1 for knowledge probing and few-shot SuperGLUE. Your kindly starring our repo can greatly encourage us to work harder :)

You may be also interested in our recent work GLM-130B: An Open Bilingual Pre-trained Model (2022-10-06). It is an open-sourced LLM outperforming GPT-3 175B over various benchmarks. Get model weights, do inference and P-Tuning v2 with only 4 * RTX 3090 or 8 * RTX 2080 Ti FOR FREE!

P-tuning v2 leverages deep prompt tuning, which is to apply continuous prompts for every layer input of the pretrained transformer. Deep prompt tuning increases the capacity of continuous prompts and closes the gap to fine-tuning across various settings, especially for small models and hard tasks.

Thanks @rainatam's joint effort in re-organizing codes for publishing!

Commonly Asked Question

  1. Some readers notice a 'mismatch' in SuperGLUE between P-tuning (v1) and P-tuning v2: This is because in P-tuning's SuperGLUE experiment, for fair comparison to PET, we follow its experimental setting where backbone pre-trained model parameters are jointly tuned with continuous prompt embeddings; while in P-tuning v2, we follow Prefix tuning and Lester et al.'s parameter-efficient setting where backbone pre-trained model parameters are frozen.

Reproduce Tips

Since experiments reported in our paper are all conducted on NVIDIA DGX-A100 servers (which might be difficult to acquire), we reimplement P-tuning v2's results on BERT-large/RoBERTa-large with:

  • Ubuntu servers with NVIDIA GeForce RTX 3090 (24G) GPUs
  • cuda 11.1
  • packages with certain versions (provided below)

We notice that the best hyper-parameters can be sensitive to your server environment and package version. If you do not have the exact same environment, we highly recommend you to run hyper-parameter search in your environment based on our example hyper-parameter search script in search_script and result collection scripts search.py.

Setup

We conduct our experiment with Anaconda3. If you have installed Anaconda3, then create the environment for P-tuning v2:

conda create -n pt2 python=3.8.5
conda activate pt2

After we setup basic conda environment, install pytorch related packages via:

conda install -n pt2 pytorch==1.7.1 torchvision==0.8.2 torchaudio==0.7.2 cudatoolkit=11.0 -c pytorch

Finally, install other python packages we need:

pip install -r requirements.txt

Data

For SuperGLUE and SQuAD datasets, we download them from the Huggingface Datasets APIs (embedded in our codes).

For sequence tagging (NER, SRL) datasets, we prepare a non-official packup here. After downloading, unzip the packup to the project root. Please use at your own risk.

Training

Run training scripts in run_script (e.g., RoBERTa for RTE):

bash run_script/run_rte_roberta.sh

Implemented Results

Currently we have released our reimplementation on following tasks and datasets. More implementation will be released soon.

Released results on BERT-large

| | BoolQ | COPA | RTE | WiC | WSC | CoNLL04 | OntoNotes 5.0 | CoNLL12 | |--------------|-------|-

For agents

This page has a .md twin and JSON over the API.

Was this helpful?

Anonymous feedback helps us improve pages and translations.