# Cohere

Cohere [Command-R](https://cohere.com/blog/command-r) は、検索拡張生成（RAG）や外部 API・ツールの呼び出しといった長文脈タスク向けに設計された、35B パラメータの多言語大規模言語モデルです。このモデルは、根拠に基づいた生成（grounded generation）に特化して訓練されており、単一ステップおよび複数ステップのツール使用をサポートしています。128K トークンのコンテキスト長に対応しています。

すべてのオリジナルのCommand-Rチェックポイントは、[Command Models](https://huggingface.co/collections/CohereForAI/command-models-67652b401665205e17b192ad)コレクション内で確認できます。

> [!TIP]
> Cohere を異なる言語タスクに適用する方法のさらなる例については、右側のサイドバーにある Cohere モデルをクリックしてください。

以下の例では、[Pipeline](/docs/transformers/main/ja/main_classes/pipelines#transformers.Pipeline)または[AutoModel](/docs/transformers/main/ja/model_doc/auto#transformers.AutoModel)、およびコマンドラインからテキストを生成する方法を示しています。

```python
from transformers import pipeline

pipeline = pipeline(
    task="text-generation",
    model="CohereForAI/c4ai-command-r-v01",
    device=0
)
pipeline("Plants create energy through a process known as")
```

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("CohereForAI/c4ai-command-r-v01")
model = AutoModelForCausalLM.from_pretrained("CohereForAI/c4ai-command-r-v01", device_map="auto", attn_implementation="sdpa")

# format message with the Command-R chat template
messages = [{"role": "user", "content": "How do plants make energy?"}]
input_ids = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to(model.device)
output = model.generate(
    input_ids,
    max_new_tokens=100,
    do_sample=True,
    temperature=0.3,
    cache_implementation="static",
)
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

```bash
# pip install -U flash-attn --no-build-isolation
transformers chat CohereForAI/c4ai-command-r-v01 --dtype auto --attn_implementation flash_attention_2
```

Quantization は、重みを低精度で表現することで、大規模モデルのメモリ負荷を軽減します。利用可能な Quantization バックエンドの詳細については、[Quantization](../quantization/overview) の概要を参照してください。

以下の例では、[bitsandbytes](../quantization/bitsandbytes) を使用して重みを4ビットに量子化します。

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(load_in_4bit=True)
tokenizer = AutoTokenizer.from_pretrained("CohereForAI/c4ai-command-r-v01")
model = AutoModelForCausalLM.from_pretrained("CohereForAI/c4ai-command-r-v01", device_map="auto", quantization_config=bnb_config, attn_implementation="sdpa")

# format message with the Command-R chat template
messages = [{"role": "user", "content": "How do plants make energy?"}]
input_ids = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to(model.device)
output = model.generate(
    input_ids,
    max_new_tokens=100,
    do_sample=True,
    temperature=0.3,
    cache_implementation="static",
)
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

[AttentionMaskVisualizer](https://github.com/huggingface/transformers/blob/beb9b5b02246b9b7ee81ddf938f93f44cfeaad19/src/transformers/utils/attention_visualizer.py#L139) を使用して、モデルが注意できるトークンと注意できないトークンをより深く理解してください。

```python
from transformers.utils.attention_visualizer import AttentionMaskVisualizer

visualizer = AttentionMaskVisualizer("CohereForAI/c4ai-command-r-v01")
visualizer("Plants create energy through a process known as")
```

    

## 注記

- FlashAttention-2 を使用している場合は、[from_pretrained()](/docs/transformers/main/ja/model_doc/auto#transformers.AutoModel.from_pretrained) で dtype パラメータを使用しないでください。FlashAttention-2 は fp16 または bf16 のみサポートしているためです。[Automatic Mixed Precision](https://pytorch.org/tutorials/recipes/recipes/amp_recipe.html) を使用するか、[Trainer](/docs/transformers/main/ja/main_classes/trainer#transformers.Trainer) を使用する場合は fp16 または bf16 を True に設定するか、[torch.autocast](https://pytorch.org/docs/stable/amp.html#torch.autocast) を使用してください。

## CohereConfig[[transformers.CohereConfig]]

#### transformers.CohereConfig[[transformers.CohereConfig]]

```python
transformers.CohereConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 256000, hidden_size: int = 8192, intermediate_size: int = 22528, logit_scale: float | None = 0.0625, num_hidden_layers: int = 40, num_attention_heads: int = 64, num_key_value_heads: int | None = None, hidden_act: str = 'silu', max_position_embeddings: int = 8192, initializer_range: float = 0.02, layer_norm_eps: float | None = 1e-05, use_cache: bool = True, pad_token_id: int | None = 0, bos_token_id: int | None = 5, eos_token_id: int | list[int] | None = 255001, tie_word_embeddings: bool = True, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, attention_dropout: float | int | None = 0.0, use_qk_norm: bool | None = False)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cohere/configuration_cohere.py#L30)

**パラメータ:**

vocab_size (`int`、*任意*、デフォルトは `256000`) : モデルの語彙サイズ。`input_ids` で表すことができるトークンの種類数を定義します。

hidden_size (`int`、*任意*、デフォルトは`8192`) : 隠れ表現の次元数。

intermediate_size (`int`、*optional*、デフォルトは `22528`) : MLP 表現の次元数。

logit_scale (`float`、*任意*、デフォルト値は 0.0625) : 出力 logits のスケーリング係数です。

num_hidden_layers (`int`、*任意*、デフォルトは `40`) : Transformer デコーダーの隠れ層の数。

num_attention_heads (`int`、*任意*、デフォルトは`64`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。

num_key_value_heads (`int`, *optional*) : Grouped Query Attention を実装するために使用する key_value ヘッドの数です。`num_key_value_heads=num_attention_heads` の場合、モデルは Multi Head Attention (MHA) を使用し、`num_key_value_heads=1` の場合は Multi Query Attention (MQA) を使用し、それ以外の場合は GQA が使用されます。マルチヘッドのチェックポイントを GQA チェックポイントに変換する際は、各グループの key ヘッドと value ヘッドは、そのグループ内の元のすべてのヘッドを平均プーリングして構築する必要があります。詳細については、[この論文](https://huggingface.co/papers/2305.13245)を参照してください。指定されない場合、デフォルトで `num_attention_heads` が使用されます。

hidden_act (`str`、*任意*、デフォルトは`silu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"`など。

max_position_embeddings (`int`、*任意*、デフォルトは`8192`) : このモデルが使用される可能性のある最大シーケンス長。

initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。

layer_norm_eps (`float`、*任意*、デフォルトは`1e-05`) : Layer Normalization 層で使用する epsilon。

use_cache (`bool`、*任意*、デフォルトは `True`) : モデルが最後のキー/バリューアテンションを返すかどうか（すべてのモデルで利用されるわけではありません）。`config.is_decoder=True` の場合、またはモデルがデコーダー専用の生成モデルである場合にのみ関連します。

pad_token_id (`int`, *任意*, デフォルトは `0`) : 語彙内でパディングに使用されるトークン ID。

bos_token_id (`int`、*任意*、デフォルトは`5`) : 語彙内でストリームの開始に使用されるトークン ID。

eos_token_id (`Union[int, list[int]]`、*任意*、デフォルトは`255001`) : 語彙内でストリーム終了に使用されるトークン ID。

tie_word_embeddings (`bool`、*任意*、デフォルトは`True`) : モデルの`tied_weights_keys`マッピングに従って重み埋め込みを共有するかどうか。

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *optional*) : RoPE 埋め込みの設定パラメータを含む辞書です。この辞書には `rope_theta` の値が含まれていなければならず、より長い `max_position_embeddings` で RoPE を使用する場合、スケーリングに使用されるパラメータが任意で含まれます。

attention_bias (`bool`、*任意*、デフォルトは`False`) : セルフアテンションにおけるクエリ、キー、バリュー、出力の投影層でバイアスを使用するかどうか。

attention_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率。

use_qk_norm (`bool`、*任意*、デフォルトは`False`) : attention で query-key 正規化を使用するかどうか。

これは CohereModel の設定を保存するための設定クラスです。指定された引数に基づいて Cohere モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[CohereForAI/c4ai-command-r-v01](https://huggingface.co/CohereForAI/c4ai-command-r-v01) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

```python
>>> from transformers import CohereModel, CohereConfig

>>> # Initializing a Cohere model configuration
>>> configuration = CohereConfig()

>>> # Initializing a model from the Cohere configuration
>>> model = CohereModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```

## CohereTokenizer[[transformers.CohereTokenizer]]

#### transformers.CohereTokenizer[[transformers.CohereTokenizer]]

```python
transformers.CohereTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, errors: str = 'replace', unk_token: str = '<UNK>', bos_token: str = '<BOS_TOKEN>', eos_token: str = '<|END_OF_TURN_TOKEN|>', pad_token: str = '<PAD>', cls_token: str = '<CLS>', sep_token: str = '<SEP>', mask_token: str = '<MASK_TOKEN>', use_default_system_prompt: bool = False, add_prefix_space: bool = False, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cohere/tokenization_cohere.py#L45)

**パラメータ:**

vocab_file (`str`, *任意*) : 語彙ファイルへのパス。

merges_file (`str`, *任意*) : マージファイルへのパス。

tokenizer_file (`str`、*任意*) : トークナイザーを読み込むために必要な情報がすべて含まれている [tokenizers](https://github.com/huggingface/tokenizers) ファイル（通常は .json 拡張子を持っています）。

clean_up_tokenization_spaces (`bool`、*任意*、デフォルトは`False`) : デコード後にスペースをクリーンアップするかどうか。クリーンアップとは、余分なスペースなどの潜在的なアーティファクトを削除することです。

unk_token (`str` または `tokenizers.AddedToken`、*任意*、デフォルトは `"<UNK>"`) : 不明トークンです。語彙に存在しないトークンは ID に変換できず、代わりにこのトークンが設定されます。

bos_token (`str` または `tokenizers.AddedToken`、*任意*、デフォルトは `"<BOS_TOKEN>"`) : 事前学習時に使用されたシーケンスの開始トークンです。シーケンス分類器のトークンとして使用できます。

eos_token (`str` または `tokenizers.AddedToken`、*任意*、デフォルトは `"<|END_OF_TURN_TOKEN|>"`) : シーケンスの終了トークン。

add_bos_token (`bool`、*任意*、デフォルトは`True`) : シーケンスの先頭に`bos_token`を追加するかどうか。

add_eos_token (`bool`、*任意*、デフォルトは`False`) : シーケンスの末尾に`eos_token`を追加するかどうか。

use_default_system_prompt (`bool`、*任意*、デフォルトは `False`) : Cohere トークナイザーのデフォルトシステムプロンプトを使用するかどうか。

add_prefix_space (`bool`、*任意*、デフォルトは`False`) : トークナイザーが自動的にプレフィックススペースを追加するかどうか

vocab (`str`、`dict`または`list`、*省略可*) : カスタムの語彙辞書。指定しない場合、vocab_fileから語彙が読み込まれます。

merges (`str` または `list[str]`、*省略可能*) : カスタムなマージリストです。指定しない場合、`merges_file` からマージが読み込まれます。

Cohereのトークナイザーを構築します。バイトレベルのByte-Pair-Encodingに基づいています。

ここでは、ByteFallbackとNFC正規化が特に使用されています。

```python
>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("CohereForAI/c4ai-command-r-v01")
>>> tokenizer.encode("Hello this is a test")
[5, 28339, 2075, 1801, 1671, 3282]
```

`bos_token` または `eos_token` を変更する場合は、モデルの初期化時にそれらを指定するか、`tokenizer.update_post_processor()` を呼び出して、後処理が正しく行われることを確認してください（そうしないと、エンコードされたシーケンスの最初のトークンと最後のトークンの値が正しくなりません）。詳細については、[post-processors] (https://huggingface.co/docs/tokenizers/api/post-processors) のドキュメントを参照してください。

この動作を回避するには、このトークナイザーをインスタンス化する際に`add_prefix_space=True`を渡すことができますが、モデルはこの方式で事前学習されていないため、パフォーマンスが低下する可能性があります。

`is_split_into_words=True` と併用する場合、このトークナイザーは `add_prefix_space=True` を指定してインスタンス化する必要があります。

このトークナイザーは、[TokenizersBackend](/docs/transformers/main/ja/main_classes/tokenizer#transformers.TokenizersBackend) を継承しており、主要なメソッドの大部分がそこに含まれています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。

#### apply_grounded_generation_template[[transformers.CohereTokenizer.apply_grounded_generation_template]]

```python
apply_grounded_generation_template(conversation: list, documents: list, citation_mode: typing.Literal['fast', 'accurate'] = 'accurate', **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cohere/tokenization_cohere.py#L297)

**パラメータ:**

conversation (list[dict[str, str]]) : これまでのチャット履歴を表す、"role" と "content" キーを持つ dict のリスト。

documents (list[dict[str, str]) : 生成の根拠となるドキュメントやツール出力を表す dict のリスト。ドキュメントは文字列から文字列へのマッピングを持つ半構造化された dict です。一般的なフィールドには `url`、`title`、`snippet` などがありますが、キーを説明するものにする必要があります。これらはプロンプトにレンダリングされます。

citation_mode : "accurate"（モデルにまず回答を生成させ、その後、引用スパンを挿入して書き直すよう指示する）または "fast"（プロンプトで、モデルに直接引用を付けた回答を生成させるよう指示する）。前者は引用の品質が高く、後者は生成に必要なトークン数が少ないという特徴があります。

add_generation_prompt (bool, *optional*) : プロンプトの末尾に、アシスタントメッセージの開始を示すトークンを付加するかどうかを指定します。モデルから応答を生成したい場合に有用です。なお、この引数はチャットテンプレートに渡されるため、この引数が効果を発揮するには、テンプレート側でのサポートが必要です。

tokenize (`bool`、デフォルトは`True`) : 出力をトークン化するかを指定します。`False`の場合、出力は文字列になります。

padding (`bool`、デフォルトは`False`) : シーケンスを最大長にパディングするかどうか。`False`の場合、この引数は無効になります。

truncation (`bool`、デフォルトは`False`) : シーケンスを最大長で切り詰めるかどうか。`False`の場合、この引数は無効です。

max_length (`int`, *任意*) : パディングや切り詰めのために使用する最大長（トークン数）。tokenize が `False` の場合は無効です。指定しない場合、デフォルトとしてトークナイザーの `max_length` 属性が使用されます。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定した場合、特定のフレームワークのテンソルを返します。tokenize が `False` の場合は効果がありません。許可される値は以下の通りです: - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: NumPy の `np.ndarray` オブジェクトを返します。

return_dict (`bool`、*任意*、デフォルトは `False`) : 名前付き出力を含む辞書を返すかどうかを指定します。`False` の場合は、この引数は無効になります。

- ****tokenizer_kwargs** : トークナイザーに渡す追加の引数。

**戻り値:** `str`

A rendered prompt string. or if tokenize=True: `list[int]`: A list of token ids representing the tokenized chat so far, including control tokens. This output is ready to pass to the model, either directly or via methods like `generate()`.

Command-R のグラウンデッド生成（RAG とも呼ばれる）プロンプトを作成します。

レンダリングが完了すると、プロンプトは、提供されたドキュメントに基づいて、引用を付けた応答を生成するようにモデルに指示します。

概念的には、これは`apply_chat_format`と同じ仕組みで動作しますが、追加の`documents`と`citation_mode`パラメータを受け取ります。

`"role"` キーと `"content"` キーを持つ辞書のリスト、およびモデルが応答の根拠とするドキュメントのリストを、プロンプト文字列またはトークン ID のリストに変換します。このメソッドは、クラスレベルで指定されたトークナイザーの `grounded_generation_template` テンプレートを使用します。`grounded_generation_template` キーワード引数を使用してデフォルトのテンプレートを上書きできますが、結果の品質が低下する可能性があります。

例:

```python
>> tokenizer = CohereTokenizer.from_pretrained('CohereForAI/c4ai-command-r-v01')

>> # define documents:
>> documents = [
    { "title": "Tall penguins", "text": "Emperor penguins are the tallest." },
    { "title": "Penguin habitats", "text": "Emperor penguins only live in Antarctica."}
]
>> # define a conversation:
>> conversation = [
    {"role": "user", "content": "What's the biggest penguin in the world?"}
]
>> # render the prompt, ready for user to inspect, or for input into the model:
>> grounded_generation_prompt = tokenizer.apply_grounded_generation_template(conversation, documents=documents, tokenize=False, add_generation_prompt=True)
>> print(grounded_generation_prompt)
>> inputs = tokenizer.encode(prompt, add_special_tokens=False, return_tensors='pt')
>> outputs = model.generate(inputs, max_new_tokens=128)
>> print(tokenizer.decode(outputs[0]))
```

#### apply_tool_use_template[[transformers.CohereTokenizer.apply_tool_use_template]]

```python
apply_tool_use_template(conversation: list, tools: list, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cohere/tokenization_cohere.py#L186)

**パラメータ:**

conversation (list[dict[str, str]]) : これまでのチャット履歴を表す、"role" と "content" キーを持つ dict のリスト。

tools (list[Dict]) : モデルが選択できるようにプロンプトにレンダリングするツールのリストです。docstring の末尾に例があります。形式は以下の通りです: * name (str): 呼び出されるツールの名前です。有効な名前は a-z、A-Z、0-9、_ の文字のみを含み、数字で始まることはできません。 * description (str): ツールの機能の説明です。モデルはこの説明に基づいて、いつどのように関数を呼び出すかを選択します。 * parameter_definitions (list[Dict]): ツールの入力パラメータです。キーがパラメータ名、値がパラメータ仕様である辞書を受け入れます。有効なパラメータ名は a-z、A-Z、0-9、_ の文字のみを含み、数字で始まることはできません。パラメータ仕様は以下の通りです: * description (str): パラメータの説明です。 * type (str): パラメータの型です - 'str' や 'bool' などの Python 組み込みデータ型に対して最も効果的です。 * required: boolean: パラメータが常に存在する（必須）かどうかを示します。デフォルトでは必須ではありません。

add_generation_prompt (bool, *optional*) : プロンプトの末尾に、アシスタントメッセージの開始を示すトークンを付加するかどうかを指定します。モデルから応答を生成したい場合に有用です。なお、この引数はチャットテンプレートに渡されるため、この引数が効果を発揮するには、テンプレート側でのサポートが必要です。

tokenize (`bool`、デフォルトは`True`) : 出力をトークン化するかを指定します。`False`の場合、出力は文字列になります。

padding (`bool`、デフォルトは`False`) : シーケンスを最大長にパディングするかどうか。`False`の場合、この引数は無効になります。

truncation (`bool`、デフォルトは`False`) : シーケンスを最大長で切り詰めるかどうか。`False`の場合、この引数は無効です。

max_length (`int`, *任意*) : パディングや切り詰めのために使用する最大長（トークン数）。tokenize が `False` の場合は無効です。指定しない場合、デフォルトとしてトークナイザーの `max_length` 属性が使用されます。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定した場合、特定のフレームワークのテンソルを返します。tokenize が `False` の場合は効果がありません。許可される値は以下の通りです: - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: NumPy の `np.ndarray` オブジェクトを返します。

return_dict (`bool`、*任意*、デフォルトは `False`) : 名前付き出力を含む辞書を返すかどうかを指定します。`False` の場合は、この引数は無効になります。

- ****tokenizer_kwargs** : トークナイザーに渡す追加の引数。

**戻り値:** `str`

A rendered prompt string. or if tokenize=True: `list[int]`: A list of token ids representing the tokenized chat so far, including control tokens. This output is ready to pass to the model, either directly or via methods like `generate()`.

Command-Rのツール使用プロンプトを作成します。

レンダリングが完了すると、プロンプトはモデルに指示し、ユーザーの要求を支援するために、ユーザーが提供したツールセットに対して実行すべきアクションのリストを生成させます。

概念的には、`apply_chat_format` と同じ仕組みで動作しますが、追加の `tools` パラメータを受け取ります。

`"role"`キーと`"content"`キーを持つ辞書のリスト形式のチャットと、モデルが使用可能なツールのリストを、プロンプト文字列またはトークンIDのリストに変換します。このメソッドは、クラスレベルで指定されたトークナイザーの`default_tool_use_template`テンプレートを使用します。`tool_use_template`キーワード引数を使用してデフォルトのテンプレートをオーバーライドできますが、結果の品質が低下する可能性があります。

例:

```python
>> tokenizer = CohereTokenizer.from_pretrained("CohereForAI/c4ai-command-r-v01")
>> tools = [
    {
        "name": "internet_search",
        "description": "Returns a list of relevant document snippets for a textual query retrieved from the internet",
        "parameter_definitions": {
            "query": {
                "description": "Query to search the internet with",
                "type": "str",
                "required": True,
            }
        },
    },
    {
        "name": "directly_answer",
        "description": "Calls a standard (un-augmented) AI chatbot to generate a response given the conversation history",
        "parameter_definitions": {},
    },
]
>> conversation = [
    {"role": "user", "content": "What's the biggest penguin in the world?"},
]
>> # Render the prompt, ready for user to inspect, or for input into the model
>> prompt = tokenizer.apply_tool_use_template(conversation, tools=tools, tokenize=False, add_generation_prompt=True)
>> print(prompt)
>> inputs = tokenizer.encode(grounded_generation_prompt, add_special_tokens=False, return_tensors='pt')
>> outputs = model.generate(inputs, max_new_tokens=128)
>> print(tokenizer.decode(outputs[0]))
[
    {
        "tool_name": "internet_search",
        "parameters": {
            "query": "biggest penguin in the world"
        }
    }
]
```

## CohereModel[[transformers.CohereModel]]

#### transformers.CohereModel[[transformers.CohereModel]]

```python
transformers.CohereModel(config: CohereConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cohere/modeling_cohere.py#L360)

**パラメータ:**

config ([CohereConfig](/docs/transformers/main/ja/model_doc/cohere#transformers.CohereConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

特定のヘッドを付加せずに、生のhidden-statesを出力する素のCohere Model。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### forward[[transformers.CohereModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cohere/modeling_cohere.py#L377)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

**戻り値:** [BaseModelOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) または `tuple(torch.FloatTensor)`

config（[CohereConfig](/docs/transformers/main/ja/model_doc/cohere#transformers.CohereConfig)）や入力に応じて、さまざまな要素で構成される、[BaseModelOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[CohereModel](/docs/transformers/main/ja/model_doc/cohere#transformers.CohereModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。

  `past_key_values`が使用されている場合、出力されるのは、形状`(batch_size, 1, hidden_size)`のシーケンスの最後の隠れ状態のみです。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  自己アテンションブロック（および `config.is_encoder_decoder=True` の場合、クロスカレンションブロック）の事前計算済みヒドゥンステート（キーとバリュー）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

## CohereForCausalLM[[transformers.CohereForCausalLM]]

#### transformers.CohereForCausalLM[[transformers.CohereForCausalLM]]

```python
transformers.CohereForCausalLM(config: CohereConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cohere/modeling_cohere.py#L434)

**パラメータ:**

config ([CohereConfig](/docs/transformers/main/ja/model_doc/cohere#transformers.CohereConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

因果言語モデリング用のCohereモデル。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### forward[[transformers.CohereForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cohere/modeling_cohere.py#L451)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

labels (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : マスク言語モデリング損失を計算するためのラベル。インデックスは `[0, ..., config.vocab_size]` の範囲内であるか、-100 である必要があります（`input_ids` のドキュメント文字列を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲内のラベルを持つトークンに対してのみ計算されます。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

logits_to_keep (`Union[int, torch.Tensor]`、*任意*、デフォルトは `0`) : `int` の場合、最後の `logits_to_keep` トークンについて logits を計算します。`0` の場合、すべての `input_ids` について logits を計算します（特殊ケース）。生成には最後のトークンの logits だけで十分であり、そのトークンのみについて計算することでメモリを節約できます。これは、長いシーケンスや大規模な語彙サイズの場合に特に顕著な効果があります。`torch.Tensor` の場合、シーケンス長次元で保持するインデックスに対応する 1 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。

**戻り値:** [CausalLMOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) または `tuple(torch.FloatTensor)`

config（[CohereConfig](/docs/transformers/main/ja/model_doc/cohere#transformers.CohereConfig)）や入力に応じて、さまざまな要素で構成される [CausalLMOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast)、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[CohereForCausalLM](/docs/transformers/main/ja/model_doc/cohere#transformers.CohereForCausalLM)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 言語モデリングの損失(次のトークンの予測用)。
- **logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの隠れ状態（自己注意ブロックのキーとバリュー）が含まれます。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

例:

```python
>> from transformers import AutoTokenizer, CohereForCausalLM

>> model = CohereForCausalLM.from_pretrained("CohereForAI/c4ai-command-r-v01")
>> tokenizer = AutoTokenizer.from_pretrained("CohereForAI/c4ai-command-r-v01")

>> 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."
```